JavaScript controlla se la variabile esiste (è definita / inizializzata)


Answers

L'operatore typeof controllerà se la variabile è davvero indefinita.

if (typeof variable === 'undefined') {
    // variable is undefined
}

L'operatore typeof , a differenza degli altri operatori, non genera un'eccezione ReferenceError quando viene utilizzata con una variabile non dichiarata.

Tuttavia, si noti che typeof null restituirà "object" . Dobbiamo stare attenti a evitare l'errore di inizializzare una variabile su null . Per sicurezza, questo è quello che potremmo usare invece:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

Per maggiori informazioni sull'uso del confronto rigoroso === invece dell'uguaglianza semplice == , vedere:
Quale operatore uguale (== vs ===) dovrebbe essere utilizzato nei confronti JavaScript?

Question

Quale metodo per verificare se una variabile è stata inizializzata è migliore / corretto? (Supponendo che la variabile possa contenere qualsiasi cosa (stringa, int, oggetto, funzione, ecc.))

if (elem) { // or !elem

o

if (typeof(elem) !== 'undefined') {

o

if (elem != null) {



Nella maggior parte dei casi useresti:

elem != null

A differenza di un semplice if (elem) , consente 0 , false , NaN e '' , ma rifiuta null o undefined , rendendolo un buon test generale per la presenza di un argomento o proprietà di un oggetto.

Anche gli altri controlli non sono sbagliati, hanno solo usi diversi:

  • if (elem) : può essere usato se elem è garantito come oggetto, o se false , 0 , ecc. sono considerati valori "predefiniti" (quindi equivalenti a undefined o null ).

  • typeof elem == 'undefined' può essere usato nei casi in cui un valore null specificato ha un significato distinto per una variabile o una proprietà non inizializzata.

    • Questo è l'unico controllo che non genera un errore se elem non viene dichiarato (cioè nessuna istruzione var , non una proprietà di window , o non un argomento di funzione). Questo è, a mio avviso, piuttosto pericoloso in quanto consente agli errori di battitura di passare inosservati. Per evitare ciò, vedere il metodo seguente.

Utile anche un confronto rigoroso contro undefined :

if (elem === undefined) ...

Tuttavia, poiché il globale undefined può essere sostituito con un altro valore, è meglio dichiarare la variabile undefined nell'ambito corrente prima di utilizzarla:

var undefined; // really undefined
if (elem === undefined) ...

O:

(function (undefined) {
    if (elem === undefined) ...
})();

Un vantaggio secondario di questo metodo è che i minificatori JS possono ridurre la variabile undefined a un singolo carattere, risparmiando ogni volta qualche byte.




Controlla se un oggetto hasOwnProperty()

Un'alternativa alla pletora di typeof risposte, è l'uso di hasOwnProperty() che ovviamente controlla se un oggetto (praticamente tutto in JS) ha una proprietà cioè una variabile (tra le altre cose).

Il metodo hasOwnProperty() restituisce un valore booleano che indica se l'oggetto ha la proprietà specificata come proprietà propria (non ereditata).

Ogni oggetto discendente da Object eredita il metodo hasOwnProperty() . Questo metodo può essere utilizzato per determinare se un oggetto ha la proprietà specificata come proprietà diretta di tale oggetto; a differenza dell'operatore in, questo metodo non controlla la catena del prototipo dell'oggetto.

// Globally established (therefore) properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
// window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ),             // true
    window.hasOwnProperty( "bar" ),             // true
    window.hasOwnProperty( "baz" ),             // true
    window.hasOwnProperty( "qux" ),             // false
    { foo: [], bar: 0 }.hasOwnProperty( "bar" ) // true
] );

La cosa fantastica di hasOwnProperty() è che nel chiamarla, non usiamo una variabile che potrebbe essere ancora indefinita - che ovviamente è metà del problema in primo luogo.

Sebbene non sia sempre la soluzione perfetta o ideale , in determinate circostanze, è proprio il lavoro!




indefinito, booleano, stringa, il numero, la funzione

if( typeof foo !== 'undefined' ) { 

}

Oggetto, Array

if( foo instanceof Array ) { 

}



In molti casi, usando:

if (elem) { // or !elem

farà il lavoro per te ... questo controllerà i seguenti casi:

  1. indefinito : se il valore non è definito e non è undefined
  2. null : se è nullo, ad esempio se un elemento DOM non esiste ...
  3. stringa vuota : ''
  4. 0 : numero zero
  5. NaN : non un numero
  6. falso

Quindi coprirà il tipo di tutti i casi, ma ci sono sempre casi strani che vorremmo coprire, ad esempio una stringa con spazi, come questa ' ' , questo sarà definito in javascript in quanto ha spazi all'interno della stringa. .. per esempio in questo caso si aggiunge un altro controllo usando trim (), come:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Creo anche l'immagine qui sotto per mostrare un breve riassunto della risposta:




if (typeof console != "undefined") {    
   ...
}

O meglio

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

Funziona su tutti i browser




Il più robusto 'è definito' il controllo è con typeof

if (typeof elem === 'undefined')

Se stai solo verificando la presenza di una variabile definita che assegna un valore predefinito, per una copertina di facile lettura puoi farlo spesso:

elem = elem || defaultElem;

Spesso è bene usare, vedi: Modo idiomatico per impostare il valore predefinito in javascript

C'è anche questo un liner con la parola chiave typeof :

elem = (typeof elem === 'undefined') ? defaultElem : elem;



Null è un valore in JavaScript e typeof null restituisce "object"

Pertanto, la risposta accettata non funzionerà se si passano valori nulli. Se si passano valori nulli, è necessario aggiungere un controllo supplementare per i valori nulli:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}



Nella particolare situazione descritta nella domanda,

typeof window.console === "undefined"

è identico a

window.console === undefined

Preferisco quest'ultimo dato che è più corto.

Si prega di notare che cerchiamo console solo in ambito globale (che è un oggetto window in tutti i browser). In questa particolare situazione è desiderabile. Non vogliamo che la console definita altrove.

@ BrianKelley nella sua grande risposta spiega i dettagli tecnici. Ho solo aggiunto la mancanza di conclusioni e l'ho digerito in qualcosa di più facile da leggere.




Dipende dalla situazione. Se stai cercando qualcosa che potrebbe essere o non essere stato definito globalmente al di fuori del tuo codice (come forse jQuery) vuoi:

if (typeof(jQuery) != "undefined")

(Non c'è bisogno di una rigorosa uguaglianza, typeof restituisce sempre una stringa.) Ma se si hanno argomenti per una funzione che può essere o non essere stata passata, saranno sempre definiti, ma null se omessi.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"



Io uso due modi diversi a seconda dell'oggetto.

if( !variable ){
  // variable is either
  // 1. empty string i.e. '';
  // 2. Integer 0;
  // 3. undefined;
  // 4. null;
}

A volte non voglio valutare una stringa vuota come falsa, quindi uso questo caso

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Se hai bisogno del contrario, allora in prima istanza! La variabile diventa !! variabile, e nella funzione non valida === diventa! = Ei nomi delle funzioni cambiano in nonInvalid.




Se vuoi che il blocco definito faccia qualcosa, usa questo

if (typeof variable !== 'undefined') {
    // the variable is defined
}

Se vuoi che il blocco non definito faccia qualcosa o assegni o definisca la variabile, allora usa questo

if (typeof variable === 'undefined') {
    // the variable is undefined
}



Per verificare se una variabile è stata dichiarata / impostata ho fatto questo trucco sporco.

Non ho trovato un modo per estrarre il codice da una funzione, anche con eval .

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}



Non riesco a vederlo nelle risposte sopra, quindi lo suggerirò qui, immagino.

function isDefined(x) { return !!x }

if( isDefined(x) ) {
    //The variable is defined
}

! x restituirà true iff x è nullo o non definito , quindi !! x restituirà solo vero iff x non è né indefinito né nullo.

Mi rendo conto che questo spiega anche il caso nullo, ma ecco un giusto avvertimento a riguardo.