1. Le Type Object

Il existe plusieurs façons de créer des objets en JavaScript. La méthode littérale et le constructeur sont couramment utilisés.

let individu = {};

Création avec le constructeur Object :

let utilisateur = new Object();
utilisateur.identifiant = "administrateur";

Utilisation de la syntaxe JSON pour initialiser un objet :

let profil = {
    nom: "admin",
    age: 25
};

Passer un objet en tant qu'argument à une fonction :

function afficherDonnees(pers) {
    alert(pers.nom);
}
afficherDonnees({nom: "admin", age: 15});

2. Le Type Array

Les tableaux peuvent être initialisés de différentes manières, y compris avec le constructeur ou la syntaxe littérale.

let liste1 = new Array(1, "b", 3, 5);
let liste2 = [1, "b", 3, 5];
let liste3 = [];

Pour vérifier si une valeur est un tableau, deux méthodes sont disponibles :

if (val instanceof Array) {
    // traiter comme un tableau
}
if (Array.isArray(val)) {
    // traiter comme un tableau
}

Convertir un tableau en chaîne de caractères :

let individus = ["B", 32];
individus.toString(); // B,32

let teintes = ["rouge", "bleu"];
teintes.join(";"); // rouge;bleu

Méthodes de pile (LIFO) : push() ajoute des éléments à la fin et retourne la nouvelle longueur, pop() supprime et retourne le dernier élément.

let couleurs = new Array();
let nb = couleurs.push("rouge", "vert"); // ajoute deux éléments
alert(nb); // 2

nb = couleurs.push("marron"); // ajoute un élément
alert(nb); // 3

let dernier = couleurs.pop(); // supprime et retourne le dernier élément
alert(dernier); // marron
alert(couleurs.length); // 2

Méthodes de file (FIFO) : shift() retire le premier élément, unshift() ajoute des éléments au début.

let liste = ["a", "b", "c"];
let premier = liste.shift(); // retire 'a'
alert(premier); // a
let nouvelleLongueur = liste.unshift("x", "y"); // ajoute au début
alert(nouvelleLongueur); // 4
alert(liste); // x,y,b,c

Méthodes de tri : reverse() inverse l'ordre, sort() trie les éléments.

let nums = [3, 1, 2];
nums.reverse(); // [2, 1, 3]
nums.sort(); // [1, 2, 3] par défaut selon les chaînes

Méthodes de manipulation sans modifier l'original :

let base = ["rouge", "vert", "bleu"];
let extension = base.concat("jaune", ["noir", "brun"]);
alert(base); // rouge,vert,bleu
alert(extension); // rouge,vert,bleu,jaune,noir,brun

let palette = ["rouge", "vert", "bleu", "jaune", "violet"];
let extrait1 = palette.slice(1);
let extrait2 = palette.slice(1, 4);
alert(extrait1); // vert,bleu,jaune,violet
alert(extrait2); // vert,bleu,jaune

La méthode splice() modifie le tableau en place pour supprimer, insérer ou remplacer des éléments.

let ensemble = ["rouge", "vert", "bleu"];
let supprimé = ensemble.splice(0, 1); // supprime un élément à l'index 0
alert(ensemble); // vert,bleu
alert(supprimé); // rouge

supprimé = ensemble.splice(1, 0, "jaune", "orange"); // insère deux éléments à l'index 1
alert(ensemble); // vert,jaune,orange,bleu
alert(supprimé); // [] tableau vide

supprimé = ensemble.splice(1, 1, "rouge", "violet"); // remplace un élément par deux nouveaux
alert(ensemble); // vert,rouge,violet,orange,bleu
alert(supprimé); // jaune

Méthodes de position : indexOf() et lastIndexOf() pour trouver l'index d'un élément.

let séquence = [1, 2, 3, 4, 2];
let position = séquence.indexOf(2); // 1
let dernièrePosition = séquence.lastIndexOf(2); // 4

Méthodes d'itération : chaque fonction prend trois argumants (valeur, index, tableau).

let valeurs = [1, 2, 3, 4, 5, 4, 3, 2, 1];
let tousSupérieurs = valeurs.every(function(elt, idx, tab) {
    return elt > 2;
});
alert(tousSupérieurs); // false

let auMoinsUn = valeurs.some(function(elt, idx, tab) {
    return elt > 2;
});
alert(auMoinsUn); // true

let filtre = valeurs.filter(function(elt, idx, tab) {
    return elt > 2;
});
alert(filtre); // [3,4,5,4,3]

let transformé = valeurs.map(function(elt, idx, tab) {
    return elt * 3;
});
alert(transformé); // [3,6,9,12,15,12,9,6,3]

valeurs.forEach(function(elt, idx, tab) {
    // exécuter une action sans retour
});

Méthodes de réduction : reduce() et reduceRight() pour accumuler une valeur.

let nombres = [1, 2, 3, 4, 5];
let total = nombres.reduce(function(acc, courant, idx, tab) {
    return acc + courant;
});
alert(total); // 15

let données = [1, 4];
let résultat = données.reduceRight(function(acc, courant, idx, tab) {
    return acc - courant;
});
alert(résultat); // 3

3. Le Type RegExp

Les expressions régulières sont utilisées pour la recherche et la manipulation de texte avec un pattern et des drapeaux.

let modèle = /motif/drapeaux;

4. Les Types Emballés Primitifs

Boolean, Number et String fournissent des méthodes pour manipuler les valeurs primitives, mais créent des objets temporaires.

let texte = new String("contenu");
texte.couleur = "rouge";
alert(texte.couleur); // undefined

let instance = new String("contenu");
alert(instance instanceof String); // true

5. Les Objets Intégrés

L'objet Global fournit des fonctions comme encodeURI() et eval().

eval("alert('salut')"); // équivalent à alert('salut')

eval("let message = 'bonjour'");
alert(message); // bonjour

L'objet Math propose des méthodes mathématiques, comme random() pour générer des nombres aléatoires.

let aléatoire = Math.floor(Math.random() * 10 + 1); // nombre entre 1 et 10