javascript - null coalescing operator c#

¿Hay un operador de "unión nula" en JavaScript?

Question

¿Hay un operador de unión nula en Javascript?

Por ejemplo, en C #, puedo hacer esto:

String someString = null;
var whatIWant = someString ?? "Cookies!";

La mejor aproximación que puedo averiguar para Javascript es usar el operador condicional:

var someString = null;
var whatIWant = someString ? someString : ''Cookies!'';

Que es una especie IMP. ¿Puedo hacerlo mejor?

Answer 1

Actualmente no hay soporte, pero el proceso de estandarización de JS está funcionando: https://github.com/tc39/proposal-optional-chaining

Answer 2

Después de leer su aclaración, la respuesta de @Ates Goral proporciona cómo realizar la misma operación que está haciendo en C # en JavaScript.

La respuesta de @Gumbo proporciona la mejor manera de verificar si hay nulos; sin embargo, es importante tener en cuenta la diferencia en == en comparación con === en JavaScript, especialmente cuando se trata de cuestiones relacionadas con la comprobación de undefined y / o null .

Hay un artículo realmente bueno sobre la diferencia en dos términos here . Básicamente, entienda que si usa == lugar de === , JavaScript intentará unir los valores que está comparando y devolver el resultado de la comparación después de esta fusión.

Answer 3

El equivalente de JavaScript del operador coalescente nulo de C # ( ?? ) está utilizando un OR lógico ( || ):

var whatIWant = someString || "Cookies!";

Hay casos (se aclara a continuación) que el comportamiento no coincidirá con el de C #, pero esta es la forma general y concisa de asignar valores predeterminados / alternativos en JavaScript.

Aclaración

Independientemente del tipo del primer operando, si convertirlo en un valor booleano resulta false , la asignación usará el segundo operando. Cuidado con todos los casos a continuación:

alert(Boolean(null)); // false
alert(Boolean(undefined)); // false
alert(Boolean(0)); // false
alert(Boolean("")); // false
alert(Boolean("false")); // true -- gotcha! :)

Esto significa:

var whatIWant = null || new ShinyObject(); // is a new shiny object
var whatIWant = undefined || "well defined"; // is "well defined"
var whatIWant = 0 || 42; // is 42
var whatIWant = "" || "a million bucks"; // is "a million bucks"
var whatIWant = "false" || "no way"; // is "false"

Answer 4

Nadie ha mencionado aquí el potencial de NaN , que, para mí, también es un valor nulo. Entonces, pensé en agregar mis dos centavos.

Para el código dado:

var a,
b = null,
c = parseInt(''Not a number''),
d = 0,
e = '''',
f = 1
;

Si fueras a utilizar el || operador, obtienes el primer valor no falso:

var result = a || b || c || d || e || f; // result === 1

Si usa el método de fusión típico, como se publica aquí , obtendrá c , que tiene el valor: NaN

var result = coalesce(a,b,c,d,e,f); // result.toString() === ''NaN''

Ninguno de estos me parece correcto. En mi propio pequeño mundo de lógica de fusión, que puede diferir de tu mundo, considero indefinido, nulo, y NaN como todos "nulos". Por lo tanto, espero volver d (cero) del método de coalescencia.

Si el cerebro de alguien funciona como el mío y desea excluir NaN , este método lo logrará:

function coalesce() {
var i, undefined, arg;
for( i=0; i < arguments.length; i++ ) {
arg = arguments[i];
if( arg !== null && arg !== undefined
&& (typeof arg !== ''number'' || arg.toString() !== ''NaN'') ) {
return arg;
}
}
return null;
}

Para aquellos que quieren el código lo más corto posible, y no les importa un poco de falta de claridad, también puede usar esto como lo sugiere @impinball. Esto aprovecha el hecho de que NaN nunca es igual a NaN. Puede leer más sobre eso aquí: ¿Por qué NaN no es igual a NaN?

function coalesce() {
var i, arg;
for( i=0; i < arguments.length; i++ ) {
arg = arguments[i];
if( arg != null && arg === arg ) { //arg === arg is false for NaN
return arg;
}
}
return null;
}

Answer 5

Sí, llegará pronto. Ver propuesta aquí y estado de implementación aquí .

Se parece a esto:

x ?? y

Ejemplo

const response = {
settings: {
nullValue: null,
height: 400,
animationDuration: 0,
headerText: '''',
showSplashScreen: false
}
};
const undefinedValue = response.settings?.undefinedValue ?? ''some other default''; // result: ''some other default''
const nullValue = response.settings?.nullValue ?? ''some other default''; // result: ''some other default''
const headerText = response.settings?.headerText ?? ''Hello, world!''; // result: ''''
const animationDuration = response.settings?.animationDuration ?? 300; // result: 0
const showSplashScreen = response.settings?.showSplashScreen ?? true; // result: false

Answer 6

Si || como un reemplazo de C # ''s ?? no es lo suficientemente bueno en tu caso, porque se traga cadenas y ceros vacíos, siempre puedes escribir tu propia función:

 function $N(value, ifnull) {
if (value === null || value === undefined)
return ifnull;
return value;
}
var whatIWant = $N(someString, ''Cookies!'');

Answer 7

cuidado con la definición específica de JavaScript de null. hay dos definiciones para "sin valor" en javascript. 1. Nulo: cuando una variable es nula, significa que no contiene datos, pero la variable ya está definida en el código. Me gusta esto:

var myEmptyValue = 1;
myEmptyValue = null;
if ( myEmptyValue === null ) { window.alert(''it is null''); }
// alerts

En tal caso, el tipo de su variable es en realidad Objeto. Pruébalo.

window.alert(typeof myEmptyValue); // prints Object

2. No definido: cuando una variable no se ha definido anteriormente en el código y, como se esperaba, no contiene ningún valor. Me gusta esto:

   if ( myUndefinedValue === undefined ) { window.alert(''it is undefined''); }
   // alerts

En tal caso, el tipo de su variable es ''indefinido''.

Observe que si usa el operador de comparación de conversión de tipo (==), JavaScript actuará por igual para ambos valores vacíos. para distinguirlos, utilice siempre el operador de comparación de tipo estricto (===).

Answer 8

function coalesce() {
var len = arguments.length;
for (var i=0; i<len; i++) {
if (arguments[i] !== null && arguments[i] !== undefined) {
return arguments[i];
}
}
return null;
}
var xyz = {};
xyz.val = coalesce(null, undefined, xyz.val, 5);
// xyz.val now contains 5

Esta solución funciona como la función de fusión de SQL, acepta cualquier número de argumentos y devuelve nulo si ninguno de ellos tiene un valor. Se comporta como el C # ?? operador en el sentido de que "", falso y 0 se consideran NOT NULL y, por lo tanto, cuentan como valores reales. Si viene de un fondo .net, esta será la solución de sensación más natural.