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
| 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.
| 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.
| 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 2Enfin 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