Coação de tipo, conversão de tipo, conversão de tipo e malabarismo de tipo: todos os nomes diferentes que se referem ao processo de conversão de um tipo de dados em outro. Esse processo está presente em quase todas as linguagens de programação e é um conceito importante na ciência da computação.
Embora o JavaScript seja conhecido como uma das linguagens de programação mais fáceis para iniciantes, também pode ser frustrante quando os desenvolvedores esperam que o JavaScript faça uma coisa e retorna outra.
E embora o padrão de Especificação de Linguagem ECMAScript esteja disponível para os desenvolvedores para ajudar a guiá-los através desses problemas, não ler e compreender o padrão de especificação pode causar mais frustração ao lidar com coerção de tipo em JavaScript.
A coerção de tipo em JavaScript é um exemplo de como a linguagem pode produzir resultados inesperados quando não sabemos exatamente como funciona. Todos que já mexeram um pouco no código em JavaScript podem relacionar que a coerção de tipo pode ser complicada.
Embora os exemplos de código que abordamos neste artigo possam parecer bugs que uma atualização de versão poderia corrigir, o motivo revisamos por que a coerção de tipo age dessa maneira é porque muitos produtos e códigos legados dependem de versões mais antigas de JavaScript.
Isso significa que a criação de alterações na linguagem pode quebrar produtos e códigos legados, e devemos, em vez disso aprenda como navegar pelas peculiaridades da coerção de tipo.
Neste post, vamos cobrir quais tipos estão em JavaScript e como usar a coerção de tipo, preparando-nos para o sucesso da programação.
Tipos em JavaScript
Podemos nos referir a JavaScript como uma linguagem não digitada , o que significa que não possui tipos estáticos. No entanto, o mito proeminente de que o JavaScript não tem tipos é falso.
JavaScript tem sete tipos primitivos :
string number Boolean undefined null Símbolo BigInt
Variáveis em JavaScript não têm tipos, entretanto. Sempre que usamos o operador typeof para retornar um tipo de variável, retornamos o tipo de valor da variável.
Agora que esclarecemos alguns equívocos sobre JavaScript e tipos, podemos aprender mais sobre coerção de tipo e como ela funciona em JavaScript.
Coerção de tipo
A coerção de tipo em JavaScript força apenas a string, o número e os tipos primitivos booleanos. Não há nenhuma maneira no JavaScript de forçar um tipo de valor a um objeto ou função.
O JavaScript tem duas formas caracterizadas de coerção: coerção implícita e coerção explícita.
A coerção implícita acontece quando JavaScript força o tipo de valor para o tipo esperado sob o capô. Este tipo de coerção acontece sem que o desenvolvedor perceba.
A coerção explícita acontece quando queremos forçar o tipo de valor a um tipo específico. Na maioria das vezes, a coerção explícita em JavaScript acontece usando funções integradas como String (), Number () e Boolean ().
Quando tentamos criar operações em JavaScript usando diferentes tipos de valor, JavaScript força os tipos de valor para nós implicitamente.
Esta é uma das razões pelas quais os desenvolvedores tendem a evitar a coerção implícita em JavaScript. Na maioria das vezes, obtemos resultados inesperados da operação se não sabemos exatamente como o JavaScript coage os tipos de valor.
A coerção implícita não é tão ruim quanto os desenvolvedores tendem a pensar e, de fato, é útil para escrever código legível, mas eficiente. A chave para entender corretamente como a coerção implícita funciona em JavaScript é entender o que ela está fazendo nos bastidores.
Número
Existem muitas maneiras possíveis de forçar um tipo primitivo a um número. A função Number () força o tipo de valor que passa para a função e depois para um número. Quando um tipo não pode ser forçado a um número, o resultado retornado é NaN.
Vejamos alguns exemplos de coerção explícita usando a função Number ():
Number (“42”);//42 Number (“”);//0 Número (verdadeiro);//1 número (falso);//0 Número (nulo);//0 Número (indefinido);//NaN
Podemos ver claramente alguns resultados óbvios e inesperados. A conversão de nulo em um número retorna 0, enquanto a conversão de undefined em um número retorna NaN. Ambas as operações devem retornar NaN, pois ambos os tipos de valor claramente não são números válidos.
A conversão de uma string vazia em um número retorna 0. Esta é outra parte estranha do JavaScript porque este tipo de valor claramente ainda não é um número válido. ele ainda converte para 0.
Kyle Simpson , o criador do You Don’t Know JS da série de livros, disse:“ String vazia se tornando 0 é a raiz de todo mal de coerção. ”
Embora os resultados que obtemos da função Number () possam parecer inesperados, a especificação ECMAScript esclarece essas discrepâncias. Mas, sem ler a especificação ECMA, os desenvolvedores podem não perceber que é assim que o JavaScript é escrito.
Em nosso primeiro exemplo, recebemos resultados diferentes para nulo e indefinido. A função de especificação ECMAScript Number () com um tipo de valor nulo retorna 0, e sempre que usamos o mesma função com undefined retorna NaN.
ToNumber é um nome de conversão de tipo que a especificação ECMAScript usa ao se referir a uma operação onde um valor é convertido em um número. Number () é um objeto wrapper primitivo em JavaScript que converte um valor em um número. É o mesmo com ToBoolean, que cobriremos mais tarde.
Abaixo está uma lista de argumentos e o resultado da operação ToNumber os converte em:
Em nosso outro exemplo, usamos a função Number () com uma string vazia e recebeu um 0. Isso é algo que está explícito na especificação ECMAScript também:
Um StringNumericLiteral que está vazio ou contém apenas espaços em branco é convertido para +0.- Especificação de linguagem ECMAScript 2015
String
Para forçar explicitamente um valor a uma string em JavaScript, podemos usar a função String (). Para forçar implicitamente um valor a uma string, podemos usar o operador + com qualquer operando que seja uma string.
Os tipos primitivos convertem em strings conforme o esperado:
String (“42″);//”42″String (verdadeiro);//”true”String (false);//String”false”(null);//String”nula”(indefinida);//”undefined”
Devemos ter cuidado ao usar a coerção de tipo quando queremos criar uma operação e um de nossos tipos de operando é uma string.
JavaScript retorna nossa operação como uma string quando o correto maneira de lidar com a operação deve gerar um erro porque não há como fazer uma operação matemática usando um número e uma string, que não é um número válido:
10 +”10″//”1010″20 +”200″//”20200″0.212 +”1″//”0.2121″
Boolean
Para forçar explicitamente um valor a Boolean em JavaScript, podemos usar a função Boolean (). Para forçar implicitamente um valor a booleano, podemos usar operadores lógicos, como ||, && e! em um contexto lógico.
A especificação da função Boolean () é muito limpo e útil. Podemos ver claramente quais resultados recebemos, dependendo do tipo de valor que passamos:
A lista de valores falsos é fácil de lembrar. Tudo o que não está na lista é um valor verdadeiro:
Boolean (”)//false Boolean (0)//false Boolean (-0)//false Boolean (NaN)//false Boolean (null)//false Boolean (undefined)//false Boolean (false)//false
Como afirmado antes, os operadores lógicos também forçam um tipo de valor a um Booleano:
true && false//false true && true//verdade verdade || falso//verdadeiro verdadeiro || ! false//verdadeiro”nome”|| 0//”nome””nome”|| []//”nome”””|| [1, 2, 3]//[1, 2, 3]
Conclusão
A coerção de tipo é um conceito principal do JavaScript usado em todos os aplicativos, APIs e serviços que usam JavaScript.
Ao todo, a menos que você busque coerção explícita, o JavaScript coage implicitamente dependendo dos tipos de valor e da operação usada. Mas, independentemente de usar coerção de tipo implícita ou explícita, ele fornece flexibilidade aos desenvolvedores e ajuda a tornar o código mais legível.
Esta breve visão geral fornece os fundamentos para entender a coerção de tipo, no entanto, a leitura das especificações ECMAScript pode fornecer mais revisão aprofundada do conceito para entender por que ocorrem resultados inesperados de coerção de tipo.
