Question Existe-t-il un opérateur de "coalescence nulle" en JavaScript?


Y a-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 peux comprendre pour Javascript est l'utilisation de l'opérateur conditionnel:

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

Ce qui est sorta icky à mon humble avis. Puis-je faire mieux?


968
2018-01-24 18:18


origine


Réponses:


L'équivalent JavaScript de l'opérateur de coalescence C # null (??) utilise un OR logique (||):

var whatIWant = someString || "Cookies!";

Il y a des cas (clarifiés ci-dessous) que le comportement ne correspondra pas à celui de C #, mais c'est la manière générale et concise d'assigner des valeurs par défaut / alternatives en JavaScript.


Clarification

Quel que soit le type du premier opérande, si le convertir en un résultat booléen false, l'affectation utilisera le deuxième opérande. Méfiez-vous de 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! :)

Ça 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"

1565
2018-01-24 18:25



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 coalesce SQL, elle accepte n'importe quel nombre d'arguments et renvoie null si aucun d'entre eux n'a de valeur. Il se comporte comme le C # ?? opérateur dans le sens où "", false et 0 sont considérés comme NOT NULL et par conséquent comptent comme des valeurs réelles. Si vous venez d'un arrière-plan .net, ce sera la solution de sentiment le plus naturel.


56
2018-03-08 05:24



Si || en remplacement de C # 's ?? n'est pas assez bon dans votre cas, car il avale des chaînes vides et des 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!');

38
2018-01-24 18:45



Personne n'a mentionné ici le potentiel de NaN, qui - pour moi - est aussi une valeur nulle. Donc, je pensais ajouter mes deux cents.

Pour le code donné:

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

Si vous deviez utiliser le || opérateur, vous obtenez la première valeur non-fausse:

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

Si vous utilisez la méthode de coalescence typique, comme posté ici, tu auras c, qui a la valeur: NaN

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

Ni de ceux-ci me semblent juste. Dans mon propre petit monde de logique de coalescence, qui peut différer de votre monde, je considère indéfini, nul et NaN comme étant tous "null-ish". Donc, je m'attendrais à revenir d (zéro) de la méthode coalesce.

Si le cerveau de quelqu'un fonctionne comme le mien, et que vous voulez exclure NaN, alors cette méthode va accomplir cela:

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;
}

Pour ceux qui veulent le code le plus court possible, et qui ne dérange pas un peu de clarté, vous pouvez aussi utiliser ceci comme suggéré par @impinball. Cela profite du fait que NaN n'est jamais égal à NaN. Vous pouvez en lire plus à ce sujet ici: Pourquoi NaN n'est pas égal à 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;
}

10
2018-05-26 21:07



Actuellement pas de support, mais le processus de standardisation JS y travaille: https://github.com/tc39/proposal-optional-chaining


6
2017-07-16 21:17



Oui, il arrive bientôt. Voir proposition ici et statut de mise en œuvre ici.

Cela ressemble à ceci:

x ?? y

Exemple

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

5
2018-05-07 09:32



méfiez-vous de la définition spécifique de JavaScript de null. il y a deux définitions pour "pas de valeur" en javascript. 1. Null: lorsqu'une variable est nulle, cela signifie qu'elle ne contient aucune donnée, mais que la variable est déjà définie dans le code. comme ça:

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. Essaye-le.

window.alert(typeof myEmptyValue); // prints Object
  1. Undefined: lorsqu'une variable n'a pas été définie auparavant dans le code et comme prévu, elle ne contient aucune valeur. comme ça:

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

si tel est le cas, le type de votre variable est 'indéfini'.

Notez que si vous utilisez l'opérateur de comparaison de conversion de type (==), JavaScript agira également pour ces deux valeurs vides. pour les distinguer, utilisez toujours l'opérateur de comparaison type-strict (===).


4
2018-01-24 18:35



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

La réponse de @ Gumbo fournit le meilleur moyen de vérifier null; Cependant, il est important de noter la différence == contre === en JavaScript notamment quand il s'agit de questions de vérification undefined et / ou null.

Il y a un très bon article sur la différence en deux termes ici. Fondamentalement, comprendre que si vous utilisez == au lieu de ===, JavaScript va essayer de fusionner les valeurs que vous comparez et de retourner quel est le résultat de la comparaison après cette coalescence.


3
2018-01-24 18:23