Nombres

023–025 • Number, Number Methods et objet Math

Comprendre la représentation numérique, les limites de précision et les outils standards fournis par l’objet `Math`.

Formats numériques

JavaScript utilise des nombres en double précision. On peut écrire de grands nombres avec `_`, la notation exponentielle ou les puissances.

console.log(1000000);
console.log(1_000_000);
console.log(1e6);
console.log(10 ** 6);
console.log(Number.MAX_SAFE_INTEGER);

Valeurs limites

`Number.MAX_SAFE_INTEGER` définit la borne des entiers exacts. `Number.MAX_VALUE` représente la plus grande valeur finie.

Number.MAX_VALUE; 
Number.MAX_VALUE + 2035; // reste MAX_VALUE

025 • Math Object

Quelques méthodes importantes de l’objet `Math`.

Math.abs()\(|x|\)

Retourne la valeur absolue.

Math.acos()\(\arccos(x)\)

Retourne l’arc cosinus.

Math.atan2()\(\arctan2(y, x)\)

Calcule l’angle à partir de deux coordonnées.

Math.max()\(\max(x_1, \dots, x_n)\)

Retourne le plus grand nombre.

Math.min()\(\min(x_1, \dots, x_n)\)

Retourne le plus petit nombre.

Math.random()\(\operatorname{random}()\)

Retourne un nombre pseudo-aléatoire entre 0 et 1.

Math.round()\(\operatorname{round}(x)\)

Arrondit à l’entier le plus proche.

Math.sqrt()\(\sqrt{x}\)

Retourne la racine carrée.

Math.round(99.2); // 99
Math.round(99.5); // 100
Math.ceil(99.2);  // 100
Math.floor(99.9); // 99
Math.min(10, 20, 100, -100, 90); // -100
Math.max(10, 20, 100, -100, 90); // 100
Math.trunc(99.99); // 99

Strings

027 • String Methods

Manipuler les chaînes est indispensable pour le DOM, les APIs et la validation de données.

Méthodes de base

Accès par index, `charAt()`, `trim()`, `toUpperCase()` et `toLowerCase()` sont parmi les premières à maîtriser.

let theName = "  Ahmed  ";

theName[5]; // m
theName.trim(); // Ahmed
theName.trim().charAt(0).toUpperCase();

Recherche et découpe

`indexOf`, `lastIndexOf`, `slice`, `repeat` et `split` permettent de chercher, découper et transformer du texte.

let text = "Elzero Web School";

text.indexOf("Web"); // 7
text.indexOf("Web", 8); // -1
text.split(" ");

Arrays

040–074 • Tableaux, ajout/retrait et higher-order functions

040 • Array Big Introduction

Les tableaux permettent de stocker plusieurs valeurs dans un ordre précis.

let myFriends = ["Ahmed", "Mohamed", "Sayed"];

042 • Add And Remove From Array

Les méthodes `unshift`, `push`, `shift` et `pop` servent à ajouter ou retirer des éléments au début ou à la fin.

066 • Arrow Function Syntax

Les fonctions fléchées raccourcissent la syntaxe, surtout avec les callbacks et transformations de tableaux.

071 • Higher Order Functions - Map

`map()` crée un nouveau tableau en transformant chaque élément de l’original.

let array = [1, 2, 3, 4];
let doubled = array.map((element) => element + element);

console.log(doubled);

074 • Higher Order Functions - Filter

`filter()` conserve seulement les éléments répondant à une condition.

let sentence = "I Love Food Code Too Playing Much";
let smallWords = sentence
  .split(" ")
  .filter((word) => word.length <= 4)
  .join(" ");

DOM

093–095 • Validation, événements et classList

093 • Validate Form And Prevent Default

On bloque l’action par défaut pour valider les données avant l’envoi.

document.links[0].onclick = function (event) {
  event.preventDefault();
};

094 • Event Simulation

`click`, `focus` et `blur` permettent de guider ou simuler des interactions utilisateur.

window.onload = function () {
  two.focus();
};

one.onblur = function () {
  document.links[0].click();
};

095 • classList

`classList` expose les méthodes `contains`, `add`, `remove` et `toggle` pour manipuler les classes proprement.

let element = document.getElementById("my-div");

element.classList.contains("two");
element.classList.item(3);

Structures

115–129 • Destructuring, Set et méthodes avancées de tableau

115 • Destructuring Arrays

Le destructuring permet d’extraire rapidement des valeurs d’un tableau et même de faire des permutations.

let myFriends = ["Ahmed", "Sayed", "Ali"];
let [x, y, z] = myFriends;

[x, y] = [y, x];

118 • Destructuring Objects

Très utile pour lire des propriétés profondes et renommer des variables localement.

const user = {
  theName: "Osama",
  theAge: 39,
  skills: { html: 70, css: 80 }
};

const {
  theName: name,
  skills: { html, css }
} = user;

123 • Set Data Types And Methods

`Set` stocke des valeurs uniques et supprime naturellement les doublons.

let myData = [1, 1, 1, 2, 3];
let myUniqueData = new Set(myData);

124 • Set vs WeakSet

  • `Set` peut stocker tout type de valeur.
  • `WeakSet` ne stocke que des objets.
  • `WeakSet` n’a pas de propriété `size`.

129 • Array.copyWithin Method

Copie une portion d’un tableau vers une autre position du même tableau, sans changer sa longueur.

OOP

148–155 • Constructeurs, classes, héritage et prototype

148 • Constructor Function Introduction

function User(id, username, salary) {
  this.id = id;
  this.u = username;
  this.s = salary + 1000;
}

let userOne = new User(100, "Hassan", 5000);

150 • Properties And Methods

class User {
  constructor(id, username, salary) {
    this.i = id;
    this.u = username || "Unknown";
    this.s = salary < 6000 ? salary + 500 : salary;
  }

  writeMsg() {
    return `Hello ${this.u} Your Salary Is ${this.s}`;
  }
}

151 • Update Properties

class User {
  constructor(id, username, salary) {
    this.i = id;
    this.u = username;
    this.s = salary;
  }

  updateName(newName) {
    this.u = newName;
  }
}

152–154 • Static, Inheritance, Encapsulation

Les `static` appartiennent à la classe, `extends` permet l’héritage, et les champs privés encapsulent les données.

155 • Prototype Introduction

Les prototypes permettent aux objets JavaScript d’hériter de comportements communs.

class User {
  constructor(id, username) {
    this.i = id;
    this.u = username;
  }
}

User.prototype;

Generator Function

Une fonction génératrice produit des valeurs à la demande via `yield`.

function* generateNumbers() {
  yield 1;
  yield 2;
}

const generator = generateNumbers();
generator.next();

Modules

167 • Import and Export

Export nommé

export let a = 10;
export let arr = [1, 2, 3, 4];

export function saySomething() {
  return "Something";
}

Import

import { a, arr, saySomething as s } from "./main.js";

console.log(a);
console.log(arr);
console.log(s());

Default export

export default function sayHello() {
  return "Hello";
}

JSON & Async

169–177 • JSON, parse/stringify, call stack, AJAX

169 • What Is JSON

JSON est un format léger d’échange de données entre client et serveur.

JSON XML
LégerPlus lourd
Pas de balisesUtilise des balises
Accepte les tableauxMoins naturel pour les tableaux
Plus courtPlus verbeux

172 • Parse And Stringify

const fromServer = '{"Username":"Osama","Age":39}';
const jsObject = JSON.parse(fromServer);

jsObject["Username"] = "Elzero";

const toServer = JSON.stringify(jsObject);

173 • Asynchronous

  • Le synchrone exécute dans l’ordre.
  • L’asynchrone permet de continuer sans bloquer l’interface.
  • Base nécessaire pour comprendre `fetch`, `Promise` et AJAX.

174 • Call Stack And Web API

setTimeout(() => {
  console.log("Web API");
}, 0);

function one() {
  console.log("One");
}

176 • What Is AJAX

AJAX combine JavaScript, DOM et `XMLHttpRequest` pour échanger des données sans recharger toute la page.

177 • Request And Response

Les réponses HTTP, les états de requête et la gestion d’erreurs sont des bases essentielles pour les APIs réelles.

Référence

Objets natifs, instructions et opérateurs

Une vue d’ensemble compacte des familles d’objets et de syntaxe JavaScript à connaître.

Objets natifs

  • globalThis, Infinity, NaN, undefined
  • Object, Function, Boolean, Symbol
  • Number, BigInt, Math, Date, Temporal
  • String, RegExp
  • Array, Map, Set, WeakMap, WeakSet
  • JSON, Promise, Reflect, Proxy, Intl

Instructions

  • if...else, switch, try...catch
  • return, break, continue, throw
  • var, let, const
  • for, for...in, for...of, while, do...while
  • function, async function, class, export, import

Opérateurs

  • Arithmétiques: `+`, `-`, `*`, `/`, `%`, `**`
  • Égalité: `==`, `!=`, `===`, `!==`
  • Logiques: `&&`, `||`, `??`
  • Affectation: `=`, `+=`, `&&=`, `??=`
  • Déploiement: `...obj`
  • Tertiaire: `(condition ? a : b)`