FazBrowse Wikipedia Viewer | Main Page |
Search Wikipedia:
|
Viewing: https://fr.wikipedia.org/wiki/Syntaxe_JavaScript

Syntaxe JavaScript — Wikipédia

Contents
    Affectations
    Booléens
    Binaires
    Boucle For..in
    Break, continue et label
Objets
    Bibliographie

La syntaxe JavaScript est un ensemble de règles qui définissent ce qui constitue un programme valide en langage JavaScript.

constmyString="123.456" constmyNumber=Number(myString);

Quand il est utilisé comme un constructeur, un objet wrapper numérique est créé (toutefois il est peu employé) :

monTableau.1;// déclenche une erreur de syntaxe monTableau["01"];// n'est pas identique à monTableau[1]

La déclaration d'un tableau peut se faire littéralement ou par l'utilisation du constructeur Array :

consta=salutation[0];// a vaut 'H'

En JavaScript les chaînes sont immuables :

- Négation unaire (inverse le signe) ++ Incrémentation (peut être utilisé en forme préfixée ou postfixée) -- Décrémentation (peut être utilisé en forme préfixée ou postfixée)

Affectations

modifiermodifier le code
== Égal à != Différent de > Supérieur à >= Supérieur ou égal à < Inférieur à <= Inférieur ou égal à === Identiques (égaux et du même type) !== Non-identiques

Booléens

modifiermodifier le code

Le langage Javascript possède 3 opérateurs booléens :

consta=0; constb=9; !a;// rend true, car Boolean( a ) rend false !b;// rend false, car Boolean( b ) rend true

En doublant l'opérateur !, on peut normaliser une valeur booléenne :

x&&y;// rend x si x est FAUX, sinon il rend y x||y;// rend x si x est VRAI, sinon il rend y

Ce fonctionnement provient du fait que l'évaluation s'effectue de gauche à droite. Dès que la réponse est déterminée, l'évaluation s'arrête :

Ce nouveau comportement est peu connu, même parmi les développeurs Javascript expérimentés, et peut causer des problèmes si on s'attend à recevoir une valeur booléenne.

Binaires

modifiermodifier le code

Opérateurs binaires

> Shift right : décalage à droite avec conservation du bit de signe (le bit de gauche, celui du signe, est décalé vers la droite et recopié à son emplacement)\n>>> Shift right : décalage à droite sans conservation du bit de signe (avec remplissage à gauche avec 0)\n\n Pour les nombres positifs, >> et >>> donnent le même résultat\n"}}'>& And : et binaire | Or : ou binaire ^ Xor : ou binaire exclusif << Shift left : décalage à gauche avec remplissage à droite avec 0) >> Shift right : décalage à droite avec conservation du bit de signe (le bit de gauche, celui du signe, est décalé vers la droite et recopié à son emplacement) >>> Shift right : décalage à droite sans conservation du bit de signe (avec remplissage à gauche avec 0) Pour les nombres positifs, >> et >>> donnent le même résultat

Opérateur unaire

= Assignation + Concaténation += Concatène et assigne
constresultat=(condition)?expression1:expression2;

Le code ci-dessus, qui utilise l'opérateur conditionnel, a le même effet que le code ci-dessous, qui utilise une structure si..sinon :

for(initialisation;condition;instruction)

Boucle For..in

modifiermodifier le code
do{ instructions; }while(condition);

Break, continue et label

modifiermodifier le code

break permet de sortir d'une boucle.

continue permet de passer à l'itération suivante de la boucle.

constObjet1={a:1} constObjet2={b:2} functionbizarre(p){ letp=Objet2;// on ignore la valeur reçue dans le paramètre p p.b=arguments[1]// on remplit Objet2.b avec la valeur du {{2e}} paramètre reçu } bizarre(Objet1,3)// Objet1 est ignoré, 3 est un paramètre additionnel console.log(`${Objet1.a}${Objet2.b}`);// affiche 1 3

Il est toutefois possible de transformer l'objet arguments en un tableau grâce à :

\")};\n console.log(parfum);\n }\n\n console.log(parfum); // affiche vanille\n dessert(); // affiche \"chocolat\" parce qu'on est dans dessert\n console.log(parfum); // affiche vanille\n glace(); // affiche \"chocolat\" et pas \"vanille\", même si on est sorti de dessert\n console.log(parfum); // affiche vanille\n"}}'>letparfum="vanille"; letglace; functiondessert(){ parfum="chocolat"; glace=function(){document.write(parfum+"<br>")}; console.log(parfum); } console.log(parfum);// affiche vanille dessert();// affiche "chocolat" parce qu'on est dans dessert console.log(parfum);// affiche vanille glace();// affiche "chocolat" et pas "vanille", même si on est sorti de dessert console.log(parfum);// affiche vanille

Objets

modifiermodifier le code

Par commodité, on sépare habituellement les types de données en primitives (ou types de données de base) et objets. Les objets sont des entités qui ont une identité (ils ne sont égaux qu'à eux-mêmes) et qui associent des noms de propriété à des valeurs. Les propriétés sont appelées slots dans le vocabulaire de la programmation orientée prototype.

Le langage Javascript propose divers types d'objets prédéfinis : tableau, booléen, date, fonction, maths, nombre, objet, expression régulière et chaîne de caractères. D'autres objets prédéfinis sont des objets hôte issus de l'environnement d'exécution. Par exemple dans un navigateur les objets hôtes appartiennent au modèle DOM : fenêtre, document, lien hypertexte, etc.

On peut voir les objets les plus simples comme des dictionnaires. En tant que dictionnaires, ils contiennent des couples clé-valeur, où la clé est une chaîne de caractères et la valeur peut être de n'importe quel type. Les objets simples sont souvent implémentés comme des dictionnaires. Cependant, les objets possèdent des fonctionnalités que n'ont pas les dictionnaires, comme une chaîne prototype.

Exemple de déclaration littérale d'un objet contenant des valeurs :

// création à l'aide du constructeur prédéfini : constpremierObjet=newObject(); // création littérale : constobjetA={}; constmonObjet={nom:'vistemboir',utilite:'cet objet ne sert à rien',prix:5000};

Les déclarations littérales d'objets et de tableaux permettent de créer facilement des structures de données adaptées aux besoins :

try{ consttablo=newArray();// création d'un tableau fonctionRisquee(tablo);// appel d'une fonction qui peut ne pas fonctionner } catch(...){ logError();// traitement des erreurs éventuelles } finally{ deletetablo;// libération de la mémoire occupée par tablo même en cas d'erreur fatale }

Le bloc finally est facultatif :

try{instruction;}// erreur

Si vous utilisez le bloc catch, le paramètre est obligatoire, même si vous ne l'utilisez pas dans le bloc.

return a+b; // ces 2 lignes renvoient undefined car elles sont traitées comme : // return; // a + b;

Autre exemple :

  1. ↑ La question est de savoir si l'itération se fera non seulement sur l'indice du tableau, mais aussi sur d'autres propriétés :
    • Un article du site Microsoft Developer Network assure que la boucle For...In peut être utilisée pour itérer sur tous les éléments d'un tableau. L'article du MSDN se réfère à JScript, qui est utilisé par Internet Explorer pour les scripts en JavaScript.
    • Le site W3Schools donne les tableaux comme exemple d'utilisation de la boucle For...In.
    • Un article du Mozilla Developer Centre explique le problème : il est tentant d'utiliser la boucle For...In pour balayer les éléments d'un tableau, mais il faut savoir qu'elle balaie aussi les propriétés définies par l'utilisateur. Si vous modifiez l'objet Array en y ajoutant des propriétés ou des méthodes, la boucle For...In rendra le nom de vos propriétés en plus des indices numériques. De ce fait, pour boucler dans un tableau, il vaut mieux utiliser une boucle For classique avec un compteur numérique.
  2. ↑ Les exemples présentés dans cet article utilisent souvent une fonction appelée println. Ce terme représente la fonction de sortie standard qui n'existe pas dans la bibliothèque standard de Javascript. Dans un navigateur, ce terme peut être remplacé par document.write.

Bibliographie

modifiermodifier le code
View original on Wikipedia | Back | FazBrowse Home