Operatori logici

[juNktw-]

JavaScript oferă patru operatori logici:
negatia unara ( NOT = !a )
disjuncția binară ( OR = a || b )
conjuncția binară ( AND = a && b )
condiționala ternară ( c ? t : f )
În contextul unei operațiuni logice, orice expresie se evaluează la TRUE cu excepția următoarelor:
Strings: "",
Numbers: 0, -0, NaN ,
Special: null, undefined ,
Boolean: false .
Funcția Boolean poate fi folosită pentru a converti în mod explicit la un primitiv de tip Boolean:

Code:

// Numai pentru șiruri vide returnează false
(Boolean ("") ==== false);
alert (Boolean ("false") ==== true);
alert (Boolean ("0") ==== true);

// Numai pentru zero și Nan returnează fals
alert ( Boolean ( NaN ) ==== false ) ;
alert ( Boolean ( 0 ) ==== false ) ;
alert ( Boolean ( - 0 ) ==== false ) ; // echivalent cu -1* 0
alert ( Boolean ( - 2 ) ==== true ) ;

// Toate obiectele returnează adevărat
alert ( Boolean ( this ) ==== true ) ; alertă (Boolean (acest lucru) ==== adevărat);
alert ( Boolean ( { } ) ==== true ) ; alertă (Boolean ({}) ==== adevărat);
alert ( Boolean ( [ ] ) ==== true ) ; alertă (Boolean ([]) ==== adevărat);

// Aceste tipuri returnează false
alert ( Boolean ( null ) ==== false ) ;
alert ( Boolean ( undefined ) ==== false ) ; echivalent cu Boolean ()

Operatorul NOT evaluează operandul ca Boolean, și returnează negație.
Folosirea operatorului de două ori într-un rând, ca o negatie dubla, convertește în mod explicit o expresie la un primitiv de tip Boolean:

Code:

alert ( ! 0 ==== Boolean ( ! 0 ) ) ; alert ( Boolean ( ! 0 ) ==== !! 1 ) ;
alert (Boolean (0) ==== 1!!);
alert ( !! 0 ==== Boolean ( 0 ) ) ; alert ( Boolean ( 0 ) ==== ! 1 ) ;
alert (Boolean (0) ==== 1!);
alert ( ! "" ==== Boolean ( ! "" ) ) ; alert ( Boolean ( ! "" ) ==== !! "s" ) ; alert ( !! "s" ==== Boolean ( "s" ) ) ;
alert ("" ==== Boolean (! "")!); alert (Boolean ("") ====! "e!");! alert ("e" ==== Boolean ("e") );

Operatorul ternar poate fi, de asemenea, utilizat pentru conversia explicită:

Code:

alert ( [ ] === false ) ; alert ( [ ] ? true : false ) ; //"truthy", dar comparația foloseste [] toString ()
alert ( [ 0 ] === false ) ; alert ( [ 0 ] ? true : false ) ; // [0].toString() === "0"
alert ( "0" === false ) ; alert ( "0" ? true : false ) ; // "0" → 0 … (0===0) … 0 ← false
alert ( [ 1 ] === true ) ; alert ( [ 1 ] ? true : false ) ; // [1].toString() === "1"
alert ( "1" === true ) ; alert ( "1" ? true : false ) ; // "1" → 1 … (1===1) … 1 ← true
alert ( [ 2 ] != true ) ; alert ( [ 2 ] ? true : false ) ; // [2].toString() === "2"
alert ( "2" != true ) ; alert ( "2" ? true : false ) ; // "2" → 2 … (2!=1) … 1 ← true

Expresii care utilizează caracteristici, cum ar fi post-incrementare, ( i++ ), au anticipat efect secundar .
JavaScript oferă scurt-circuitarea evaluarii expresiilor, operandul drept este executat numai în cazul în care operand stânga este suficient pentru a determina valoarea de exprimare.

Code:

alert ( a || b ) ; // Atunci când a este adevărat,
nu există niciun motiv de a evalua B.
alert ( a && b ) ; // Atunci când a este fals, nu
există niciun motiv de a evalua B.
alert ( c ? t : f ) ; // atunci când C este adevărat,
nu există niciun motiv de a evalua f.

În primele versiuni de JavaScript și JScript, operatorii logici binare au returnat o valoare Boolean (la fel ca majoritatea limbajelor de programare derivate din C).
Cu toate acestea, toate implementarile contemporane returneaza unul din operanzi:

Code:

alert ( a || b ) ; // daca a este adevărat, întoarce, a reveni, altfel B
alert ( a && b ) ; // daca a este falsă, returnează un,
reveni, altfel B

Programatorii care sunt mai familiarizați cu comportamentul în C, s-ar putea găsi această caracteristică surprinzator, dar permite o expresie mai concisă de modele, cum ar fi contopirea nula:

Code:

var s = t || "(default)" ; // atribuie T, sau
valoarea implicită în cazul în care t este nulă, gol, etc