Je sais que je peux tester une variable javascript, puis la définir si elle n'est pas définie, mais n'y a-t-il pas moyen de dire
var setVariable = localStorage.getItem ('value') || 0;
semble être un moyen beaucoup plus clair, et je suis presque sûr d’avoir vu cela dans d’autres langues.
Oui, il peut le faire, mais à proprement parler, cela assignera la valeur par défaut si la valeur récupérée est falsey, par opposition à vraiment undefined. Cela correspondrait donc non seulement à undefined
mais aussi à null
, false
, 0
, NaN
, ""
(mais pas"0"
).
Si vous souhaitez définir la valeur par défaut uniquement si la variable est strictement undefined
, le moyen le plus sûr consiste à écrire:
var x = (typeof x === 'undefined') ? def_val : x;
Sur les nouveaux navigateurs, vous pouvez écrire en toute sécurité:
var x = (x === undefined) ? def_val : x;
mais sachez qu'il est possible de subvertir cela sur des navigateurs plus anciens où il était autorisé à déclarer une variable nommée undefined
qui a une valeur définie, ce qui entraîne l'échec du test.
La réponse ES6 2018 est :
return Object.is(x, undefined) ? y : x;
Si la variable x n'est pas définie, retourne la variable y ... sinon, si la variable x est définie, renvoie la variable x.
Je devais "définir une variable si non définie" à plusieurs endroits. J'ai créé une fonction en utilisant la réponse @Alnitak. Espérons que cela aide quelqu'un.
function setDefaultVal(value, defaultValue){
return (value === undefined) ? defaultValue : value;
}
Usage:
hasPoints = setDefaultVal(this.hasPoints, true);
Il semble plus logique de vérifier typeof
au lieu de undefined
? Je suppose que vous attendez un nombre lorsque vous définissez la variable var à 0
sans définition:
var getVariable = localStorage.getItem('value');
var setVariable = (typeof getVariable == 'number') ? getVariable : 0;
Dans ce cas si getVariable
n'est pas un nombre (chaîne, objet, peu importe), setVariable est défini sur 0
var setVariable = (typeof localStorage.getItem('value') !== 'undefined' && localStorage.getItem('value')) || 0;
Couru dans ce scénario aujourd'hui aussi où je ne voulais pas que zéro soit écrasé pour plusieurs valeurs. Nous avons un fichier avec des méthodes utilitaires communes pour des scénarios comme celui-ci. Voici ce que j'ai ajouté pour gérer le scénario et faire preuve de souplesse.
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;
}
}
Il peut ensuite être appelé, les deux derniers paramètres étant facultatifs si je souhaite uniquement définir des valeurs indéfinies ou également remplacer des valeurs nulles ou nulles. Voici un exemple d'appel qui définira l'ID sur -1 si l'ID est indéfini ou nul, mais n'écrasera pas une valeur 0.
data.ID = Util.getIfNotSet(data.ID, -1, true);
Il me semble que pour les implémentations javascript actuelles,
var [result='default']=[possiblyUndefinedValue]
est une bonne façon de faire cela (en utilisant la déconstruction d’objets).
Fonctionne même si la valeur par défaut est une valeur booléenne:
var setVariable = ( (b = 0) => b )( localStorage.getItem('value') );