Hay varias formas de lograr este principio, por ejemplo, si crea clases, puede heredar las funciones y luego ampliar su funcionalidad. Por ejemplo:

 class NumberConverter { isNumber(number) { return true; } convertBase(number, fromBase, toBase) { return parseInt(number, fromBase).toString(toBase); } } class DecimalToBinary extends NumberConverter { isDecimalNumber(number) { return true; } dec2bin(number) { return this.convertBase(number, 10, 2); } }

Puede ver cómo puede ampliar convertBase y ampliar su funcionalidad. Puede extender desde varias clases simplemente agregando una coma después de cada clase, como extends Products, Music .

Pero si desea crear otro tipo de enfoque, puede hacer composición en lugar de herencia, lo que significa que con el ejemplo anterior, puede crear una nueva clase así:

 class Calculator { properties; numberConverter; setDecimalConverter(numberConverter) { this.numberConverter = numberConverter; } convertDec2bin(number) { return this.numberConverter.convertBase(number, 10, 2); } }

Entonces puedes usar la nueva Calculator de clase de esta manera:

 const calculator = new Calculator(); calculator.numberConverter = new NumberConverter(); // If you don't want to do this, you would have to add the NumberConverter in the Calculator constructor calculator.convertDec2bin(5);

Y toda esta funcionalidad se puede hacer como una función. (Aunque puede que no sea exactamente un principio abierto-cerrado, creo que aún resuelve su caso de uso). Puedes usarlo así:

 const Calculator = function(NumberConverter) { const numberConverter = NumberConverter; return { convertDec2bin(number) { return numberConverter.convertBase(number, 10, 2); } } } const calculator = Calculator(NumberConverter()); calculator.convertDec2bin(5)

Claro , de hecho, FP tiene que ver con la reutilización de funciones para crear otras nuevas.

Por ejemplo:

Puede declarar una función add :: Number -> Number -> Number

 const add = (x) => (y) => x + y

Y luego use add para construir otra función como mult :: Number -> Number -> Number

 const mult = (x) => (y) => y === 0 ? 0 : x + mult(x)(y - 1)

Cada función podría considerarse atómica, ya que no es necesario realizar más cambios. Entonces, de esta manera no modifica funciones anteriores, las reutiliza para formar otras nuevas.