Comment effectuer une conversion de type forcée en javascript

Méthode de conversion forcée : 1. Utilisez la méthode ToString(), ToNumber() ou ToBoolean() ; 2. Utilisez la méthode String(), Number() ou Boolean() ; -" ; 4. Utilisez des instructions telles que "if()" et "while()".

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

1. Règles de conversion de type

1.ToString

Pour les objets ordinaires, sauf si vous définissez vous-même la méthode toString, la méthode Object.prototype.toString() sera appelée. Si l'objet a sa propre méthode toString, la stringification appellera la méthode et utilisera sa valeur de retour.

2.ToNumber

• Pour les types de base où true est converti en 1 et false est converti en 0 ; 🎜> undefined est converti en NaN, null est converti en 0.
Le type d'objet sera d'abord converti en une valeur de type de base. Si une valeur de type de base non numérique est renvoyée, elle sera ensuite forcée d'être convertie en nombre selon les règles de conversion de type de base. Afin de convertir une valeur en valeur de type primitif correspondante, l'opération abstraite
• ToPrimitive vérifie d'abord si la valeur a une méthode valueOf(). S'il existe et renvoie une valeur de type de base, utilisez cette valeur pour la conversion. Sinon, utilisez la valeur de retour de toString() (si elle existe) pour effectuer la conversion. Si ni valueOf() ni toString() ne renvoient une valeur de type de base, une TypeError sera générée.

let a = {
    valueOf:function(){
        return "42";
    }
};
let b = {
    toString:function(){
        return "42";
    }
};
let c = [4,2];
c.toString = function(){
    return this.join(""); //"42"
};

Number(a);     //42
Number(b);     //42
Number(c);     //42
Number('');    //0
Number([]);    //0
Number(["abc"];//NaN

3.ToBoolean

Les valeurs en JavaScript peuvent être divisées en valeurs qui peuvent être forcées à false et valeurs pouvant être forcées Convertit deux types de valeurs en vrai.

Fausses valeurs :

undefined
• null
• false
• +0, -0, NaN
• ""

Vraie valeur : À l'exception de la liste ci-dessus, tous les objets peuvent être compris comme de vraies valeurs, et tous les objets sont de vraies valeurs

let a1 = new Boolean( false );
let b1 = new Number( 0 );
let c1 = new String( "" );
let d1 = Boolean(a1 && b1 && c1); //true

let a2 = [];
let b2 = {};
let c2 = function(){};
let d2 = Boolean(a2 && b2 && c2); //true

2. Afficher la conversion de type forcée

1. Afficher la conversion entre les chaînes et les nombres

Chaîne et The. la conversion entre les nombres s'effectue via les deux fonctions intégrées

String(..) et Number(..). 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 d'affichage 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 un type en valeur booléenne 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

[Apprentissage recommandé :

Tutoriel JavaScript avancé]

3 . Casting implicite

1. Casting implicite entre chaîne et nombre

( 1) L'opérateur +

peut être utilisé pour l'addition de nombres et la concaténation de chaînes

Si l'un des opérandes de + est une chaîne (ou obtenez une chaîne en appelant l'opération abstraite ToPrimitive dessus ), effectuez une concaténation de chaînes ; sinon effectuez une addition numérique. É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"

peut 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"

a + "" (implicite) et il y a un subtil différence à noter entre le String(a) précédent (explicite).

Selon les règles de l'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(). Ils renvoient finalement 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 d'une chaîne en nombre

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

2. Type forcé implicite Convertir en valeur booléenne <.>La conversion implicite de la valeur booléenne se produira dans les situations suivantes :

(1) Expression conditionnelle dans l'instruction if (..) .

(2) L'expression conditionnelle (seconde) dans l'instruction for ( .. ; .. ; .. ).

(3) Expressions conditionnelles dans les boucles while (..) et do..while(..).

(4) ? : Expression de jugement conditionnel.

(5) L'opérande sur le côté gauche des opérateurs logiques || (OU logique) et && (ET logique) (en tant qu'expression conditionnelle).

Dans le cas ci-dessus, les valeurs non booléennes seront implicitement converties en valeurs booléennes, en suivant les règles d'opération abstraites ToBoolean introduites précédemment.

Pour plus de connaissances liées à la programmation, veuillez visiter : Introduction à la programmation ! !

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!