Comment effectuer une coercition de type en javascript

Méthode de conversion forcée : 1. Utilisez la fonction String(), Number() ou toString() pour convertir le type d'affichage entre les chaînes et les nombres. 2. Utilisez la fonction Boolean() pour convertir la valeur en un ; Valeur booléenne ;3. Utilisez les opérateurs "+" et "-" pour la conversion de type implicite entre les chaînes et les nombres.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

1. Afficher la conversion de type forcée entre les chaînes et les nombres

La conversion entre les chaînes et les nombres se fait via String(..) et Number(..) Ces deux fonctions intégrées.
En plus de String(..) et Number(..), il existe d'autres moyens d'obtenir une conversion explicite entre des chaînes et des nombres :

let a = 42;
let b = a.toString();
let c = "3.14";
let d = +c;
b; // "42"
d; // 3.14

a.toString() est explicit , mais il existe un conversion implicite impliquée. Étant donné que toString() ne fonctionne pas avec des valeurs primitives telles que 42, le moteur JavaScript crée automatiquement un objet wrapper pour 42, puis appelle toString() sur cet objet. Cette conversion explicite contient une conversion implicite.

2. Conversion explicite en valeur booléenne

let a = "0";
let b = [];
let c = {};
let d = "";
let e = 0;
let f = null;
let g;
Boolean( a ); // true
Boolean( b ); // true
Boolean( c ); // true
Boolean( d ); // false
Boolean( e ); // false
Boolean( f ); // false
Boolean( g ); // false

Bien que Boolean(..) soit explicite, il n'est pas couramment utilisé. La manière la plus courante de convertir explicitement en booléen est !!

let a = "0";
let b = [];
let c = {};
let d = "";
let e = 0;
let f = null;
let g;
!!a; // true
!!b; // true
!!c; // true
!!d; // false
!!e; // false
!!f; // false
!!g; // false

3 Cast implicite entre la chaîne et le nombre

(1) L'opérateur + <🎜. >

peut être utilisé à la fois pour l'addition numérique et la concaténation de chaînes.

Si l'un des + Si l'opérande est une chaîne (ou une chaîne est obtenue en appelant l'opération abstraite ToPrimitive sur celui-ci), puis la concaténation de chaînes est effectuée, sinon une addition numérique est effectuée ; Étant donné que l'opération valueOf() du tableau ne peut pas obtenir une simple valeur primitive, elle appelle à la place toString(). Ainsi, les deux tableaux de l'exemple ci-dessous deviennent "1,2" et "3,4". + Concaténez-les et renvoyez "1,23,4".

let a = "42";
let b = "0";
a + b; // "420"

let c = 42;
let d = 0;
c + d; // 42

let x = [1,2];
let y = [3,4];
x + y; // "1,23,4"

Vous pouvez utiliser l'opérateur + pour la conversion de chaîne, + le nombre et la chaîne vide "" pour la convertir en chaîne

let a = 42;
let b = a + "";
b; // "42"

Il y a une différence subtile à noter entre a + "" (implicite) et le String(a) précédent (explicite).

Selon les règles d'opération abstraite ToPrimitive, un + "" appellera la méthode valueOf() sur a, puis convertira la valeur de retour en chaîne via l'opération abstraite ToString. String(a) appelle directement ToString(). Ce qu'ils renvoient finalement, ce sont des chaînes, mais si a est un objet plutôt qu'un nombre, le résultat peut être différent

let a = {
    valueOf: function() { return 42; },
    toString: function() { return 4; }
};
a + "";         // "42"
String( a );    // "4"

(2) Cas de transtypage de chaîne en nombre

- est l'opérateur de soustraction numérique, donc a - 0 convertira a en un nombre. Vous pouvez également utiliser un * 1 et un /1, car ces deux opérateurs ne s'appliquent qu'aux nombres, mais une telle utilisation est moins courante

let a = [3];
let b = [1];
a - b; // 2

[Apprentissage recommandé :

Tutoriel avancé Javascript】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!