Javascript : 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 quottes.
    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 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;

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";

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

 

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é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

Les opérateurs logiques

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

Liste des opérateurs logiques
Opérateur Fonction
! Non logique
&& ET logique.
|| Ou 

 

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érateur permettent de comparer deux opérandes.

Liste des opérateurs de comparaison
Opérateur Fonction
==  É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 effectue une opération sur un ou plusieurs opérandes et renvoient le résultat.

Liste des opérateurs mathématiques
Opérateur Fonction
+ 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ésultat est 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