Programmation JavaScript/Mots réservés
Cet article va passer en revue les mots réservés et constantes prédéfinies de JavaScript.
La norme ECMA 262, définit les mots réservés de JavaScript en deux catégories :
On ne doit pas utiliser un mot réservé comme identificateur. Cela provoque une erreur. Mais comme le langage différencie les majuscules et minuscules, il est possible de mettre en majuscule une lettre pour rendre l'identificateur utilisable.
On peut, avec la plupart des navigateurs utiliser un futur mot réservé comme identificateur, mais cela est déconseillé, car le programme ne fonctionnera probablement plus à l'apparition d'une version future de JavaScript.
Voici une description sommaire des mots réservés :
Déclarations.
var.
Déclaration d'une variable locale, avec ou sans affectation. À placer en début d'instruction.
var ma_variable;
var ma_variable = "Je suis affecté";
Une variable locale est détruite automatiquement à la fin de la fonction où elle a été créée (sauf dans le cas des "closures"). Seul le code écrit dans cette fonction peut y accéder, et dans ce code, la variable est prioritaire sur tout autre identifiant homonyme. En revanche, elle ne peut être détruite par l'opérateur delete.
Voir la section sur rehaussement des déclarations.
const.
Déclaration d'une constante locale.
let.
Comme "var" mais restreint la portée au bloc, comme si ce bloc était situé dans une autre fonction. Exemple :
var a = 1;
var b = 2;
 var a = 11;
 let b = 22;
console.log(a); // 11
console.log(b); // 2
function.
Déclaration d'une fonction utilisateur. C'est aussi un opérateur.
function ma_fonction()
 alert("Je suis exécuté dans ma_fonction");
void.
void est une déclaration placée obligatoirement en début d'instruction. void ne fait rien, ne retourne rien, et n'est utile que dans un seul contexte : les pseudo-URL codice_1. En effet, si l'instruction qui compose cet URL retourne une valeur, cette valeur remplace le contenu de la page, ce qui est souvent indésirable. On place alors la déclaration void pour que l'instruction n'ait aucune valeur.
<a href="javascript:void(maFonction())">...</a>
with.
Permet de simplifier la référence aux propriétés et méthodes des objets en précédant un bloc d'instruction dans lequel un objet devient implicite. La déclaration with rajoute en fait un niveau tout en haut de la pile de "scopes".
with(navigator)
 alert(appName + " " + appVersion);
est équivalent à 
alert(navigator.appName + " " +navigator.appVersion);
Structures de contrôle.
return.
Employé dans une fonction, provoque le retour au programme appelant avec renvoi facultatif d'un résultat.
function ma_fonction(aparam)
 s = "";
 if (aparam == "")
 return; // Sortie sans renvoyer de résultat
 else
 s = "Le résultat";
 return s; // Renvoie le contenu de s
if.
Permet de définir l'exécution conditionnelle d'instructions ou d'un bloc d'instructions.
Peut-être utilisé conjointement à else.
a = 5;
if (a==5)
 alert("la condition est remplie");
else.
Utilisé conjointement à if, permet d'exécuter des instructions alternativement au résultat de la condition spécifiée par if.
a = 5
if (a==5)
 alert("a est égal à 5");
else
 alert("a est différent de 5");
switch.
Utilisé conjointement à case, permet d'implanter un sélecteur de cas.
function test(condition)
 switch(condition)
 case "1":
 alert("condition='1'");
 break;
 case "3":
 alert("condition='3'");
 break;
 case "5":
 alert("condition='5'");
 break;
case.
Utilisé à l'intérieur d'un bloc switch, constitue un des choix du selecteur.
break.
Utilisé à l'intérieur d'un bloc switch, permet de sortir du sélecteur sans procéder tests suivants.
Utilisé à l'intérieur d'une boucle telle un bloc switch, permet de quitter la boucle immédiatement.
default.
Utilisé à l'intérieur d'un bloc switch, constitue l'option par défaut du sélecteur.
for.
Introduit une boucle itérative.
for (i=0;i<5;i++)
 alert(i);
For each :
var array = [1, 2, 3];
for (line in array)
 alert(line);
En tableau associatif :
var array = { "a" : 1, "b" : 2, "c": 3 };
for (line in array)
 alert('Clé : ' + line + ', valeur : ' + array[line]);
NB : voir aussi la méthode Array.prototype.forEach().
do.
Introduit une boucle itérative conditionnelle avec test effectué à chaque tour par "while" :
i=0
do
 i++
 alert(i); // Affichera 1, puis 2, puis 3, puis 4, puis 5
while(i<5);
while.
Introduit une boucle itérative conditionnelle:
i=0
while(i<5)
 i++; // Incrémenter i
 alert(i); // Affiche 1, puis 2, puis 3, puis 4, puis 5
continue.
Utilisé dans une boucle "for", "while" et "do", permet de sauter un tour.
for (i=-2;i<=2;i++)
 if (i==0) continue; // Si i == 0, on passe directement à 1
 alert(5/i); // On évite ainsi la division par zéro.
Gestions des erreurs.
throw.
Provoque une erreur personnalisée.
throw new Error("votre erreur");// a le même effet visuel que alert("votre erreur");
try ... catch ... finally.
Évalue un bloc (try) en capturant les erreurs, tente de les gérer (catch) si elles se produisent, et quoiqu'il arrive, évalue un dernier bloc (finally).
Opérateurs.
in.
Opérateur qui détermine l'appartenance à un objet. Dans une boucle for... in, permet de répéter des instructions pour chaque propriété d'un objet.
new.
Opérateur qui permet l'instanciation d'un objet.
var mon_tableau = new Array();
instanceof.
Cet opérateur permet de tester si une valeur est une instance d'un objet :
t = new Array();
alert(t instanceof Array); // Affiche true
alert(t instanceof Date); // Affiche false
typeof.
Cet opérateur renvoie le type de la variable placée à droite.
Les valeurs renvoyées par typeof correspondent aux types de variables JavaScript, soit : 
boolean string number function object undefined.
delete.
Cet opérateur permet de supprimer une propriété.
Valeurs spéciales.
this.
Dans le constructeur ou une méthode d'un objet, c'est une référence à l'objet. Hors de ce contexte, this référence l'objet global "window".
true.
Valeur booléenne "vrai".
if (true)
 alert("Je m'affiche toujours");
false.
Valeur booléenne "faux".
if (ma_bool == false)
 alert("C'est pas vrai...")
null.
Valeur de type "object" qui ne référence rien.
undefined.
C'est la valeur de toutes les variables inexistantes ou supprimées.
Futurs mots réservés.
Les versions futures de JavaScript intégreront peut-être un ou plusieurs mots réservés parmi la liste suivante. Il est donc officiellement déconseillé de les employer comme identificateurs dans les programmes actuels, sous peine de risquer un comportement bizarre dans le futur.
abstract
boolean
byte 
char
double
enum
final
float 
goto
implements
int
interface
long
native
package
private
protected
public
short
super

Programmation JavaScript/Identificateurs

La programmation JavaScript, comme tous les langages informatiques, demande au développeur de définir des identificateurs, et ceci dans deux cas : 
Pour construire notre identificateur nous pouvons utiliser les caractères autorisés, et devons proscrire les caractères interdits. De plus, certaines combinaisons sont interdites. Notre identificateur ne doit pas correspondre à un mot réservé. Enfin, il est utile de se conformer à certaines recommandations en ce qui concerne le choix et l'orthographe de l'identificateur, pour renforcer l'expressivité du code.
Caractères autorisés.
Tous les caractères sont autorisés, sauf ceux qui contreviennent aux règles précédentes et aux caractères interdits.
Standardisation.
Les identificateurs sont en particulier standardisés par l'ECMA 262, au chapitre §7.6.
Ce standard s'appuie sur la chapitre 5 de l'Unicode version 3.
Sont en particulier autorisés les échappement Unicode, s'ils conduisent à un identificateur autorisé.
Enfin, deux identificateurs équivalent ne sont considérés identique que s'ils sont identiques binairement.
Les versions suivants d'Unicode peuvent fonctionner mais ne sont pas nécessairement portables et compatibles.