Détection d'une propriété d'objet non définie

StackOverflow https://stackoverflow.com/questions/27509

  •  09-06-2019
  •  | 
  •  

Question

Quelle est la meilleure façon de vérifier si une propriété d'objet en JavaScript n'est pas définie ?

Était-ce utile?

La solution

Utiliser:

if (typeof something === "undefined") {
    alert("something is undefined");
}

Si une variable objet possède certaines propriétés, vous pouvez utiliser la même chose comme ceci :

if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}

Autres conseils

Je pense qu'il existe un certain nombre de réponses incorrectes à ce sujet.Contrairement à la croyance populaire, « indéfini » signifie pas un mot-clé en JavaScript et peut en fait se voir attribuer une valeur.

Code correct

La manière la plus robuste d’effectuer ce test est la suivante :

if (typeof myVar === "undefined")

Cela renverra toujours le résultat correct et gérera même la situation où myVar n’est pas déclaré.

Code dégénéré.NE PAS UTILISER.

var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}

En plus, myVar === undefined générera une erreur dans la situation où myVar n'est pas déclaré.

Bien qu'il soit vivement recommandé par de nombreuses autres réponses ici, typeof est un mauvais choix.Il ne doit jamais être utilisé pour vérifier si les variables ont la valeur undefined, car il agit comme un contrôle combiné de la valeur undefined et pour savoir si une variable existe.Dans la grande majorité des cas, vous savez quand une variable existe, et typeof introduira simplement le potentiel d'un échec silencieux si vous faites une faute de frappe dans le nom de la variable ou dans la chaîne littérale '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 n'effectuiez une détection de fonctionnalités², où il y a une incertitude quant à savoir si un nom donné sera dans la portée (comme vérifier typeof module !== 'undefined' comme une étape de code spécifique à un environnement CommonJS), typeof est un choix préjudiciable lorsqu'il est utilisé sur une variable, et la bonne option est de comparer directement la valeur :

var foo = …;

if (foo === undefined) {
    ⋮
}

Certaines idées fausses courantes à ce sujet incluent :

  • que la lecture d'une variable "non initialisée" (var foo) ou un paramètre (function bar(foo) { … }, appelé comme bar()) échouera.Ce n’est tout simplement pas vrai : les variables sans initialisation explicite et les paramètres auxquels aucune valeur n’a été attribuée deviennent toujours undefined, et sont toujours dans la portée.

  • que undefined peut être écrasé.Il y a bien plus à cela. undefined n'est pas un mot-clé en JavaScript.Au lieu de cela, il s'agit d'une propriété sur l'objet global avec la valeur Undefined.Cependant, depuis ES5, cette propriété a été lecture seulement et non configurable.Aucun navigateur moderne ne permettra au undefined propriété à changer, et depuis 2017, c'est le cas depuis longtemps.L'absence de mode strict n'affecte pas undefinedle comportement de non plus – il fait simplement des déclarations comme undefined = 5 ne rien faire au lieu de lancer.Comme il ne s’agit pas d’un mot-clé, vous pouvez déclarer variables avec le nom undefined, et ces variables pourraient être modifiées, créant ainsi ce modèle autrefois courant :

    (function (undefined) {
    // …
})()

    plus dangereux que d'utiliser le global undefined.Si vous devez être compatible ES3, remplacez undefined avec void 0 – ne recourez pas à typeof. (void a toujours été un opérateur unaire qui évalue la valeur non définie pour n'importe quel opérande.)

Maintenant que les variables fonctionnent, il est temps de répondre à la vraie question :propriétés de l'objet.Il n'y a aucune raison d'utiliser typeof pour les propriétés de l'objet.L’exception précédente concernant la détection de 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.

Ce:

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 dérouter les lecteurs quant aux raisons pour lesquelles vous utilisez typeof, car il est plus logique d'utiliser === pour vérifier l'égalité, car il pourrait être refactorisé pour vérifier la valeur d'une variable plus tard, et parce qu'il semble tout simplement meilleur, 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 souhaitez vraiment vérifier undefined du tout.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 ou l'autre de ceux qui ont un non-undefined valeur. 'key' in obj vous dira si une clé se trouve quelque part sur la chaîne de prototypes d'un objet, et Object.prototype.hasOwnProperty.call(obj, 'key') vous dira si c’est 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îne, car elle vise principalement à contrer tous les mauvais conseils contenus dans d'autres réponses, quelles que soient les interprétations possibles de la question d'origine.Lire sur prototypes 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 couvert est acceptable en général.vulnérabilité bonus causée par un abus de portée dynamique : Projet Zéro 1225
³ en supposant encore une fois un environnement ES5+ et que undefined se réfère à la undefined propriété de l’objet global.remplaçant void 0 sinon.

En JavaScript, il y a nul et voici indéfini.Ils ont des significations différentes.

  • indéfini signifie que la valeur de la variable n'a pas été définie ;on ne sait pas quelle est la valeur.
  • nul signifie que la valeur de la variable est définie et définie sur null (n'a aucune valeur).

Marijn Haverbeke déclare dans son livre gratuit en ligne "JavaScript éloquent" (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 signification entre indéfini et null 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 == undéfini peut être utilisée, car, même si ce n'est pas exactement la même valeur, null == undéfini produira vrai.

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 de l'objet devraient fonctionner de la même manière.

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

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 le 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?Bien sûr!Il n’y a aucune propriété « b » du tout !OK, voyons 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

On voit clairement que typeof obj.prop == 'undefined' et obj.prop === undefined sont équivalents et ne distinguent pas ces différentes situations.Et 'prop' in obj peut détecter la situation dans laquelle 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.

Alors que faire?

1) Vous voulez savoir si une propriété n'est pas définie par le premier ou le deuxième sens (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

Remarques:

  • Vous ne pouvez pas vérifier un objet et sa propriété en même temps.Par exemple, ceci x.a === undefined ou ca typeof x.a == 'undefined' soulève ReferenceError: x is not defined si x n'est pas défini.
  • Variable undefined est une variable globale (donc en fait c'est window.undefined dans les navigateurs).Il est pris en charge depuis ECMAScript 1ère édition et depuis ECMAScript 5, il est lecture seulement.Donc, dans les navigateurs modernes, cela ne peut pas être le cas redéfini en vrai comme de nombreux auteurs aiment nous effrayer, mais cela reste vrai pour les navigateurs plus anciens.

Combat final: obj.prop === undefined contre typeof obj.prop == 'undefined'

Avantages de obj.prop === undefined:

  • C'est un peu plus court et ça a l'air un peu plus joli
  • Le moteur JavaScript vous donnera une erreur si vous avez mal orthographié undefined

Inconvénients de obj.prop === undefined:

  • undefined peut être remplacé dans les anciens navigateurs

Avantages de typeof obj.prop == 'undefined':

  • C'est vraiment universel !Cela fonctionne dans les nouveaux et anciens navigateurs.

Inconvénients 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.

Mise à jour (pour JavaScript côté serveur) :

Node.js prend en charge la variable globale undefined comme global.undefined (il peut également être utilisé sans le préfixe « global »).Je ne connais pas d'autres implémentations de JavaScript côté serveur.

Le problème se résume à trois cas :

  1. L'objet a la propriété et sa valeur n'est pas undefined.
  2. L'objet a la propriété et sa valeur est undefined.
  3. L'objet n'a pas la propriété.

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 les mêmes pour null les entrées aussi

                               |  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 cas rare de une entrée réelle dans l'objet avec une valeur indéfinie.

Par exemple:Je viens de refactoriser un tas de code qui vérifiait 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 d'undé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 ( typeof( something ) == "undefined")

Cela a fonctionné pour moi alors que les autres ne l'ont pas fait.

Je ne sais pas où est l'origine de l'utilisation === avec typeof vient, et comme convention, je le vois utilisé dans de nombreuses bibliothèques, mais l'opérateur typeof renvoie une chaîne littérale, et nous le savons d'emblée, alors pourquoi voudriez-vous également taper check-le 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

Crossposter mon répondre de la question connexe Comment vérifier « 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 in les tests font une différence lorsqu'ils sont dans un wrapper étendu)

Code pour 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 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 interrompu et le test n'a aucun effet.

Étant donné que l'objet window a une portée globale (objet par défaut) en dehors d'une fonction, une déclaration sera « attachée » à l'objet window.

Par exemple:

var myvar = 'test';

La variable globale mavar est le même que fenêtre.myvar ou fenêtre['myvar']

Pour éviter les erreurs lors du test lorsqu'une variable globale existe, il est préférable d'utiliser :

if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

La question de savoir si une variable existe réellement n'a pas d'importance, sa valeur est incorrecte.Sinon, il est idiot d'initialiser les 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 pour vérifier s'il a une valeur appropriée/valide.Ainsi, même lorsque la variable n'est pas définie, alors !window.myvar c'est pareil pour myvar = undefined ou myvar = false ou myvar = 0.

Lorsque vous attendez un type spécifique, testez le type de la variable.Pour accélérer le test d'une condition, vous feriez mieux de :

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 vraie, l’interprète 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 une valeur valide.C’est plus stable et constitue une meilleure façon de programmer.

(o)

Je n'ai vu (j'espère ne pas l'avoir manqué) personne vérifier l'objet devant la propriété.Voici donc le plus court et le plus efficace (mais pas nécessairement le plus clair) :

if (obj && obj.prop) {
  // Do something;
}

Si obj ou obj.prop est indéfini, nul ou « faux », l'instruction if n'exécutera pas le bloc de code.C'est généralement le comportement souhaité dans la plupart des instructions de bloc de code (en JavaScript).

Dans l'article Explorer l'abîme du nul et de l'indéfini en JavaScript J'ai lu que des frameworks comme Souligner.js utilise cette fonction :

function isUndefined(obj){
    return obj === void 0;
}

'si (fenêtre.x) { }' est sans erreur

Très probablement, vous voulez 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.

Exemple:Je veux savoir si mon navigateur prend en charge l'API History

if (window.history) {
    history.call_some_function();
}

Comment cela fonctionne :

fenêtre est un objet qui contient toutes les variables globales comme membres, et il est légal d'essayer d'accéder à un membre non existant.Si X n'a pas été déclaré ou n'a pas été défini alors window.x Retour indéfini. indéfini mène à FAUX quand si() l'évalue.

"propertyName" in obj //-> true | false

En lisant ceci, je suis étonné de ne pas avoir vu cela.J'ai trouvé plusieurs algorithmes qui fonctionneraient pour cela.

Jamais défini

Si la valeur d'un objet n'a jamais été définie, cela empêchera le retour true s'il est défini comme null ou undefined.Ceci est utile si vous souhaitez que true soit renvoyé pour les valeurs définies comme undefined

if(obj.prop === void 0) console.log("The value has never been defined");

Défini comme indéfini ou jamais défini

Si vous voulez que le résultat soit comme true pour les valeurs définies avec la valeur de undefined, ou jamais défini, vous pouvez simplement utiliser === undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

Défini comme une valeur fausse, non définie, nulle ou jamais définie.

Souvent, les gens me demandent un algorithme pour déterminer si une valeur est fausse, undefined, ou null.Les travaux suivants.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

Vous pouvez obtenir un tableau non défini avec un chemin en utilisant le 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;
    }

jsFiddle lien

Tout simplement, rien n'est défini en JavaScript, c'est indéfini, peu importe qu'il s'agisse d'une propriété à l'intérieur d'un objet/tableau ou d'une simple variable...

JavaScript a typeof ce qui permet de détecter très facilement une variable non définie.

Vérifiez simplement si typeof whatever === 'undefined' et il renverra un booléen.

C'est ainsi que la fameuse fonction isUndefined() dans AngularJs v.1x est écrit :

function isUndefined(value) {return typeof value === 'undefined';}

Ainsi, comme vous voyez la fonction recevoir une valeur, si cette valeur est définie, elle renverra false, sinon pour les valeurs non définies, retournez true.

Voyons donc quels seront les résultats lorsque nous transmettrons des valeurs, y compris les propriétés de l'objet 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 en 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 vérifier n'importe quoi en utilisant quelque chose comme ça dans notre code, comme mentionné, vous pouvez simplement utiliser typeof dans votre code, mais si vous l'utilisez encore et encore, créez une fonction comme l'échantillon angulaire que je partage et continuez à 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 d'abord si l'objet existe.

Si vous vérifiez une propriété sur un objet et que l'objet n'existe pas, une erreur sera générée et l'exécution de l'ensemble de l'application sera arrêtée.

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

C'est si simple que vous pouvez l'insérer dans une instruction if comme ci-dessous :

if(typeof x !== 'undefined') {
  //do something
}

Ce qui est également égal à isDefined dans Angular 1.x...

function isDefined(value) {return typeof value !== 'undefined';}

D'autres frameworks javascript comme le trait de 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 contient des informations utiles sur typeof, undefined et void(0).

Égalité stricte et indéfinie
Vous pouvez utiliser des opérateurs d'égalité et d'inégalité stricts et stricts 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 évalue à true.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

Note:L'opérateur d'égalité strict plutôt que l'opérateur d'égalité standard doit être utilisé ici, car x == Undefined vérifie également si X est nul, tandis que l'égalité stricte ne le fait pas.Null n'est pas équivalent à non défini.Voir les opérateurs de comparaison pour plus de détails.

Type d'opérateur et non défini
Alternativement, typeof peut être utilisé :

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

L'une des raisons d'utiliser le type de type est qu'elle ne lance 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 genre de technique est à éviter.JavaScript est une langue statiquement portée, donc savoir si une variable est déclarée peut être lue en voyant si elle est déclarée dans un contexte entorant.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 vide 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

Comparer avec void 0, pour la concision.

if (foo !== void 0)

Ce n'est pas aussi verbeux que if (typeof foo !== 'undefined')

La solution est incorrecte.En JavaScript,

null == undefined

renverra vrai, car ils sont tous deux "convertis" en booléen et sont faux.La bonne façon serait de vérifier

if (something === undefined)

qui est l'opérateur d'identité...

Voici ma situation :

J'utilise le résultat d'un appel REST.Le résultat doit être analysé de JSON vers un objet JavaScript.

Il y a une erreur que je dois défendre.Si les arguments de l’appel rest étaient incorrects dans la mesure où l’utilisateur les a mal spécifiés, l’appel rest revient fondamentalement vide.

En utilisant ce post pour m'aider à me défendre contre cela, j'ai essayé ceci.

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

Pour ma situation, si restResult.data[0] === "object", alors je peux commencer en toute sécurité à inspecter le reste des membres.S'il n'est pas défini, lancez l'erreur comme ci-dessus.

Ce que je dis, c'est que pour ma situation, toutes les suggestions ci-dessus dans cet article 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.

Il existe une manière agréable et élégante 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 secours 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 indé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 cette bonne réponse soit ensevelie sous de mauvaises réponses >_<

Alors, pour tous ceux qui passeraient par là, je vous offrirai 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, est-il 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, alors jQuery.isEmptyObject() 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 Angulaire : 

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Soulignement.js :

_.isUndefined(obj) 
_.isUndefined(obj.prop)

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 s'il est défini dans le dictionnaire.Mais nous pouvons utiliser this ou window comme objet dictionnaire puisque 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 cette variable abc n'est pas défini et il est défini après l'initialisation.

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

Renvoie false si la variable est définie et true si elle n'est pas définie.

Utilisez ensuite :

if (isUnset(var)) {
  // initialize variable here
}

Les mêmes choses peuvent également être écrites plus courtes :

if (!variable){
    //do it if variable is Undefined
}

ou 

if (variable){
    //do it if variable is Defined
}

J'aimerais vous montrer quelque chose que j'utilise pour protéger le undefined variable:

Object.defineProperty(window, 'undefined', {});

Ceci interdit à quiconque de modifier le window.undefined value détruisant donc le code basé sur cette variable.Si vous utilisez "use strict", toute tentative de modification de sa valeur se terminera par une erreur, sinon elle sera silencieusement ignorée.

De lodash.js.

var undefined;
function isUndefined(value) {
  return value === undefined;
}

Il crée une variable LOCAL nommée undefined qui est initialisé avec la valeur par défaut -- le réel undefined, puis compare value avec la variable undefined.

Je propose ici trois manières pour ceux qui s'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);

estUndéfini1 :

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 Erreur de type non détectée :Impossible de lire la propriété 'b' de non défini

estUndéfini2 :

Convertir la valeur d'entrée en chaîne pour comparer "undefined" et assurez-vous que sa valeur est négative.

estUndéfini3 :

En js, le paramètre facultatif fonctionne lorsque la valeur d'entrée est exactement undefined.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top