Un aperçu détaillé des conversions de types en JavaScript

JavaScript est un langage de programmation très flexible qui prend en charge plusieurs types de données. Toute conversion de type (toute conversion de type) est l'un des problèmes souvent rencontrés en JavaScript.

Les types de données en JavaScript peuvent être divisés en types primitifs et types d'objets. Les types primitifs incluent les nombres, les chaînes, les valeurs booléennes, nulles et non définies, et les types d'objets incluent Objet, Fonction, Tableau, etc.

Tout type de données peut être converti en d'autres types de données à l'aide de règles de conversion de type. Certaines règles de conversion doivent être suivies lors de ce processus de conversion.

Ci-dessous, nous présenterons en détail la conversion de type en JavaScript.

Conversion de type explicite

JavaScript fournit des fonctions intégrées qui peuvent convertir tout type de données en d'autres types de données. Ces fonctions peuvent être utilisées comme des fonctions ordinaires, comme indiqué ci-dessous :

// 将数字转换为字符串
var num = 123;
var str = num.toString(); // str 将会是 "123"

// 将字符串转换为数字
var str = "123";
var num = Number(str); // num 将会是 123

// 将字符串转换为布尔值
var str = "123";
var bool = Boolean(str); // bool 将会是 true

Dans ces fonctions, toString(), Number() et Boolean() sont utilisés pour la conversion de type explicite.

En JavaScript, vous pouvez également utiliser des opérateurs de conversion (tels que +, -, ++, --, etc.) pour effectuer des conversions de type explicites.

Lors de la conversion de type explicite, vous devez faire attention aux points suivants :

• Lorsque des nombres et des chaînes sont ajoutés, JavaScript convertira automatiquement le nombre en chaîne, puis effectuera la concaténation des chaînes. L'exemple de code est le suivant :

var num = 123;
var str = "456";
var result = num + str; // result 将会是 "123456"

• Lorsque des chaînes et des valeurs booléennes sont ajoutées, JavaScript convertit la valeur booléenne en nombre puis l'ajoute. L'exemple de code est le suivant :

var str = "123";
var bool = true;
var result = str + bool; // result 将会是 "123true"

• Lorsqu'une valeur booléenne est ajoutée à un nombre, JavaScript convertit la valeur booléenne en nombre, puis l'ajoute. L'exemple de code est le suivant :

var num = 123;
var bool = true;
var result = num + bool; // result 将会是 124

Conversion de type implicite

En JavaScript, certains opérateurs et fonctions convertissent implicitement un type de données en un autre.

Conversion de type implicite de chaînes et de nombres

Lorsque des chaînes et des nombres sont comparés ou exploités, JavaScript convertira automatiquement la chaîne en nombre, puis effectuera la comparaison ou l'opération. L'exemple de code est le suivant :

var str = "123";
var num = 456;
var result1 = str + num; // result1 将会是 "123456"
var result2 = num + str; // result2 将会是 "456123"

Dans le code ci-dessus, le symbole + peut être utilisé pour épisser des chaînes ou ajouter des nombres. En raison du fonctionnement des chaînes et des nombres, JavaScript convertira automatiquement les chaînes en nombres, donc le résultat final. est une chaîne.

Conversion de type implicite des valeurs booléennes

En JavaScript, lorsqu'une valeur booléenne participe à une comparaison ou à une opération, la valeur booléenne sera automatiquement convertie en un type numérique pour une comparaison ou une opération. Vrai passe à 1, Faux passe à 0. L'exemple de code est le suivant :

var num = 5;
var bool1 = num == true; // bool1 将会是 false
var bool2 = num == false; // bool2 将会是 false
var bool3 = num > false; // bool3 将会是 true

Conversion de type automatique

En JavaScript, certaines opérations déclencheront automatiquement la conversion de type.

En JavaScript, tous les types non booléens dans les instructions if, for, while, etc. déclencheront automatiquement la conversion de type.

Donnons des exemples ci-dessous :

Conversion automatique de type dans les instructions if

En JavaScript, les types non booléens dans les instructions if déclencheront automatiquement la conversion de type. Lorsqu'un type non booléen est utilisé comme condition, JavaScript appelle la fonction Boolean() pour le convertir en type valeur booléenne.

L'exemple suivant illustre la conversion de types non booléens dans des instructions if en types booléens :

if (null) {
    console.log("null is true");
} else {
    console.log("null is false");
}

if (undefined) {
    console.log("undefined is true");
} else {
    console.log("undefined is false");
}

if (0) {
    console.log("0 is true");
} else {
    console.log("0 is false");
}

if ("") {
    console.log("'' is true");
} else {
    console.log("'' is false");
}

Les résultats de sortie sont les suivants :

null is false
undefined is false
0 is false
'' is false

Comme le montrent les résultats de sortie ci-dessus, lorsque des types non booléens sont utilisés dans if déclarations, ils doivent le convertir en type booléen, puis juger.

Conversion automatique de type dans la boucle for

En JavaScript, les types non booléens dans les boucles for déclencheront automatiquement la conversion de type. Lorsqu'un type non booléen est utilisé comme condition dans une boucle for, JavaScript appelle la fonction Boolean() pour le convertir en type valeur booléenne.

L'exemple suivant illustre la conversion de types non booléens en types booléens dans une boucle for :

for(var i=0; i<=10; i++) {
    if(i) {
        console.log(i);
    }
}

Les résultats de sortie sont les suivants :

1
2
3
4
5
6
7
8
9
10

Comme le montrent les résultats de sortie ci-dessus, dans la boucle for, non booléens les types peuvent également être convertis. Il est de type booléen puis jugé.

Conversion automatique de type dans la boucle while

En JavaScript, les types non booléens dans les boucles while déclencheront automatiquement la conversion de type. Lorsqu'un type non booléen est utilisé comme condition dans une boucle while, JavaScript appelle la fonction Boolean() pour le convertir en type valeur booléenne.

L'exemple suivant illustre la conversion de types non booléens en types booléens dans des boucles while :

var i = 0;
while(i < 10) {
    i++;
    if(i%2) {
        console.log(i + "是奇数");
    } else {
        console.log(i + "是偶数");
    }
}

Les résultats de sortie sont les suivants :

1是奇数
2是偶数
3是奇数
4是偶数
5是奇数
6是偶数
7是奇数
8是偶数
9是奇数
10是偶数

Comme le montrent les résultats de sortie ci-dessus, dans les boucles while, les types non booléens peuvent également être converti en types booléens, puis porter un jugement.

Résumé

En JavaScript, toute conversion de type doit suivre certaines règles. Pendant le processus de conversion de type, vous devez faire attention à plusieurs points clés :

• Les types de données en JavaScript incluent les types primitifs et les types d'objet ;
• La conversion de type explicite peut utiliser des fonctions de conversion de type ou des opérateurs de conversion ;
• La conversion de type implicite est une méthode de conversion de type courante en JavaScript ;
• La conversion de type automatique signifie que les types non- Les types booléens if, for, while et d'autres instructions déclencheront automatiquement la conversion de type ;
• Lorsque vous effectuez une conversion de type, vous devez faire attention aux règles de conversion de type, afin de garantir l'exactitude du code.

Ce qui précède est une introduction détaillée à toute conversion de type en JavaScript. J'espère qu'il pourra vous aider.

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!