Existe-t-il un opérateur "null coalescing" en JavaScript ?

Question

Existe-t-il un opérateur de coalescence nul en Javascript ?

Par exemple, en C#, je peux faire ceci :

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

La meilleure approximation que je puisse trouver pour Javascript est d'utiliser l'opérateur conditionnel :

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

Ce qui est un peu dégoûtant, selon moi. Je peux faire mieux ?

Answer 1

Mise à jour

JavaScript prend désormais en charge la fonction opérateur de coalescence nul ( ??) . Elle retourne son opérande de droite lorsque son opérande de gauche est null o undefined et, sinon, renvoie son opérande de gauche.

Ancienne réponse

Veuillez vérifier la compatibilité avant de l'utiliser.

---

L'équivalent en JavaScript de l'opérateur de fusion de nullité en C# ( ?? ) utilise un OU logique ( || ) :

var whatIWant = someString || "Cookies!";

Dans certains cas (précisés ci-dessous), le comportement ne correspond pas à celui du C#, mais il s'agit de la manière générale et laconique d'attribuer des valeurs par défaut/alternatives en JavaScript.

---

Clarification

Indépendamment du type du premier opérande, si la transformation en booléen donne le résultat suivant false l'affectation utilise le deuxième opérande. Attention à tous les cas ci-dessous :

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

Cela signifie :

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 2

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

cette solution fonctionne comme la fonction SQL coalesce, elle accepte un nombre quelconque d'arguments, et renvoie null si aucun d'entre eux n'a de valeur. Elle se comporte comme l'opérateur C# ? ? dans le sens où "", false et 0 sont considérés comme NOT NULL et comptent donc comme des valeurs réelles. Si vous venez d'un environnement .net, cette solution sera la plus naturelle.

Answer 3

Si || en remplacement de la méthode C# ?? n'est pas suffisante dans votre cas, car elle avale les chaînes vides et les zéros, vous pouvez toujours écrire votre propre fonction :

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

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

Answer 4

Attention à la définition spécifique de null en JavaScript. Il existe deux définitions de "no value" en JavaScript. 1. Null : quand une variable est nulle, cela signifie qu'elle ne contient aucune donnée, mais la variable est déjà définie dans le code. comme ceci :

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

dans ce cas, le type de votre variable est en fait Object. testez-le.

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

2. Undefined : quand une variable n'a pas été définie auparavant dans le code, et comme prévu, elle ne contient aucune valeur. comme ceci :

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

Si tel est le cas, le type de votre variable est 'undefined'.

Notez que si vous utilisez l'opérateur de comparaison à conversion de type (==), JavaScript agira de la même manière pour ces deux valeurs vides. Pour les distinguer, utilisez toujours l'opérateur de comparaison à conversion de type (===).

Answer 5

Après avoir lu votre précision, la réponse de @Ates Goral fournit comment effectuer la même opération que vous faites en C# en JavaScript.

La réponse de @Gumbo fournit la meilleure façon de vérifier l'existence de null ; cependant, il est important de noter la différence entre == contre === en JavaScript notamment lorsqu'il s'agit de vérifier si undefined et/ou null .

Il y a un très bon article sur la différence entre les deux termes. aquí . En gros, comprenez que si vous utilisez == au lieu de === JavaScript essaiera de regrouper les valeurs que vous comparez et renverra le résultat de la comparaison. après cette coalescence.