javascript - boolean i ett if-uttryck

Idag har jag fått en kommentar om koden med tanke på hur jag kontrollerar om en variabel är sann eller falsk i en skoluppgift.

Koden som jag hade skrivit var något i stil med detta:

var booleanValue = true;

function someFunction(){
    if(booleanValue === true){
        return "something";
    }
}

De sa att det var bättre/noggrannare att skriva det så här:

var booleanValue = true;

function someFunction(){
    if(booleanValue){
        return "something";
    }
}

Kommentaren jag har fått om delen "=== true" var att den inte var nödvändig och kunde skapa förvirring.

Mitt förslag är dock att det är bättre att kontrollera om variabeln är en boolean eller inte, särskilt eftersom Javascript är ett lös typat språk.

I det andra exemplet skulle en sträng också returnera "something";

Så min fråga; Är det snyggare att släppa delen "=== true" i framtiden, eller är det god praxis att också kontrollera variabelns typ.

Redigera: I min "riktiga" kod representerar booleanen om en bild har raderats eller inte, så de enda värden som boolValue någonsin bör ha är true eller false.

0 och 1 till exempel borde inte vara i den variabeln.

Svar #1

För det första, fakta:

if (booleanValue)

Kommer att uppfylla if-satsen för vilket sanningsenligt värde av booleanValue som helst, inklusive true, vilket icke-nolltal som helst, vilken icke-tom sträng som helst, vilken objekt- eller arrayreferens som helst, etc...

Å andra sidan:

if (booleanValue === true)

Detta kommer endast att uppfylla if-villkoret om booleanValue är exakt lika med true. Inget annat sant värde kommer att uppfylla det.

Å andra sidan, om du gör detta:

if (someVar == true)

Då kommer JavaScript att typkonvertera true för att matcha typen av someVar och sedan jämföra de två variablerna. Det finns många situationer där detta sannolikt inte är vad man skulle avse. På grund av detta vill man i de flesta fall undvika == eftersom det finns en ganska lång uppsättning regler för hur JavaScript typkonverterar två saker för att bli av samma typ, och om man inte förstår alla dessa regler och kan förutse allt som JS-tolkaren kan göra när den ges två olika typer (vilket de flesta JS-utvecklare inte kan), vill man troligtvis undvika == helt och hållet.

Som ett exempel på hur förvirrande det kan vara:

var x;

x = 0;
console.log(x == true);   // false, as expected
console.log(x == false);  // true as expected

x = 1;
console.log(x == true);   // true, as expected
console.log(x == false);  // false as expected

x = 2;
console.log(x == true);   // false, ??
console.log(x == false);  // false

För värdet 2 skulle du kunna tro att 2 är ett sant värde så det skulle jämföras gynnsamt med true, men det är inte så typomvandlingen fungerar. Den konverterar värdet på höger sida för att matcha typen på värdet på vänster sida, så den konverterar true till numret 1 så det jämför 2 == 1 vilket definitivt inte är vad du troligen avsåg.

Så, köparen bör vara försiktig. Det är troligtvis bäst att undvika == i nästan alla fall om du inte uttryckligen vet vilka typer du kommer att jämföra och vet hur alla möjliga typer av tvingningsalgoritmer fungerar.

Så det beror verkligen på de förväntade värdena för booleanValue och hur du vill att koden ska fungera. Om du på förhand vet att det bara någonsin kommer att ha ett true- eller false-värde, då genom att jämföra det uttryckligen med

if (booleanValue === true)

är bara extra kod och onödig och

if (booleanValue)

är mer kompakt och möjligen renare/bättre.

Om du å andra sidan inte vet vad booleanValue kan vara och du vill testa om det verkligen är satt till true utan några andra automatiska typkonverteringar, då

if (booleanValue === true)

är inte bara en bra idé, utan krävs.

Till exempel, om du tittar på implementeringen av .on() i jQuery, har den ett valfritt returvärde. Om callbacken returnerar false, kommer jQuery automatiskt att stoppa händelsens spridning. I det här specifika fallet, eftersom jQuery endast vill stoppa spridningen om false returnerades, kontrollerar de returvärdet uttryckligen för === false eftersom de inte vill att undefined eller 0 eller "" eller något annat som automatiskt kan konverteras till false även ska uppfylla jämförelsen.

Till exempel, här är jQuery-händelsehanteringscallback-koden:

ret = ( specialHandle || handleObj.handler ).apply( matched.elem, args );

if ( ret !== undefined ) {
     event.result = ret;
     if ( ret === false ) {
         event.preventDefault();
         event.stopPropagation();
     }
 }

Du kan se att jQuery uttryckligen letar efter ret === false.

Men det finns också många andra ställen i jQuery-koden där en enklare kontroll är lämplig med tanke på kodens avsikt. Till exempel:

// The DOM ready check for Internet Explorer
function doScrollCheck() {
    if ( jQuery.isReady ) {
        return;
    }
    ...

Svar #2

Om du skriver: if(x === true) , kommer det endast att vara sant för x=true

Om du skriver: if(x) , kommer det att vara sant för varje x som inte är: '' (tom sträng), false, null, undefined, 0, NaN.

Svar #3

I allmänhet är det renare och enklare att utelämna === true.

Men i Javascript är de där påståendena olika.

if (booleanValue) kommer att köras om booleanValue är sant - allt annat än 0, false, '', NaN, null och undefined.

if (booleanValue === true) kommer endast att köras om booleanValue är exakt lika med true.

Relaterade artiklar