Fiche mémo JavaScript et TypeScript

Où s'exécute le code

Hôte	Apporte	N'a pas
navigateur	DOM, `fetch`, `localStorage`, bac à sable	fichiers, processus
Node.js	`node:fs`, `process`, réseau, droits de l'utilisateur	`window`, `document`
TypeScript	types vérifiés à la compilation, effacés à l'exécution	validation des données reçues

Variables et types

Besoin	Écriture
constante (pas de réaffectation)	`const x = 1;` (l'objet reste modifiable)
variable réaffectable	`let n = 0;` (portée de bloc)
à éviter	`var` (portée de fonction)
primitifs	`string number bigint boolean undefined null symbol`
type d'une valeur	`typeof x` (`typeof null` vaut `"object"`)
valeur par défaut	`a ?? 10` (seulement `null`, `undefined`) ; `a \|\| 10` (tout falsy)
chaînage facultatif	`obj?.champ?.[0]?.()`
gabarit	` Bonjour ${nom} `

Falsy : false 0 "" null undefined NaN.

Égalité et coercition

Expression	Résultat
`"0" == 0`	`true` (conversion)
`0 == false`	`true`
`null == undefined`	`true` (et rien d'autre)
`"0" === 0`	`false`
`NaN === NaN`	`false` ; `Number.isNaN(x)` ou `Object.is(NaN, NaN)`
`Object.is(0, -0)`	`false` (alors que `0 === -0`)
`"5" + 1` / `"5" - 1`	`"51"` / `4`
`0.1 + 0.2 === 0.3`	`false` (flottants)

À retenir : === et !== partout ; seule exception acceptable : x == null.

Fonctions, portée, this

javascript

function f(a, b = 2, ...reste) { return a + b; }
const g = (x) => x * x;                 // flèche : this lexical
const h = f.bind(null, 1);              // this et arguments fixés

Appel	`this`
`obj.m()`	`obj`
`m()` seul	`undefined` (strict) ou objet global
flèche	celui de la portée englobante (figé)
`new C()`	le nouvel objet
`call(o, a)` / `apply(o, [a])` / `bind(o)`	`o` (pas pour une flèche)
écouteur DOM	l'élément

Fermeture : une fonction garde l'accès aux variables de sa portée de création.

Objets, classes

javascript

const o = { a: 1, m() { return this.a; } };
const { a, ...reste } = o;               // destructuration
const copie = { ...o, a: 2 };            // copie superficielle
class B { #prive = 0; constructor(n) { this.n = n; } get v() { return this.#prive; } static s() {} }
class D extends B { constructor(n) { super(n); } }

Besoin	Outil
clés / valeurs / paires	`Object.keys` / `values` / `entries`
propriété propre	`Object.hasOwn(o, "k")`
prototype	`Object.getPrototypeOf(o)`, `Object.create(p)`
copie profonde	`structuredClone(o)` (disponibilité par version non vérifiée)
clés externes	`Map` ou `Object.create(null)`

Tableaux

Méthode	Rôle	Modifie ?
`map(f)` / `filter(f)`	transforme / filtre	non
`reduce((acc, x) => …, init)`	agrège	non
`find` / `findIndex` / `some` / `every` / `includes`	cherche, teste	non
`slice` / `concat` / `[...a]`	copie	non
`push` `pop` `shift` `unshift` `splice` `reverse` `sort`	modifie	oui

[10, 2, 1].sort() trie en chaînes ; nombres : .sort((a, b) => a - b). Parcourir : for (const x of a) (pas for…in).

Modules ES

javascript

export const A = 1;  export default function () {}
import d, { A as B } from "./m.mjs";   import * as m from "./m.mjs";
const mod = await import("./m.mjs");    // dynamique

Sujet	Règle
strict	automatique dans un module
liaisons	vivantes, en lecture seule
Node.js	`.mjs` = ES, `.cjs` = CommonJS, `.js` selon `"type"` de `package.json`
`__dirname`	absent en ES : `import.meta.dirname`
navigateur	`<script type="module" src="…">`

Asynchrone

Ordre : synchrone → toutes les micro-tâches → une tâche → …

Boucle d'événements : micro-tâches avant tâches.

Besoin	Outil
micro-tâche	`Promise.then`, `await`, `queueMicrotask(f)`
tâche	`setTimeout(f, 0)`, événements, E/S
toutes tenues, échec rapide	`Promise.all([…])`
toutes réglées	`Promise.allSettled([…])`
première réglée / première tenue	`Promise.race` / `Promise.any`
nettoyage	`.finally(f)`

javascript

async function charger() {
  try {
    const [a, b] = await Promise.all([lireA(), lireB()]);   // parallèle
    return a + b;
  } catch (e) {
    console.error(e.message);
    throw e;
  }
}
charger().catch((e) => { process.exitCode = 1; });

Attention : await oublié ; await dans forEach ; promesse sans catch ; calcul long qui bloque tout.

Erreurs et JSON

Besoin	Écriture
lever	`throw new Error("message")` / sous-classe de `Error`
capter	`try { … } catch (e) { … } finally { … }`
tester le type	`e instanceof MonErreur` ; relancer le reste
texte vers valeur	`JSON.parse(t)` (lève si invalide)
valeur vers texte	`JSON.stringify(v, null, 2)` (pas de `undefined`, de fonction ni de date)

Après JSON.parse : valider la forme des champs. Jamais d'eval.

DOM et événements

Besoin	Écriture
sélectionner	`document.querySelector("#id")` / `querySelectorAll(".c")`
texte	`el.textContent = valeur` (sûr)
créer / ajouter / retirer	`createElement("li")` / `parent.append(el)` / `el.remove()`
écouter	`el.addEventListener("click", (ev) => …)`
délégation	un écouteur sur le parent, test de `ev.target`
annuler l'action par défaut	`ev.preventDefault()`

Node.js

Besoin	Écriture
arguments	`process.argv` : `[exécutable, script, …arguments]`
environnement	`process.env.NOM`
code de sortie	`process.exitCode = 1`
module intégré	`import { readFile } from "node:fs/promises";`

Terminal

node script.mjs argumentecho $?

Contexte : Terminal, dossier de test ; Node.js (version non vérifiée).
Droits : utilisateur normal.
Effet : lance le script ; le script a les droits de l'utilisateur.
Vérification : echo $? donne le code de sortie.
Retour arrière : sans objet.

npm : sûr par défaut

Commande	Effet	Réserve
`npm ci`	installe exactement le verrou ; échoue s'il y a désaccord ; supprime `node_modules`	exige `package-lock.json` ; scripts des dépendances exécutés
`npm install nom`	ajoute une dépendance, modifie `package.json` et le verrou	exécute du code tiers (scripts d'installation)
`npm install --ignore-scripts …`	n'exécute pas les scripts d'installation	effet exact par commande non relu
`npm audit`	rapport de vulnérabilités déjà connues (envoi au registre)	propre ne veut pas dire sûr
`npm audit fix`	met à jour (lance un `npm install`, scripts compris)	`--force` : changements majeurs, relire
`npm audit signatures`	vérifie signatures et attestations de provenance
`npm ls`	liste l'arbre installé	lecture seule

Scripts exécutés à l'installation : preinstall, install, postinstall, prepublish, preprepare, prepare, postprepare.

Attention : installer un paquet = exécuter le code de son auteur avec vos droits. Verrou versionné, peu de dépendances, nom du paquet vérifié, jamais sudo npm, jamais curl … | sh ou npx d'un paquet non relu, aucun secret dans le dépôt.

Sécurité : à ne pas faire

Interdit avec une entrée externe	Remplaçant
`el.innerHTML = entree`	`el.textContent = entree` ; sinon Trusted Types + assainissement + CSP
`eval(t)`, `new Function(t)`	`JSON.parse`, table de correspondance
`exec("cmd " + entree)`	`execFile` / `spawn` avec liste d'arguments (non relu)
requête SQL concaténée	paramètres liés du pilote
`href = entree`	valider le schéma de l'URL
fusion aveugle d'objets	valider les clés ; `Map`
secret dans le code du navigateur	secret côté serveur

Validation : liste blanche de champs et de valeurs, côté serveur aussi. Un type TypeScript ne valide rien à l'exécution.

TypeScript

typescript

type Statut = "ouvert" | "ferme";                       // union de littéraux
interface Ticket { id: number; titre: string; statut: Statut; note?: string; readonly cree: string }
function premier<T>(xs: T[]): T | undefined { return xs[0]; }
function cle<T, K extends keyof T>(o: T, k: K): T[K] { return o[k]; }

Besoin	Écriture
inférence	n'annoter que paramètres et retours exportés
type inconnu sûr	`unknown` (à réduire avant usage) ; éviter `any`
tableau, dictionnaire	`string[]`, `Record<string, number>`
assertion (aucun effet à l'exécution)	`x as T` ; `x!` retire `null`/`undefined` : à éviter
`type` ou `interface`	`interface` pour une forme d'objet (extensible) ; `type` pour unions
vérifier sans produire	`npx tsc --noEmit`

Réduction de type (narrowing)

Technique	Exemple
`typeof`	`typeof x === "string"`
vérité	`if (x)`
égalité	`x === y` ; `x == null`
`in`	`"vol" in animal`
`instanceof`	`x instanceof Date`
prédicat	`function ok(a): a is Poisson`
union discriminée	`switch (f.genre) { case "cercle": … }`
exhaustivité	`const _: never = f;` dans `default`

tsconfig

Option	Effet
`strict: true`	active `alwaysStrict`, `strictNullChecks`, `strictBindCallApply`, `strictBuiltinIteratorReturn`, `strictFunctionTypes`, `strictPropertyInitialization`, `noImplicitAny`, `noImplicitThis`, `useUnknownInCatchVariables`
`noUncheckedIndexedAccess`	`undefined` ajouté aux accès par index (hors `strict`)
`target`, `module`, `lib`, `outDir`, `include`	cible, modules, API connues, sortie, fichiers (valeurs : selon la version, non vérifiées)

Pièges courants

Piège	Remède
`==`	`===`
`0.1 + 0.2`	tolérance ou entiers
`typeof null`	`x === null`
`sort()` par chaînes	comparateur numérique
`this` perdu	flèche, `bind`
`await` oublié / dans `forEach`	`await`, `for…of`, `Promise.all`
rejet non géré	`catch` partout
copie superficielle	`structuredClone`
`innerHTML`, `eval`	`textContent`, `JSON.parse`
`npm install` aveugle	`--ignore-scripts`, dossier jetable, verrou
`as` / `!`	réduction de type, validation

Sources

Consultées le 17 octobre 2026 (versions affichées : Node.js v26.12.0, npm v11.21.0, ECMAScript 2027 brouillon).