¿Hay un operador de "coalescencia nula" en JavaScript?

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 SQL coalesce, acepta cualquier número de argumentos y devuelve null si ninguno de ellos tiene un valor. ¿Se comporta como el C# ?? operador en el sentido de que"", false y 0 se consideran NO NULOS y por lo tanto cuentan como valores reales. Si usted viene de un fondo.net, esta será la solución de sensación más natural.

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

 function $N(value, ifnull) {
    if (value === null || value === undefined)
      return ifnull;
    return value;
 }

 var whatIWant = $N(someString, 'Cookies!');

Nadie ha mencionado aquí el potencial para NaN, que me para mí also es también un valor null-ish. Así que pensé en añadir mis dos centavos.

Para el código dado:

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

Si utilizas el operador ||, obtienes el primer valor no falso:

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

Si usa el método típico de coalescencia, 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 pequeño mundo de la lógica de fusión, que puede diferir de su mundo, considero indefinido, nulo y NaN como todos siendo "null-ish". Por lo tanto, esperaría volver d (cero) del método coalesce.

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

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 la falta de claridad, también puede usar esto como lo sugiere @impinball. Esto aprovecha el hecho de que NaN nunca es igual a NaN. Puedes leer más sobre esto 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;
}

Sí, está llegando pronto. Véase la propuesta aquíy el estado de aplicación aquí.

Se ve así:

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

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

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

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

En tal caso, el tipo de su variable es realmente Objeto. pruébalo.

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

1. Undefined: cuando una variable no ha sido definida antes en el código, y como se esperaba, no contiene ningún valor. como esto:

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

Si tal caso, el tipo de su variable es 'undefined'.

Observe que si usa el operador de comparación de conversión de tipos (==), JavaScript actuará igualmente para ambos valores vacíos. para distinguir entre ellos, utilice siempre el operador de comparación type-strict (===).

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 null; sin embargo, es importante notar la diferencia en == versus === en JavaScript especialmente cuando se trata de problemas de verificar undefined y/o null.

Hay un muy buen artículo sobre la diferencia en dos términos aquí. Básicamente, entender que si usted use == en lugar de ===, JavaScript intentará fusionar los valores que está comparando y devolver lo que el resultado de la comparación después de esta coalescencia.