while - javascript string not equal




Qual 'é !!(non non) operatore in JavaScript? (20)

! è "non booleano", che essenzialmente tipizza il valore di "abilita" al suo opposto booleano. Il secondo ! ribalta questo valore. Quindi, !!enable significa "not not enable", dandoti il ​​valore di enable come booleano.

Ho visto un codice che sembra utilizzare un operatore che non riconosco, sotto forma di due punti esclamativi, in questo modo: !! . Qualcuno può dirmi cosa fa questo operatore?

Il contesto in cui ho visto questo era,

this.vertical = vertical !== undefined ? !!vertical : this.vertical;

È solo l'operatore logico NOT, due volte: è usato per convertire qualcosa in booleano, ad esempio:

true === !!10

false === !!0

È una doppia operazione. Il primo ! converte il valore in booleano e inverte il suo valore logico. Il secondo ! inverte il valore logico.


Alcuni operatori in JavaScript eseguono conversioni di tipo implicito e talvolta vengono utilizzati per la conversione dei tipi.

L'unario ! l'operatore converte il suo operando in un booleano e lo nega.

Questo fatto porta al seguente idioma che puoi vedere nel tuo codice sorgente:

!!x // Same as Boolean(x). Note double exclamation mark

Coerces oObject su booleano. Se fosse falso (es. 0, null , undefined , ecc.), Sarà false , altrimenti true .

!oObject  //Inverted boolean
!!oObject //Non inverted boolean so true boolean representation

Quindi !! non è un operatore, è solo il ! operatore due volte.

Esempio di mondo reale "Prova versione IE":

let isIE8 = false;  
isIE8 = !! navigator.userAgent.match(/MSIE 8.0/);  
console.log(isIE8); // returns true or false 

Se tu ⇒

console.log(navigator.userAgent.match(/MSIE 8.0/));  
// returns null  

ma se tu ⇒

console.log(!!navigator.userAgent.match(/MSIE 8.0/));  
// returns true or false

Converte il suffisso in un valore booleano.


Doppia negazione booleana. Spesso usato per verificare se il valore non è indefinito.


Il !! costrutto è un modo semplice per trasformare qualsiasi espressione JavaScript nel suo equivalente booleano.

Ad esempio: !!"he shot me down" === true e !!0 === false .


Non è un solo operatore, sono due. È equivalente al seguente ed è un modo rapido per assegnare un valore booleano.

val.enabled = !(!enable);

Penso che degno di nota è che una condizione combinata con AND / OR logico non restituirà un valore booleano ma l'ultimo successo o il primo esito negativo nel caso di && e il primo successo o l'ultimo errore in caso di || della catena di condizioni.

res = (1 && 2); // res is 2
res = (true && alert) // res is function alert()
res = ('foo' || alert) // res is 'foo'

Per trasmettere la condizione a un vero valore letterario booleano, possiamo usare la doppia negazione:

res = !!(1 && 2); // res is true
res = !!(true && alert) // res is true
res = !!('foo' || alert) // res is true

Sembra che il !! l'operatore produce una doppia negazione.

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true

Simula il comportamento della funzione di fusione Boolean() . Il primo NOT restituisce un valore booleano indipendentemente dall'operando che viene fornito. Il secondo NOT nega quel valore Boolean e quindi fornisce il true valore booleano di una variabile. Il risultato finale è lo stesso dell'utilizzo della funzione Boolean() su un valore.


Utilizzare l'operatore logico non due volte
significa! true = false
e !! true = true


Volevo solo aggiungere quello

if(variableThing){
  // do something
}

equivale a

if(!!variableThing){
  // do something
}

Ma questo può essere un problema quando qualcosa non è definito.

// a is undefined, b is empty object.
var a, b = {};

// Both of these give error a.foo is not defined etc.
// you'd see the same behavior for !!a.foo and !!b.foo.bar

a.foo 
b.foo.bar

// This works -- these return undefined

a && a.foo
b.foo && b.foo.bar
b && b.foo && b.foo.bar

Il trucco qui è la catena di && s restituirà il primo valore di falsi che trova - e questo può essere inserito in un'istruzione if ecc. Quindi se b.foo non è definito, ritornerà indefinito e salterà la b.foo.bar dichiarazione, e non otteniamo alcun errore.

Il sopra riportato non è definito ma se hai una stringa vuota, false, null, 0, indefinite, quei valori torneranno e appena li incontreremo nella catena - [] e {} sono entrambi veritieri.


!! converte il valore a destra di esso al suo valore booleano equivalente. (Pensa al modo in cui il "tipo-casting" del povero). Il suo intento è solitamente quello di trasmettere al lettore che il codice non si cura di quale valore è nella variabile, ma qual è il suo valore "verità" .


!! sta usando l'operazione NOT due volte insieme ! convertire il valore in un boolean e invertire, ecco un semplice esempio per vedere come !! lavori:

All'inizio, posto hai:

var zero = 0;

Allora fai !0 , sarà convertito in booleano e sarà valutato true , perché 0 è falsy , quindi ottieni il valore inverso e convertito in booleano, quindi viene valutato true .

!zero; //true

ma non vogliamo la versione booleana invertita del valore, quindi possiamo invertire nuovamente per ottenere il nostro risultato! Ecco perché ne usiamo un altro ! .

Fondamentalmente, !! rendici sicuri, il valore che otteniamo è booleano, non falsy, verità o stringa ecc ...

Quindi è come usare Boolean funzione Boolean in javascript, ma è un modo facile e più breve per convertire un valore in booleano:

var zero = 0;
!!zero; //false

!!expr restituisce un valore booleano ( true o false ) a seconda della veridicità dell'espressione. Ha più senso se usato su tipi non booleani. Considera questi esempi, specialmente il terzo esempio e in poi:

          !!false === false
           !!true === true

              !!0 === false
!!parseInt("foo") === false // NaN is falsy
              !!1 === true
             !!-1 === true  // -1 is truthy

             !!"" === false // empty string is falsy
          !!"foo" === true  // non-empty string is truthy
        !!"false" === true  // ...even if it contains a falsy value

     !!window.foo === false // undefined is falsy
           !!null === false // null is falsy

             !!{} === true  // an (empty) object is truthy
             !![] === true  // an (empty) array is truthy; PHP programmers beware!

!!foo applica l'operatore unary not due volte e viene utilizzato per eseguire il cast su un tipo booleano simile all'utilizzo di unary plus +foo per eseguire il cast sul numero e concatenare una stringa vuota ''+foo per eseguire il cast alla stringa.

Invece di questi hack, puoi anche usare le funzioni di costruzione corrispondenti ai tipi primitivi ( senza usare new ) per esprimere esplicitamente i valori, cioè

Boolean(foo) === !!foo
Number(foo)  === +foo
String(foo)  === ''+foo

Prepara un po 'di tè:

!! non è un operatore. È il doppio uso di ! - che è l'operatore logico "non".

In teoria:

! determina la "verità" di ciò che un valore non è:

  • La verità è che il false non è true (ecco perché !false Risultati !false in true )

  • La verità è che il true non è false (ecco perché !true Risultati !true in false )

!! determina la "verità" di ciò che un valore non è:

  • La verità è che il true non è true (ecco perché !!true risultati true in true )

  • La verità è che il false non è false (ecco perché !!false risultati false in false )

Ciò che desideriamo determinare nel confronto è la "verità" sul valore di un riferimento, non sul valore del riferimento stesso. C'è un caso d'uso in cui potremmo voler sapere la verità su un valore, anche se ci aspettiamo che il valore sia false (o falso), o se ci aspettiamo che il valore non sia di tipo boolean .

In pratica:

Si consideri una funzione concisa che rileva la funzionalità delle funzionalità (e in questo caso la compatibilità della piattaforma) mediante la digitazione dinamica (ovvero "digitazione anatra"). Vogliamo scrivere una funzione che ritorna true se il browser di un utente supporta l'elemento <audio> HTML5, ma non vogliamo che la funzione lanci un errore se <audio> non è definito; e non vogliamo usare try ... catch per gestire eventuali errori (perché sono grossolani); e inoltre non vogliamo utilizzare un controllo all'interno della funzione che non rivelerà in modo coerente la verità sulla funzione (ad esempio, document.createElement('audio') creerà comunque un elemento chiamato <audio> anche se HTML5 <audio> non è supportato).

Ecco i tre approcci:

// this won't tell us anything about HTML5 `<audio>` as a feature
var foo = function(tag, atr) { return document.createElement(tag)[atr]; }

// this won't return true if the feature is detected (although it works just fine)
var bar = function(tag, atr) { return !document.createElement(tag)[atr]; }

// this is the concise, feature-detecting solution we want
var baz = function(tag, atr) { return !!document.createElement(tag)[atr]; }

foo('audio', 'preload'); // returns "auto"
bar('audio', 'preload'); // returns false
baz('audio', 'preload'); // returns true

Ogni funzione accetta un argomento per un <tag> e un attribute da cercare, ma ognuno restituisce valori diversi in base a ciò che determina il confronto.

Ma aspetta, c'è di più!

Alcuni di voi probabilmente hanno notato che in questo esempio specifico, si potrebbe semplicemente verificare la presenza di una proprietà usando i mezzi leggermente più performanti per verificare se l'oggetto in questione ha una proprietà. Ci sono due modi per farlo:

// the native `hasOwnProperty` method
var qux = function(tag, atr) { return document.createElement(tag).hasOwnProperty(atr); }

// the `in` operator
var quux = function(tag, atr) { return atr in document.createElement(tag); }

qux('audio', 'preload');  // returns true
quux('audio', 'preload'); // returns true

Stiamo divagando ...

Per quanto rare possano essere queste situazioni, possono esistere alcuni scenari in cui il mezzo più conciso, più performante e quindi il più preferito per ottenere il true da un valore non booleano, possibilmente indefinito, è in effetti usando !! . Spero che questo lo ridicolizzi in modo ridicolo.


Dopo aver visto tutte queste grandi risposte, vorrei aggiungere un altro motivo per l'utilizzo !! .Currenty Sto lavorando in Angular 2-4 (TypeScript) e voglio restituire un valore booleano come falsequando il mio utente non è autenticato. Se non è autenticato, la stringa token sarebbe nullo "". Posso farlo usando il prossimo blocco di codice:

public isAuthenticated(): boolean {
   return !!this.getToken();
}




operators