Eu sei que posso testar uma variável javascript e defini-la se for indefinida, mas não há como dizer

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

parece uma maneira muito mais clara e tenho certeza de que já vi isso em outros idiomas.

Sim, ele pode fazer isso, mas estritamente falando, isso atribuirá o valor padrão se o valor recuperado for falsey , ao contrário de verdadeiramente indefinido . Seria, portanto, não só igualar undefined, mas também null, false, 0, NaN, "" (mas não "0" ).

Se você deseja definir o padrão apenas se a variável for estritamente undefined, a maneira mais segura é escrever:

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

Em navegadores mais recentes, é realmente seguro escrever:

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

mas lembre-se de que é possível subvertê-lo em navegadores mais antigos, nos quais foi permitido declarar uma variável denominada undefinedcom um valor definido, causando falha no teste.

A resposta do ES6 2018 é :

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

Se a variável x não estiver definida, retorne a variável y ... caso contrário, se a variável x estiver definida, retorne a variável x.

Eu precisava "definir uma variável se indefinida" em vários lugares. Criei uma função usando a resposta @Alnitak. Espero que ajude alguém.

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

Uso:

hasPoints = setDefaultVal(this.hasPoints, true);

Parece mais lógico verificar em typeofvez de undefined? Suponho que você espere um número ao definir o var 0quando indefinido:

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

Nesse caso, se getVariablenão for um número (string, objeto, qualquer que seja), setVariable será definido como0

ES2020 Resposta

Com o Operador de coalizão nulo , você pode definir um valor padrão se valuefor nulo ou indefinido.

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

No entanto, você deve estar ciente de que o operador coalescente nulo não retorna o valor padrão para outros tipos de valor falso, como 0e ''.

Observe que o suporte do navegador para o operador é limitado. De acordo com os dados da caniuse , apenas 48,34% dos navegadores são suportados (a partir de abril de 2020). O suporte ao Node.js foi adicionado na versão 14 .

Se você é um fã de FP ( programação funcional ), o Ramda possui uma função auxiliar pura para isso chamada defaultTo :

uso:

const result = defaultTo(30)(value)

É mais útil ao lidar com undefinedvalores booleanos:

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

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

Também deparei com esse cenário hoje, onde eu não queria que zero fosse substituído por vários valores. Temos um arquivo com alguns métodos utilitários comuns para cenários como este. Aqui está o que eu adicionei para lidar com o cenário e ser flexível.

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

Em seguida, ele pode ser chamado com os dois últimos parâmetros sendo opcionais se eu desejar definir apenas valores indefinidos ou também substituir valores nulos ou 0. Aqui está um exemplo de uma chamada para ele que definirá o ID para -1 se o ID for indefinido ou nulo, mas não substituirá um valor 0.

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

Nos nossos dias, você realmente pode fazer sua abordagem com o JS:

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

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

console.log(x); // default value

Portanto, seu exemplo funcionará:

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

Funciona mesmo que o valor padrão seja um valor booleano:

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

Parece-me que, para implementações atuais de javascript,

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

é uma boa maneira de fazer isso (usando a desconstrução de objetos).

Designação nula lógica, solução ES2020 +

Novos operadores estão sendo adicionados aos navegadores, ??=, ||=, e &&=. Esta postagem será focada ??=.

Isso verifica se o lado esquerdo está indefinido ou nulo, em curto-circuito, se já definido. Caso contrário, o lado direito é atribuído à variável do lado esquerdo.

Métodos de comparação

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

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

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

Exemplos básicos

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

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

// Equivalent to
a = a ?? true

Exemplos de objeto / matriz

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

?? = Suporte do navegador julho de 2020 - 0,03%

?? = Documentação Mozilla

|| = Documentação Mozilla

&& = Documentação Mozilla