web-dev-qa-db-fra.com

Existe-t-il un opérateur "coalescent nul" en JavaScript?

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 comprendre pour Javascript utilise l'opérateur conditionnel:

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

Quel est le sorta Ivo IMick. Puis-je faire mieux?

javascriptoperatorsnull-coalescing-operatornull-coalescing
1232
Daniel Schaffer

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

var whatIWant = someString || "Cookies!";

Il existe des cas (expliqués ci-dessous) selon lesquels le comportement ne correspondra pas à celui de C #, mais il s’agit de la façon générale et concise d’attribuer des valeurs par défaut/alternatives en JavaScript.

Clarification

Quel que soit le type du premier opérande, si le transtypage en booléen a pour résultat 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"
1925
Ates Goral
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 la valeur null si aucun d’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 NON NOT et sont donc considérés comme des valeurs réelles. Si vous venez d'un fond .net, ce sera la solution la plus naturelle.

69
Brent Larsen

Si || en remplacement du ?? de C # 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!');
43
sth

Oui, ça vient 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
31
vaughan

Personne n'a mentionné ici le potentiel de NaN, qui - pour moi - est également une valeur nulle. Alors, j'ai pensé ajouter mes deux centimes.

Pour le code donné:

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

Si vous utilisiez l'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 typique de coalesce, telle que publiée ici , vous obtiendrez c, qui a pour valeur: NaN

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

Ni l'un ni l'autre ne me semble correct. Dans mon propre petit monde de logique de cohésion, qui peut différer de votre monde, je considère non défini, nul et NaN comme étant tous "nuls-ish". Donc, je m'attendrais à récupérer d (zéro) à partir de la méthode de coalesce.

Si le cerveau de quelqu'un fonctionne comme le mien et que vous voulez exclure NaN, alors cette méthode accomplira 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 un code aussi court que possible et qui ne craignent pas un petit manque de clarté, vous pouvez également l'utiliser comme suggéré par @impinball. Cela tire parti du fait que NaN n'est jamais égal à NaN. Vous pouvez en lire plus ici: Pourquoi NaN n’est-il 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;
}
12
Kevin Nelson

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

7
Elmar Jansen

méfiez-vous de la définition de JavaScript spécifique à JavaScript. il y a deux définitions pour "aucune valeur" en javascript. 1. Null: lorsqu'une variable est null, 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 réellement Object. Essaye-le.

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

  1. Non défini: lorsqu'une variable n'a pas encore été définie 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 de manière égale pour ces deux valeurs vides. pour les distinguer, utilisez toujours l'opérateur de comparaison type-strict (===).

4
farzad

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

La réponse de @ Gumbo constitue le meilleur moyen de vérifier la valeur null; Cependant, il est important de noter la différence entre == et === en JavaScript , en particulier en ce qui concerne la vérification de undefined et/ou null.

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

3
Tom

JS devient un opérateur de coalescence nul maintenant! Actuellement à la troisième étape et à la quatrième étape, oui! https://github.com/tc39/proposal-nullish-coalescing

exemple dans la proposition:

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
0
Jacob