Il rilevamento di un oggetto non definito proprietà

https://stackoverflow.com/questions/27509

09-06-2019
|

Domanda

Qual è il modo migliore per controllare se la proprietà di un oggetto in JavaScript non è definito?

Soluzione

Uso:

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

Se una variabile oggetto che hanno alcune proprietà che è possibile utilizzare stessa cosa come questa:

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

Altri suggerimenti

Io credo che ci sono un certo numero di risposte errate a questo argomento.Contrariamente alla credenza comune, "undefined" è non una parola chiave in JavaScript e può, infatti, hanno un valore assegnato.

Il Codice Corretto

La maggior parte del modo efficace di eseguire questo test è:

if (typeof myVar === "undefined")

Questo restituirà sempre il risultato corretto, e persino gestisce la situazione in cui myVar non è dichiarato.

Degenerare codice.NON UTILIZZARE.

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

Inoltre, myVar === undefined verrà generato un errore nel caso in cui la variabile è dichiarata.

Pur essendo fortemente raccomandato da molte altre risposte qui, typeof è una cattiva scelta.Non dovrebbe mai essere usato per controllare se le variabili hanno il valore undefined, in quanto agisce come un combinato di controllo per il valore undefined e se una variabile esiste.Nella stragrande maggioranza dei casi, si sa, quando una variabile esiste, e typeof sarà sufficiente introdurre il potenziale per un silent fallimento se si commette un errore di battitura nel nome di variabile o nel valore letterale stringa '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!
}

Quindi, a meno che si sta facendo caratteristica detection2, dove c'è incertezza sul fatto che un determinato nome sarà portata (come il controllo typeof module !== 'undefined' come un passo in codice specifico per CommonJS ambiente), typeof è un dannoso scelta quando viene utilizzato su una variabile, e l'opzione corretta è quello di confrontare il valore direttamente:

var foo = …;

if (foo === undefined) {
    ⋮
}

Alcune idee sbagliate comuni circa questo includono:

che la lettura di un “non inizializzato” variabile (var foo) o parametro (function bar(foo) { … }, chiamata bar()) avrà esito negativo.Questo semplicemente non è vero – le variabili senza inizializzazione esplicita e parametri che non sono stati dati i valori di sempre undefined, e sono sempre in ambito.
che undefined può essere sovrascritto.C'è molto di più di questo. undefined non è una parola chiave in JavaScript.Invece, è una proprietà dell'oggetto globale con un valore Indefinito.Tuttavia, dal momento che ES5, questa proprietà è stata di sola lettura e non è configurabile.Nessuno dei moderni browser permettono l' undefined proprietà di essere cambiato, e come 2017 questo è stato il caso per un lungo periodo di tempo.La mancanza di rigorose modalità non influisce undefinedi comportamenti di entrambi – si fa solo affermazioni come undefined = 5 non fare niente invece di buttare.Dato che non è una parola chiave, però, è possibile dichiarare le variabili con il nome undefined, e quelli variabili potrebbe essere cambiato, rendendo questo una volta-schema comune:
```
(function (undefined) {
    // …
})()
```
più pericoloso di utilizzo globale undefined.Se devi essere ES3-compatibile, sostituire undefined con void 0 – non ricorrere a typeof. (void è sempre stato un operatore unario che restituisce il valore Indefinito per ogni operando.)

Come variabili di lavoro al di fuori del modo, è ora di affrontare la questione reale:le proprietà dell'oggetto.Non vi è alcun motivo per utilizzare mai typeof per le proprietà dell'oggetto.La prima eccezione per quanto riguarda il rilevamento delle funzionalità non si applica qui – typeof ha solo comportamento particolare sulle variabili ed espressioni che fanno riferimento a proprietà dell'oggetto non sono variabili.

Questo:

if (typeof foo.bar === 'undefined') {
    ⋮
}

è sempre esattamente equivalente per this3:

if (foo.bar === undefined) {
    ⋮
}

e tenendo conto del parere di cui sopra, per evitare di confondere i lettori perché si sta utilizzando typeof, perché rende più senso per l'uso === per verificare l'uguaglianza, perché potrebbe essere rielaborato per il controllo di un valore della variabile dopo, e perché è semplicemente un aspetto migliore, si dovrebbe sempre usare === undefined3 qui.

Qualcos'altro da prendere in considerazione quando si tratta di oggetto di proprietà è se si vuole veramente di controllo per undefined a tutti.Un dato nome di proprietà può essere assente su un oggetto (la generazione del valore undefined quando leggi), presente sull'oggetto stesso con il valore undefined, presente sull'oggetto del prototipo con il valore undefined, o presente su uno di questi con un nonundefined valore. 'key' in obj è possibile verificare se una chiave è ovunque su un oggetto catena di prototipi, e Object.prototype.hasOwnProperty.call(obj, 'key') vi dirà se è direttamente sull'oggetto.Non voglio entrare nel dettaglio in questa risposta, su prototipi e l'utilizzo di oggetti come stringa chiave mappe, però, perché è principalmente rivolta contro tutti i cattivi consigli in altre risposte a prescindere delle possibili interpretazioni della domanda originale.Leggere oggetto prototipi su MDN per saperne di più!

_{1 insolita scelta di un esempio, il nome della variabile?questo è vero morti codice di estensione NoScript per Firefox.}
_{2 non date per scontato che non sapendo cosa c'è in questo ambito è bene in generale, però.bonus vulnerabilità causata da abuso di dinamica ambito: Project Zero 1225}
_{3 ancora una volta, assumendo una ES5+ ambiente e che undefined si riferisce alla undefined proprietà dell'oggetto globale.sostituire void 0 altrimenti.}

In JavaScript non c'è null e c'è undefined.Essi hanno significati diversi.

undefined significa che il valore della variabile non è stata definita;non è noto che cosa è il valore.
null significa che il valore della variabile è definita e impostare a null (non ha valore).

Marijn Haverbeke stati, nella sua libera, libro online "Eloquente JavaScript"(il corsivo è mio):

C'è anche un valore simile, null, il cui significato è 'questo valore è definito, ma non hanno un valore".La differenza di significato tra indefinito e null è per lo più accademico, e di solito non è molto interessante. In pratica i programmi, è spesso necessario per verificare se qualcosa ha un valore".In questi casi, l'espressione di qualcosa == undefined può essere utilizzato, perché, anche se non sono esattamente lo stesso valore, null == undefined produrrà vero.

Così, credo che il modo migliore per controllare se c'era qualcosa di indefinito sarebbe:

if (something == undefined)

Spero che questo aiuta!

Edit: In risposta a modificare le proprietà dell'oggetto dovrebbe funzionare allo stesso modo.

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

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

Che cosa significa questo: "indefinito proprietà dell'oggetto"?

In realtà può significare due cose totalmente diverse!Primo, si può dire la proprietà che non è mai stato definito in oggetto e, in secondo luogo, può significare la proprietà che ha un valore indefinito.Diamo un'occhiata a questo codice:

var o = { a: undefined }

È o.a undefined?Sì!Il suo valore non è definito.È o.b undefined?Sicuro!Non vi è alcuna propriet 'a ' b' a tutti!OK, ora vedere come i diversi approcci si comportano in entrambe le situazioni:

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

Possiamo vedere chiaramente che typeof obj.prop == 'undefined' e obj.prop === undefined sono equivalenti, e non distinguere le diverse situazioni.E 'prop' in obj in grado di rilevare la situazione quando un immobile non è stato definito a tutti e non prestare attenzione al valore della proprietà, che può essere definito.

Quindi cosa fare?

1) Si vuole sapere se una proprietà non è definito sia il primo o il secondo significato (la più tipica situazione).

obj.prop === undefined // IMHO, see "final fight" below

2) Si vuole solo sapere se l'oggetto ha alcune proprietà e non sul suo valore.

'prop' in obj

Note:

Non è possibile controllare un oggetto e la sua struttura allo stesso tempo.Per esempio, questo x.a === undefined o questo typeof x.a == 'undefined' solleva ReferenceError: x is not defined se x non è definita.
Variabile undefined è una variabile globale (quindi in realtà non è window.undefined nel browser).E ' stato sostenuto dal ECMAScript 1 ° Edizione e dal ECMAScript 5 è sola lettura.Così nel browser moderni non può essere ridefinito vero come molti autori amore ci spaventa, ma questo è ancora vero per i vecchi browser.

Final fight: `obj.prop === undefined` vs `typeof obj.prop == 'undefined'`

Plus di obj.prop === undefined:

È un po 'più corto e sembra un po' più bella
Il motore JavaScript vi darà un errore se si hanno errori di ortografia undefined

Svantaggi di obj.prop === undefined:

undefined può essere sottoposto a override in vecchi browser

Plus di typeof obj.prop == 'undefined':

È davvero universale!Si lavora a nuovi e vecchi browser.

Svantaggi di typeof obj.prop == 'undefined':

'undefned' (errori di ortografia) qui è solo una stringa costante, in modo che il motore JavaScript non posso aiutarti se hai scritto male, come ho appena fatto.

Aggiornamento (per JavaScript lato server):

Node.js supporta la variabile globale undefined come global.undefined (può essere utilizzato anche senza la 'globale' prefisso).Non so su altre implementazioni di server-side JavaScript.

Il problema si riduce a tre casi:

L'oggetto ha la proprietà e il suo valore non è undefined.
L'oggetto ha la proprietà e il suo valore è undefined.
L'oggetto non ha la proprietà.

Questo ci dice qualcosa di importante:

C'è una differenza tra un indefinito membro e un membro definito con un valore indefinito.

Ma purtroppo typeof obj.foo non ci dice quale dei tre casi che abbiamo.Tuttavia siamo in grado di combinare questo con "foo" in obj per distinguere i casi.

                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true

Vale la pena notare che questi test sono le stesse per null voci troppo

                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false

Direi che in alcuni casi ha più senso (ed è più chiaro) per verificare se la struttura c'è, oltre al controllo se non è definito, e l'unico caso in cui questo controllo sarà diverso è il caso 2, caso raro di un vero e proprio voce in oggetto con un valore indefinito.

Per esempio:Ho appena fatto il refactoring di un gruppo di codice che aveva un sacco di verifica se un oggetto ha una data proprietà.

if( typeof blob.x != 'undefined' ) {  fn(blob.x); }

Che era più chiaro quando viene scritto senza controllare per non definito.

if( "x" in blob ) { fn(blob.x); }

Ma, come si è detto, questi non sono esattamente le stesse (ma sono più che sufficiente per le mie esigenze).

if ( typeof( something ) == "undefined")

Questo ha funzionato per me, mentre gli altri non.

Non so dove l'origine di utilizzo === con typeof è venuto da, e come convenzione di vedere utilizzato in molte librerie, ma l'operatore typeof restituisce una stringa letterale, e sappiamo che di fronte, quindi, perché si desidera anche il tipo di controllo è troppo?

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

Crosspost mio risposta dalla domanda relativa Come verificare la presenza di "indefinito" in JavaScript?

Specifico a questa domanda, vedi i casi di test con someObject.<whatever>.

Alcuni scenari di illustrare i risultati delle varie risposte:http://jsfiddle.net/drzaus/UVjM4/

(Si noti che l'uso di var per in test di fare la differenza quando in un ambito wrapper)

Codice di riferimento:

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

E i risultati:

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

Se si

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

si avrà esito negativo quando la variabile myvar non esiste, perché la variabile non è definita, quindi lo script è rotto e il test non ha alcun effetto.

Perché l'oggetto finestra ha una portata globale (oggetto predefinito) al di fuori di una funzione, di una dichiarazione sara 'attaccato' alla finestra oggetto.

Per esempio:

var myvar = 'test';

La variabile globale myvar è lo stesso finestra.myvar o la finestra['variabile']

Per evitare errori al test quando una variabile globale esiste, è meglio utilizzare:

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

La questione se una variabile esiste davvero, non importa, il suo valore non è corretto.In caso contrario, è stupido per inizializzare le variabili indefiniti, ed è meglio usare il valore da false a inizializzare.Quando si sa che tutte le variabili che si dichiara vengono inizializzati con dati falsi, si può semplicemente controllare il suo tipo o si basano su !window.myvar per verificare se si ha una corretta/valore valido.Così, anche quando la variabile non è definita quindi !window.myvar è lo stesso per myvar = undefined o myvar = false o myvar = 0.

Quando si aspetta un tipo specifico, verificare il tipo di variabile.Per velocizzare la prova di una condizione è meglio fare:

if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

Quando la prima e la semplice condizione è true, l'interprete salta il prossimo test.

È sempre meglio utilizzare l'istanza/oggetto della variabile da controllare se ha un valore valido.È più stabile ed è un modo migliore di programmazione.

(y)

Non ho visto (spero di non perdere) chiunque controllo l'oggetto prima che la proprietà.Quindi, questo è il più breve e più efficace (anche se non necessariamente il più chiaro):

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

Se l'obj obj.l'elica è indefinita, null, o "falsy", se la dichiarazione non viene eseguito il blocco di codice.Questo è di solito il comportamento desiderato nella maggior parte codice blocco di istruzioni (in JavaScript).

Nell'articolo Esplorare l'Abisso di Null e Undefined in JavaScript Ho letto che framework come Underscore.js utilizzare questa funzione:

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

'if (window.x) { }'è un errore di sicuro

Più probabile che si desidera if (window.x).Questo controllo è sicuro, anche se x non è stato dichiarato,var x;) - browser non genera un errore.

Esempio:Voglio sapere se il mio browser supporta Storia API

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

Come funziona:

finestra è un oggetto che contiene tutte le variabili globali come i suoi membri, ed è legale per tentare di accedere a un non-membro esistente.Se x non è stata dichiarata o non è stato impostato in poi window.x restituisce undefined. undefined porta a false quando se() valuta.

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

Leggendo questo, mi meraviglio che non ho visto questo.Ho trovato più algoritmi che lavorano per questo.

Non Ha Mai Definito

Se il valore di un oggetto non è mai stato definito, questo impedirà il ritorno true se è definito come null o undefined.Questo è utile se si desidera vero di essere tornato per impostare i valori come undefined

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

Definito come definito O non Definito

Se si desidera che il risultato come true per valori definiti con il valore di undefined, o non ha mai definito, si può semplicemente utilizzare === undefined

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

Definito come un falsy valore, indefinita,null, o non ha mai definito.

Comunemente, le persone che mi hanno chiesto per un algoritmo per capire se un valore è falsy, undefined, o null.Le seguenti opere.

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

Si può ottenere un array tutti indefinito con percorso utilizzando il codice riportato di seguito.

 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 link

Semplicemente nulla, non è definito in JavaScript, è undefined, non importa se si tratta di un immobile all'interno di un Oggetto/Matrice o come una semplice variabile...

JavaScript ha typeof che rendono molto facile per rilevare una variabile non definita.

Controllare semplicemente se typeof whatever === 'undefined' e restituisce un booleano.

Ecco come il famoso funzione isUndefined() in AngularJs v. 1x è scritto:

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

Come vedete la funzione di ricevere un valore, se tale valore è definito, verrà restituito false, altrimenti per i valori non definiti, di ritorno true.

Quindi, diamo un'occhiata a cosa sarà il risultato quando abbiamo il passaggio di valori, tra cui le proprietà dell'oggetto, come di seguito, questo è l'elenco di variabili che abbiamo:

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

e noi li controlla, come di seguito, è possibile vedere i risultati davanti a loro come un commento:

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

Come potete vedere siamo in grado di controllare qualsiasi cosa, con l'utilizzo di qualcosa di simile a questo nel nostro codice, come accennato, si può semplicemente utilizzare typeof nel tuo codice, ma se si utilizza più e più volte, creare una funzione come la velocità angolare di un campione, che condivido e mantenere il riutilizzo come di seguito LAVAGGIO schema di codice.

Anche una cosa in più, per la verifica di proprietà su un oggetto in una vera e propria applicazione che non è sicuro anche l'oggetto esiste o non esiste, controllare se l'oggetto esiste in primo luogo.

Se si verifica una proprietà di un oggetto e l'oggetto non esiste, verrà generato un errore e interrompere l'intera applicazione in esecuzione.

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

In modo semplice si può avvolgere all'interno di un'istruzione if, come di seguito:

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

Che anche uguale a isDefined Angolare 1.x...

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

Anche altri framework javascript come sottolineatura è simile alla definizione di controllare, ma mi consiglia di utilizzare typeof se già non si utilizza uno qualsiasi dei quadri.

Aggiungo anche questa sezione, MDN, che ha ottenuto informazioni utili su typeof, indefinito e void(0).

Di uguaglianza rigorosa e indefinito
È possibile utilizzare indefinito e di uguaglianza rigorosa e operatori di disuguaglianza per determinare se una variabile ha un valore.Nel codice seguente, la variabile x non è definita, e la se l'istruzione restituisce true.

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

Nota:L'operatore di uguaglianza rigorosa piuttosto che lo standard di uguaglianza l'operatore deve essere utilizzato qui, perché x == undefined controlla anche se x è nullo, mentre l'uguaglianza rigorosa non.null non è equivalente a non definito.Vedere gli operatori di confronto per i dettagli.

Operatore Typeof e indefinito
In alternativa, typeof può essere utilizzato:

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

Una buona ragione per usare typeof è che non genera un errore se l' variabile non è stata dichiarata.

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

Tuttavia, questo tipo di tecnica, che deve essere evitato.JavaScript è un staticamente ambito della lingua, in modo da sapere se una variabile è dichiarata può da leggere, da vedere se si è dichiarato in un allegando contesto.Il unica eccezione è l'ambito globale, ma la portata globale è destinata a l'oggetto globale, in modo da verificare l'esistenza di una variabile in contesto globale può essere fatto controllando l'esistenza di una proprietà su l'oggetto globale (tramite l'operatore in, per esempio).

Void operator e indefinito

L'operatore void è una terza alternativa.

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`)
}

più > > qui

Confrontare con void 0, per la concisione.

if (foo !== void 0)

Non è così dettagliato come if (typeof foo !== 'undefined')

La soluzione non è corretto.In JavaScript,

null == undefined

restituisce true, perché entrambe sono "fuse" per un valore booleano false.Il modo corretto sarebbe quello di controllare

if (something === undefined)

che è l'identità dell'operatore...

Ecco la mia situazione:

Sto usando il risultato di un periodo di RIPOSO di chiamata.Il risultato dovrebbe essere analizzato da JSON per un oggetto JavaScript.

C'è un errore ho bisogno di difendere.Se il args per il resto chiamata non erano corretti, per quanto l'utente specifica il args sbagliato, il resto chiamata torna praticamente vuoto.

Durante l'utilizzo di questo post per aiutarmi a difendersi da questo, ho provato questo.

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

Per la mia situazione, se restResult.dati[0] === "oggetto", quindi posso tranquillamente iniziare ad analizzare il resto dei membri.Se non definito, quindi lancia l'errore di cui sopra.

Quello che sto dicendo è che per la mia situazione, tutti i suggerimenti di cui sopra in questo post non ha funzionato.Non sto dicendo che ho ragione e tutti torto.Io non sono un JavaScript master a tutti, ma spero che questo possa aiutare qualcuno.

C'è una bella ed elegante modo per assegnare una proprietà definita una nuova variabile se è definito o assegnare un valore di default ad esso come una soluzione di ripiego, se le sue indefinite.

var a = obj.prop || defaultValue;

È adatto se si dispone di una funzione che riceve un ulteriore config proprietà:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}

Ora, l'esecuzione di

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

Tutte le risposte sono incomplete.Questo è il modo giusto di sapere che c'è una proprietà 'definito non definito' :

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;

Esempio:

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

Peccato che questa è stata la risposta giusta è sepolto in risposte errate >_<

Così, per chi passa, io vi darò undefineds gratis!!

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

Passando attraverso i commenti, per chi vuole controllare entrambi è indefinito o il suo valore è null:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

Se si utilizza la Libreria jQuery poi jQuery.isEmptyObject() sarà sufficiente per entrambi i casi,

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;

Se si utilizza Angolare:

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

Underscore.js:

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

Io uso if (this.variable) per verificare se è definito.Semplice if (variable), consigliato sopra, non per me.Si scopre che funziona solo quando la variabile è un campo di un oggetto, obj.someField per verificare se è definito nel dizionario.Ma possiamo usare this o window come il dizionario in oggetto, dal momento che qualsiasi variabile è un campo nella finestra corrente, da quanto ho capito.Quindi è un test

if (this.abc) alert("defined"); else alert("undefined");

abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");

Innanzitutto rileva che la variabile abc è indefinito e definito dopo l'inizializzazione.

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

Restituisce false se la variabile è impostata, ed è vero, se non è definito.

Quindi, utilizzare:

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

Anche le stesse cose possono essere scritti più brevi:

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

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

Vorrei mostrarvi qualcosa di sto utilizzando per proteggere il undefined variabile:

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

Questo vieta a chiunque di modificare il window.undefined valore perciò distruggere il codice basato su tale variabile.Se si utilizza "use strict", tutto ciò cercando di cambiare il suo valore si concluderà in errore, altrimenti sarebbe ignorata.

Da lodash.js.

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

Crea una variabile LOCALE denominato undefined che viene inizializzata con il valore di default -- il vero undefined, poi confronta value con la variabile undefined.

Ho a disposizione tre modi qui per coloro che si aspettano strano risposte:

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

isUndefined1:

Cercare di ottenere una proprietà del valore di input, controllare il messaggio di errore, se esiste.Se il valore non è definito, il messaggio di errore sarebbe Uncaught TypeError:Non è possibile leggere la proprietà 'b' undefined

isUndefined2:

Convertire il valore di input di una stringa da confrontare con "undefined" e assicurarsi che il valore negativo.

isUndefined3:

In js, parametro opzionale funziona quando il valore di ingresso è esattamente undefined.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow