So che posso testare una variabile javascript e quindi definirla se non è definita, ma non c'è modo di dire

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

sembra un modo molto più chiaro e sono abbastanza sicuro di averlo visto in altre lingue.

Sì, può farlo, ma a rigor di termini che assegnerà il valore predefinito se il valore recuperato è falso , al contrario di veramente indefinito . Sarebbe quindi non solo corrispondere undefined, ma anche null, false, 0, NaN, "" (ma non è "0" ).

Se si desidera impostare il valore predefinito solo se la variabile è rigorosamente, undefinedil modo più sicuro è scrivere:

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

Sui browser più recenti è effettivamente sicuro scrivere:

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

ma tieni presente che è possibile sovvertirlo nei browser più vecchi in cui era consentito dichiarare una variabile denominata undefinedche ha un valore definito, causando il fallimento del test.

La risposta ES6 2018 è :

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

Se la variabile x non è definita, restituisce la variabile y ... altrimenti, se viene definita la variabile x, restituisce la variabile x.

Avevo bisogno di "impostare una variabile se non definita" in diversi punti. Ho creato una funzione usando la risposta @Alnitak. Spero che aiuti qualcuno.

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

Uso:

hasPoints = setDefaultVal(this.hasPoints, true);

Sembra più logico controllare typeofinvece di undefined? Presumo che ti aspetti un numero quando imposti il ​​var su 0quando non definito:

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

In questo caso, se getVariablenon è un numero (stringa, oggetto, qualunque cosa), setVariable è impostato su0

Risposta ES2020

Con l' operatore Nullish Coalescing , è possibile impostare un valore predefinito se valueè nullo o non definito.

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

Tuttavia, è necessario tenere presente che l'operatore di coalescenza nullish non restituisce il valore predefinito per altri tipi di valori falsi come 0e ''.

Si noti che il supporto del browser per l'operatore è limitato. Secondo i dati di caniuse , solo il 48,34% dei browser è supportato (ad aprile 2020). Il supporto Node.js è stato aggiunto nella versione 14 .

Se sei un fan di FP ( programmazione funzionale ), Ramda ha una funzione di aiuto ordinata per questo chiamato defaultTo :

utilizzo:

const result = defaultTo(30)(value)

È più utile quando si hanno a che fare con undefinedvalori booleani:

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

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

Sono andato in questo scenario anche oggi, dove non volevo che zero venisse sovrascritto per diversi valori. Abbiamo un file con alcuni metodi di utilità comuni per scenari come questo. Ecco cosa ho aggiunto per gestire lo scenario ed essere flessibile.

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

Può quindi essere chiamato con gli ultimi due parametri che sono facoltativi se voglio impostare solo per valori non definiti o anche sovrascrivere valori null o 0. Ecco un esempio di una chiamata che imposta l'ID su -1 se l'ID è indefinito o nullo, ma non sovrascriverà un valore 0.

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

Ai nostri giorni puoi effettivamente fare il tuo approccio con JS:

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

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

console.log(x); // default value

Quindi il tuo esempio funzionerà:

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

Funziona anche se il valore predefinito è un valore booleano:

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

Mi sembra che per le attuali implementazioni javascript,

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

è un bel modo per farlo (usando la decostruzione degli oggetti).

Assegnazione nullo logica, soluzione ES2020 +

I nuovi operatori sono attualmente in fase aggiunti ai browser, ??=, ||=, e &&=. Questo post si concentrerà su ??=.

Controlla se il lato sinistro è indefinito o nullo, corto circuito se già definito. In caso contrario, il lato destro è assegnato alla variabile del lato sinistro.

Metodi di confronto

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

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

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

Esempi di base

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

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

// Equivalent to
a = a ?? true

Esempi di oggetti / array

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

?? = Supporto browser luglio 2020 - .03%

?? = Documentazione di Mozilla

|| = Documentazione Mozilla

&& = Documentazione Mozilla