Hoje, recebi um comentário sobre código, considerando a maneira como verifico se uma variável é verdadeira ou falsa em uma tarefa da escola.
O código que eu escrevi era mais ou menos assim:
var booleanValue = true;
function someFunction(){
if(booleanValue === true){
return "something";
}
}
Eles disseram que era melhor / mais puro escrever assim:
var booleanValue = true;
function someFunction(){
if(booleanValue){
return "something";
}
}
A observação que recebi sobre a parte "=== true" foi que ela não era necessária e poderia criar confusão.
No entanto, minha ideia é que é melhor verificar se a variável é booleana ou não, especialmente porque o Javascript é uma linguagem com folga.
No segundo exemplo, uma string também retornaria "algo";
Então minha pergunta; É melhor perder a parte "=== true" no futuro ou é uma boa prática verificar também o tipo da variável.
Edit: No meu código "real", o booleano representa se uma imagem foi excluída ou não; portanto, os únicos valores que o boolValue deve ter é verdadeiro ou falso.
0 e 1, por exemplo, não devem estar nessa variável.
fonte
=== true
. Evita confusão !![0] === true
avalia como false.=== true
quando precisar garantir que a condição seja exatamente igual atrue
.Respostas:
Primeiro, os fatos:
Satisfará a
if
declaração para qualquer valor verdadeiro debooleanValue
inclusãotrue
, qualquer número diferente de zero, qualquer valor de string não vazio, qualquer referência a objeto ou matriz, etc ...Por outro lado:
Isso só satisfará a
if
condição sebooleanValue
for exatamente igual atrue
. Nenhum outro valor verdadeiro o satisfará.Por outro lado, se você fizer isso:
Em seguida, o que o Javascript fará é digitar coerce
true
para corresponder ao tipo desomeVar
e comparar as duas variáveis. Existem muitas situações em que isso provavelmente não é o que se pretenderia. Por isso, na maioria dos casos, você deseja evitar,==
porque há um conjunto de regras bastante longo sobre como o Javascript digitar coagirá duas coisas para serem do mesmo tipo e, a menos que você entenda todas essas regras e possa antecipar tudo o que o interpretador JS pode fazer quando dados dois tipos diferentes (que a maioria dos desenvolvedores de JS não pode), você provavelmente deseja evitar==
completamente.Como um exemplo de quão confuso pode ser:
Para o valor
2
, você pensaria que2
é um valor verdadeiro para que ele se comparasse favoravelmente comtrue
, mas não é assim que a coerção de tipos funciona. Ele está convertendo o valor da mão direita para coincidir com o tipo do valor da mão esquerda e, portanto, está convertendotrue
para o número,1
para comparar, o2 == 1
que certamente não é o que você provavelmente pretendia.Então, cuidado com o comprador. Provavelmente, é melhor evitar isso
==
em quase todos os casos, a menos que você saiba explicitamente os tipos que irá comparar e saiba como todos os algoritmos de coerção de tipos possíveis funcionam.Portanto, depende realmente dos valores esperados
booleanValue
e de como você deseja que o código funcione. Se você sabe de antemão que isso só terá um valortrue
oufalse
, compare-o explicitamente comé apenas código extra e desnecessário e
é mais compacto e sem dúvida mais limpo / melhor.
Se, por outro lado, você não sabe o que
booleanValue
pode ser e deseja testar se está realmente definido comotrue
sem outras conversões de tipo automáticas permitidas,não é apenas uma boa ideia, mas necessária.
Por exemplo, se você observar a implementação
.on()
no jQuery, ele terá um valor de retorno opcional. Se o retorno de chamada retornarfalse
, o jQuery interromperá automaticamente a propagação do evento. Nesse caso específico, como o jQuery deseja interromper a propagação SOMENTE sefalse
for retornado, eles verificam a explicitação do valor de retorno=== false
porque não queremundefined
ou0
ou""
ou qualquer outra coisa que automaticamente converta o tipo em falso para também satisfazer a comparação.Por exemplo, aqui está o código de retorno de chamada de manipulação de evento jQuery:
Você pode ver que o jQuery está procurando explicitamente
ret === false
.Porém, também existem muitos outros lugares no código jQuery em que uma verificação mais simples é apropriada, dado o desejo do código. Por exemplo:
fonte
Se você escrever
if(x === true)
:, será verdadeiro apenas para x = trueSe você escrever
if(x)
:, será verdadeiro para qualquer x que não seja: '' (sequência vazia), falso, nulo, indefinido, 0, NaN.fonte
NaN
e-0
.Na planície "se" a variável será coagida a um booleano e usa toBoolean no objeto: -
Mas a comparação com === não tem nenhum tipo de coerção, portanto, eles devem ser iguais sem coerção.
Se você está dizendo que o objeto pode até não ser um booleano, talvez seja necessário considerar mais do que verdadeiro / falso.
fonte
Depende do seu caso. Pode fazer sentido verificar o tipo também, mas se for apenas uma bandeira, não será.
fonte
===
comparação não executa coerção de tipo. Portanto, o código do OP efetivamente testa o tipo do sinalizador. Ele só será bem-sucedido se o valor for um booleano e for verdadeiro.Em geral, é mais limpo e mais simples omitir o arquivo
=== true
.No entanto, em Javascript, essas instruções são diferentes.
if (booleanValue)
será executado sebooleanValue
é truthy - outra coisa senão0
,false
,''
,NaN
,null
, eundefined
.if (booleanValue === true)
só será executado sebooleanValue
for precisamente igual atrue
.fonte
''
.O
(===)
operador de identidade se comporta de maneira idêntica ao(==)
operador de igualdade , exceto que nenhuma conversão de tipo é feita e os tipos devem ser os mesmos para serem considerados iguais.fonte
if (booleanValue)
eif (booleanValue==true)
quandobooleanValue
for2
. Essas duas declarações não fornecem o mesmo resultado.Como o valor verificado é
Boolean
preferível usá-lo diretamente para menos codificação e, ao mesmo tempo, fez o mesmo==true
fonte
Como você já inicializou claramente como bool, acho que o
===
operador não é necessário.fonte
Se a variável puder apenas assumir valores booleanos, é razoável usar a sintaxe mais curta.
Se ele puder ser atribuído a outros tipos, e você precisar diferenciá-lo
true
de1
ou"foo"
, deverá usá-lo=== true
.fonte
Eu acho que seu raciocínio é sólido. Mas, na prática, descobri que é muito mais comum omitir a
===
comparação. Eu acho que existem três razões para isso:undefined
ou um inesperadonull
. Freqüentemente, você só quer que seu teste falhe nesses casos. (Embora eu tente equilibrar essa visão com o lema "falhe rápido").Considere este exemplo:
Eu acho que esse tipo de código não é incomum. Ele lida com casos onde
getInput()
os retornosundefined
,null
ou uma cadeia vazia. Devido às duas avaliações booleanassubmitInput()
é chamado apenas se a entrada fornecida for uma sequência que contenha caracteres que não sejam espaços em branco.Em JavaScript
&&
retorna seu primeiro argumento se for falso ou seu segundo argumento se o primeiro argumento for verdadeiro; assimnormalized
seráundefined
sesomeString
foi indefinido e assim por diante. Isso significa que nenhuma das entradas para as expressões booleanas acima são realmente valores booleanos.Eu sei que muitos programadores que estão acostumados a fortes checagens de verificação de tipo quando vêem códigos como este. Mas observe que a aplicação de digitação forte provavelmente exigiria verificações
null
ouundefined
valores explícitos , o que desorganizaria o código. Em JavaScript, isso não é necessário.fonte
Isso depende Se você está preocupado com o fato de que sua variável pode acabar como algo que resolve como VERDADEIRO. Então, a verificação rigorosa é uma obrigação. Caso contrário, cabe a você. No entanto, duvido que a sintaxe
whatever == TRUE
possa confundir quem sabe o que está fazendo.fonte
Em Javascript, a idéia de booleano é bastante ambígua. Considere isto:
Portanto, quando você está usando uma instrução if (ou qualquer outra instrução de controle), não é necessário usar um tipo "booleano" var. Portanto, na minha opinião, a parte "=== true" da sua declaração é desnecessária se você souber que é um booleano, mas absolutamente necessária se o seu valor for uma var ambígua "verdade". Mais sobre booleanos em javscript podem ser encontrados aqui .
fonte
Revisa https://www.w3schools.com/js/js_comparisons.asp
exemplo:
=== significa o mesmo tipo e também o mesmo valor == apenas o mesmo valor
fonte
Também pode ser testado com objeto booleano, se você precisar testar um objeto
error={Boolean(errors.email)}
fonte