Informatique


Conversion de type (coercion)

Aller à


Conversion explicite

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


String ---> 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);
	

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
	console.log(Number(v1));
	console.log(Number(v2));
	console.log(Number(v3));

Quelques valeurs particulières:

Démo
	console.log(Number(true));		//1
	console.log(Number(false));	//0
	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

Tentative de conversion d'un type object vers un Number:

Démo
var a;
a={
	val:"5"
};
	console.log(Number(a));		//NaN
parseInt()
Syntaxe
	parseInt(string, base);
	

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 çà!

parseFloat()
Syntaxe
	parseFloat(string);
	
Démo
	/*Déclaration
	---------------*/
	var valeur;

	/*Affectation externe de la variable valeur
	-----------------------------------------*/
	valeur=window.prompt("Entrer une valeur","--ici---");

	/*Modification du type de la variable valeur
	-------------------------------------------*/
	valeur=parseInt(valeur);

	/*Affichage du type de la variable valeur
	----------------------------------------*/
	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

La méthode toString() ou String() permet de convertir vers le type 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
	/*Déclaration
	----------------*/
	var valeur;

	/*Affectation externe de la variable valeur
	------------------------------------------*/
	valeur=window.prompt("Entrer une valeur","--ici---");

	/*Modification du type de la variable valeur
	--------------------------------------------*/
	valeur=parseInt(valeur);
	document.write(valeur," est de type:",typeof valeur,"<br>");

	/*Modification vers le type chaîne (représentation en base 16)
	-------------------------------------------------------------------*/
	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
La méthode Boolean() permet de convertir vers le type boolean.
Syntaxe
	Boolean(valeur)
Démo
	/*Déclaration
	----------------*/
	var valeur;

	/*Affectation externe de la variable valeur
	------------------------------------------*/
	valeur=window.prompt("Entrer une valeur","--ici---");

	/*Modification du type de la variable valeur
	--------------------------------------------*/
	valeur=Boolean(valeur);
	document.write("Type de votre variable:",typeof valeur);

		

Conversion implicite

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


Conversion implicite de type (coercion)

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="69";
	v2=69;
	console.log(v1==v2);	//true
	console.log(v1===v2);	//false

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.