Conversion explicite

La conversion explicite est celle qui nécessite l'utilisation d'une méthode.

---

String|Boolean --->Number

On utilisera préférentiellement la méthode Number().

Number()

Les fonctions Number(), parseInt() et parseFloat() permettent de convertir vers le type nombre.

Syntaxe
	Number(string);

	Number(boolean);
	

les valeurs hexadécimales doivent commncer par "0x", les binaires par ou "0b", la conversion se fait vers la base 10.

Démo
	var v1,v2,v3;
	v1="123.69";	//123.69
	v2="0x11";	//17
	v3="0b1111";	//15
	v4=true;		//1
	v5=false;		//0

	console.log(Number(v1));
	console.log(Number(v2));
	console.log(Number(v3));
	console.log(Number(v4));
	console.log(Number(v5));

Tentons une conversion des types suivants:

Démo
	console.log(Number(""));	//0
	console.log(Number(" "));	//0
	console.log(Number([]));	//0
	console.log(Number([1,2,3]));	//NaN
	console.log(Number("80 96"));	//NaN
	console.log(Number("brol"));	//NaN
	console.log(Number(null));	//0
	console.log(Number("undefined"));	//NaN
	console.log(Number({val:"5"}));	//NaN

NaN ne veut pas dire not a number, NaN est une valeur de type number qui est générée lorsque JS n'a pas pu réaliser une opération arithmétique, remarquons que NaN n'est pas égale à NaN, il faut donc éviter de faire des comparaisons sur cette valeur.

Démo
	console.log(NaN == NaN);
	console.log(NaN === NaN);
	console.log(Number.NaN === Number.NaN);

parseInt() et parseFloat()

Syntaxe
	parseInt(string, base);
	

Syntaxe
	parseFloat(string);
	

Si base est omis la chaîne de caractères (si cette action est possible!) est renvoyée en Number base 10.

Ne jamais passer à parseInt un nombre réel, car l'interpréteur commencera par convertir en String et ensuite convertira cette valeur alphanumérique en Number. Utiliser plutôt Math.floor, Math.ceil ou Math.round, c'est fait pour çà!

Démo
	valeur=parseInt(window.prompt("Entrer une valeur","--ici---"));
	document.write("Type de votre variable: ",typeof valeur);
		

Si la conversion ne se fait pas, les méthodes précédentes renvoient NaN.

---

Number ---> String

toString()

Syntaxe
		num.toString([base])
	

base représente la base dans laquelle la valeur de type Number doit être renvoyée, une valeur de 2 à 32 (10 par défaut)

Démo
	valeur=window.prompt("Entrer une valeur","--ici---");
	valeur=parseInt(valeur);
	document.write(valeur," est de type:",typeof valeur,"<br>");
	valeur=valeur.toString(16);
	document.write(valeur," est de type:",typeof valeur);

String()

Syntaxe
		String(num)
	

Démo
	var val=125;
	val=String(val);
	console.log(val);
	console.log(typeof val);

---

Number | String ---> Boolean

Convertir en booléen

Syntaxe
	Boolean(valeur)

Démo
	var valeur=window.prompt("Entrer une valeur","--ici---");
	valeur=Boolean(valeur);
	document.write("Type de votre variable:",typeof valeur);

Voir Evaluation booléenne des variables.

---

Conversion implicite de type (coercion)

La conversion implicite est celle qui est effectuée automatiquement, si nécessaire, par l'interpreteur JavaScript.

La conversion implicite n'est pas un problème, il y a simplement lieu de bien savoir ce qui va se passer.
Elle induit quand même souvent la confusion..., la conversion explicite est bien plus sûr.

Exemple 1: la comparaison

Démo
	var v1,v2;
	v1="69";
	v2=69;
	console.log(v1==v2);	//true
	console.log(v1===v2);	//false

Avec == JS tente de convertir la partie gauche de la comparaison et donc la chaîne en type Number, et effectue la comparaison après.

Avec === JS il y a comparaison sur le type et le contenu et donc aucune conversion.

Exemple 2: addition/soustraction et multiplication/division

Démo
	var v1,v2;
	v1="169";
	v2=69;
	console.log(v1+v2);	//16969
	console.log(v1-v2);	//100
	console.log(v1*v2);	//11661
	console.log(v1/v2);	//2,44927...

La conversion vers le type Number se fait pour tous les opérateurs sauf pour le +, celui-ci devenant l'opérateur de concaténation.

La conversion implicite peut amener à certaines confusions, à utiliser seulement si vous maîtrisez parfaitement les conversions qui seront appliquées par JavaScript.