Chapitre 169 minDébutant
Aide-mémoire JavaScript : la syntaxe et les méthodes
Par Josselyn C., prof de BTS SIO. Mis à jour le .
À la fin de ce chapitre, tu sauras
- retrouver vite une syntaxe ou une méthode ;
- éviter les pièges classiques de JavaScript lors d'une évaluation.
Cet aide-mémoire rassemble la syntaxe de JavaScript et les méthodes vues dans le cours, sur une seule page, pour réviser avant une évaluation ou retrouver vite une écriture pendant un projet. Chaque ligne renvoie au chapitre qui l'explique.
Variables, types et opérateurs
| Écriture | Rôle | Chapitre |
|---|---|---|
const x = 1; / let y = 2; | Déclarer (const par défaut, let si réaffectée, jamais var) | 2 |
typeof x / Array.isArray(t) | Connaître le type / tester un tableau | 2 |
Number(s), parseInt(s, 10), String(n) | Convertir | 2 |
Number.isNaN(x), Number.isInteger(x) | Tester NaN, un entier | 2 |
===, !== | Comparer sans conversion (toujours) | 2 |
a ?? b | b si a vaut null ou undefined | 2 |
a?.b | undefined au lieu d'une erreur si a est absent | 6 |
`Total : ${n} €` | Gabarit de chaîne | 2 |
cond ? a : b | Ternaire | 3 |
Valeurs falsy : false, 0, -0, 0n, '', null, undefined, NaN. Tout le reste est truthy, y compris '0', [] et {}.
Conditions et boucles
if (a) { … } else if (b) { … } else { … }
switch (x) { case 'A': … break; default: … }
for (let i = 0; i < t.length; i++) { … }
for (const element of tableau) { … } // tableaux, chaînes, Map, Set
for (const cle in objet) { … } // propriétés d'un objet
while (condition) { … }
break; // sortir de la boucle
continue; // passer au tour suivant
Fonctions
function nom(a, b = 0, ...reste) { return a + b; }
const f = (x) => x * 2; // retour implicite
const g = (p) => ({ ref: p.ref }); // renvoyer un objet : parenthèses
const h = ({ ref, quantite = 0 }) => …; // décomposition des paramètres
setTimeout(() => { … }, 1000); // callback
Tableaux
| Méthode | Renvoie | Modifie le tableau ? |
|---|---|---|
push(x), pop(), unshift(x), shift() | Longueur / élément retiré | Oui |
splice(i, n) | Éléments retirés | Oui |
sort(f), reverse() | Le même tableau | Oui |
slice(debut, fin) | Une copie partielle | Non |
map(f) | Un tableau transformé, même longueur | Non |
filter(f) | Les éléments qui passent le test | Non |
reduce((acc, x) => …, depart) | Une seule valeur | Non |
find(f), findIndex(f), findLast(f) | Le premier élément (ou undefined), son indice (ou -1) | Non |
some(f), every(f) | Un booléen | Non |
includes(x), indexOf(x) | Un booléen, un indice | Non |
toSorted(f), toReversed(), with(i, x) | Une copie modifiée | Non |
join(', ') | Une chaîne | Non |
forEach(f) | undefined | Non |
Trier des nombres : t.toSorted((a, b) => a - b). Trier des chaînes en français : t.toSorted((a, b) => a.localeCompare(b, 'fr')). Copier : [...t]. Dédoublonner : [...new Set(t)].
Objets, JSON, Map et Set
const p = { ref: 'SSD-512', quantite: 12 };
p.quantite; p['quantite']; // lire
const copie = { ...p, quantite: 11 }; // copier en modifiant (copie superficielle)
const profonde = structuredClone(p); // copie complète
const { ref, quantite: q = 0 } = p; // décomposer
Object.keys(p); Object.values(p); Object.entries(p);
Object.fromEntries(paires);
JSON.stringify(valeur, null, 2); // objet → texte JSON
JSON.parse(texte); // texte JSON → objet (SyntaxError si invalide)
const s = new Set(); s.add(x); s.has(x); s.size;
const m = new Map(); m.set(cle, v); m.get(cle); m.has(cle);
new Intl.NumberFormat('fr-FR', { style: 'currency', currency: 'EUR' }).format(42.9); // '42,90 €'
new Intl.DateTimeFormat('fr-FR', { dateStyle: 'short' }).format(date); // '02/11/2026'
DOM
| Écriture | Rôle | Chapitre |
|---|---|---|
document.querySelector('#id') | Premier élément correspondant, ou null | 7 |
document.querySelectorAll('.classe') | Tous les éléments (NodeList) | 7 |
el.closest('tr') | Ancêtre le plus proche correspondant | 7 |
el.textContent = texte | Écrire du texte : pour toute donnée | 7 |
el.innerHTML = html | Écrire du HTML : jamais avec une donnée (XSS) | 7 |
el.classList.add / remove / toggle('c', cond) | Gérer les classes | 7 |
el.setAttribute('aria-label', '…'), el.dataset.ref | Attributs, attributs data-* | 7 |
document.createElement('li') | Créer un élément | 7 |
parent.append(a, b), el.remove() | Insérer, retirer | 7 |
parent.replaceChildren(...elements) | Remplacer tout le contenu | 7 |
Événements et formulaires
el.addEventListener('click', (event) => { … });
form.addEventListener('submit', (event) => {
event.preventDefault();
const saisie = Object.fromEntries(new FormData(form)); // valeurs = chaînes
});
champ.addEventListener('input', () => { … }); // à chaque frappe
parent.addEventListener('click', (event) => { // délégation
const b = event.target.closest('button[data-action]');
if (!b) return;
});
/^[A-Z]{3}-\d{2,3}$/.test(texte); // regex : ^ début, $ fin
Stockage
localStorage.setItem('app.cle', JSON.stringify(donnees));
const donnees = JSON.parse(localStorage.getItem('app.cle')); // null si absente
localStorage.removeItem('app.cle');
Toujours dans un try…catch. Jamais de jeton d'authentification, de mot de passe ou de clé secrète : une session se garde dans un cookie HttpOnly, Secure, SameSite posé par le serveur.
Asynchrone et fetch
async function charger(url) {
let reponse;
try {
reponse = await fetch(url, { headers: { Accept: 'application/json' }, signal: AbortSignal.timeout(5000) });
} catch (erreur) {
throw new Error('Serveur injoignable.', { cause: erreur }); // pas de réponse
}
if (!reponse.ok) throw new Error(`Erreur HTTP ${reponse.status}`); // 4xx, 5xx
return reponse.json();
}
await fetch(url, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(objet),
});
const [a, b] = await Promise.all([charger(u1), charger(u2)]); // en parallèle
Ordre d'exécution : tout le code synchrone, puis les suites de promesses (microtâches), puis les minuteries et les événements (tâches).
Modules et classes
export function f() {} // export nommé
export default function g() {} // export par défaut
import g, { f } from './fichier.js'; // chemin complet, avec ./ et .js
// <script type="module" src="js/main.js"></script>
class Piece extends Base {
static MAX = 99;
#quantite = 0; // champ privé
constructor(ref) { super(); this.ref = ref; }
get quantite() { return this.#quantite; }
ajouter(n = 1) { this.#quantite += n; }
}
Les erreurs les plus fréquentes
| Message | Cause |
|---|---|
Cannot read properties of null (reading '…') | querySelector n'a rien trouvé, ou script sans defer |
Cannot read properties of undefined (reading '…') | Indice ou propriété inexistants, find sans résultat |
… is not a function | Mauvais type (chaîne JSON non parsée, promesse sans await), faute de frappe |
… is not defined | Variable inconnue ou hors de portée, import manquant |
Assignment to constant variable. | const réaffectée |
Unexpected token '<', "<!doctype "... is not valid JSON | Le serveur a renvoyé du HTML : vérifier reponse.ok et l'URL |
Cannot use import statement outside a module | type="module" manquant |
Uncaught (in promise) | Promesse rompue sans catch |
Promise { <pending> } ou [object Promise] affiché | await manquant |
[object Object] dans le stockage | Objet stocké sans JSON.stringify |
Les règles d'or
constpar défaut,===toujours,??pour les valeurs par défaut.- Convertir les saisies en nombre dès leur lecture.
- Afficher les données avec
textContent, jamaisinnerHTML. - Un seul écouteur délégué pour les éléments d'une liste.
- Valider côté client pour le confort, côté serveur pour la sécurité.
- Ne jamais stocker de jeton ni de secret dans le navigateur.
- Tout
fetch:try…catch, test deok, délai maximal. - Les règles métier dans des fonctions pures, testées.
- Des éléments natifs (
button,a,dialog) et un focus jamais perdu. - La console ouverte en permanence pendant le développement.