La syntaxe

La syntaxe

1 Les Constantes

Les constantes sont des valeurs définies qui ne varie pas pendant l'exécution du programme.

Elle peuvent être définie sous la forme de littéraux ou à l'aide du mot clé const.

Les littéraux sont des valeurs spécifiées en suivant les règles javascript :

Les chaînes de caractères sont entre quotes. Il peuvent être simple ou double à condition d'utiliser le même pour ouvrir ou ferme la chaîne. Les nombres peuvent être entier ou flottant. Pour ces derniers le séparateur décimal est le point et la notation exponentielle accepte indifféremment le e minuscule et le E majuscule. Voici des exemples de constantes littérales :

'Chaîne de caractères'

"Chaîne de caractères"

0.12

1.2e-1

Ici les deux chaînes sont équivalentes, tout comme les deux nombres décimaux.

Le même exemples dans un déclaration de constante

const string1 = 'Chaîne de caractères';

const string2 = "Chaîne de caractères";

const float1 = 0.12;

const float2 = 1.2e-1;

Encore une fois les constantes 1 et 2 sont deux écritures équivalentes.

NOTE :

l'intérêt de pour voir utiliser l'un ou l'autre des guillemets simple ou double est de pouvoir utiliser l'autre à l'intérieur de la chaîner sans avoir à l'"échapper".

Exemple :

const quote1 = 'pot d\'échappement';
const quote 2 = "pot d'échapement";

2 Les Variables

1 Présentation

Les variables servent à stocker des valeurs susceptible d'être modifiées au cours de l'exécution du programme.

Elle sont désignées par un nom qui est composé de caractères alphanumériques auxquels s'ajoute le souligné _ et le et dollar $.

Le nom doit commencer par une lettre ou _ ou $.

par exemple :

var  _nom_de_variable$valide ;

var pas.bon;

2 Déclaration

Les variables sont déclarées à l'aide du mot clé var suivi du nom de la variables.

La déclaration peut être accompagnée d'un affectation en la faisant suivre du signe égal et d'une expression

Par exemple :

const quote1 = 'pot d\'échappement';
const quote 2 = "pot d'échapement";

2 Les Variables

1 Présentation

Les variables servent à stocker des valeurs susceptible d'être modifiées au cours de l'exécution du programme.

Elle sont désignées par un nom qui est composé de caractères alphanumériques auxquels s'ajoute le souligné _ et le et dollar $.

Le nom doit commencer par une lettre ou _ ou $.

par exemple :

var  _nom_de_variable$valide ;

var pas.bon;

Ici les deux chaînes sont équivalentes, tout comme les deux nombre décimaux.

Le même exemples dans un déclaration de constante

const string1 = 'Chaîne de caractères';

const string2 = "Chaîne de caractères";

const float1 = 0.12;

const float2 = 1.2e-1;

2 Déclaration

Les variables sont déclarés à l'aide du mot clé var suivi du nom de la variables.

La déclaration peut être accompagnée d'un affectation en la faisant suivre du signe égal et d'une expression

Par exemple :

var mavariable;

var variableavecaffactation = 1;

var variableavecaffectation2 = variableavecaffactation + 1;

3 Les fonctions

1 Présentation

Les fonctions sont des extrait de codes qui peuvent être réutilisées. Elles évitent la duplication de morceaux de programmes qui sont répétés. Cela permet de faciliter la maintenance en cas de bug à corriger et la lisibilité des programmes. Elles peuvent avoir des paramètres afin de traiter des données d'entrées variable et renvoi un résultat.

2 Déclaration

Pour déclarer une fonction on ulitilise le mot clé... function suivi du nom de la fonction et d'une liste facultative de paramètres entre parentheses.Les parenthèses sont obligatoires, même vides. Enfin vient le corps de la fonction composées du code à exécuter entre accolades.

Exemples :

function minimum() {

};

function avecParametres(param) {
};

function afficheMessage() {
   alert('Hello')
};

function renvoi1() {
   return(1);
};

4 Les expressions

1 présentation

Une expression est un suite d'opérandes séparés par des opérateurs. Un opérande est une variable, une constante, le résultat d'une fonction ou une expression.

Les opérateurs sont de trois catégories :

  • Les opérateurs logiques
  • Les opérateurs de comparaisons
  • Les opérateurs mathématiques

2 Les opérateurs logiques

Ces opérateurs permettent d'évaluer des condition multiples

Liste des opérateurs de comparaison
OpérateurFonction
== Égalité
!=Inégalité
===Égalité stricte
!==Inégalité stricte
>Supériorité stricte
>= Supériroté ou égalité
<Infériorité stricte
<=Infériorité ou égalité

Exemples :

// renvoi true

true  || false // vrai ou faux 

true && true // vrai et vrai

!false // le contraire de faux

Les opérateurs de comparaisons

Ces opérateurs permettent de comparer deux opérandes.

Liste des opérateurs de comparaison
OpérateurFonction
== Égalité
!=Inégalité
===Égalité stricte
!==Inégalité stricte
>Supériorité stricte
>= Supériroté ou égalité
<Infériorité stricte
<=Infériorité ou égalité

Les opérateurs d'égalité et d'inégalité considèrent que deux variables sont égales si elle ont la même VALEUR.

Les opérateurs d'égalité stricte et d'inégalité stricte considèrent que deux variables sont égales si elle ont la même VALEUR et le même TYPE.

Les opérateurs de supériorité et d'infériorité suivent les définition mathématique, c'est a dire que si le = n'est pas précisé la comparaison est stricte et alors deux valeur indentique renvoient faux quelque soit le sens.

Exemple :

1 === '1' // renvoie false

1 == '1' // renvoie true

1 >= 1  // renvoie true

1 > 1 // renvoie false

1 !== '1' // renvoie true

1 == 'un' // renvoie false...faut pas trop en demander !

Les opérateurs mathématiques

Ces opérateurs effectuent une opération sur un ou plusieurs opérandes et renvoient le résultat.

Liste des opérateurs mathématiques

Liste des opérateurs mathématiques
OpérateurFonction
+Addition
-Soustraction
/Division
*Multiplication
%Modulo
--Décrémentation
++Incrémentation
-Moins unaire (signe dans un nombre)
+Plus unaire (signe dans un nombre)
**Puissance
&Et binaire (Et bit par bit)
|Ou binaire (Ou bit par bit)
^Ou exclusif binaire (bit par bit)
~Non binaire (négation bit par bit)
<<Décalage binaire à gauche avec comblement par des zéro
>>Décalage binaire à droite avec propagation du signe
>>>Décalage binaire à droite avec comblement par des zéro
<<<Décalage binaire à gauche avec comblement par des zéro

Les opérateurs d'incrémentation et de décrémentation peuvent être placé avant ou après l'opérande.
Si l'opérateur est avant alors l'opérande est incrémenté et les résultats est renvoyé, on parle de préincrémentation ou de prédécrémentation.
Si l'opérateur est placé après alors la valeur de l'opérande est renvoyé puis la variable est incrémenté, on parle de postincrémentation ou de post postdecrémentation.

Exemple :

var test = 0; /// on met 0 dans test

test;  // renvoie 0

test++ ; // renvoie zéro !!!! mais incrémente test 

test ; // renvoie 1 maintenant

--test ; //renvoie 0

test --; // vous l'avez devinez renvoi......0

--test ; // incrémente test ( qui vaut -1) et renvoi le résultat (soit 0) !
 

Les opérateurs binaires réalisent des opérations bit à bit entre deux opérandes (un seul pour la négation).

En binaire il n'y a que deux chiffres 1 et 0. les nombres sont un succession de 1 et de 0. Par exemple 1 en base 10 (noté 110) se représente (sur 32 bits) 0000 0000 0000 0000 0000 0000 0000 0001 en binaire.

En logique binaire

  • 1 ou 1 = 1 ou 0 = 0 ou 1 = 1, 0 ou 0 = 0.
  • 1 et 1 = 1, 1 et 0 = 0 et 1 = 1 = 0 et 0 = 0.

La différence en le ou et le ou exclusif est que pour le ou exclusif (1 ou exclusif 1) = 0.

Pour vous aider à comprendre voici quelques exemples ( à tester dans la console) :

// -1 en binaire : 1111 1111 1111 1111 1111 1111 1111 1111 
// 0 en binaire : 0000 0000 0000 0000 0000 0000 0000 0000
// 1 en binaire : 0000 0000 0000 0000 0000 0000 0000 0001 
// 2 en binaire : 0000 0000 0000 0000 0000 0000 0000 0010 
// 3 en binaire : 0000 0000 0000 0000 0000 0000 0000 0011 
// 4 en binaire : 0000 0000 0000 0000 0000 0000 0000 0100 
// 5 en binaire : 0000 0000 0000 0000 0000 0000 0000 0101 


-1 & 1 ; // vaut 1
-1 & 2 ; // vaut 2
-1 | 3 ; // vaut -1
1 ^ 3; // vaut 2 soit 01 ^ 11 ->  10
~ -1 ; // vaut 0

Pour les opérateurs de de décalage cela consiste à déplacer les bit vers la gauche ou la droite en faisant disparaitre ceux qui déborde et comblant soit par des zéro soit par le bit de signe (le plus à gauche).

Exemple :

8 >> 1; //vaut 4
4>>1 ; // vaut  2
2 >> 1; //vaut 1

1 << 0; //vaut 2
2 << 0 ;// vaut 4

-1 >>> 31 ; vaut 1
-1 >> 31 ; vaut -1

Dans les deux derniers cas le décalage soit rempli avec des zéros soit avec le bit de signe (1 pour le négatif).

-1 étant un suite de 32 bit à 1, y compris pour le bit s'il est propagé cela ne change rien, si les 1 sont éliminé par la droite et remplacé à gauche par des zéros alors chaque étape donne un chiffre différent.

Les plus matheux auront sûrement remarqué que le décalage revient à diviser ou multiplier par deux (en arrondissant à l'entier inférieur pour la division).

7 >>1 ; // vaut 3
6 >>1; // vaut 3
5>>1 ; // vaut 2
4>>1 ; // vaut 2

Enfin une curiosité de javascript.

En travaillant sur des entier de 32 bit un décalage de 32 bit ou plus devrait donner 0, pourtant si on fait -1 >> 32 on tombe sur 4 294 967 295 qui est 232 soit la version non signé de -1 sur 32 bit alors que si on le fait en deux fois on a 0 !

-1 >>> 32 ; // vaut 0 mais renvoi 4294967295

-1 >>> 16 ; // vaut et renvoi 65535
65535 >>16 ;  // vaut et renvoi 0
-1 >>> 16 >>> 16;  // vaut et renvoi 0

Les différentes boucles. Il existes trois façons de faire des boucles en Javascript : for, while et do...while.

Ces trois instructions sont interchangeables, la différences étant essentiellement d'ordre syntaxique et dans la façon dont sont interprétées les expression contrôlant la boucle.

La boucle avec for La syntaxe est :

for(expression1;expression2; instruction2) { instructions; } Le fonctionnement est le suivant :

expression1 est évaluée. Puis expression2 est évaluée et tant que elle renvoie une valeur correspondant à vrai (voir le passage sur les conditions dans le chapitre précédent) les instructions sont exécutés, instruction2 est exécuté et on reboucle sur l'évaluation de expression2.

Exemple :

for(i = 1; i <= 5 ; i++) { alert(i) } Ce bout de code affiche des boite de dialogue successives indiquant la valeur de la variable i ( de 1 à 5). D'abord i reçoit la valeur 1 (i = 1 en expression1) puis i est comparé à 5 (i <= 5 en expression2). Comme i est inférieur à 5 le contenu du corps de la boucle est exécuté ( instructions qui vaut alert(i) ). Enfin i est incrémenté (instruction2 valant i++ ) et le code reprend à l'évaluation de expression 2.

On pourrait afficher le décompte de 1 à 5 d'une autre façon :

for(i = 0 ; i++ < 5 ; ) { alert(i) } ici la variable i est incrémentée aprés avoir été comparé à 5, ce qui fait que la valeur utilisé par la fonction alert() est 1 pour le premier passage, 2 pour le second...et 5 pour le dernier. N'oubliez pas qu'avec la post incrémentation dans expression2 la valeur utilisée par alert() et supérieur de 1 à celle qui a été évaluée lors du test.

Vous remarquerez que instruction2 est omis. En effet les trois paramètres de for sont facultatif. Attention si expression2 est omise alors elle est considéré comme vrai et la boucle devient infinie. nous verrons plus tard comment en sortir si nécessaire.

La boucle avec while La syntaxe est :

while(expression) { instructions; } Le fonctionnement est le suivant : Tant que expression renvoi vrai ou non nul, alors la listes d'instructions contenue entre les accolades est exécutée. Si les instructions n'ont aucune influence sur la valeur de expression, seul un événement extérieur arrêter l'exécution de la boucle. Par exemple pour surveiller la valeur d'un champs input ou d'une case à cocher.

Le même exemple que ci dessus

i = 0; while(i++ < 4 ) { alert(i); } La boucle avec do...while La syntaxe est :

do { instructions; } while(expression) Le fonctionnement est le suivant : La liste d'instructions est exécuté tant que expression renvoie vrai ou non nul. Et non ! ce n'est pas pareil (quoique...). En effet cette version exécute d'abords la liste d'instruction puis évalue expression et boucle ou pas.

toujours le même exemple :

i = 1; do { alert(i); } while(i++ < 5 )

Dernière modification le 11/12/2024 16:57:20