Colerction em JavaScript

x

privacidade & Biscoitos

Este site usa cookies. Por continuação, você concorda com o uso deles. Saiba mais, incluindo como controlar cookies.

anúncios

O que é coerção?

pode ser dito que a coerção é a ação de forçar que um objeto se comporta como se fosse de outra forma. Sem dúvida, este é um dos aspectos mais interessantes do JavaScript. Sendo uma linguagem fracamente típica e dinâmica, não é necessário especificar o tipo de dados para as variáveis porque o tipo está associado ao valor (datilografia de pato), isso significa que no tempo de execução, podemos alterar o valor das variáveis sem qualquer problema.
💡 uma das vantagens deste recurso, é que podemos verificar a existência de um objeto através de seu valor, assim JavaScript permite que alguns princípios OOP a ser implementado muito fácil, pois a sobrecarga de método (sobrecarga), overrocatura de (métodos de sobreposição) e polimorfismo. Um exemplo disso é como implementos JQuery o padrão composto em seu construtor, definindo um método que pode ser adaptado de acordo com o número de argumentos, ou o tipo de argumentos.

Porque agora vemos como funciona a coerção à bilhetes, isto é, como outros tipos de dados se comportam, se eles são tratados como bilhetes.

 var var1, // -> undefined var2 = 9; if (v1) { } // -> undefined se evalúa como false if (v2) { } // -> 9 se evalúa como true if (!v1) { } // -> al negar undefined, se evalúa como true if (!v2) { } // -> al negar 9, se evalúa como false var v3 = !!v1; // -> convierte explícitamente undefined a false var v4 = !!v2; // -> convierte explícitamente 9 a true // asigna 0 si la coerción v1 es false v1 = v1 || 0; // ejecuta el alert si la coerción de v2 es true v2 && alert("Hey!");

💡 Observe o uso do Operador ! (não), que leva o operando à direita e avalia-o como booleano, mas negado. 😎 Esse truque é usado o suficiente para verificar a existência de um valor não falso em uma variável.

Da mesma forma, Double Negial! (Duplo não), converte um valor de qualquer tipo para booleano. 😎 Este truque é usado para verificar explicitamente se um valor representa true ou false.

verbe e falsey

Conhecendo os valores falsos que resultam da avaliação de um condicional ou coerção, é muito importante e nos ajudará a evitar erros de lógica. A tabela a seguir mostra os valores falsos.

tr /

false Colercion false false
0 false
false
false
false
undefined false
Colercion

➡ Todos os outros valores são avaliados como verdadeiros (Boolean: True), incluindo funções, arrays vazios, objetos vazios e string "0" e "false".

coerção para números

⭐ a unidade + (plus) Ele pode ser usado para converter uma string para número, se essa seqüência representa um número em sua totalidade, caso contrário retorna NAN (não NÚMERO).

 n = +"13"; // 13, type: number n = +"0"; // 0, type: number n = +"5px"; // NaN, type: number

💡 as funções parseFloat () e parseInt (), operam de uma forma muito semelhante, mas com uma diferença em relação ao Abrir operador +, e é que os métodos acima mencionados converter os primeiros dígitos numéricos de uma string para sua representação numérica, embora essa cadeia não é composta em sua totalidade por números:

 n = +"12px"; // NaN, type: number n = parseFloat("12px"); // 12, type: number

coerção em objetos

Quando JavaScript tenta fazer coerção em um objeto, primeiro procura se o método valueof () retornar um valor primitivo, se você não puder fazê-lo, tente obtê-lo no método de toString ().

Agora vamos ver alguns exemplos de coerção com diferentes tipos:

 var u, // undefined fn = function() {}, // retorna undefined obj = { valueOf: function() { return 7 } }; // coerción en diferentes tipos de objetos console.log("a.", !!fn); // !!bool: true, type: function console.log("b.", !!fn()); // !!bool: false, type: undefined console.log("c.", !!u); // !!bool: false, type: undefined console.log("d.", !!0); // !!bool: false, type: number console.log("e.", !!""); // !!bool: false, type: string console.log("f.", !!+""); // !!bool: false, type: number console.log("g.", !!+"x"); // !!bool: false, type: number (NaN) console.log("h.", !!null); // !!bool: false, type: object console.log("i.", !!); // !!bool: true, type: object console.log("j.", !!{}); // !!bool: true, type: object console.log("k.", !!obj); // !!bool: true, type: object console.log("l.", !!+obj); // !!bool: true, type: number

Para obter o tipo de um objeto, geralmente usamos o operador Typeof, mas no exemplo Anterior Observamos que para os itens H, I, J, o operador typeof retorna "object" como tipo de dados, 😡 e isso não é conveniente Em alguns casos em que precisamos diferenciar adequadamente um Array de um Object ou outros construtores.

💡 para resolver esta desvantagem, podemos usar o método ToString do protótipo Object para detectar o tipo / construtor de um objeto.

 // usando typeof typeof ({}) === "object" typeof () === "object" typeof null === "object" typeof Math === "object" // usando toString var toString = Object.prototype.toString; toString.call({}); // toString.call(); // toString.call(null); // toString.call(Math); // 

➡ De acima, podemos dizer que o operador do tipo funciona bem com os tipos primitivos (string, number, boolean, function, undefined) mas para diferenciar melhor os outros tipos (object, null) Recomenda-se usar Object.prototype.toString()

mais Coerção

Finalmente vemos outros cenários em que a coerção é dada:

 // accediendo elementos de un array var array = ; console.log("a.", array]); // coerción a number 0 console.log("b.", array]); // coerción a number 1 console.log("c.", array); // coerción a number 1 console.log("d.", array); // accediendo propiedades de un objeto var obj = { id: 1, "5": "cinco" }; console.log("e.", obj); console.log("f.", obj); // coerción a string // coerción con number, string, boolean console.log("g.", 5 - '3'); //= 2, coerción a number console.log("h.", 5 + '3'); //= "53", coerción a string console.log("i.", 5 + (+'3')); //= 8, coerción a number console.log("j.", 5 * '3'); //= 15, coerción a number console.log("k.", "" - 3); //= -3, coerción a number ("" -> 0) console.log("l.", true + 1); //= 2, coerción a number (true -> 1) console.log("m.", '1' - true); //= 0, coerción a number (true -> 1) console.log("n.", '1' + true); //= "1true", coerción a string console.log("o.", false - true); //= -1, coerción a number // coerción con fechas var d = new Date(); console.log("p.", +d); // number, llama a .valueOf() console.log("q.", "" + d); // string, llama a .toString()

Colercion

Conclusão

A coerção é uma daquelas características de JavaScript que é bom saber, de modo que nós corretamente entendemos os fragmentos de código e evitamos fazer erros lógicos , que são mais difíceis de rastrear.

➡ Eu recomendo que você leia a colerição de dados do artigo em JavaScript.

😎 Codificação feliz!

anúncios

Deixe uma resposta

O seu endereço de email não será publicado. Campos obrigatórios marcados com *