Gibt es eine „Null-Koaleszenz“ Operator in JavaScript?

Question

Gibt es einen Null-Koaleszenz-Operator in Javascript?

Zum Beispiel in C #, ich kann dies tun:

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

Die beste Annäherung ich für Javascript ausrechnen kann, wird mit dem Bedingungsoperator:

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

Welche ist sorta Icky IMHO. Kann ich besser machen?

Answer 1

Das JavaScript Äquivalent der C # null koaleszierenden Operator (??) wird mit einem logischen OR (||):

var whatIWant = someString || "Cookies!";

Es gibt Fälle (geklärte unten), dass das Verhalten, das nicht von C # übereinstimmen, aber dies ist die allgemeine, prägnanten Art und Weise default / alternative Werte in JavaScript zuzuweisen.

---

Klarstellung

Unabhängig von der Art des ersten Operanden, wenn es zu einem Booleschen Ergebnisse in false Gießen wird die Zuordnung des zweiten Operanden verwenden. Hüten Sie sich vor allen Fällen unter:

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

Das bedeutet:

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

Diese Lösung funktioniert wie die SQL coalesce Funktion übernimmt es eine beliebige Anzahl von Argumenten und gibt null zurück, wenn keiner von ihnen einen Wert hat. Es verhält sich wie der C # ?? Operator in dem Sinne, dass „“, false und 0 NOT NULL betrachtet und daher als Ist-Werte zählen. Wenn Sie von einem .net Hintergrund kommen, wird dies die natürlichste Gefühl Lösung sein.

Answer 3

Wenn || als Ersatz von C # 's ?? ist nicht gut genug, um in Ihrem Fall, weil es leere Strings und Nullen schluckt, können Sie immer Ihre eigene Funktion schreiben:

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

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

Answer 4

Ja, es kommt bald. Siehe Vorschlag hier und Umsetzungsstatus hier .

Es sieht wie folgt aus:

x ?? y

Beispiel

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

Niemand hat hier das Potenzial für NaN genannt, die - für mich - ist auch ein Null-ish Wert. Also, ich dachte, ich würde meine zwei Cent hinzufügen.

Für den gegebenen Code:

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

Wenn Sie den || Operator verwenden sind, können Sie den ersten nicht-Falsch-Wert erhalten:

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

Wenn Sie die typische coalesce Methode verwenden, wie hier geschrieben, werden Sie c erhalten, die den Wert hat: NaN

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

Weder von ihnen scheinen mir richtig. In meiner eigenen kleinen Welt von coalesce Logik, die von Ihrer Welt unterscheiden kann, halte ich nicht definiert, null, und NaN als alles Sein „Null-ish“. Also, ich würde erwarten, d (Null) aus der coalesce Methode zurück zu erhalten.

Wenn jemand das Gehirn wie mir arbeitet, und Sie wollen NaN ausschließen, dann wird diese Methode erreichen, dass:

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

Für diejenigen, die den Code so kurz wie möglich wollen, und nicht ein wenig Mangel an Klarheit nichts, können Sie auch diese verwenden, wie von @impinball vorgeschlagen. Dies nutzt die Tatsache, dass NaN ist nie gleich NaN. Sie können bis mehr dazu lesen Sie hier: Warum ist NaN ungleich 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

Zur Zeit keine Unterstützung, aber der JS-Standardisierungsprozess arbeitet daran: https: // Github .com / tc39 / Vorschlag-optional Verkettungs

Answer 7

Achtung, der JavaScript spezifischen Definition von null. gibt es zwei Definitionen für „keinen Wert“ in Javascript. 1. Null: wenn eine Variable null ist, bedeutet es keine Daten enthält, aber die Variable ist bereits in den Code definiert. wie folgt aus:

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

in einem solchen Fall die Art Ihrer Variable Objekt tatsächlich. testen Sie es.

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

2. Nicht definiert: wenn eine Variable wurde im Code nicht definiert vor, und wie erwartet, macht es keinen Wert enthalten. wie folgt aus:

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

wenn ein solcher Fall ist die Art Ihrer Variable 'undefined'.

Beachten Sie, dass, wenn Sie den Typ-Converting-Vergleichsoperator (==) verwenden, wird JavaScript gleichermaßen wirken für diese beiden leeren Werte. zwischen ihnen zu unterscheiden, immer den Typ-strengen Vergleichsoperator (===).

Answer 8

Nach der Klärung Lesen, @Ates Goral Antwort liefert, wie die gleiche Operation auszuführen Sie in C # in JavaScript tun.

@ Gumbo Antwort liefert die beste Art und Weise für null zu überprüfen; jedoch ist es wichtig, den Unterschied in == gegen === in JavaScript insbesondere zu beachten, wenn es um Fragen der Kontrolle für undefined und / oder null.

Es ist ein wirklich guter Artikel über den Unterschied in zwei Begriffen hier . Grundsätzlich verstehen, dass, wenn Sie == statt === verwenden, wird JavaScript versuchen, die Werte zu vereinigen Sie vergleichen und zurück, was das Ergebnis des Vergleichs nach diese Verschmelzung.

Answer 9

JS bekommt jetzt einen Null-Koaleszenz-Operator! Derzeit in der Stufe-3-Umzug in der Stufe 4, yay! https://github.com/tc39/proposal-nullish-coalescing

Beispiel in Vorschlag:

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