Les six types en javascript

Javascript est un langage très peu typé avec seulement 6 types:

1. "boolean",
   
2. "number",
   
3. "string" ,
   
4. "object" ,
   
5. "function" ,
   
6. "undefined" .

Ces types peuvent être mis en évidence par l'opérateur unaire (un seul argument) typeof, l'opérateur double parenthèse ( ) après typeof est facultatif.
Voici quelques exemples dans la console Firebug:

>>> typeof(1==2); // "boolean"
>>> typeof 'hello'; //"string"
>>> typeof({reel: 3, imaginaire:1}); //"object"
>>> typeof [1,3,4] //"object"
>>> typeof (alert) //"function"
>>> typeof(5); ///"number"
>>> typeof(function(){return 0}); //"function"
>>> typeof(variable_inconnue); //"undefined"
>>> typeof null ; // "object" !! le type null c'est à dire rien est "object"!
>>> typeof typeof ; // erreur !



Attention :
Il est remarquable que le type "null" est considéré comme un objet alors que lorsqu'une variable est inconnu elle prend la valeur "undefined".

Conversion des types renvoyés par les opérateurs booléens:

Le typage est très particulier et se fait à la volée ainsi un "booléen" devient "number" voire "string " ou "objet" lorsque les précédents éléments sont évalués vrais.

>>> 1==1&&2 ; //2
>>> 1==2||3||4==4 ; // 3 : premier élément vrai retrouvé
>>> typeof(1==1&&2); //"number" 2
>>> typeof !!1 ; //"boolean" traduit un entier en booléen



Les valeurs fausses ou "faussées" :

Certaines valeurs renvoient false, "falsy values ":

1. 0 ,
2. "" ,
3. NaN,
   
4. null et
   
5. undefined.

Et toutes les autres valeurs sont considérées comme vrai.

if(0){ true; }else{ false;} // false;
"hello" && true ; // true;


Expressions idiomatiques et usages en javascript:

Ainsi, pour comprendre les expressions javascript il faut étudier le type retourné par une expression booléenne.
L'évaluation paresseuse du "ou" || fait que le premier élément renvoyé est le premier élément vrai.

Ainsi on trouve des lignes de code ressemblant à cela :
return a||"non trouvé" ; qui permet de renvoyer l'élément a s'il existe..



Problème de l'opérateur == :

L'opérateur double égal provoque une contrainte de type (en anglais "type coercion" ) ainsi on obtient des résultats étonnants avec l'utilisation de cet opérateur :
1 == true ; // true !
false==0 ; // true!

Ainsi l'opérateur = = risque de transformer le type et de poser des problèmes de débuggage inattendus ! Le même problème se pose avec l'opérateur !=
Douglas Crockford propose de bannir cet opérateur et d'utiliser l'opérateur triple égal qui réalise une véritable comparaison booléenne :

false === 0 ; // false ;
1=== true ; // false