Esiste un & # 8220; null coalescenza & # 8221; operatore in JavaScript?

Question

Esiste un operatore null coalescente in Javascript?

Ad esempio, in C #, posso farlo:

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

La migliore approssimazione che riesco a capire per Javascript sta usando l'operatore condizionale:

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

Che è una specie di imho malizioso. Posso fare di meglio?

Answer 1

L'equivalente JavaScript dell'operatore di coalescenza null C # ( ?? ) utilizza un OR logico ( || ):

var whatIWant = someString || "Cookies!";

Esistono casi (chiariti di seguito) in cui il comportamento non corrisponde a quello di C #, ma questo è il modo generale e conciso di assegnare valori predefiniti / alternativi in ??JavaScript.

---

Chiarimento

Indipendentemente dal tipo di primo operando, se il cast su un valore booleano risulta in false , l'assegnazione utilizzerà il secondo operando. Fai attenzione a tutti i casi seguenti:

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

Ciò significa:

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

questa soluzione funziona come la funzione di coalescenza SQL, accetta un numero qualsiasi di argomenti e restituisce null se nessuno di essi ha un valore. Si comporta come il C # ?? operatore nel senso che " " ;, false e 0 sono considerati NOT NULL e quindi contano come valori effettivi. Se vieni da uno sfondo .net, questa sarà la soluzione di sentimento più naturale.

Answer 3

Se || in sostituzione del ?? di C # non è abbastanza buono nel tuo caso, perché ingoia stringhe e zeri vuoti, puoi sempre scrivere il tuo funzione:

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

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

Answer 4

Sì, arriverà presto. Vedi proposta qui e stato di implementazione qui .

Sembra così:

x ?? y

Esempio

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

Nessuno ha menzionato qui il potenziale per NaN , che - per me - è anche un valore nullo. Quindi, ho pensato di aggiungere i miei due centesimi.

Per il codice dato:

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

Se dovessi usare l'operatore || , otterrai il primo valore non falso:

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

Se usi il tipico metodo di coalescenza, come pubblicato qui , otterrai c , che ha il valore: NaN

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

Nessuno dei due mi sembra giusto. Nel mio piccolo mondo di logica di coesione, che può differire dal tuo mondo, considero indefiniti, nulli e NaN come tutti "null-ish". Quindi, mi aspetterei di recuperare d (zero) dal metodo di coalescenza.

Se il cervello di qualcuno funziona come il mio e si desidera escludere NaN , questo metodo comporterà che:

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

Per coloro che desiderano che il codice sia il più breve possibile e non dispiaccia un po 'di chiarezza, puoi anche usarlo come suggerito da @impinball. Questo sfrutta il fatto che NaN non è mai uguale a NaN. Puoi saperne di più qui: Perché NaN non è uguale a 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

Attualmente nessun supporto, ma il processo di standardizzazione JS ci sta lavorando: https: // github .com / TC39 / proposta-optional-chaining

Answer 7

attenzione alla definizione specifica di JavaScript di null. ci sono due definizioni per "nessun valore" in javascript. 1. Null: quando una variabile è nulla, significa che non contiene dati al suo interno, ma la variabile è già definita nel codice. in questo modo:

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

in tal caso, il tipo di variabile è in realtà Oggetto. testalo.

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

2. Non definito: quando una variabile non è stata definita in precedenza nel codice e, come previsto, non contiene alcun valore. in questo modo:

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

in tal caso, il tipo di variabile è "non definito".

si noti che se si utilizza l'operatore di confronto per la conversione dei tipi (==), JavaScript agirà allo stesso modo per entrambi questi valori vuoti. per distinguerli, utilizzare sempre l'operatore di confronto di tipo rigoroso (===).

Answer 8

Dopo aver letto il tuo chiarimento, la risposta di @Ates Goral fornisce come eseguire la stessa operazione che stai facendo in C # in JavaScript.

La risposta di @ Gumbo fornisce il modo migliore per verificare la presenza di null; tuttavia, è importante notare la differenza tra == rispetto a === in JavaScript specialmente quando si tratta di problemi di controllo di non definito e / o null .

C'è davvero un buon articolo sulla differenza in due termini qui . Fondamentalmente, capisci che se usi == invece di === , JavaScript proverà a fondere i valori che stai confrontando e restituirà quale sia il risultato del confronto dopo questa coalescenza.

Answer 9

JS sta ottenendo un operatore a coalescenza nulla ora! Attualmente nella fase 3 passare alla fase 4, yay! https://github.com/tc39/proposal-nullish-coalescing

esempio nella proposta:

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