Existe-t-il une & # 8220; fusion nulle & # 8221; opérateur en JavaScript?

Question

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

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

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!';

Qui est un peu imbécile à mon humble avis. Puis-je faire mieux?

Answer 1

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

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 convertir en un booléen entraîne false , l'affectation utilisera 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 coalesce SQL, elle accepte un nombre quelconque d’arguments et renvoie 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 NON NULL 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.

Answer 3

Si || remplace le ?? de C # dans votre cas, car il engloutit les chaînes vides et les zéros, vous pouvez toujours écrire vos propres fonction:

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

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

Answer 4

Oui, ça vient bientôt. Consultez la proposition ici et état de la 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

Answer 5

Personne n'a mentionné ici le potentiel de NaN , qui - pour moi - est également une valeur null-ish. 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 deviez utiliser 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 de fusion typique, telle que publiée ici , vous obtiendrez c . , qui a la valeur: NaN

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

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

Si le cerveau de quelqu'un fonctionne comme le mien et que vous souhaitez exclure NaN , cette méthode remplit cette fonction:

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 à ce sujet 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;
}

Answer 6

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

Answer 7

Méfiez-vous de la définition spécifique à JavaScript de null. il existe 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 ceci:

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

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

2. 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 ceci:

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

Si tel est le cas, le type de votre variable est "non dé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 (===).

Answer 8

Après avoir lu votre clarification, la réponse de @Ates Goral explique 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 existe un très bon article sur la différence entre les deux termes ici . En gros, 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.

Answer 9

JS devient un opérateur de coalescence nul maintenant! Actuellement en 3ème étape passant à la 4ème étape, yay! 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