⚡ 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 JSComment ça s'appelle en ReactExemple
Variable d'état (let count = 0)useStateconst [count, setCount] = useState(0)
Observer / abonnement à un changementuseEffectuseEffect(() => { fetch... }, [dep])
Singleton store globaluseContext / Zustandconst store = useContext(StoreCtx)
el.innerHTML = items.map(...).join('')JSX + .map(){items.map(i => <li key={i.id}>{i.nom}</li>)}
classList.toggle('active')className dynamiqueclassName={isActive ? 'active' : ''}
addEventListener('click', fn)Prop onClick<button onClick={fn}>
Immutabilité (spread)setState toujours avec nouveau objetsetUser({...user, age: 31})
async/await fetch()Dans useEffect ou React QueryuseEffect(() => { fetchData() }, [])
Import/Export ES6Identique — chaque composant = un fichierimport Button from './Button'
Classe (class Produit {...})Peu utilisé — préférer des objets simplesHooks > 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 JSComment ça s'appelle en Vue 3Exemple
Variable réactive (Proxy)ref() / reactive()const count = ref(0)
Observer / watcherwatch() / watchEffect()watch(count, (val) => { ... })
Singleton store (Module 09)Pinia storedefineStore('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 + asynconMounted(async () => { data.value = await fetch... })
Import/Export ES6Identique — SFC = Single File Componentimport 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 ?
ReactVue 3
Courbe d'apprentissagePlus raide (JSX, hooks rules)Plus douce (template HTML-like)
Offres d'emploi⭐⭐⭐⭐⭐ Beaucoup plus⭐⭐⭐ Moins mais stable
ÉcosystèmeImmense (Next.js, React Native)Solide (Nuxt, Quasar)
SyntaxeJS pur (JSX = JS+HTML)HTML + attributs spéciaux
État globalRedux, Zustand, JotaiPinia (officiel, simple)
RecommandationSi tu vises startup/grande boîteSi 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.

React (1–2 mois)

useState, useEffect, useContext, React Router, React Query. Faire 2–3 projets.

Projet full-stack (1 mois)

React + Node.js/Express + SQL. Déployer sur Vercel/Railway.

Portfolio + GitHub + Candidatures

3 projets déployés, README soigné, profil LinkedIn, entretiens techniques.

🔗 Liens de référence
RessourceUtilité
MDN Web Docs — developer.mozilla.orgRéférence JS officielle, la plus complète
javascript.infoTutoriel JS moderne, très bien écrit (en anglais)
react.devDoc officielle React avec exemples interactifs
vuejs.orgDoc officielle Vue 3, très claire
vitejs.devDoc Vite
vitest.devDoc Vitest
typescriptlang.org/playPlayground TypeScript en ligne
roadmap.sh/frontendRoadmap frontend visuelle et interactive
frontendmentor.ioDéfis front-end avec design fourni
javascript30.com30 projets JS pur en 30 jours (Wes Bos)