Quali sono i valori di verità e falsi in AngularJS?

Question

Penso che verrà preso in considerazione nel contesto di ng-show o ng-class? Ci sono altre situazioni? Sembra che la verità e il falso siano leggermente diversi dal puro JavaScript, ma l'unica eccezione che conosco finora è [] - che è vero in JavaScript ma falsa in AngularJS.

(in realtà, ho provato con AngularJS 1.2.1 e [] è falsy, mentre AngularJS 1.4.8 e 1.5.0, [] è truthy. https://jsfiddle.net/6ayaLhbk/ vedere, https://jsfiddle.net/6ayaLhbk/1/ e https://jsfiddle.net/6ayaLhbk/2/)

Credo che abbia una presa che si può pensare ng-show="ctrl.foo" è la stessa di ng-hide="!ctrl.foo" ma nel caso di Angular 1.2.1, non lo è. Per ottenere il risultato identico di puro JavaScript angolare 1.2.1, sembra che possiamo usare ng-show="!!ctrl.foobar"https://jsfiddle.net/6ayaLhbk/3/

Se è ng-class in angolare 1.2.1, quindi sembra che risale al JS regola truthy e falsy puro : https://jsfiddle.net/6ayaLhbk/5/

Answer 1

espressioni angolari sono come le espressioni JavaScript con le seguenti differenze:

Contesto: JavaScript espressioni sono valutate contro la finestra globale. In Angolare, le espressioni vengono valutate rispetto a un oggetto ambito.

Perdonatore: In JavaScript, il tentativo di valutare le proprietà non definite genera ReferenceError o TypeError. In Angular, la valutazione delle espressioni è indulgente a indefinito e nullo.

Filtri: è possibile utilizzare i filtri all'interno delle espressioni per formattare i dati prima di visualizzarli.

Nessuna dichiarazione di flusso di controllo: Non è possibile utilizzare quanto segue in un'espressione Angolare: condizionali, cicli o eccezioni.

Nessuna dichiarazione di funzione: non è possibile dichiarare funzioni in un'espressione angolare, anche all'interno della direttiva ng-init.

Nessuna creazione RegExp con notazione letterale: Non è possibile creare espressioni regolari in un'espressione Angolare.

Nessuna creazione di oggetti con nuovo operatore: Non è possibile utilizzare il nuovo operatore in un'espressione Angolare.

Nessun Operatore bit a bit, virgola e vuoto: Non è possibile utilizzare Operatori bit a bit, o nulli in un'espressione Angolare.

Source

Answer 2

Prima angolare 1.2.7,

espressioni che erano una funzione con uno o più argomenti valutati al vero, ma le funzioni con zero argomenti è risultata falsa.

Questo comportamento sembra non intenzionale e indesiderabile.Questa patch rende una funzione indipendente dal suo numero di argomenti.

Si prega di trovare il link GitHub: https://github.com/angular/angular.js/commit/01c5be4681e34cdc5f5c461b7a618fefe8038919

Answer 3

I seguenti valori sono sempre falsy:

• falsa
• "" (stringa vuota)
• 0 (zero)
• null
• undefined
• NaN (un valore Numero speciale significato non-a-numero!)

Tutti gli altri valori sono truthy, tra cui "0" (zero tra virgolette), "false" (false tra virgolette) , funzioni vuote, matrici vuote e oggetti vuoti.

var a = !!(0); // variable is set to false 
var b = !!("0"); // true 

Confrontando Falsy Valori valori Falsy seguire alcune regole di confronto un po 'strano che può portare a errori nella logica del programma.

I valori falsy falsa, 0 (zero), e "" (stringa vuota) sono tutti equivalenti e possono essere confrontati uno contro l'altro:

var c = (false == 0); // true 
var d = (false == ""); // true 
var e = (0 == ""); // true 

I valori falsy nullo e indefinito non sono equivalenti a nulla tranne se stessi:

var f = (null == false); // false 
var g = (null == null); // true 
var h = (undefined == undefined); // true 
var i = (undefined == null); // true 

Infine, il valore falsy NaN non è equivalente a qualsiasi cosa - compreso NaN!

var j = (NaN == null); // false 
var k = (NaN == NaN); // false 

Si dovrebbe anche essere consapevoli del fatto che typeof(NaN) restituisce "numero". Fortunatamente, la funzione JavaScript nucleo isNaN() può essere utilizzata per valutare se un valore è NaN o meno.

In caso di dubbio ... Usa rigorosa uguale (===) e la rigorosa non uguale (! ==) in situazioni in cui i valori truthy o falsy potrebbe portare ad errori di logica. Questi operatori assicurano che gli oggetti vengano confrontati per tipo e per valore.

var l = (false == 0); // true 
var m = (false === 0); // false