Sé que puedo probar una variable de JavaScript y luego definirla si no está definida, pero ¿no hay alguna forma de decirlo?

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

Parece una forma mucho más clara, y estoy bastante seguro de que he visto esto en otros idiomas.

Sí, puede hacer eso, pero estrictamente hablando, asignará el valor predeterminado si el valor recuperado es falsey , en lugar de verdaderamente indefinido . Sería, por tanto, no sólo igualar undefined, sino también null, false, 0, NaN, "" (pero no "0" ).

Si desea establecer el valor predeterminado solo si la variable es estrictamente, undefinedentonces la forma más segura es escribir:

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

En los navegadores más nuevos, en realidad es seguro escribir:

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

pero tenga en cuenta que es posible subvertir esto en navegadores antiguos donde se le permitió declarar una variable llamada undefinedque tiene un valor definido, lo que hace que la prueba falle.

La respuesta ES6 2018 es :

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

Si la variable x no está definida, devuelva la variable y ... de lo contrario, si la variable x está definida, devuelva la variable x.

Necesitaba "establecer una variable si no estaba definida" en varios lugares. Creé una función usando la respuesta @Alnitak. Esperemos que ayude a alguien.

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

Uso:

hasPoints = setDefaultVal(this.hasPoints, true);

Parece más lógico verificar en typeoflugar de undefined? Supongo que espera un número cuando establece la var 0cuando no está definido:

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

En este caso, si getVariableno es un número (cadena, objeto, lo que sea), setVariable se establece en0

Respuesta de ES2020

Con el Operador de fusión nula , puede establecer un valor predeterminado si valuees nulo o no está definido.

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

Sin embargo, debe tener en cuenta que el operador de fusión nulo no devuelve el valor predeterminado para otros tipos de valores falsos como 0y ''.

Tenga en cuenta que el soporte del navegador para el operador es limitado. Según los datos de caniuse , solo el 48.34% de los navegadores son compatibles (a partir de abril de 2020). El soporte de Node.js se agregó en la versión 14 .

Si eres un fan de FP ( programación funcional ), Ramda tiene una función de ayuda ordenada para esto llamada defaultTo :

uso:

const result = defaultTo(30)(value)

Es más útil cuando se trata de undefinedvalores booleanos:

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

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

Hoy también me encontré con este escenario donde no quería que se sobrescribiera cero para varios valores. Tenemos un archivo con algunos métodos de utilidad comunes para escenarios como este. Esto es lo que agregué para manejar el escenario y ser flexible.

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

Luego se puede invocar con los dos últimos parámetros como opcionales si solo quiero establecer valores indefinidos o también sobrescribir valores nulos o 0. Aquí hay un ejemplo de una llamada que establecerá la ID en -1 si la ID no está definida o es nula, pero no sobrescribirá un valor 0.

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

En nuestros días puedes hacer tu acercamiento 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

Entonces su ejemplo FUNCIONARÁ:

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

Funciona incluso si el valor predeterminado es un valor booleano:

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

Me parece que, para las implementaciones actuales de JavaScript,

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

es una buena manera de hacer esto (usando la deconstrucción de objetos).

Asignación nula lógica, solución ES2020 +

Los nuevos operadores se están agregando actualmente a los navegadores, ??=, ||=, y &&=. Esta publicación se centrará en??= .

Esto verifica si el lado izquierdo no está definido o es nulo, cortocircuitando si ya está definido. Si no, el lado derecho se asigna a la variable del lado izquierdo.

Métodos comparativos

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

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

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

Ejemplos 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

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

?? = Soporte del navegador Julio 2020 - .03%

?? = Documentación de Mozilla

|| = Documentación de Mozilla

&& = Documentación de Mozilla