Come posso determinare se una variabile è 'indefinita' o 'nulla'?


2131

Come posso determinare se la variabile è undefinedo null?

Il mio codice è il seguente:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};
<div id="esd-names">
  <div id="name"></div>
</div>

Ma se lo faccio, l'interprete JavaScript interrompe l'esecuzione.


Risposte:


2851

È possibile utilizzare le qualità dell'operatore di uguaglianza astratta per fare ciò:

if (variable == null){
    // your code here.
}

Perché null == undefinedè vero, il codice sopra prenderà sia nulle undefined.


5
Sto cercando di verificare se l'evento è null in Firefox e un errore blocca l'esecuzione: "L'evento non è definito"
Entretoize

3
@MichaelFever Come non funziona? Copia incollalo nella tua console: const y = undefined; y == null;dovrebbe tornaretrue
Seraf

2
@ChrisStryczynski Nell'esempio del tuo commento hai dichiarato ycostante, ma stai confrontando abc(non y). Quando ho provato ytramite console.log(y == null);Chrome e Firefox ho ottenuto truecome risultato. Se hai ricevuto un errore, forse hai provato a utilizzare l'operatore di assegnazione =anziché il confronto, il ==che avrebbe senso restituire l'errore poiché constnon può essere riassegnato.
Pshemo,

2
esempio dal vivo di confronti rilevanti. lgtm.
Ryan Haining,

2
@ZaytsevDmitry perché dovresti aspettarti un test se una variabile è nullo undefinedpassa se la variabile è uguale 0? La domanda non riguarda il test per un valore veritiero, ma piuttosto il test esplicito per nullo undefined.
rodrigo-silveira,

1108

Il modo standard per catturare nulle undefinedcontemporaneamente è questo:

if (variable == null) {
     // do something 
}

- che equivale al 100% al più esplicito ma meno conciso:

if (variable === undefined || variable === null) {
     // do something 
}

Quando si scrive JS professionale, si dà per scontato che il tipo di uguaglianza e il comportamento di ==vs=== siano compresi. Pertanto usiamo ==e confrontiamo solo con null.


Modifica di nuovo

I commenti che suggeriscono l'uso di typeofsono semplicemente sbagliati. Sì, la mia soluzione sopra causerà un ReferenceError se la variabile non esiste. Questa è una buona cosa. Questo errore di riferimento è desiderabile: ti aiuterà a trovare i tuoi errori e risolverli prima di spedire il tuo codice, proprio come farebbero gli errori del compilatore in altre lingue. Usa try/ catchse stai lavorando con input su cui non hai il controllo.

Non dovresti avere riferimenti a variabili non dichiarate nel tuo codice.


47
Ciò causerà un errore di riferimento e interromperà l'esecuzione se la variabile non è definita o non viene affatto citata nel codice, l'utilizzo di typeof è più sicuro.
Mani Gandham,

56
Questo è più un punto stilistico. Se la variabile non è stata dichiarata affatto , è davvero solo una cattiva scrittura da parte dell'autore. Dovresti sapere se la tua variabile è stata dichiarata o meno, non dovrebbe essere una domanda. Ma , se per qualche motivo è il caso, questo dovrebbe essere cambiato in window.variable invece che semplicemente variabile , il che non causerà un errore di riferimento. Typeof dovrebbe essere evitato.
temporaneo

6
Sì perché hai scritto !==invece di !=.
temporaneo

9
-OP: L'affermazione che tali confronti sono "equivalenti al 100%" è SEMPLICEMENTE ERRATA, come hai notato nel tuo EDIT, il secondo causerà un errore di riferimento. Per quanto riguarda l'asserzione: "Non dovresti avere riferimenti a variabili non dichiarate nel tuo codice." VERAMENTE? Hai mai sentito parlare di parametri opzionali? jsfiddle.net/3xnbxfsu
Timothy Kanski il

16
I parametri opzionali di @TimothyKanski potrebbero non essere definiti se non vengono forniti facoltativamente, ma sono sicuramente variabili dichiarate. Sono dichiarati e hanno un valore di undefined, come farebbe qualsiasi variabile dichiarata ma non inizializzata, vale a dire var someVar;quindi il tuo argomento non regge davvero
chiliNUT

228

Combinando le risposte di cui sopra, sembra che la risposta più completa sarebbe:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Questo dovrebbe funzionare per qualsiasi variabile non dichiarata o dichiarata e impostata esplicitamente su null o indefinita. L'espressione booleana deve essere valutata come falsa per qualsiasi variabile dichiarata che ha un valore effettivo non nullo.


2
@Aerovistae Riconosco che typeofè un operatore, non una funzione, quindi non ha bisogno delle parentesi, ma apprezzo comunque le parentesi - semplicemente per leggere la chiarezza.
user664833

1
che ne dici di verificare direttamente se (variabile === non definito) invece di usare typeof?
Frozen Crayon

2
@ArjunU che causerà un ReferenceError se la variabile non viene dichiarata. Se non sai se viene dichiarata o meno una variabile, utilizza la soluzione sopra. Se puoi garantire che la variabile sia almeno dichiarata, puoi usarevariable == null
Rogue

3
Questa è una soluzione migliore perché, come sottolineato da @Rogue, la variabile potrebbe non essere dichiarata.
Abdul Sadik Yalcin,

Correggimi se sbaglio, ma il primo condizionale non è un superset del secondo, e quindi il secondo condizionale è superfluo?
Ho marzo

187
if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

14
Nel caso in cui qualcuno pensi che questa sia un'altra mezza risposta, in realtà funziona. undefinedvaluta uguale a null.
Chuck,

3
Non riuscito nella console Chrome ... ReferenceError: la variabile non è definita, quindi potrebbe funzionare, ma non per me ...
Eran Medan

48
Funziona solo con variabili dichiarate, non con variabili che possono o non possono essere dichiarate, cosa che accade raramente. (Devi usare typeof + un controllo null per quel caso)

11
Ho appena capito che puoi aggiungere questo commento: /*jshint eqnull:true */all'inizio del documento o della funzione JS, e JSHint smetterà di avvisarti del tuo utilizzo di == null.
Web_Designer,

3
@Aerovistae puoi indicarmi un riferimento che afferma esplicitamente che ==è rotto. Il coercitivo if(variable == null)in questa risposta ha perfettamente senso per me ...
Ben Aston,

94
if (typeof EmpName != 'undefined' && EmpName) {

valuterà vero se il valore non è:

  • nullo

  • non definito

  • NaN

  • stringa vuota ("")

  • 0

  • falso


13
Penso che questa sia una tecnica pericolosa che si è diffusa come il fuoco selvaggio. Perché molte delle variabili che vengono controllate potrebbero essere booleane o numeri. Quindi, se l'utente non comprende appieno le conseguenze, questo non va bene.
utileBee

Fornisci un riferimento a questa specifica di JavaScript
villamejia,

1
Questo è lo stesso di if (EmpName). Se undefinedsarà già falso.
Rudy,

1
Se la variabile non è definita. quindi se (EmpName) genererà un errore
Thamaraiselvam,

1
@Thamaraiselvam Penso che Rudy avrebbe potuto significare questo var EmpName; if (EmpName). Dove viene definita la variabile ma non è assegnato un valore.
Hungerstar,

28

La attr()funzione jQuery restituisce una stringa vuota o il valore effettivo (e mai nullo undefined). L'unica volta che ritorna undefinedè quando il selettore non ha restituito alcun elemento.

Quindi potresti voler provare contro una stringa vuota. In alternativa, poiché le stringhe vuote, null e undefined sono false-y, puoi semplicemente fare questo:

if (!EmpName) { //do something }

1
Chrome 17.0.963.78 m dà questo errore:ReferenceError: EmpName is not defined
Eran Medan

6
@EranMedan So che è tardi, ma speriamo che aiuti le persone che verranno qui più tardi. Il motivo per cui ricevi un errore è perché non è stato dichiarato affatto. Di solito si vorrebbe che EmpName (o qualche altra variabile) venisse passato in una funzione o che il valore restituito di un'altra funzione fosse dichiarato (Esempio: "var x;"). Per verificare se ha restituito una stringa non definita, nulla o vuota, è possibile utilizzare la soluzione sopra.
Dave,

Mi rendo conto che questa è una domanda fredda, ma jQuery restituirà undefinedse l'attributo non esiste sull'elemento (non solo se il selettore non ha elementi corrispondenti, come per la risposta). Ad esempio, un imgcon no srcritornerebbe undefinedper$('img').attr('src');
codinghands il

20

Sono venuto a scrivere la mia funzione per questo. JavaScript è strano.

È utilizzabile su qualsiasi cosa. (Si noti che questo controlla anche se la variabile contiene valori utilizzabili . Ma poiché queste informazioni sono di solito necessarie, penso che valga la pena pubblicare). Ti preghiamo di considerare di lasciare una nota.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Dattiloscritto-compatibili.


Questa funzione dovrebbe fare esattamente la stessa cosa della empty()funzione di PHP (vedi RETURN VALUES)

Ritiene undefined, null, false, 0, 0.0, "0" {}, []come svuotare.

"0.0", NaN, " ", trueSono considerati non vuota.


2
Ho riscontrato un piccolo problema di controllo null. Voglio verificare se un parametro che viene passato è nullo o un oggetto vuoto { }. Questo è un problema linguistico comune e sciocco, ma me ne ero dimenticato. Tutte le mie ricerche mostrano risposte per valori indefiniti di valore nullo o confronti di uguaglianza libera (==), ma non uguaglianza rigorosa (===) o equivalente. E poi qui nella tua risposta in classifica -1 in fondo alla pagina (prima che io abbia votato) è la risposta che mi ha eluso. Object.keys( obj ).length < 1o forse === 0, supponendo che non sarà mai -1. Comunque, votato a 0, woo. : p

Grazie, sono stato in grado di inserire questa funzione e ripulire un sacco di codice. Perché questa non è una funzione JS standard è oltre me.
Andy,

3
Si dovrebbe cambiare tutto della vostra ==a ===qui, allora questo sarebbe una funzione ragionevole.
Ben McIntyre,

13

Se la variabile che vuoi controllare è globale, fallo

if (window.yourVarName) {
    // Your code here
}

Questo modo di verificare non genererà un errore anche se la yourVarNamevariabile non esiste.

Esempio: voglio sapere se il mio browser supporta l'API Cronologia

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

Come funziona:

windowè un oggetto che contiene tutte le variabili globali come sue proprietà e in JavaScript è legale tentare di accedere a una proprietà dell'oggetto non esistente. Se historynon esiste, window.historyritorna undefined. undefinedè falso, quindi il codice in un if(undefined){}blocco non verrà eseguito.


2
I lettori dovrebbero notare che un approccio come questo è idiomatico per verificare - da JavaScript in esecuzione in un browser - se è stata dichiarata una variabile globale e soprattutto se è disponibile un globale fornito dal browser (come l'API della cronologia). Non funzionerà per verificare se una variabile non globale è nullo undefined, né funzionerà se JavaScript è in esecuzione all'esterno di un browser (ovvero in Node.js). Tratterà anche i globi impostati su 0, falseo ''gli stessi di quelli che sono non dichiarati o undefinedo null, che di solito va bene.
Mark Amery,

Ciò presuppone che lo script sia in esecuzione in un browser. Non è un dato di fatto.
GreenAsJade,

13

Il più breve e semplice:

if(!EmpName ){
 // DO SOMETHING
}

questo valuterà vero se EmpName è:

  • nullo
  • non definito
  • NaN
  • vuoto
  • corda ("")
  • 0
  • falso

3
Il caso d'uso qui è che voglio conoscere la differenza tra indefinito e falso. Userò il controllo su null allora.
gast128,

12

Probabilmente il modo più breve per farlo è:

if(EmpName == null) { /* DO SOMETHING */ };

Ecco la prova:

E qui ci sono maggiori dettagli su ==(fonte qui )

Inserisci qui la descrizione dell'immagine

BONUS : motivo per cui ===è più chiaro di ==(guarda la risposta agc )

Inserisci qui la descrizione dell'immagine


9

Ho appena avuto questo problema, ovvero verificare se un oggetto è nullo.
Lo uso semplicemente:

if (object) {
    // Your code
}

Per esempio:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

3
sarebbe meglio impostare var A = document.getElementById ("enterJob") se (A) A.className + = 'current'; in questo modo lavori al 50% per lo stesso risultato ... Ma forse l'hai fatto solo per gli spettacoli e poi saluto.
Harry Svensson,

8

Dato che stai usando jQuery , puoi determinare se una variabile non è definita o il suo valore è nullo usando una singola funzione.

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;

Questo non ha funzionato per me. Ho ancora ricevuto l'errore: ReferenceError: s is not definedper il primo esempio.
Segna

6

jQuery check element non null:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

5

In JavaScript, per quanto ne so, possiamo controllare una variabile indefinita, nulla o vuota come di seguito.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Controlla tutte le condizioni:

if(variable === undefined || variable === null || variable === ''){
}

varè una parola riservata, questo lanceràSyntaxError
dhilt il

5

Puoi semplicemente usare quanto segue (so che ci sono modi più brevi per farlo, ma questo potrebbe rendere più facile l'osservazione visiva, almeno per gli altri che guardano il codice).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

4

Il modo più semplice per verificare è:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

1
Questo eseguirà il codice se la variabile ha un valore di false, che è potenzialmente indesiderabile.
byxor,

La domanda è chiara "Come determinare se la variabile è" non definita "o" nulla "?" e in javascript se una variabile ha un valore nullo o indefinito, il suo valore è falso.
M. Arnold,

1
Scusa, ma non è corretto. Ecco un JSfiddle per dimostrarlo.
byxor,

Con la vostra risposta, undefined, null e un paio di altre cose come stringa vuota, 0, -0 NaNe falsepassare. !operatore costringe l'operando variable- qui - a booleano: ecma-international.org/ecma-262/#sec-toboolean
Alireza

Ma controlla la domanda: "Come determinare se una variabile è indefinita o nulla", il! l'operando utilizzato con un if tornerà sempre su true se la variabile è nulla o non definita.
M. Arnold,

3

Con la soluzione di seguito:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Sono in grado di verificare quanto segue:

  • nullo
  • non definito
  • NaN
  • vuoto
  • corda ("")
  • 0
  • falso

Questo non risponde alla domanda, che è "come posso catturare null e indefinito?" non "come posso rilevare ogni valore di falso in JavaScript?"
temporaneo

@Aerovistae, pensavo di averlo fatto con console.log (isDeepEqual (null, null)); e console.log (isDeepEqual (undefined, undefined)); ?
Tony Tai Nguyen,

2

Per verificare se una variabile è nulla o non definita, utilizzo il codice seguente.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Chiudi ma no. Perdi il typeofe confrontalo per undefineddirlo, non come una stringa. Funziona ma l'operatore extra non ha alcun effetto se non quello di renderlo più elaborato.
temporaneo

In questo caso sì, hai ragione, non abbiamo bisogno di usare typeof. Ma è una buona pratica usare typeof quando si ha a che fare con variabili non definite. Un motivo per utilizzare typeof è che non genera un errore se la variabile non è stata dichiarata.
DanKodi,

In realtà è una brutta cosa. Non vuoi variabili non dichiarate nel tuo codice. Volete che lanci un ReferenceError in modo da poter trovare la variabile e dichiararla. Certamente non lo proveresti in un linguaggio compilato come C ++! Solo perché JS lo consente non significa che dovrebbe essere fatto.
temporaneo

1
La tua o dichiarazione è al contrario. Controllare che qualcosa non sia definito sarebbe il primo passo, non il secondo.
Anthony Rutledge,

2

Eseguo questo test nella console di Chrome. Usando (void 0) puoi controllare undefined:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

2

Diamo un'occhiata a questo,

  1.  

    let apple; // Only declare the variable as apple
    alert(apple); // undefined

    In quanto sopra, la variabile è dichiarata solo come apple. In questo caso, se chiamiamo metodo alertverrà visualizzato indefinito.

  2.  

       let apple = null; /* Declare the variable as apple and initialized but the value is null */
       alert(apple); // null

Nel secondo viene visualizzato null, poiché la variabile di applevalore è null.

Quindi puoi verificare se un valore è indefinito o nullo.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

1

Miglior modo:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

6
Questa soluzione esatta è già stata fornita da @jkindwall l'11 ottobre 2013. stackoverflow.com/a/19323555/2943403 Questo post di solo codice è completamente inutile perché non aggiunge alcun nuovo valore alla pagina. In effetti, sta aggiungendo un eccesso di pagina e sta sprecando il tempo dei ricercatori a leggerlo. Rimuovi questa risposta.
mickmackusa,

1
(null == undefined)  // true

(null === undefined) // false

Perché === controlla sia il tipo che il valore. Il tipo di entrambi è diverso ma il valore è lo stesso.


1
var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

3
Cosa succede se l'utente inserisce la parola "non definito"?
Chuck,

La tua domanda è buona, mostra che la condizione è vera, quindi dobbiamo cambiare l'opzione normale non definita in tipo di condizione. @Chuck
KARTHIKEYAN.A

Questo è sbagliato. typeofnon cederà mai undefined, solo la stringa 'undefined'. Inoltre, i == nullè già vero se lo iè undefined, quindi il secondo booleano sarebbe ridondante anche se funzionasse.
temporaneo

1
Questa soluzione (con le condizioni invertite) è già stata fornita da @jkindwall l'11 ottobre 2013. stackoverflow.com/a/19323555/2943403 Questo post di solo codice è completamente inutile perché non aggiunge alcun nuovo valore alla pagina. In effetti, sta aggiungendo un eccesso di pagina e sta sprecando il tempo dei ricercatori a leggerlo. Rimuovi questa risposta.
Mickmackusa,

1

Il foo == nullcontrollo dovrebbe fare il trucco e risolvere il caso "non definito OR null" nel modo più breve. (Non considerando il caso "foo non dichiarato"). Ma le persone che sono abituate ad avere 3 uguali (come la migliore pratica) potrebbero non accettarlo. Guarda le regole di eqeqeq o triple- egals in eslint e tslint ...

L'approccio esplicito, quando stiamo verificando se una variabile è undefinedo nullseparatamente, dovrebbe essere applicato in questo caso, e il mio contributo all'argomento (27 risposte non negative per ora!) È di usare void 0sia un modo breve che sicuro per eseguire il controllo per undefined.

L'uso foo === undefinednon è sicuro perché non definito non è una parola riservata e può essere ombreggiato ( MDN ). L'uso di typeof === 'undefined'check è sicuro, ma se non ci occuperemo del caso foo-is -larlared è possibile utilizzare il seguente approccio:

if (foo === void 0 || foo === null) { ... }

1

se si crea una funzione per verificarla:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

-1

La chiamata di typeof null restituisce un valore di "oggetto", poiché il valore speciale null viene considerato come riferimento a un oggetto vuoto. Safari fino alla versione 5 e Chrome fino alla versione 7 hanno una stranezza in cui la chiamata di typeof su un'espressione regolare restituisce "funzione" mentre tutti gli altri browser restituiscono "oggetto".


-1
var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Puoi usare solo il secondo: poiché controllerà sia la definizione che la dichiarazione


-1

Penso ancora che il modo migliore / sicuro per testare queste due condizioni sia quello di trasmettere il valore a una stringa:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

puoi spiegare perché ritieni che questo sia il "modo migliore / sicuro" per eseguire i test?
sadmic Microwave,

Poiché la conversione restituisce sempre una stringa "standardizzata" (ovvero [oggetto indefinito]), non si verificano problemi verificando i valori falsi. Questa è solo la mia opinione basata su esperienze che ho avuto con valori di verità / falsità.
n1kkou,

Grazie per la spiegazione. Non sto criticando, è una risposta interessante, volevo solo che tu fornissi una spiegazione per gli altri sul perché questo è potenzialmente superiore ad altri metodi.
sadmic Microwave,

Nessun problema! Ho avuto molti problemi con questo tipo di confronti e fino ad ora lo trovo come l'approccio più utile in materia.
n1kkou,

-2

Puoi verificare se il valore è indefinito o nullo semplicemente usando typeof:

if(typeof value == 'undefined'){

Vedere i commenti nella risposta precedente ( stackoverflow.com/a/21273362/6305294 ) per quanto riguarda il tipo di.
Alex,

4
Questo non è corretto Non cattura null. Non capisco perché vengono fornite risposte nuove e errate a una domanda a cui è stata data una risposta corretta e completa molti anni fa. Pensi che le risposte attuali siano in qualche modo insufficienti?
temporaneo

-4

if(x==null)è una cattiva idea in JavaScript. Giudicare con "=="- può causare una coercizione di tipo imprevista e non può essere letto da CoffeeScript, non usare mai "==" o "! =" Nel giudizio di condizione!

if(x)andrà meglio, ma fai attenzione con 0 e "" . Sarà trattata come falsa , non il metodo di parità con "!= null"è vero .

Inserisci qui la descrizione dell'immagine

Vedi le best practice di JavaScript .


3
Ciò è completamente errato e lo studio rapido di qualsiasi framework o software di livello professionale lo confermerà in pochi istanti. Usare ==per confrontare con nullè il modo standard di cattura nulle undefinedin JS. La coercizione del tipo con ==non è un rischio in questo specifico contesto e viene infatti sfruttata per raggiungere l'obiettivo di catturare sia nulle undefinedcontemporaneamente. Per favore, dedica più tempo a lavorare con la lingua prima di scegliere di offrire risposte errate e fuorvianti a domande che sono state risolte in modo soddisfacente anni fa.
temporaneo

evitare "==". Tutto è sempre in continua evoluzione, non sono d'accordo con te @Aerovistae
Albert.Qing

3
Non sei in disaccordo con me , non sei d'accordo con l'intero stabilimento JavaScript. Cerchiamo di essere chiari.
temporaneo
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.