JavaScript

Raconté par Vincent Jugé
sur la base d'un cours créé par Rémi Forax

Historique des versions

ECMAScript 1/2	1997/1998
ECMAScript 3	1999
~~ECMAScript 4~~	Abandonné
ECMAScript 5	2009
ECMAScript 5.1	2011
ECMAScript 6	2015
ECMAScript 15	2024

Le nom du langage strandardisé est ECMAScript, pas JavaScript !

Pour bien démarrer…

Mode strict

Dans le mode par défaut (pas strict)

pas d'erreur si une variable n'est pas déclarée
possibilité de supprimer une déclaration avec delete
010 n'est pas égal à 10
etc.

ce qui est stupide !

La première ligne du fichier doit être


"use strict";

Commentaire

Il y a deux formes de commentaires : // et /* */


// le commentaire sur une ligne
// 3
/*
   le commentaire sur plusieurs lignes
*/

Constantes et variables

Variable

Une variable locale se déclare avec le mot-clé let.
Il existe aussi un mot-clé var, mais on évitera à tout prix de s'en servir.
Il y a également un mot-clé const que l'on verra très bientôt.

Une variable peut être initialisée en même temps que la déclaration ou plus tard.

let a = 7;
let b = 42;
let sum;
sum = a + b;

Le nom d'une variable est composé de lettres, '_', '$', et chiffres (sauf en première position).
La définition précise de l'ensemble des noms autorisés est plus compliquée.

Instruction et ;

On termine toujours une initialisation/déclaration par un ';'.
La syntaxe d'ECMAScript est ambiguë si on omet les ';'.

L'indentation est optionnelle mais fortement recommandée.

Variable non déclarée

Si on oublie de déclarer une variable, le programme plante !

console.log(a);

Si on tente d'utiliser une variable avant de la déclarer, le programme plante aussi !

console.log(a);
let a = 3;

Variable non initialisée

Une variable locale non initialisée a la valeur undefined.

let a;
a;
a = 42;
a;
a = 54;
a;

Constante

Une constante locale se déclare avec le mot-clé const.
Une constante est une variable qui ne varie pas.

Une constante doit être initialisée en même temps que la déclaration, et sa valeur ne peut pas changer.

const a = 7;
const b = 42;
//const sum;
//sum = a + b;

On peut bien sûr n'utiliser que le mot-clé let, mais c'est moins sympa pour le lecteur qui croira que notre variable a vocation à varier.

Opérations de base

Types de base

Il existe trois types de base : number, boolean et string.
L'opérateur typeof permet d'obtenir le type à partir d'une valeur.

typeof 747;
typeof -34.6;
typeof true;
typeof false;
typeof 'foo';
typeof "bar";
let one = 1;
typeof one;

Il y a aussi deux autres types : object et function.

typeof [0,1];
typeof (a => a+1);

Opérateurs arithmétiques

Les opérateurs classiques +, -, *, /, % sur les number :

const a = 13;
const b = 4;
a + b;
a - b;
a * b;
a / b;
a % b;

Les nombres sont soit des entiers,
soit des nombres à virgule flottante.

Calcul sur les flottants

Les résultats d'un calcul sont arrondis au
flottant le plus proche.

const a = 0.1;
const b = 0.2;
a + b - b - a;

Il y aura toujours des erreurs d'arrondi !

Opérateurs de test

Les opérateurs de tests ==, !=, <, <=, >, >= sur les number :

const a = 13;
const b = 4;
a == b;
a != b;
a < b;
a <= b;
a > b;
a >= b;

true (vrai) et false (faux) sont des valeurs prédéfinies.

Tests, flottants et types

Ne jamais faire des tests d'égalité sur des flottants :

const a = 0.1;
const b = 0.2;
const c = 0.3;
a + b == c;

Ne jamais faire des tests d'égalité sur des objets de types différents :

const d = 3;
const e = "3";
d == e;

Opérateurs booléens

Les opérateurs && (ET) et || (OU) permettent
de tester plusieurs conditions.
L'opérateur ! (NON) permet d'inverser une condition.

true && false;
true && true;
true || false;
false || false;
!true;
!false;
const a = 3;
const b = 4;
a > 2 && b < 7;

Opérateurs d'égalité

== et != sont définis pour tous les types, avec plus ou moins de bonheur si les types sont différents.

'hello' == "hello";
true != false;
4 == "4";
4 != "4";
4 === "4";
4 !== "4";

=== et !== testent d'abord que le type est identique !

Concaténation de chaînes de caractères

Le + fait la concaténation si l'opérande à gauche ou à droite est une string.

const name = 'Bob';
'hello' + 'Bob';
'hello' + name;
'hello' + 3;
false + 'hello';
1 + 1 + name + 1 + 1;

Cela permet d'insérer une expression dans une chaîne de caractères.

Interpolation de chaînes de caractères

Les anti-quotes (`) permettent de définir une chaîne de caractères contenant des expressions.
${...} introduit une expression.

const name = 'Bob';
`Hello ${name}`;
const x = 21;
`result = ${ x * 2 }`;
"${name}" + `${ x * 2 }`;