pasar - parametros no obligatorios en javascript

Pasar NULL como un parámetro en ES6 no usa el parámetro predeterminado cuando se proporciona uno (3)

¿Existe alguna razón conocida por la que pasar un parámetro null como parámetro en ES6 no use el parámetro predeterminado cuando se proporciona uno?

function sayHello(name = "World") { console.log("Hello, " + name + "!"); } sayHello("Jim"); // Hello, Jim! sayHello(undefined); // Hello, World! sayHello(null); // Hello, null!

Esto no es tan obvio.

He leído algunos comentarios de por qué undefined es completamente diferente a null y es por eso que explica el comportamiento actual de los parámetros predeterminados.

Se podría argumentar que pasar explícitamente undefined no debe activar la sustitución del valor predeterminado porque cuando tengo una función:

const f = (x = ''default'') => console.log(x);

Me gustaría que imprima "default" cuando lo ejecuto como:

f();

pero me gustaría que se imprima "undefined" cuando lo ejecuto explícitamente como:

f(undefined);

porque de otro modo, ¿por qué usaría f(undefined) en primer lugar? Claramente, mi intención aquí es proporcionar algún argumento en lugar de omitirlo.

Ejemplos de lo contrario.

Ahora, considera esta función:

const g = (...a) => console.log(JSON.stringify(a));

Cuando lo uso como:

g();

Me sale: []

Pero cuando lo uso como:

g(undefined);

Me sale: [null]

lo que demuestra claramente que:

pasar undefined no es lo mismo que no pasar un argumento en absoluto
a veces null puede ser un valor predeterminado en lugar de undefined

Decisión TC39

Se puede ver algunos antecedentes sobre el comportamiento actual de los parámetros predeterminados en las Notas de la reunión del 24 de julio de 2012 de TC39:

https://github.com/rwaldron/tc39-notes/blob/master/es6/2012-07/july-24.md

Por cierto, muestra que pasar explícitamente undefined originalmente no activó el valor predeterminado en el primer borrador y hubo una discusión sobre si debería hacerlo o no. Entonces, como puede ver, el comportamiento actual no era tan obvio para los miembros del TC39 como lo parece ahora para las personas que comentan aquí.

Otros idiomas

Dicho esto, la decisión de qué debe y qué no debe desencadenar la sustitución del valor predeterminado es completamente arbitraria al final del día. Incluso tener un nombre undefined y null puede ser bastante extraño si lo piensas. Algunos idiomas solo tienen undefined (como undef en Perl), algunos solo tienen null (como Java), algunos lenguajes usan equivalentes de false o una lista vacía o una matriz para eso (como Esquema donde puede tener una lista vacía o #f (falso ) pero no hay un equivalente de null que sea distinto de una lista vacía y un valor falso) y algunos idiomas ni siquiera tienen equivalentes de null , false o undefined (como C que usa números enteros en lugar de true y false y un El puntero NULL que en realidad es un puntero normal que apunta a la dirección 0, lo que hace que esa dirección sea inaccesible, incluso cuando se asigna mediante cualquier código que pruebe los punteros nulos).

Lo que puedes hacer

Ahora, puedo entender su necesidad de sustituir los valores predeterminados por null . Desafortunadamente, este no es un comportamiento predeterminado, pero puede realizar una función simple para ayudarlo a:

const N = f => (...a) => f(...a.map(v => (v === null ? undefined : v)));

Ahora, cada vez que desee que los valores predeterminados se sustituyan por valores null , puede usarlo de esta manera. Por ejemplo, si tiene esta función de uno de los ejemplos anteriores:

const f = (x = ''default'') => console.log(x);

se imprimirá "default" para f() f(undefined) pero no para f(null) . Pero cuando usas la función N definida anteriormente para definir la función f esta manera:

const f = N((x = ''default'') => console.log(x));

ahora f() f(undefined) pero también f(null) imprime "default" .

Si desea un comportamiento algo diferente, por ejemplo, sustituyendo los valores predeterminados por cadenas vacías: útil para las variables de entorno que a veces se pueden configurar como cadenas vacías en lugar de no existentes, puede usar:

const N = f => (...a) => f(...a.map(v => (v === '''' ? undefined : v)));

Si desea que todos los valores falsos sean sustituidos, puede usarlo así:

const N = f => (...a) => f(...a.map(v => (v || undefined)));

Si quisiera que se sustituyeran objetos vacíos, podría usar:

const N = f => (...a) => f(...a.map(v => (Object.keys(v).length ? v : undefined)));

y así...

Conclusión

El punto es que es su código y usted sabe cuál debe ser la API de sus funciones y cómo deberían funcionar los valores predeterminados. Afortunadamente, JavaScript es lo suficientemente potente como para permitirte lograr fácilmente lo que necesitas (incluso si ese no es el comportamiento predeterminado de los valores predeterminados, por así decirlo) con alguna función mágica de orden superior.

Así es como se definen los parámetros por defecto en la especificación. Ver MDN : (énfasis mío)

Los parámetros de función predeterminados permiten que los parámetros formales se inicialicen con valores predeterminados si no se pasa ningún valor o undefined .

null no es ningún valor ni undefined , por lo que no activa la inicialización predeterminada.

null es un valor que no activará el valor predeterminado que se utilizará, los valores predeterminados se utilizarán cuando el argumento undefined esté undefined .