Ich weiß, dass ich auf eine Javascript-Variable testen und sie dann definieren kann, wenn sie nicht definiert ist, aber es gibt keine Möglichkeit zu sagen

var setVariable = localStorage.getItem ('Wert') || 0;

scheint ein viel klarerer Weg zu sein, und ich bin mir ziemlich sicher, dass ich das in anderen Sprachen gesehen habe.

Ja, das kann es, aber genau genommen wird der Standardwert zugewiesen , wenn der abgerufene Wert falsch ist , im Gegensatz zu wirklich undefiniert . Es wäre daher nicht nur entsprechen , undefinedsondern auch null, false, 0, NaN, "" (aber nicht "0" ).

Wenn Sie nur dann die Standardeinstellung festlegen möchten, wenn die Variable streng undefinedist, schreiben Sie am sichersten:

var x = (typeof x === 'undefined') ? your_default_value : x;

In neueren Browsern ist es tatsächlich sicher zu schreiben:

var x = (x === undefined) ? your_default_value : x;

Beachten Sie jedoch, dass dies in älteren Browsern möglich ist, in denen eine Variable undefinedmit einem definierten Wert deklariert werden durfte, wodurch der Test fehlschlug.

Die ES6-Antwort für 2018 lautet :

return Object.is(x, undefined) ? y : x;

Wenn die Variable x undefiniert ist, geben Sie die Variable y zurück. Wenn die Variable x definiert ist, geben Sie die Variable x zurück.

Ich musste an mehreren Stellen "eine Variable setzen, wenn sie nicht definiert ist". Ich habe eine Funktion mit der Antwort von @Alnitak erstellt. Hoffentlich hilft es jemandem.

function setDefaultVal(value, defaultValue){
   return (value === undefined) ? defaultValue : value;
}  

Verwendung:

hasPoints = setDefaultVal(this.hasPoints, true);

Es scheint logischer zu überprüfen, typeofanstatt undefined? Ich gehe davon aus, dass Sie eine Zahl erwarten, 0wenn Sie die Variable auf undefiniert setzen:

var getVariable = localStorage.getItem('value');
var setVariable = (typeof getVariable == 'number') ? getVariable : 0;

In diesem Fall getVariablewird setVariable auf gesetzt, wenn es sich nicht um eine Zahl (Zeichenfolge, Objekt, was auch immer) handelt0

ES2020 Antwort

Mit dem Nullish Coalescing Operator können Sie einen Standardwert festlegen , wenn dieser valuenull oder undefiniert ist.

const setVariable = localStorage.getItem('value') ?? 0;

Beachten Sie jedoch, dass der nullish coalescing-Operator den Standardwert für andere Arten von Falschwerten wie 0und nicht zurückgibt ''.

Beachten Sie, dass die Browserunterstützung für den Bediener begrenzt ist. Nach Angaben von caniuse werden nur 48,34% der Browser unterstützt (Stand April 2020). Die Unterstützung von Node.j wurde in Version 14 hinzugefügt .

Wenn Sie ein FP- Fan ( Functional Programming ) sind, hat Ramda eine nette Hilfsfunktion für diese Funktion namens defaultTo :

Verwendung:

const result = defaultTo(30)(value)

Es ist nützlicher, wenn es um undefinedboolesche Werte geht:

const result2 = defaultTo(false)(dashboard.someValue)

var setVariable = (typeof localStorage.getItem('value') !== 'undefined' && localStorage.getItem('value')) || 0;

Ich bin auch heute auf dieses Szenario gestoßen, in dem ich nicht wollte, dass Null für mehrere Werte überschrieben wird. Wir haben eine Datei mit einigen gängigen Dienstprogrammmethoden für solche Szenarien. Folgendes habe ich hinzugefügt, um das Szenario zu handhaben und flexibel zu sein.

function getIfNotSet(value, newValue, overwriteNull, overwriteZero) {
    if (typeof (value) === 'undefined') {
        return newValue;
    } else if (value === null && overwriteNull === true) {
        return newValue;
    } else if (value === 0 && overwriteZero === true) {
        return newValue;
    } else {
        return value;
    }
}

Es kann dann aufgerufen werden, wobei die letzten beiden Parameter optional sind, wenn ich nur undefinierte Werte festlegen oder auch Null- oder 0-Werte überschreiben möchte. Hier ist ein Beispiel für einen Aufruf, bei dem die ID auf -1 gesetzt wird, wenn die ID undefiniert oder null ist, ein 0-Wert jedoch nicht überschrieben wird.

data.ID = Util.getIfNotSet(data.ID, -1, true);

In unseren Tagen können Sie Ihren Ansatz tatsächlich mit JS machen:

// Your variable is null
// or '', 0, false, undefined
let x = null;

// Set default value
x = x || 'default value';

console.log(x); // default value

Ihr Beispiel wird also funktionieren:

const setVariable = localStorage.getItem('value') || 0;

Funktioniert auch, wenn der Standardwert ein boolescher Wert ist:

var setVariable = ( (b = 0) => b )( localStorage.getItem('value') );

Es scheint mir, dass für aktuelle Javascript-Implementierungen,

var [result='default']=[possiblyUndefinedValue]

ist eine gute Möglichkeit, dies zu tun (mithilfe der Objektdekonstruktion).

Logische Nullzuweisung, ES2020 + -Lösung

Neue Betreiber werden derzeit in den Browsern hinzugefügt werden, ??=, ||=, und &&=. Dieser Beitrag wird sich auf konzentrieren ??=.

Dies prüft, ob die linke Seite undefiniert oder null ist, und schließt kurz, falls bereits definiert. Wenn nicht, wird die rechte Seite der linken Variablen zugewiesen.

Methoden vergleichen

// Using ??=
name ??= "Dave"

// Previously, ES2020
name = name ?? "Dave"

// Before that (not equivalent, but commonly used)
name = name || "Dave" // name ||= "Dave"

Grundlegende Beispiele

let a          // undefined
let b = null
let c = false

a ??= true  // true
b ??= true  // true
c ??= true  // false

// Equivalent to
a = a ?? true

Objekt- / Array-Beispiele

let x = ["foo"]
let y = { foo: "fizz" }

x[0] ??= "bar"  // "foo"
x[1] ??= "bar"  // "bar"

y.foo ??= "buzz"  // "fizz"
y.bar ??= "buzz"  // "buzz"

x  // Array [ "foo", "bar" ]
y  // Object { foo: "fizz", bar: "buzz" }

?? = Browser-Unterstützung Juli 2020 - .03%

?? = Mozilla-Dokumentation

|| = Mozilla-Dokumentation

&& = Mozilla-Dokumentation