Tutti i valori di falso in JavaScript

Quali sono i valori in JavaScript che sono 'falso' , nel senso che valutano come falsi in espressioni come if(value), value ?e !value?

Esistono già alcune discussioni sullo scopo dei valori di falsey su Stack Overflow , ma nessuna esaustiva risposta completa che elenca quali sono tutti i valori di falsey.

Non sono riuscito a trovare alcun elenco completo su Riferimenti JavaScript MDN e sono stato sorpreso di scoprire che i risultati migliori quando cercavo un elenco completo e autorevole di valori di falsi in JavaScript erano articoli del blog, alcuni dei quali presentavano ovvie omissioni (ad esempio, NaN) e nessuno dei quali aveva un formato come Stack Overflow in cui si potevano aggiungere commenti o risposte alternative per evidenziare stranezze, sorprese, omissioni, errori o avvertenze. Quindi, sembrava logico crearne uno.

Valori di Falsey in JavaScript

• false
• Zero del Numbertipo: 0e anche -0, 0.0e forma esagonale 0x0( RBT grazie )
• Zero di BigInttipo: 0ne -0n(nuovo nel 2020, grazie GetMeARemoteJob )
• "", ''E ``- stringhe di lunghezza 0
• null
• undefined
• NaN
• document.all (solo nei browser HTML)
  • Questo è strano. document.allè un oggetto falso, con typeofas undefined. Era una funzione di proprietà di Microsoft in IE prima di IE11 e veniva aggiunta alla specifica HTML come "violazione intenzionale della specifica JavaScript" in modo che i siti scritti per IE non si interrompessero nel tentativo di accedere, ad esempio document.all.something; è falso perché if (document.all)era un modo popolare per rilevare IE, prima dei commenti condizionali. Vedi Perché document.all è falso? per dettagli

"Falsey" significa semplicemente che la ToBooleanfunzione interna di JavaScript ritorna false. ToBooleansottende !value, value ? ... : ...;e if (value). Ecco le sue specifiche ufficiali (bozza di lavoro del 2020) (le uniche modifiche dalla prima specifica ECMAscript del 1997 sono l'aggiunta dei simboli ES6 , che sono sempre veritieri, e BigInt, di cui sopra:

Confronti con ==(uguaglianza libera)

Vale la pena parlare dei falsi confronti con i== valori falsi , che usano ToNumber()e possono causare confusione a causa delle differenze sottostanti. Formano effettivamente tre gruppi:

• false, 0, -0, "", '' tutti coincidono con ==
  • ad es false == "". '' == 0e quindi4/2 - 2 == 'some string'.slice(11);
• null, undefined abbinare con ==
  • ad es. null == undefinedmaundefined != false
  • Vale anche la pena ricordare che mentre typeof nullritorna 'object', nonnull è un oggetto, si tratta di un bug / stranezza di vecchia data che non è stato risolto al fine di mantenere la compatibilità. Non è un oggetto vero e gli oggetti sono veritieri (tranne per quella "violazione intenzionale" document.allquando Javascript è implementato in HTML)
• NaN non corrisponde a nulla, con ==o ===nemmeno se stesso
  • ad esempio NaN != NaN, NaN !== NaN, NaN != false,NaN != null

Con "uguaglianza rigorosa" ( ===), non esistono tali raggruppamenti. Solo false === false.

Questo è uno dei motivi per cui molti sviluppatori e molte guide di stile (ad esempio standardjs ) preferiscono ===e non usano quasi mai ==.

Valori veri che in realtà == false

"Verità" significa semplicemente che la ToBooleanfunzione interna di JavaScript ritorna true. Un cavillo di Javascript di essere a conoscenza (e un altro buon motivo per preferire ===sopra ==): è possibile per un valore da truthy ( ToBooleanrendimenti true), ma anche == false.

Potresti pensare che if (value && value == false) alert('Huh?')sia un'impossibilità logica che non potrebbe accadere, ma lo farà, per:

• "0"e '0'- sono stringhe non vuote, che sono veritiere, ma Javascript ==corrisponde numeri con stringhe equivalenti (ad es 42 == "42".). Dal momento che 0 == false, se "0" == 0, "0" == false.
• new Number(0)e new Boolean(false)- sono oggetti, che sono veri, ma ==vede i loro valori, quali == false.
• 0 .toExponential(); - un oggetto con un valore numerico equivalente a 0
• Qualsiasi costruzione simile che ti dia un valore di falso eguaglianza racchiuso in un tipo che è vero
• [], [[]]E [0](grazie cloudfeet per il collegamento JavaScript uguaglianza Tabella )

Alcuni valori più veritieri

Questi sono solo alcuni dei valori che alcune persone potrebbero aspettarsi di essere falsi, ma in realtà sono veri.

• -1 e tutti i numeri negativi diversi da zero
• ' ', " ", "false", 'null'... tutte le stringhe non vuote, tra le stringhe che sono solo gli spazi bianchi

• Qualsiasi cosa typeof, che restituisce sempre una stringa non vuota, ad esempio:

  • typeof null(restituisce una stringa a 'object' causa di un bug / stranezza di vecchia data )
  • typeof undefined(restituisce una stringa 'undefined')

• Qualsiasi oggetto (tranne quella "violazione intenzionale" document.allnei browser; ricorda che in nullrealtà non è un oggetto nonostante typeofsuggerisca diversamente). Compreso:

  • {}
  • []
  • function(){}o () => {}(qualsiasi funzione, comprese le funzioni vuote)
  • Error e qualsiasi istanza di Error
  • Qualsiasi espressione regolare
  • Qualsiasi cosa creata con new(incluso new Number(0)e new Boolean(false))
• Qualsiasi simbolo

true, 1, "1"E [1]il ritorno truein confronto tra loro con ==.

Non dimenticare la stringa non vuota "false"che valutatrue

Solo per aggiungere all'elenco di @ user568458 i valori falsi:

• Oltre al numero intero 0, anche il numero decimale 0,0, 0,00 o qualsiasi altro numero zero è un valore falso.

  var myNum = 0.0;
  if(myNum){
      console.log('I am a truthy value');
  }
  else {
      console.log('I am a falsy value');
  }

  Stampe sopra lo snippet di codice I am a falsy value

• Allo stesso modo la rappresentazione esadecimale del numero 0 è anche un valore errato, come mostrato nello snippet di codice seguente:

  var myNum = 0x0; //hex representation of 0
  if(myNum){
      console.log('I am a truthy value');
  }   
  else {
      console.log('I am a falsy value');
  }

  Lo snippet di codice sopra viene nuovamente stampato I am a falsy value.

Oltre all'argomento, a partire da ES2020 abbiamo un nuovo valore che è falso, è BigInt zero (0n):

0n == false // true
-0n == false // true

Quindi, con questo, ora abbiamo 7 valori "falsi" in totale (escluso document.all come menzionato dall'utente sopra poiché fa parte di DOM e non di JS).