--- title: Comparison Operators localeTitle: Operadores de Comparação --- O JavaScript possui comparações de **conversão** **estrita** e de **tipo** . * Uma comparação estrita (por exemplo, ===) só é verdadeira se os operandos forem do mesmo tipo. * A comparação abstrata mais usada (por exemplo, ==) converte os operandos para o mesmo tipo antes de fazer a comparação. * Para comparações abstratas relacionais (por exemplo, <=), os operandos são primeiro convertidos em primitivos, depois para o mesmo tipo, antes da comparação. * As cadeias de caracteres são comparadas com base na ordem lexicográfica padrão, usando valores Unicode. ## Recursos de comparações: * Duas strings são estritamente iguais quando possuem a mesma sequência de caracteres, o mesmo comprimento e os mesmos caracteres nas posições correspondentes. * Dois números são estritamente iguais quando são numericamente iguais (possuem o mesmo valor numérico). NaN não é igual a nada, incluindo NaN. Zeros positivos e negativos são iguais entre si. * Dois operandos booleanos são estritamente iguais se ambos forem verdadeiros ou se ambos forem falsos. * Dois objetos distintos nunca são iguais para comparações estritas ou abstratas. * Uma expressão comparando Objetos só é verdadeira se os operandos fizerem referência ao mesmo Objeto. * Tipos nulos e indefinidos são estritamente iguais a si mesmos e abstratamente iguais entre si. ## Operadores de igualdade ### Igualdade (==) O operador de igualdade converte os operandos, se eles **não** forem **do mesmo tipo** , e aplicará uma comparação estrita. Se **ambos os operandos são objetos** , então o JavaScript compara referências internas que são iguais quando operandos se referem ao mesmo objeto na memória. #### Sintaxe ``` x == y ``` #### Exemplos ``` 1 == 1 // true "1" == 1 // true 1 == '1' // true 0 == false // true 0 == null // false 0 == undefined // false null == undefined // true ``` ### Desigualdade (! =) O operador de desigualdade retorna verdadeiro se os operandos não forem iguais. Se os dois operandos **não** forem **do mesmo tipo** , o JavaScript tentará converter os operandos em um tipo apropriado para a comparação. Se os **dois operandos são objetos** , o JavaScript compara referências internas que não são iguais quando operandos se referem a objetos diferentes na memória. #### Sintaxe ``` x != y ``` #### Exemplos ``` 1 != 2 // true 1 != "1" // false 1 != '1' // false 1 != true // false 0 != false // false ``` ### Identidade / igualdade estrita (===) O operador de identidade retorna true se os operandos forem estritamente iguais **sem conversão de tipo** . #### Sintaxe ``` x === y ``` #### Exemplos ``` 3 === 3 // true 3 === '3' // false ``` ### Não identidade / desigualdade estrita (! ==) O operador não identificador retorna true se os operandos **não forem iguais e / ou não do mesmo tipo** . #### Sintaxe ``` x !== y ``` #### Exemplos ``` 3 !== '3' // true 4 !== 3 // true ``` ## Operadores relacionais ### Maior que o operador (>) O operador maior que retorna true se o operando esquerdo for maior que o operando direito. #### Sintaxe ``` x > y ``` #### Exemplos ``` 4 > 3 // true ``` ### Operador maior que ou igual (> =) O operador maior que ou igual retorna verdadeiro se o operando esquerdo for maior ou igual ao operando direito. #### Sintaxe ``` x >= y ``` #### Exemplos ``` 4 >= 3 // true 3 >= 3 // true ``` ### Menos que o operador (<) O operador menor que retorna true se o operando esquerdo for menor que o operando direito. #### Sintaxe ``` x < y ``` #### Exemplos ``` 3 < 4 // true ``` ### Operador menor que ou igual (<=) O operador menor que ou igual retorna verdadeiro se o operando esquerdo for menor ou igual ao operando direito. #### Sintaxe ``` x <= y ``` #### Exemplos ``` 3 <= 4 // true ``` _Você pode encontrar mais informações no [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators) ._ ## Comparando null e undefined Quando comparamos nulo e indefinido, vemos um comportamento diferente. Vamos verificar diferentes cenários através de exemplos #### Exemplo - verificação de igualdade estrita (===) console.log (null === indefinido); // O / P - falso Otuput é falso e isso é correto porque sabemos que "nulo" e "indefinido" são tipos diferentes. #### Exemplo - verificação de igualdade não estrita (==) console.log (null == indefinido); // O / P: - true Como? Isso ocorre porque existe uma regra especial para "null" e "undefined". Devido a que eles são iguais em caso de verificação não estrita (==), mas não são iguais a qualquer outro valor. Se usarmos operadores de comparação como <,>, <=,> = etc., "nulo" e "indefinido" serão convertidos em números e, nesses casos, "nulo" se tornará 0 e "indefinido" será NaN. Vamos verificar alguns desses exemplos. #### Exemplo - comparar nulo com 0 (zero) console.log (nulo> 0); // O / P - falso console.log (null> = 0); // O / P - true console.log (null == 0); // O / P - falso Estranho? De acordo com a primeira instrução, nulo não é maior que 0 e da segunda instrução nulo é maior ou igual a 0. Então, se pensarmos matematicamente e compararmos ambas as declarações, chegaremos ao resultado que nulo é igual a 0. Mas , conforme a terceira afirmação não é verdadeira. Por quê? A razão é "comparação" e "verificação de igualdade" ambos funcionam de maneira diferente. Em comparação, "null / undefined" é primeiro convertido em number, portanto, nos dois primeiros casos, "null" se torna 0 e, portanto, case1) (null> 0) -> false e case2) (null> = 0) -> true. Mas, na verificação de igualdade (==), "null / undefined" funciona sem qualquer conversão e como explicado acima (regra especial), na verificação de igualdade "null / undefined" são apenas iguais entre si e não são iguais a qualquer outra coisa. Daí (null == 0) -> falso. #### Exemplo - comparar indefinido com 0 (zero) console.log (indefinido> 0); // O / P - falso console.log (indefinido> = 0); // O / P - falso console.log (indefinido == 0); // O / P - falso Aqui, testamos os mesmos casos que fizemos para null, mas novamente o resultado é diferente. Por quê? As razões são as seguintes. Nos dois primeiros casos, estamos comparando undefined com 0 e como mencionado acima na comparação undefined é convertido para NaN. NaN é um valor especial que sempre retorna falso quando comparado com qualquer número e é por isso que temos resultados falsos nos dois primeiros casos. Para a terceira instrução, a razão é a mesma mencionada para "null". Na verificação de igualdade, "null / undefined" são apenas iguais entre si e não iguais a qualquer outra coisa. Daí (indefinido == 0) -> falso.