Quelle est la meilleure façon de vérifier si une propriété d'objet en JavaScript est undefined
?
Quelle est la meilleure façon de vérifier si une propriété d'objet en JavaScript est undefined
?
Réponses:
La façon habituelle de vérifier si la valeur d'une propriété est la valeur spéciale undefined
est la suivante:
if(o.myProperty === undefined) {
alert("myProperty value is the special value `undefined`");
}
Pour vérifier si un objet ne possède pas réellement une telle propriété, et reviendra donc undefined
par défaut lorsque vous essayez d'y accéder:
if(!o.hasOwnProperty('myProperty')) {
alert("myProperty does not exist");
}
Pour vérifier si la valeur associée à un identifiant est la valeur spéciale undefined
, ou si cet identifiant n'a pas été déclaré. Remarque: cette méthode est la seule façon de se référer à un identifiant non déclaré (note: différent d'avoir une valeur de undefined
) sans erreur précoce:
if(typeof myVariable === 'undefined') {
alert('myVariable is either the special value `undefined`, or it has not been declared');
}
Dans les versions de JavaScript antérieures à ECMAScript 5, la propriété nommée "undefined" sur l'objet global était accessible en écriture, et par conséquent une simple vérification foo === undefined
pouvait se comporter de manière inattendue si elle avait été accidentellement redéfinie. En JavaScript moderne, la propriété est en lecture seule.
Cependant, dans JavaScript moderne, "undefined" n'est pas un mot-clé, et donc les variables à l'intérieur des fonctions peuvent être nommées "undefined" et masquer la propriété globale.
Si vous êtes préoccupé par ce cas de bord (peu probable), vous pouvez utiliser l'opérateur void pour obtenir la undefined
valeur spéciale elle-même:
if(myVariable === void 0) {
alert("myVariable is the special value `undefined`");
}
obj !== undefined
maintenant. undefined
utilisé pour être mutable, comme undefined = 1234
ce qui entraînerait des résultats intéressants. Mais après Ecmascript 5, il n'est plus accessible en écriture, nous pouvons donc utiliser la version plus simple. codereadability.com/how-to-check-for-undefined-in-javascript
Je pense qu'il existe un certain nombre de réponses incorrectes à ce sujet. Contrairement à la croyance courante, "non défini" n'est pas un mot clé en JavaScript et peut en fait avoir une valeur qui lui est affectée.
La façon la plus robuste d'effectuer ce test est:
if (typeof myVar === "undefined")
Cela retournera toujours le résultat correct et gère même la situation où myVar
n'est pas déclaré.
var undefined = false; // Shockingly, this is completely legal!
if (myVar === undefined) {
alert("You have been misled. Run away!");
}
En outre, myVar === undefined
générera une erreur dans la situation où myVar n'est pas déclaré.
=== undefined
déroutant. Oui, vous pouvez l'affecter à undefined
, mais il n'y a aucune raison légitime de le faire et il est prévisible que cela puisse briser votre code. En C, vous pouvez #define true false
, et en Python, vous pouvez attribuer à True
et False
, mais les gens ne ressentent pas le besoin de concevoir leur code dans ces langages de manière à se protéger contre la possibilité de saboter délibérément leur propre environnement ailleurs dans le code . Pourquoi la possibilité d'attribuer à undefined
mérite-t-elle même d'être envisagée ici?
void 0
pour obtenir la valeur qui undefined
pointe vers. Vous pouvez donc le faire if (myVar === void 0)
. le 0
n'est pas spécial, vous pouvez littéralement y mettre n'importe quelle expression.
undefined
. MDN: undefined
Bien qu'il soit vivement recommandé par de nombreuses autres réponses ici, typeof
c'est un mauvais choix . Il ne doit jamais être utilisé pour vérifier si les variables ont la valeur undefined
, car il agit comme une vérification combinée de la valeur undefined
et si une variable existe. Dans la grande majorité des cas, vous savez quand une variable existe, et vous typeof
introduirez simplement le potentiel d'un échec silencieux si vous faites une faute de frappe dans le nom de la variable ou dans le littéral de chaîne 'undefined'
.
var snapshot = …;
if (typeof snaposhot === 'undefined') {
// ^
// misspelled¹ – this will never run, but it won’t throw an error!
}
var foo = …;
if (typeof foo === 'undefned') {
// ^
// misspelled – this will never run, but it won’t throw an error!
}
Donc, à moins que vous ne fassiez de la détection de fonctionnalités², où il y a une incertitude quant à la portée d'un nom donné (comme la vérification en typeof module !== 'undefined'
tant qu'étape de code spécifique à un environnement CommonJS), typeof
est un choix nuisible lorsqu'il est utilisé sur une variable, et l'option correcte est pour comparer directement la valeur:
var foo = …;
if (foo === undefined) {
⋮
}
Voici quelques idées fausses courantes à ce sujet:
que la lecture d'une variable ( var foo
) ou d'un paramètre (non function bar(foo) { … }
appelé bar()
) (non appelé ) échouera. Ce n'est tout simplement pas vrai - les variables sans initialisation explicite et les paramètres qui n'ont pas reçu de valeurs deviennent toujours undefined
, et sont toujours dans la portée.
qui undefined
peut être écrasé. Il y a beaucoup plus à cela. undefined
n'est pas un mot clé en JavaScript. Au lieu de cela, c'est une propriété sur l'objet global avec la valeur Undefined. Cependant, depuis ES5, cette propriété est en lecture seule et non configurable . Aucun navigateur moderne ne permettra de modifier la undefined
propriété, et depuis 2017, cela a été le cas depuis longtemps. Le manque de mode strict n'affecte pas non plus undefined
le comportement de - il fait juste des instructions comme undefined = 5
ne rien faire au lieu de lancer. Comme il ne s'agit pas d'un mot clé, vous pouvez déclarer des variables avec le nom undefined
, et ces variables peuvent être modifiées, ce qui rend ce modèle autrefois commun:
(function (undefined) {
// …
})()
plus dangereux que d'utiliser le global undefined
. Si vous devez être compatible ES3, remplacez-le undefined
par void 0
- ne pas y recourir typeof
. ( void
a toujours été un opérateur unaire qui évalue la valeur non définie pour n'importe quel opérande.)
Avec la façon dont les variables fonctionnent, il est temps de répondre à la question réelle: les propriétés des objets. Il n'y a aucune raison de jamais utiliser typeof
pour les propriétés d'objet. L'exception précédente concernant la détection des fonctionnalités ne s'applique pas ici - typeof
n'a qu'un comportement spécial sur les variables, et les expressions qui font référence aux propriétés des objets ne sont pas des variables.
Cette:
if (typeof foo.bar === 'undefined') {
⋮
}
est toujours exactement équivalent à ceci³:
if (foo.bar === undefined) {
⋮
}
et en tenant compte des conseils ci-dessus, pour éviter de confondre les lecteurs quant à la raison pour laquelle vous utilisez typeof
, car il est plus judicieux d'utiliser ===
pour vérifier l'égalité, car il pourrait être remanié pour vérifier la valeur d'une variable plus tard, et parce qu'il est tout simplement clair semble mieux, vous devriez toujours utiliser === undefined
³ ici aussi .
Une autre chose à considérer en ce qui concerne les propriétés des objets est de savoir si vous voulez vraiment vérifier undefined
. Un nom de propriété donné peut être absent sur un objet (produisant la valeur undefined
lors de la lecture), présent sur l'objet lui-même avec la valeur undefined
, présent sur le prototype de l'objet avec la valeur undefined
, ou présent sur l'un de ceux avec une non- undefined
valeur. 'key' in obj
vous dira si une clé se trouve n'importe où sur la chaîne de prototype d'un objet et Object.prototype.hasOwnProperty.call(obj, 'key')
vous dira si elle se trouve directement sur l'objet. Je n'entrerai pas dans les détails dans cette réponse sur les prototypes et l'utilisation d'objets comme cartes à chaînes de caractères, car cela est principalement destiné à contrer tous les mauvais conseils dans les autres réponses, quelles que soient les interprétations possibles de la question d'origine. Lire surprototypes d'objets sur MDN pour plus!
¹ choix inhabituel d'exemple de nom de variable? c'est du vrai code mort de l'extension NoScript pour Firefox.
² ne présumez pas que ne pas savoir ce qui est dans la portée est bien en général, cependant. vulnérabilité supplémentaire causée par un abus de portée dynamique: Project Zero 1225
³ supposant une fois de plus un environnement ES5 + et qui se undefined
réfère à la undefined
propriété de l'objet global. remplacer void 0
autrement.
undefined
, masquant celui par défaut. Ce qui, à des fins pratiques, a le même effet que de l'écraser.
void 0
pour comparer avec indéfini mais encore une fois - c'est idiot et exagéré.
typeof something === "undefined")
dans le code.
void 0
c'est (pour une fois) à la fois plus court et plus sûr! C'est une victoire dans mon livre.
En JavaScript, il y a null et il n'y a pas de définition . Ils ont des significations différentes.
Marijn Haverbeke déclare, dans son livre en ligne gratuit " Eloquent JavaScript " (c'est moi qui souligne):
Il existe également une valeur similaire, null, dont la signification est «cette valeur est définie, mais elle n'a pas de valeur». La différence de sens entre indéfini et nul est principalement académique et généralement peu intéressante. Dans les programmes pratiques, il est souvent nécessaire de vérifier si quelque chose «a une valeur». Dans ces cas, l'expression quelque chose == undefined peut être utilisée, car, même si elles ne sont pas exactement la même valeur, null == undefined produira true.
Donc, je suppose que la meilleure façon de vérifier si quelque chose n'était pas défini serait:
if (something == undefined)
J'espère que cela t'aides!
Modifier: En réponse à votre modification, les propriétés des objets devraient fonctionner de la même manière.
var person = {
name: "John",
age: 28,
sex: "male"
};
alert(person.name); // "John"
alert(person.fakeVariable); // undefined
undefined
est juste une variable qui peut être réassignée par l'utilisateur: l'écriture undefined = 'a';
fera que votre code ne fera plus ce que vous pensez qu'il fait. L'utilisation typeof
est meilleure et fonctionne également pour les variables (pas seulement les propriétés) qui n'ont pas été déclarées.
Qu'est-ce que cela signifie: "propriété d'objet non définie" ?
En fait, cela peut signifier deux choses bien différentes! Premièrement, cela peut signifier la propriété qui n'a jamais été définie dans l'objet et, deuxièmement, cela peut signifier la propriété qui a une valeur indéfinie . Regardons ce code:
var o = { a: undefined }
Est o.a
indéfini? Oui! Sa valeur n'est pas définie. Est o.b
indéfini? Sûr! Il n'y a aucune propriété «b» du tout! OK, voyez maintenant comment les différentes approches se comportent dans les deux situations:
typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false
Nous pouvons clairement voir cela typeof obj.prop == 'undefined'
etobj.prop === undefined
sont équivalents, et ils ne distinguent pas ces différentes situations. Et 'prop' in obj
peut détecter la situation où une propriété n'a pas été définie du tout et ne fait pas attention à la valeur de la propriété qui peut être indéfinie.
1) Vous voulez savoir si une propriété n'est pas définie par la première ou la deuxième signification (la situation la plus typique).
obj.prop === undefined // IMHO, see "final fight" below
2) Vous voulez simplement savoir si l'objet a une propriété et ne vous souciez pas de sa valeur.
'prop' in obj
x.a === undefined
ou cela typeof x.a == 'undefined'
augmente ReferenceError: x is not defined
si x n'est pas défini.undefined
est une variable globale (elle se trouve donc window.undefined
dans les navigateurs). Il est pris en charge depuis ECMAScript 1st Edition et depuis ECMAScript 5, il est en lecture seule . Donc, dans les navigateurs modernes, cela ne peut pas être redéfini sur vrai car de nombreux auteurs aiment nous faire peur, mais cela reste vrai pour les navigateurs plus anciens.obj.prop === undefined
vstypeof obj.prop == 'undefined'
Avantages de obj.prop === undefined
:
undefined
Moins de obj.prop === undefined
:
undefined
peut être remplacé dans les anciens navigateursAvantages de typeof obj.prop == 'undefined'
:
Moins de typeof obj.prop == 'undefined'
:
'undefned'
( mal orthographié ) voici juste une constante de chaîne, donc le moteur JavaScript ne peut pas vous aider si vous l'avez mal orthographié comme je viens de le faire.Node.js prend en charge la variable globale undefined
as global.undefined
(elle peut également être utilisée sans le préfixe «global»). Je ne connais pas les autres implémentations de JavaScript côté serveur.
undefined
tant que membre de global
. De plus, console.log(global);
ni for (var key in global) { ... }
ne s'affiche pas indéfini en tant que membre de global . Mais tester comme 'undefined' in global
montrer le contraire.
[[Enumerable]]
c'est faux :-)
Minuses of typeof obj.prop == 'undefined'
, cela peut être évité en écrivant comme typeof obj.prop == typeof undefined
. Cela donne également une symétrie très agréable.
obj.prop === undefined
.
if ('foo' in o
)… votre réponse est vraiment la première bonne réponse ici. Presque tout le monde répond à cette phrase.
Le problème se résume à trois cas:
undefined
.undefined
.Cela nous dit quelque chose que je considère important:
Il existe une différence entre un membre non défini et un membre défini avec une valeur non définie.
Mais malheureusement, typeof obj.foo
ne nous dit pas lequel des trois cas nous avons. Cependant, nous pouvons combiner cela avec "foo" in obj
pour distinguer les cas.
| typeof obj.x === 'undefined' | !("x" in obj)
1. { x:1 } | false | false
2. { x : (function(){})() } | true | false
3. {} | true | true
Il convient de noter que ces tests sont également les mêmes pour les null
entrées
| typeof obj.x === 'undefined' | !("x" in obj)
{ x:null } | false | false
Je dirais que dans certains cas, il est plus logique (et plus clair) de vérifier si la propriété est là, que de vérifier si elle n'est pas définie, et le seul cas où cette vérification sera différente est le cas 2, le rare cas de une entrée réelle dans l'objet avec une valeur non définie.
Par exemple: je viens de refactoriser un tas de code qui avait un tas de vérifications si un objet avait une propriété donnée.
if( typeof blob.x != 'undefined' ) { fn(blob.x); }
Ce qui était plus clair lorsqu'il était écrit sans vérification pour indéfini.
if( "x" in blob ) { fn(blob.x); }
Mais comme cela a été mentionné, ce ne sont pas exactement les mêmes (mais ils sont plus que suffisants pour mes besoins).
if (!("x" in blob)) {}
avec des crochets autour de l'intérieur, car le! L'opérateur a la priorité sur «in». J'espère que cela aide quelqu'un.
a = {b: undefined}
; alors typeof a.b === typeof a.c === 'undefined'
mais 'b' in a
et !('c' in a)
.
{ x : undefined }
ajouter ou du moins comme une autre alternative à (2.) dans le tableau - j'ai dû réfléchir un instant pour réaliser que le point (2.) correspond à undefined
(bien que vous en parlez plus tard).
if ( typeof( something ) == "undefined")
Cela a fonctionné pour moi tandis que les autres ne l'ont pas fait.
typeof (something == "undefined")
.
(typeof something) === "undefined"
.
Je ne sais pas d'où vient l'utilisation de ===
with typeof
, et comme convention je le vois utilisé dans de nombreuses bibliothèques, mais l'opérateur typeof renvoie un littéral de chaîne, et nous le savons d'avance, alors pourquoi voudriez-vous également taper vérifier aussi?
typeof x; // some string literal "string", "object", "undefined"
if (typeof x === "string") { // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") { // sufficient
==
nécessite toujours au moins une vérification de type - l'interpréteur ne peut pas comparer les deux opérandes sans connaître d'abord leur type.
==
est un caractère de moins que ===
:)
Crossposting ma réponse à partir d'une question connexe Comment vérifier si "non défini" en JavaScript?
Spécifique à cette question, voir les cas de test avec someObject.<whatever>
.
Quelques scénarios illustrant les résultats des différentes réponses: http://jsfiddle.net/drzaus/UVjM4/
(Notez que l'utilisation de var
pour les in
tests fait une différence dans un wrapper de portée)
Code de référence:
(function(undefined) {
var definedButNotInitialized;
definedAndInitialized = 3;
someObject = {
firstProp: "1"
, secondProp: false
// , undefinedProp not defined
}
// var notDefined;
var tests = [
'definedButNotInitialized in window',
'definedAndInitialized in window',
'someObject.firstProp in window',
'someObject.secondProp in window',
'someObject.undefinedProp in window',
'notDefined in window',
'"definedButNotInitialized" in window',
'"definedAndInitialized" in window',
'"someObject.firstProp" in window',
'"someObject.secondProp" in window',
'"someObject.undefinedProp" in window',
'"notDefined" in window',
'typeof definedButNotInitialized == "undefined"',
'typeof definedButNotInitialized === typeof undefined',
'definedButNotInitialized === undefined',
'! definedButNotInitialized',
'!! definedButNotInitialized',
'typeof definedAndInitialized == "undefined"',
'typeof definedAndInitialized === typeof undefined',
'definedAndInitialized === undefined',
'! definedAndInitialized',
'!! definedAndInitialized',
'typeof someObject.firstProp == "undefined"',
'typeof someObject.firstProp === typeof undefined',
'someObject.firstProp === undefined',
'! someObject.firstProp',
'!! someObject.firstProp',
'typeof someObject.secondProp == "undefined"',
'typeof someObject.secondProp === typeof undefined',
'someObject.secondProp === undefined',
'! someObject.secondProp',
'!! someObject.secondProp',
'typeof someObject.undefinedProp == "undefined"',
'typeof someObject.undefinedProp === typeof undefined',
'someObject.undefinedProp === undefined',
'! someObject.undefinedProp',
'!! someObject.undefinedProp',
'typeof notDefined == "undefined"',
'typeof notDefined === typeof undefined',
'notDefined === undefined',
'! notDefined',
'!! notDefined'
];
var output = document.getElementById('results');
var result = '';
for(var t in tests) {
if( !tests.hasOwnProperty(t) ) continue; // bleh
try {
result = eval(tests[t]);
} catch(ex) {
result = 'Exception--' + ex;
}
console.log(tests[t], result);
output.innerHTML += "\n" + tests[t] + ": " + result;
}
})();
Et les résultats:
definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined
Si tu fais
if (myvar == undefined )
{
alert('var does not exists or is not initialized');
}
il échouera lorsque la variable myvar
n'existe pas, car myvar n'est pas défini, donc le script est cassé et le test n'a aucun effet.
Étant donné que l'objet fenêtre a une portée globale (objet par défaut) en dehors d'une fonction, une déclaration sera «attachée» à l'objet fenêtre.
Par exemple:
var myvar = 'test';
La variable globale myvar est la même que window.myvar ou window ['myvar']
Pour éviter les erreurs de test lorsqu'une variable globale existe, il vaut mieux utiliser:
if(window.myvar == undefined )
{
alert('var does not exists or is not initialized');
}
La question de savoir si une variable existe vraiment n'a pas d'importance, sa valeur est incorrecte. Sinon, il est stupide d'initialiser des variables avec undefined, et il vaut mieux utiliser la valeur false pour initialiser. Lorsque vous savez que toutes les variables que vous déclarez sont initialisées avec false, vous pouvez simplement vérifier son type ou vous fier !window.myvar
à vérifier si elle a une valeur correcte / valide. Ainsi, même lorsque la variable n'est pas définie, il en !window.myvar
va de même pour myvar = undefined
ou myvar = false
oumyvar = 0
.
Lorsque vous attendez un type spécifique, testez le type de la variable. Pour accélérer le test d'une condition, il vaut mieux:
if( !window.myvar || typeof window.myvar != 'string' )
{
alert('var does not exists or is not type of string');
}
Lorsque la première et simple condition est remplie, l'interpréteur ignore les tests suivants.
Il est toujours préférable d'utiliser l'instance / l'objet de la variable pour vérifier si elle a obtenu une valeur valide. Il est plus stable et constitue un meilleur moyen de programmation.
(y)
Je n'ai vu (j'espère pas l'avoir manqué) quiconque vérifier l'objet avant la propriété. C'est donc le plus court et le plus efficace (mais pas forcément le plus clair):
if (obj && obj.prop) {
// Do something;
}
Si obj ou obj.prop est indéfini, nul ou "falsifié", l'instruction if n'exécutera pas le bloc de code. Il s'agit généralement du comportement souhaité dans la plupart des instructions de bloc de code (en JavaScript).
var x = obj && obj.prop || 'default';
Dans l'article Exploring the Abyss of Null and Undefined in JavaScript, j'ai lu que les frameworks comme Underscore.js utilisent cette fonction:
function isUndefined(obj){
return obj === void 0;
}
void 0
est juste une courte façon d'écrire undefined
(puisque c'est ce que void suivi de toute expression renvoie), il enregistre 3 caractères. Cela pourrait aussi faire l'affaire var a; return obj === a;
, mais c'est un personnage de plus. :-)
void
est un mot réservé, alors qu'il undefined
n'est pas ie tandis que undefined
est égal à void 0
par défaut, vous pouvez assigner une valeur à undefined
eg undefined = 1234
.
isUndefined(obj)
: 16 caractères. obj === void 0
: 14 caractères. dit-il.
Tout simplement, tout n'est pas défini en JavaScript, n'est pas défini , peu importe qu'il s'agisse d'une propriété à l'intérieur d'un objet / tableau ou simplement d'une simple variable ...
JavaScript a typeof
qui le rend très facile à détecter une variable non définie.
Vérifiez simplement si typeof whatever === 'undefined'
et cela renverra un booléen.
C'est ainsi que la célèbre fonction isUndefined()
d'AngularJs v.1x s'écrit:
function isUndefined(value) {return typeof value === 'undefined';}
Donc, comme vous voyez que la fonction reçoit une valeur, si cette valeur est définie, elle retournera false
, sinon pour les valeurs non définies, retournera true
.
Voyons donc quels seront les résultats lorsque nous passerons des valeurs, y compris les propriétés des objets comme ci-dessous, voici la liste des variables que nous avons:
var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;
et nous les vérifions comme ci-dessous, vous pouvez voir les résultats devant eux sous forme de commentaire:
isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true
Comme vous le voyez, nous pouvons tout vérifier en utilisant quelque chose comme ça dans notre code, comme mentionné, vous pouvez simplement l'utiliser typeof
dans votre code, mais si vous l'utilisez encore et encore, créez une fonction comme l'exemple angulaire que je partage et continue à réutiliser comme suivant le modèle de code DRY.
Encore une chose, pour vérifier la propriété d'un objet dans une application réelle dont vous n'êtes pas sûr que l'objet existe ou non, vérifiez si l'objet existe en premier.
Si vous vérifiez une propriété sur un objet et que cet objet n’existe pas, une erreur se produit et l’application entière s'arrête.
isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)
Si simple que vous pouvez envelopper une instruction if comme ci-dessous:
if(typeof x !== 'undefined') {
//do something
}
Qui est également égal à isDefined dans Angular 1.x ...
function isDefined(value) {return typeof value !== 'undefined';}
D'autres frameworks javascript comme le soulignement ont également une vérification de définition similaire, mais je vous recommande d'utiliser typeof
si vous n'utilisez déjà aucun framework.
J'ajoute également cette section de MDN qui a obtenu des informations utiles sur typeof, undefined et void (0).
Égalité stricte et non défini
Vous pouvez utiliser les opérateurs undefined et stricte d'égalité et d'inégalité pour déterminer si une variable a une valeur. Dans le code suivant, la variable x n'est pas définie et l'instruction if prend la valeur true.
var x;
if (x === undefined) {
// these statements execute
}
else {
// these statements do not execute
}
Remarque: L'opérateur d'égalité stricte plutôt que l'opérateur d'égalité standard doit être utilisé ici, car x == non défini vérifie également si x est nul, contrairement à l'égalité stricte. null n'est pas équivalent à undefined. Voir les opérateurs de comparaison pour plus de détails.
Opérateur typeof et indéfini
Alternativement, typeof peut être utilisé:
var x;
if (typeof x === 'undefined') {
// these statements execute
}
L'une des raisons d'utiliser typeof est qu'il ne génère pas d'erreur si la variable n'a pas été déclarée.
// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
// these statements execute
}
if (x === undefined) { // throws a ReferenceError
}
Cependant, ce type de technique doit être évité. JavaScript est un langage à portée statique, donc savoir si une variable est déclarée peut être lu en voyant si elle est déclarée dans un contexte englobant. La seule exception est la portée globale, mais la portée globale est liée à l'objet global, donc la vérification de l'existence d'une variable dans le contexte global peut être effectuée en vérifiant l'existence d'une propriété sur l'objet global (en utilisant l'opérateur in, par exemple).
Opérateur nul et non défini
L'opérateur void est une troisième alternative.
var x;
if (x === void 0) {
// these statements execute
}
// y has not been declared before
if (y === void 0) {
// throws a ReferenceError (in contrast to `typeof`)
}
plus> ici
Vous le souhaitez très probablement if (window.x)
. Cette vérification est sûre même si x n'a pas été déclaré ( var x;
) - le navigateur ne génère pas d'erreur.
if (window.history) {
history.call_some_function();
}
window est un objet qui contient toutes les variables globales en tant que membres, et il est légal d'essayer d'accéder à un membre inexistant. Si x n'a pas été déclaré ou n'a pas été défini, window.x
retourne undefined . undefined conduit à false lorsque if () l' évalue.
typeof history != 'undefined'
fonctionne réellement dans les deux systèmes.
En lisant ceci, je suis étonné de ne pas l'avoir vu. J'ai trouvé plusieurs algorithmes qui fonctionneraient pour cela.
Si la valeur d'un objet n'a jamais été définie, cela empêchera de revenir true
s'il est défini comme null
ou undefined
. Cela est utile si vous souhaitez que true soit renvoyé pour les valeurs définies commeundefined
if(obj.prop === void 0) console.log("The value has never been defined");
Si vous voulez que cela résulte comme true
pour les valeurs définies avec la valeur de undefined
, ou jamais définies, vous pouvez simplement utiliser=== undefined
if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");
Généralement, les gens m'ont demandé un algorithme pour déterminer si une valeur est soit fausse undefined
, soit null
. Les œuvres suivantes.
if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
console.log("The value is falsy, null, or undefined");
}
if (!obj.prop)
var obj = {foo: undefined}; obj.foo === void 0
-> true
. Comment est-ce "jamais défini comme undefined
"? C'est faux.
Comparez avec void 0
, pour la concision.
if (foo !== void 0)
Ce n'est pas aussi verbeux que if (typeof foo !== 'undefined')
foo
n'est pas déclaré.
La solution est incorrecte. En JavaScript,
null == undefined
retournera vrai, car ils sont tous les deux "castés" en booléens et sont faux. La bonne façon serait de vérifier
if (something === undefined)
qui est l'opérateur d'identité ...
===
s'agit du type égalité + (égalité primitive | identité d'objet), où les primitives incluent des chaînes. Je pense que la plupart des gens considèrent que ce 'abab'.slice(0,2) === 'abab'.slice(2)
n'est pas intuitif si l'on considère ===
comme l'opérateur d'identité.
Vous pouvez obtenir un tableau non défini avec chemin à l'aide du code suivant.
function getAllUndefined(object) {
function convertPath(arr, key) {
var path = "";
for (var i = 1; i < arr.length; i++) {
path += arr[i] + "->";
}
path += key;
return path;
}
var stack = [];
var saveUndefined= [];
function getUndefiend(obj, key) {
var t = typeof obj;
switch (t) {
case "object":
if (t === null) {
return false;
}
break;
case "string":
case "number":
case "boolean":
case "null":
return false;
default:
return true;
}
stack.push(key);
for (k in obj) {
if (obj.hasOwnProperty(k)) {
v = getUndefiend(obj[k], k);
if (v) {
saveUndefined.push(convertPath(stack, k));
}
}
}
stack.pop();
}
getUndefiend({
"": object
}, "");
return saveUndefined;
}
Lien jsFiddle
getUndefiend
devrait l'être getUndefined
.
Voici ma situation:
J'utilise le résultat d'un appel REST. Le résultat doit être analysé à partir de JSON vers un objet JavaScript.
Il y a une erreur que je dois défendre. Si les arguments de l'appel de repos étaient incorrects dans la mesure où l'utilisateur spécifiant les arguments de manière incorrecte, l'appel de repos revient essentiellement vide.
En utilisant ce post pour m'aider à me défendre contre cela, j'ai essayé cela.
if( typeof restResult.data[0] === "undefined" ) { throw "Some error"; }
Pour ma situation, si restResult.data [0] === "objet", alors je peux commencer en toute sécurité à inspecter le reste des membres. Si non défini, lancez l'erreur comme ci-dessus.
Ce que je dis, c'est que pour ma situation, toutes les suggestions ci-dessus dans ce post n'ont pas fonctionné. Je ne dis pas que j'ai raison et que tout le monde a tort. Je ne suis pas du tout un maître JavaScript, mais j'espère que cela aidera quelqu'un.
typeof
garde ne se garde pas réellement contre tout ce qu'une comparaison directe ne pourrait pas gérer. S'il restResult
n'est pas défini ou non déclaré, il sera toujours lancé.
if(!restResult.data.length) { throw "Some error"; }
Il existe un moyen agréable et élégant d’attribuer une propriété définie à une nouvelle variable si elle est définie ou de lui attribuer une valeur par défaut comme solution de rechange si elle n’est pas définie.
var a = obj.prop || defaultValue;
Cela convient si vous avez une fonction, qui reçoit une propriété de configuration supplémentaire:
var yourFunction = function(config){
this.config = config || {};
this.yourConfigValue = config.yourConfigValue || 1;
console.log(this.yourConfigValue);
}
En cours d'exécution
yourFunction({yourConfigValue:2});
//=> 2
yourFunction();
//=> 1
yourFunction({otherProperty:5});
//=> 1
Toutes les réponses sont incomplètes. C'est la bonne façon de savoir qu'il existe une propriété «définie comme non définie»:
var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;
Exemple:
var a = { b : 1, e : null } ;
a.c = a.d ;
hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null
// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined
Dommage que cela ait été la bonne réponse est enterré dans de mauvaises réponses> _ <
Donc, pour tous ceux qui passeront, je vous donnerai des indéfinis gratuitement !!
var undefined ; undefined ; // undefined
({}).a ; // undefined
[].a ; // undefined
''.a ; // undefined
(function(){}()) ; // undefined
void(0) ; // undefined
eval() ; // undefined
1..a ; // undefined
/a/.a ; // undefined
(true).a ; // undefined
En parcourant les commentaires, pour ceux qui veulent vérifier les deux, c'est indéfini ou sa valeur est nulle:
//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
alert('either it is undefined or value is null')
}
Si vous utilisez la bibliothèque jQuery, jQuery.isEmptyObject()
cela suffira dans les deux cas,
var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;
s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;
//Usage
if (jQuery.isEmptyObject(s)) {
alert('Either variable:s is undefined or its value is null');
} else {
alert('variable:s has value ' + s);
}
s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;
Si vous utilisez Angular:
angular.isUndefined(obj)
angular.isUndefined(obj.prop)
Underscore.js:
_.isUndefined(obj)
_.isUndefined(obj.prop)
1
à une variable x
? Ai-je besoin de Underscore ou jQuery? (incroyable que les gens utilisent les bibliothèques même pour les opérations les plus élémentaires comme un typeof
chèque)
J'utilise if (this.variable)
pour tester s'il est défini. Simple if (variable)
, recommandé ci - dessus , échoue pour moi. Il s'avère que cela ne fonctionne que lorsque la variable est un champ d'un objet, obj.someField
pour vérifier si elle est définie dans le dictionnaire. Mais nous pouvons utiliser this
ou window
comme objet dictionnaire car toute variable est un champ dans la fenêtre actuelle, si je comprends bien. Voici donc un test
if (this.abc) alert("defined"); else alert("undefined");
abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");
Il détecte d'abord que la variable abc
n'est pas définie et elle est définie après l'initialisation.
Je propose ici trois façons pour ceux qui attendent des réponses étranges:
function isUndefined1(val) {
try {
val.a;
} catch (e) {
return /undefined/.test(e.message);
}
return false;
}
function isUndefined2(val) {
return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
const defaultVal={};
return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
console.group(`test start :`+func.name);
console.log(func(undefined));
console.log(func(null));
console.log(func(1));
console.log(func("1"));
console.log(func(0));
console.log(func({}));
console.log(func(function () { }));
console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);
Essayez d'obtenir une propriété de la valeur d'entrée, vérifiez le message d'erreur s'il existe. Si la valeur d'entrée n'est pas définie, le message d'erreur serait Uncaught TypeError: Impossible de lire la propriété «b» de non défini
Convertir la valeur d'entrée en chaîne pour comparer avec "undefined"
et assurez-vous qu'il s'agit d'une valeur négative.
Dans js, le paramètre facultatif fonctionne lorsque la valeur d'entrée est exactement undefined
.
ES2019 a introduit une nouvelle fonctionnalité - chaînage facultatif que vous pouvez utiliser pour utiliser une propriété d'un objet uniquement lorsqu'un objet est défini comme ceci:
const userPhone = user?.contactDetails?.phone;
Il fera référence à la propriété du téléphone uniquement lorsque l'utilisateur et contactDetails sont définis.
Réf. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining
function isUnset(inp) {
return (typeof inp === 'undefined')
}
Renvoie false si la variable est définie et true si n'est pas défini.
Utilisez ensuite:
if (isUnset(var)) {
// initialize variable here
}
typeof
test dans une fonction. Étonnant que 4 personnes aient voté pour cela. -1.
Je voudrais vous montrer quelque chose que j'utilise pour protéger la undefined
variable:
Object.defineProperty(window, 'undefined', {});
Cela interdit à quiconque de modifier la window.undefined
valeur, détruisant ainsi le code basé sur cette variable. Si vous utilisez "use strict"
, tout ce qui tente de changer sa valeur se terminera par erreur, sinon il serait ignoré en silence.
vous pouvez également utiliser Proxy, cela fonctionnera avec les appels imbriqués, mais nécessitera une vérification supplémentaire:
function resolveUnknownProps(obj, resolveKey) {
const handler = {
get(target, key) {
if (
target[key] !== null &&
typeof target[key] === 'object'
) {
return resolveUnknownProps(target[key], resolveKey);
} else if (!target[key]) {
return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
}
return target[key];
},
};
return new Proxy(obj, handler);
}
const user = {}
console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }
vous allez donc l'utiliser comme:
const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
// do someting
}