1.1 Conversion de type explicite
La conversion de type en JavaScript est le processus de transformation d'une valeur d'un type de données à un autre. Il existe deux types de conversion : explicite (manuelle) et implicite (automatique). Comprendre ces processus est important pour éviter les erreurs et créer un code prévisible.
La conversion explicite, également connue sous le nom de conversion manuelle, est effectuée en utilisant des fonctions intégrées et des méthodes JavaScript. C'est une conversion où le programmeur indique explicitement quel type de données doit être converti en un autre type.
Méthodes principales de conversion explicite :
1. Conversion en chaîne
- La méthode
String(value): convertit une valeur en chaîne
let num = 123;
let str = String(num);
console.log(typeof str); // "string"
value.toString(): méthode d'objet qui convertit une valeur en chaîne
let bool = true;
let str = bool.toString();
console.log(typeof str); // "string"
2. Conversion en nombre
Number(value): convertit une valeur en nombre
let str = "456";
let num = Number(str);
console.log(typeof num); // "number"
parseInt(value, base): convertit une chaîne en un entier. Le paramètrebasespécifie la base du système numérique
let str = "123";
let num = parseInt(str, 10);
console.log(typeof num); // "number"
parseFloat(value): convertit une chaîne en nombre à virgule flottante
let str = "123.45";
let num = parseFloat(str);
console.log(typeof num); // "number"
3. Conversion en valeur booléenne
Boolean(value): convertit une valeur en booléen
let str = "";
let bool = Boolean(str);
console.log(typeof bool); // "boolean"
1.2 Conversion de type implicite
La conversion implicite, également connue sous le nom de conversion automatique ou cachée, est effectuée par JavaScript automatiquement lors de l'exécution d'opérations avec différents types de données. La conversion implicite peut conduire à des résultats inattendus, donc il faut la comprendre et l'utiliser avec précaution.
1. Conversion en chaîne
Lors de l'addition de tout objet avec une chaîne, JavaScript essaiera de le convertir en chaîne.
Exemple :
let result = "The number is " + 123;
console.log(result); // "The number is 123"
2. Conversion en nombre
Lors de l'utilisation de tout opérateur arithmétique (sauf +) avec des chaînes contenant des nombres.
let result = "123" - 0;
console.log(result); // 123 (nombre)
Comment cela fonctionne en pratique :
let result = "123" - 10;
console.log(result); // 113 (nombre)
let result2 = "123" + 10;
console.log(result2); // 12310 (chaîne)
3. Conversion en valeur booléenne
Lors de l'utilisation de valeurs dans des contextes logiques (opérateurs conditionnels, boucles, etc.).
let value = "hello";
if (value) {
console.log("Value is truthy"); // Affichage : "Value is truthy"
}
Exemples de conversions dans un contexte logique :
false,0,""(chaîne vide),null,undefined, etNaNsont considérés comme des valeurs fausses (false)- Toutes les autres valeurs sont considérées comme vraies (
true)
if ("") {
console.log("This won't be logged.");
} else {
console.log('"" is considered false in a boolean context.');
}
// '"" is considered false in a boolean context.'
1.3 Exemples de conversion implicite
Exemple avec des opérations arithmétiques :
let width = "100";
let height = "200";
let area = Number(width) * Number(height); // Conversion explicite
console.log(area); // 20000
let perimeter = (+width) + (+height); // Utilisation du plus unaire pour une conversion explicite
console.log(perimeter); // 300
Exemple avec un contexte logique :
let userInput = ""; // Chaîne vide
if (!userInput) {
console.log("L'utilisateur n'a pas saisi de données."); // Conversion implicite de la chaîne en valeur booléenne
}
Exemple avec des types combinés :
let value = "10";
let increment = 5;
let result = value + increment; // Conversion implicite du nombre en chaîne
console.log(result); // "105"
result = Number(value) + increment; // Conversion explicite de la chaîne en nombre
console.log(result); // 15
GO TO FULL VERSION