Colerction en JavaScript

x

Confidentialité & Cookies

Ce site utilise des cookies. Par continuation, vous acceptez leur utilisation. En savoir plus, y compris comment contrôler les cookies.

a eu!

annonces

Qu’est-ce que la coercition?

pourrait être dit que la coercition est l’action de forcer qu’un objet se comporte comme si c’était autrement. Sans aucun doute, c’est l’un des aspects les plus intéressants de Javascript. Étant une langue faiblement typique et dynamique, il n’est pas nécessaire de spécifier le type de données pour les variables car le type est associé à la valeur (dactylographie du canard), cela signifie qu’à temps de l’exécution, nous pouvons modifier la valeur des variables sans tout problème.

L’un des avantages de cette fonctionnalité est que nous pouvons vérifier l’existence d’un objet par sa valeur, de sorte que JavaScript permet de mettre en œuvre des principes de l’OOP très faciles que la surcharge de la méthode (surcharge), la surcharme de méthodes (remplacement) et polymorphisme. Un exemple de ceci est comme JQuery implémente le motif composite dans son constructeur, définissant une méthode pouvant être adaptée en fonction du nombre d’arguments ou du type d’arguments.

pour l’instant, nous voyons comment la coercition fonctionne vers billets, c’est-à-dire que d’autres types de données se comportent s’ils sont traités comme des billets.

 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!");

Notez l’utilisation de l’opérateur ! (non), qui prend l’opérande à droite et l’évalue comme booléen mais refusé. 😎 Cette astuce est suffisamment utilisée pour vérifier l’existence d’une valeur non fausse dans une variable.

De même, Double Denial! (Double non), convertit une valeur de tout type à Boolean. 😎 Cette astuce est utilisée pour vérifier explicitement si une valeur représente true ou

ou

false

Truthy and DIGYY

Connaître les fausses valeurs résultant de l’évaluation d’une conditionnelle ou de coercition, il est très important et nous aidera à éviter les erreurs de logique. Le tableau suivant montre les fausses valeurs.

Colercion
false
false
0 false
«  » false
NaN false
false
undefined false
CoercionColercion

➡ Toutes les autres valeurs sont évaluées comme une vérité (Boolean: true), y compris des fonctions, des tableaux vides, des objets vides et une chaîne "0" et "false".

coercition à des chiffres

⭐ L’unité + (plus) Il peut être utilisé pour convertir une chaîne en nombre, si cette chaîne représente un nombre dans son intégralité, sinon renvoie Nan (pas numéro).

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

💡 Les fonctions Paysfloat () et Paysint () fonctionnent de manière très similaire, mais avec une différence par rapport à l’opérateur ouvert +, et que les méthodes susmentionnées convertissent les premiers chiffres numériques d’une chaîne à Sa représentation numérique, bien que cette chaîne ne soit pas composée dans son intégralité par des chiffres:

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

coercition dans les objets

⭐ Lorsque JavaScript tente de faire de la contrainte dans un objet, cherche d’abord si la méthode ValueOf () renvoie une valeur primitive, si vous ne pouvez pas le faire, essayez-le de l’obtenir à partir de la méthode Tostring ().

Voyons maintenant quelques exemples de contrainte avec différents types:

 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

Pour obtenir le type d’objet, nous utilisons habituellement le type d’opérateur, mais dans l’exemple Précédent Nous notons que pour les éléments H, i, j, l’opérateur typeof retourne"object"

comme type de données, 😡 et ceci n’est pas pratique. Dans certains cas où nous devons différencier correctement un Array d’un Object ou d’autres constructeurs.

💡 pour résoudre Cet inconvénient, nous pouvons utiliser la méthode de tostrage du prototype Object pour détecter le type / constructeur d’un objet.

 // 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 ce qui précède, nous pouvons dire que l’opérateur de typeOf fonctionne bien avec les types primitifs (string, number, boolean, function, undefined) mais pour mieux différencier les autres types (object, null), il est recommandé d’utiliser Object.prototype.toString()

plus coercition

Nous constatons enfin d’autres scénarios où la coercition est donnée:

 // 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

Conclusion

La coercition est l’une de ces caractéristiques javascript qui est bon à savoir, afin que nous comprenions correctement les fragments de code et évitez de faire des erreurs de logique , ce qu’ils sont plus difficiles à tracer.

Je vous recommande de lire la Colérition des données de l’article en JavaScript.

😎 codage heureux!

annonces

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *