⚡ Cheat Sheet JavaScript Modules 01–07
Variables
const nom = "Alice" // immuable
let count = 0 // mutable
// var → ne pas utiliser
// Types
typeof "str" // "string"
typeof 42 // "number"
typeof true // "boolean"
typeof null // "object" ← piège
Fonctions
// Classique
function add(a, b) { return a + b }
// Arrow (préférer)
const add = (a, b) => a + b
const double = n => n * 2
// Paramètre par défaut
const saluer = (nom = "monde") =>
`Bonjour ${nom}!`
Tableaux — map / filter / reduce
const nums = [1, 2, 3, 4]
nums.map(n => n * 2) // [2,4,6,8]
nums.filter(n => n > 2) // [3,4]
nums.find(n => n > 2) // 3
nums.reduce((a, n) =>
a + n, 0) // 10
nums.includes(3) // true
nums.every(n => n > 0) // true
nums.some(n => n > 3) // true
Objets & Destructuring
const user = { nom: "Alice", age: 30 }
// Destructuring objet
const { nom, age } = user
// Destructuring tableau
const [a, b] = [1, 2]
// Spread
const copy = { ...user, age: 31 }
const arr2 = [...nums, 5]
Closures
function creerCompteur() {
let count = 0
return () => ++count
}
const inc = creerCompteur()
inc() // 1
inc() // 2
DOM Essentiels
document.querySelector('#id')
el.textContent = 'texte' // sûr
el.innerHTML = '<p>' // HTML
el.classList.toggle('cls')
el.addEventListener('click', fn)
localStorage.setItem('k',
JSON.stringify(data))
JSON.parse(localStorage.getItem('k'))
⏳ Async / Await Module 05
Pattern de base
async function getData() {
try {
const res = await fetch(url)
if (!res.ok) throw new Error(res.status)
return await res.json()
} catch (err) {
console.error(err)
}
}
En parallèle
// Séquentiel (lent)
const a = await fetchA()
const b = await fetchB()
// Parallèle (rapide) ✅
const [a, b] = await Promise.all([
fetchA(),
fetchB(),
])
Event Loop — ordre
console.log("1 sync")
setTimeout(() =>
console.log("3 macro"), 0)
Promise.resolve().then(() =>
console.log("2 micro"))
// → 1 sync, 2 micro, 3 macro
Async Generator
async function* paginer(url) {
let page = 1
while (true) {
const data = await fetch(`${url}?page=${page}`)
.then(r => r.json())
if (!data.length) return
yield data; page++
}
}
for await (const page of paginer(url)) {
// traiter chaque page
}
🏗 Classes & Modules Module 06
Classe complète
class Animal {
#nom // privé
static count = 0 // statique
constructor(nom) {
this.#nom = nom
Animal.count++
}
get nom() { return this.#nom }
parler() { return `${this.#nom}!` }
}
class Chien extends Animal {
parler() { return "Woof!" }
}
Import / Export
// utils.js
export const PI = 3.14
export function add(a, b) { return a+b }
export default class Calculator {}
// main.js
import Calculator, { PI, add }
from './utils.js'
// Tout importer
import * as utils from './utils.js'
🏛 Patterns essentiels Modules 08–09
Observer (EventEmitter)
class EventEmitter {
#listeners = {}
on(ev, fn) {
(this.#listeners[ev] ??= []).push(fn)
return () => this.off(ev, fn)
}
emit(ev, ...args) {
this.#listeners[ev]?.forEach(f => f(...args))
}
}
Singleton
class Config {
static #inst = null
static getInstance() {
return (Config.#inst ??= new Config())
}
// ... méthodes
}
const cfg = Config.getInstance()
Proxy réactif
const etat = new Proxy({count:0}, {
set(cible, prop, val) {
cible[prop] = val
console.log(`${prop} → ${val}`)
return true
}
})
etat.count = 1 // log: "count → 1"
Immutabilité
// ❌ mutation
state.items.push(item)
// ✅ nouveau tableau
const next = [...state.items, item]
// ✅ update d'un item
items.map(i =>
i.id === id ? {...i, done: true} : i
)
⚛️ JS → React React 18+
💡 React est du JS avec une convention : les composants retournent du JSX (HTML-like). Tout ce que tu as appris s'y retrouve directement.
| Ce que tu connais en JS | Comment ça s'appelle en React | Exemple |
|---|---|---|
Variable d'état (let count = 0) | useState | const [count, setCount] = useState(0) |
| Observer / abonnement à un changement | useEffect | useEffect(() => { fetch... }, [dep]) |
| Singleton store global | useContext / Zustand | const store = useContext(StoreCtx) |
el.innerHTML = items.map(...).join('') | JSX + .map() | {items.map(i => <li key={i.id}>{i.nom}</li>)} |
classList.toggle('active') | className dynamique | className={isActive ? 'active' : ''} |
addEventListener('click', fn) | Prop onClick | <button onClick={fn}> |
| Immutabilité (spread) | setState toujours avec nouveau objet | setUser({...user, age: 31}) |
async/await fetch() | Dans useEffect ou React Query | useEffect(() => { fetchData() }, []) |
| Import/Export ES6 | Identique — chaque composant = un fichier | import Button from './Button' |
Classe (class Produit {...}) | Peu utilisé — préférer des objets simples | Hooks > Classes en React moderne |
Composant React — ce que tu reconnais
// MODULE 02 : arrow function
// MODULE 03 : map(), filter()
// MODULE 04 : événements
// MODULE 05 : async/await
// MODULE 06 : import/export
import { useState, useEffect } from 'react'
export default function TodoList() {
const [todos, setTodos] = useState([]) // état
// useEffect = Observer sur [deps]
useEffect(() => {
fetch('/api/todos') // MODULE 05
.then(r => r.json())
.then(data => setTodos(data))
}, [])
// Immutabilité — MODULE 09
const ajouter = item =>
setTodos(prev => [...prev, item])
// JSX = map() + HTML — MODULE 03
return (
<ul>
{todos.map(t => (
<li key={t.id}>{t.texte}</li>
))}
</ul>
)
}
💚 JS → Vue 3 Vue 3 Composition API
💡 Vue utilise le Proxy JS (Module 08) pour sa réactivité. Si tu as compris le Proxy, tu comprends comment Vue fonctionne sous le capot.
| Ce que tu connais en JS | Comment ça s'appelle en Vue 3 | Exemple |
|---|---|---|
Variable réactive (Proxy) | ref() / reactive() | const count = ref(0) |
| Observer / watcher | watch() / watchEffect() | watch(count, (val) => { ... }) |
| Singleton store (Module 09) | Pinia store | defineStore('cart', { state, actions }) |
el.innerHTML = items.map(...) | v-for | <li v-for="i in items" :key="i.id"> |
classList.toggle | :class | :class="{ active: isActive }" |
addEventListener('input', fn) | v-model | <input v-model="recherche"> |
async/await fetch() | onMounted + async | onMounted(async () => { data.value = await fetch... }) |
| Import/Export ES6 | Identique — SFC = Single File Component | import MyComp from './MyComp.vue' |
| Computed (getter) | computed() | const total = computed(() => items.reduce(...)) |
Composant Vue — ce que tu reconnais
<!-- TodoList.vue -->
<script setup>
import { ref, computed, onMounted } from 'vue'
const todos = ref([]) // Proxy réactif — MODULE 08
const filtre = ref('tout')
// Computed = getter recalculé — MODULE 06
const filtered = computed(() =>
filtre.value === 'fait'
? todos.value.filter(t => t.fait) // MODULE 03
: todos.value
)
// onMounted = useEffect(fn, []) en React
onMounted(async () => { // MODULE 05
const res = await fetch('/api/todos')
todos.value = await res.json()
})
const ajouter = item =>
todos.value.push(item) // Vue gère la mutation
</script>
<template>
<ul>
<!-- v-for = .map() en JSX -->
<li v-for="t in filtered" :key="t.id">
{{ t.texte }}
</li>
</ul>
</template>
🤔 React ou Vue ?
| React | Vue 3 | |
|---|---|---|
| Courbe d'apprentissage | Plus raide (JSX, hooks rules) | Plus douce (template HTML-like) |
| Offres d'emploi | ⭐⭐⭐⭐⭐ Beaucoup plus | ⭐⭐⭐ Moins mais stable |
| Écosystème | Immense (Next.js, React Native) | Solide (Nuxt, Quasar) |
| Syntaxe | JS pur (JSX = JS+HTML) | HTML + attributs spéciaux |
| État global | Redux, Zustand, Jotai | Pinia (officiel, simple) |
| Recommandation | Si tu vises startup/grande boîte | Si tu veux apprendre vite et faire des apps |
🎯 Conseil : commence par React (plus demandé), puis Vue si tu veux diversifier. Les concepts sont identiques — seule la syntaxe change.
❌ Erreurs fréquentes à éviter
1. Muter l'état directement en React
❌ state.items.push(item) // React ne voit pas le changement !
✅ setState([...state.items, item]) // nouveau tableau
2. Oublier le tableau de dépendances dans useEffect
❌ useEffect(() => { fetchData() }) // boucle infinie !
✅ useEffect(() => { fetchData() }, []) // une seule fois
3. Appeler un hook dans une condition ou une boucle
❌ if (condition) { const [x] = useState(0) } // interdit
✅ const [x] = useState(0) // toujours au niveau du composant
4. Oublier la clé (key) dans un .map() React/Vue
❌ items.map(i => <li>{i.nom}</li>) // warning + bugs
✅ items.map(i => <li key={i.id}>{i.nom}</li>)
5. Async dans useEffect sans cleanup
❌ useEffect(async () => { ... }) // interdit
✅ useEffect(() => { const fn = async () => {...}; fn() }, [])
6. Utiliser == au lieu de ===
❌ if (user.role == 1) // 1 == "1" vaut true en JS
✅ if (user.role === 1) // comparaison stricte toujours
7. Fetch sans vérifier response.ok
❌ const data = await fetch(url).then(r => r.json()) // 404 = pas d'erreur !
✅ if (!response.ok) throw new Error(response.status)
8. Stocker des secrets dans VITE_ ou le code client
❌ VITE_API_SECRET=abc123 // visible dans le bundle JS
✅ Les secrets = backend uniquement (Node.js, API serverless)
🔍 Débugger efficacement
Console avancée
console.table(tableau)
console.group("bloc"); ...; console.groupEnd()
console.time("op"); ...; console.timeEnd("op")
console.trace() // stack trace
console.assert(cond, msg)
Chrome DevTools raccourcis
F12 / Ctrl+Shift+I → ouvrir DevTools
Ctrl+P → chercher un fichier
Ctrl+Shift+F → chercher dans tous les fichiers
F8 → pause/resume l'exécution
F10 → step over (prochaine ligne)
F11 → step into (entrer dans la fn)
$0 → l'élément sélectionné dans Elements
🗺 Roadmap — après la formation
✓
JS Fondamentaux (Modules 01–07)
Variables, fonctions, tableaux, DOM, async, classes, Node.js
✓
JS Avancé (Modules 08–11)
Event Loop, Patterns, Tests Vitest, Vite/ESLint
→
TypeScript (2–3 semaines)
Types, interfaces, generics, enums. Toutes les offres d'emploi l'exigent.
4
React (1–2 mois)
useState, useEffect, useContext, React Router, React Query. Faire 2–3 projets.
5
Projet full-stack (1 mois)
React + Node.js/Express + SQL. Déployer sur Vercel/Railway.
6
Portfolio + GitHub + Candidatures
3 projets déployés, README soigné, profil LinkedIn, entretiens techniques.
🔗 Liens de référence
| Ressource | Utilité |
|---|---|
| MDN Web Docs — developer.mozilla.org | Référence JS officielle, la plus complète |
| javascript.info | Tutoriel JS moderne, très bien écrit (en anglais) |
| react.dev | Doc officielle React avec exemples interactifs |
| vuejs.org | Doc officielle Vue 3, très claire |
| vitejs.dev | Doc Vite |
| vitest.dev | Doc Vitest |
| typescriptlang.org/play | Playground TypeScript en ligne |
| roadmap.sh/frontend | Roadmap frontend visuelle et interactive |
| frontendmentor.io | Défis front-end avec design fourni |
| javascript30.com | 30 projets JS pur en 30 jours (Wes Bos) |