Compreendendo conversão de tipo e coerção em JavaScript

A tipagem dinâmica do JavaScript significa que seu código pode ser um pouco mais simples, mas ainda é possível cometer erros. Para evitá-los, é útil saber como o JavaScript resolve valores com tipos diferentes, para compará-los.

Compreender a conversão de tipo e a coerção em JavaScript é crucial para escrever programas confiáveis ​​e eficientes. Cada conceito tem casos de uso específicos e melhores práticas que podem afetar o comportamento do seu código.

Por que a conversão de tipo e a coerção acontecem no JavaScript?

A linguagem JavaScript é digitado dinamicamente. Isso significa que, ao contrário das linguagens de tipagem estática, o JavaScript não exige que você defina explicitamente o tipo de dados de uma variável antes de usá-la. Em vez disso, o JavaScript determina o tipo em tempo de execução, dependendo do valor da variável.

Como os tipos de dados não são declarados explicitamente até o tempo de execução, quando você executa operações que exigem dados diferentes tipos, o JavaScript verifica automaticamente a compatibilidade entre eles para a operação que você deseja executar. Se forem compatíveis entre si, a operação prossegue normalmente.

No entanto, suponha que sejam incompatíveis com a operação, por exemplo, tentando adicionar uma string e um número. Nesses casos, o JavaScript “coage” automaticamente um dos tipos para se ajustar ao outro para garantir que a operação seja bem-sucedida em vez de gerar um erro. Esse processo é conhecido como coerção de tipo ou coerção implícita.

Tipo de coerção

A coerção de tipo é a conversão automática de um valor de um tipo de dados para outro, realizada pelo JavaScript durante a execução de um programa para garantir que uma operação seja executada com sucesso.

Mas nem todos os tipos de dados podem ser coagidos. String, número e booleano são os únicos tipos de dados JavaScript que a linguagem irá coagir em um tipo diferente. Quando você tenta executar uma operação incompatível com tipos de dados que o JavaScript não pode coagir, ele gera um erro.

O JavaScript coage os tipos com base no tipo de operação e no operador que você usa na operação.

Coerção com o operador “+”

Em JavaScript, o “+” tem dois comportamentos diferentes dependendo dos tipos de seus operandos. Ele pode realizar adição numérica e concatenação de strings. Isso pode levar à coerção de tipo quando um dos operandos não é do tipo esperado.

Se ambos os operandos forem números, o “+” o operador executa a adição:

deixar num1 = 42;
deixar num2 = 10;
deixar soma = num1 + num2; // Adição
console.log (soma); // 52

Se ambos os operandos forem strings, o “+” operador executa a concatenação de strings:

deixar str1 = "Olá";
deixar str2 = "mundo";
deixar resultado = str1 + " " + estr2; // Concatenação de strings
console.log (resultado); // "Olá Mundo"

No entanto, se um dos operandos não for uma string, o JavaScript o converterá implicitamente em uma string antes de realizar a concatenação:

// Número e String
deixar num = 42;
deixar str = "Olá";
// num é forçado a uma string e então concatenado
deixar resultado_1 = num + str;
console.log (resultado_1); // "42Olá"
// String e Booleano
deixar booleano = verdadeiro;
// bool é forçado a uma string e então concatenado
deixar resultado_2 = bool + str;
console.log (resultado_2); // "verdadeiroOlá"

Coerção com o operador “-”

Em JavaScript, o “-” é usado principalmente para operações de subtração. Quando um ou ambos os operandos em uma operação envolvendo o “-” não é um número, o JavaScript tentará transformá-lo em um número.

Quando ambos os operandos são números, o JavaScript realiza a subtração. Ele também realiza subtração quando um ou ambos os operandos são strings que representam um número:

const num1 = 10;
const num2 = 20;
const resultado_1 = num2 - num1; // Subtração
console.log (resultado_1); // 10
const StrNum = "10";
const StrNum2 = "20";
const resultado = StrNum2 - StrNum; // Digite coerção para números, então subtração
console.log (resultado_1); // 10

Quando nenhum dos operandos for um número ou uma string representando um número, o JavaScript tentará forçar o tipo de dados para seu equivalente numérico. Se o tipo de dado não tiver equivalente numérico, a operação retornará NaN (Não é um número):

// verdadeiro é convertido em 1, falso é convertido em 0
const boolNum = verdadeiro;
const boolNum2 = falso;
const resultado_1 = boolNum - boolNum2;
console.log (resultado_1); // 1
// arrays vazios são forçados a 0
const arrNum = [];
const arrNum2 = [];
const resultado_2 = arrNum - arrNum2;
console.log (resultado_2); // 0
// objetos vazios são forçados a NaN
const objNum = {};
const result_3 = arrNum - objNum;
console.log (resultado_3); // 0 - NaN = NaN

Neste exemplo, JavaScript coage valores booleanos verdadeiro e falso aos seus valores numéricos equivalentes, 1 e 0, respectivamente. Arrays vazios são forçados a 0, e objetos vazios são coagidos a NaN.

Coerção com os operadores de igualdade (==)/()

Em JavaScript, os operadores de igualdade (== e ) compara valores para igualdade. No entanto, eles se comportam de maneira diferente devido à coerção de tipo.

O "==” (loose equality) executa coerção de tipo, o que significa que ele tenta converter operandos para o mesmo tipo antes da comparação:

"10" == 10; // verdadeiro

Neste exemplo, o JavaScript converte a string “10” no número 10, então a expressão é avaliada como verdadeiro.

No entanto, o "” (estrita igualdade) operador não executa a coerção de tipo. Requer que o valor e o tipo sejam os mesmos para que a comparação retorne verdadeiro:

"10"10; // falso

Neste exemplo, a comparação retorna falso porque os operandos são de tipos diferentes (string e número).

Você geralmente deve usar o (estrita igualdade) em JavaScript para evitar comportamento inesperado de coerção de tipo.

A coerção de tipo ou a conversão implícita podem levar a um comportamento inesperado devido à sua natureza automática. Nos casos em que você precisa converter tipos, é aconselhável converter explicitamente os tipos. O processo de conversão explícita dos tipos é conhecido como conversão de tipo. Também é conhecido como conversão de tipo e conversão de tipo explícito.

conversão de tipo

A conversão de tipo, também conhecida como conversão de tipo, é o processo explícito de converter um valor de um tipo de dados para outro em JavaScript usando funções integradas como Número(), Corda(), Boleano(), parseInt(), e parseFloat().

Você pode executar a conversão de tipo passando o valor que deseja converter para as funções de conversão integradas como um argumento. Essas funções então convertem seu valor para o tipo desejado.

Aqui está um exemplo usando o Número() função:

const numStr = "123";
const num = Número(numStr); // Converte uma string em um número
console.log (num); // 123

Passar uma string que é um número válido como argumento para o Número() função retornará um número. Passar uma string que é um número inválido retornará NaN.

Aqui está um exemplo usando o Corda() função:

const booleano = verdadeiro;
const str2 = Corda(bool); // Converte um booleano em uma string
console.log (str2); // "verdadeiro"

Passando qualquer tipo de dados para o exceto um símbolo para o Corda() função irá converter o tipo de dados em uma string.

Aqui está um exemplo usando o Boleano() função:

// Converte uma string em booleana (verdadeiro: verdadeiro, falso: falso)
const str = "olá";
const bool2 = boleano(str);
console.log (bool2); // verdadeiro

Passando valores verdadeiros para o Boleano() A função retorna o booleano “verdadeiro” enquanto a passagem de valores falsos retorna o booleano “falso”.

Aqui está um exemplo usando o ParseInt() e ParseFloat() função:

// Converte uma string em um inteiro
const numStr = "123.00";
const num1 = parseInt(numStr);
console.log (num1); // 123
// Converte uma string em um número de ponto flutuante
const floatStr = "3.14";
const num2 = parseFloat(floatStr);
console.log (num2); // 3.14

O parseInt() função analisa um argumento de string e retorna um inteiro. O parseFloat() A função converte uma string em um número de ponto flutuante.

Aproveitando a coerção e a conversão de tipos

Compreendendo a conversão e a coerção de tipo, você pode tomar decisões informadas sobre quando e como aproveitá-los de forma eficaz em seu código. É importante encontrar o equilíbrio certo, usando a coerção de tipo criteriosamente para um código conciso e conveniente e contando com a conversão de tipo explícita para conversões de tipo intencionais e previsíveis.