Command Palette

Search for a command to run...

JavaScript

Référence JavaScript moderne avec ES6+ et méthodes courantes

Variables et Types

Déclarer une variable

let nom = 'Alice';
const PI = 3.14;

let est réassignable, const ne l'est pas

Vérifier le type

typeof 'hello'    // 'string'
typeof 42         // 'number'
typeof true       // 'boolean'
typeof undefined  // 'undefined'
typeof null       // 'object' (bug historique)
typeof []         // 'object'

Types primitifs

const str = 'texte';       // string
const num = 42;            // number
const bool = true;         // boolean
const nul = null;          // null
const undef = undefined;   // undefined
const sym = Symbol('id');  // symbol
const big = 9007199254740991n; // bigint

Fonctions

Déclaration classique

function saluer(nom) {
  return `Bonjour ${nom}`;
}

Arrow function

const saluer = (nom) => `Bonjour ${nom}`;

Paramètres par défaut

function creer(nom, role = 'user') {
  return { nom, role };
}

Paramètres rest

function somme(...nombres) {
  return nombres.reduce((a, b) => a + b, 0);
}

Tableaux (Arrays)

Créer un tableau

const fruits = ['pomme', 'banane', 'cerise'];

map - transformer chaque élément

const doubles = [1, 2, 3].map(n => n * 2);
// [2, 4, 6]

filter - filtrer les éléments

const pairs = [1, 2, 3, 4].filter(n => n % 2 === 0);
// [2, 4]

reduce - réduire à une valeur

const somme = [1, 2, 3].reduce((acc, n) => acc + n, 0);
// 6

find / findIndex

const users = [{nom: 'Alice'}, {nom: 'Bob'}];
const user = users.find(u => u.nom === 'Bob');
const index = users.findIndex(u => u.nom === 'Bob');

some / every

[1, 2, 3].some(n => n > 2);   // true
[1, 2, 3].every(n => n > 0);  // true

slice - extraire sans modifier

const sub = [1, 2, 3, 4].slice(1, 3);
// [2, 3]

splice - modifier en place

const arr = [1, 2, 3, 4];
arr.splice(1, 2); // supprime 2 éléments à l'index 1
// arr = [1, 4]

sort - trier

const nums = [3, 1, 2];
nums.sort((a, b) => a - b); // [1, 2, 3] croissant
nums.sort((a, b) => b - a); // [3, 2, 1] décroissant

flat / flatMap

[[1, 2], [3, 4]].flat();       // [1, 2, 3, 4]
[1, 2].flatMap(n => [n, n*2]); // [1, 2, 2, 4]

Spread sur tableaux

const tous = [...fruits, 'mangue'];
const copie = [...fruits];

Objets

Créer un objet

const user = { nom: 'Alice', age: 30 };

Accès aux propriétés

user.nom          // 'Alice'
user['age']       // 30

Object.keys / values / entries

Object.keys(user);    // ['nom', 'age']
Object.values(user);  // ['Alice', 30]
Object.entries(user); // [['nom', 'Alice'], ['age', 30]]

Fusionner des objets

const merged = { ...user, role: 'admin' };
const merged2 = Object.assign({}, user, { role: 'admin' });

Vérifier l'existence d'une propriété

'nom' in user             // true
user.hasOwnProperty('nom') // true

Optional chaining

const ville = user?.adresse?.ville ?? 'inconnue';

Chaînes de caractères

Template literals

const msg = `Bonjour ${nom}, vous avez ${age} ans`;

Méthodes courantes

'hello'.length              // 5
'hello'.toUpperCase()       // 'HELLO'
'  hello  '.trim()          // 'hello'
'hello world'.split(' ')    // ['hello', 'world']
'hello'.includes('ell')     // true
'hello'.startsWith('he')    // true
'hello'.replace('l', 'L')   // 'heLlo'
'hello'.replaceAll('l', 'L') // 'heLLo'
'ha'.repeat(3)              // 'hahaha'
'hello'.slice(1, 3)         // 'el'
'hello'.indexOf('l')        // 2

Padding

'5'.padStart(3, '0')  // '005'
'5'.padEnd(3, '0')    // '500'

Déstructuration et Spread

Déstructuration d'un tableau

const [a, b, ...reste] = [1, 2, 3, 4];
// a=1, b=2, reste=[3,4]

Déstructuration d'un objet

const { nom, age, role = 'user' } = user;

Renommer lors de la déstructuration

const { nom: username } = user;

Spread sur objets

const copie = { ...user };
const enrichi = { ...user, email: 'a@b.com' };

Promesses et Async/Await

Créer une promesse

const p = new Promise((resolve, reject) => {
  resolve('OK');
});

Chaîner then/catch

fetch('/api/data')
  .then(res => res.json())
  .then(data => console.log(data))
  .catch(err => console.error(err))
  .finally(() => console.log('terminé'));

Async/Await

async function getData() {
  try {
    const res = await fetch('/api/data');
    const data = await res.json();
    return data;
  } catch (err) {
    console.error(err);
  }
}

Promise.all - exécuter en parallèle

const [users, posts] = await Promise.all([
  fetch('/api/users').then(r => r.json()),
  fetch('/api/posts').then(r => r.json()),
]);

Promise.race - premier résolu

const result = await Promise.race([
  fetch('/api/fast'),
  fetch('/api/slow'),
]);

Modules

Export nommé

export const PI = 3.14;
export function add(a, b) { return a + b; }

Export par défaut

export default class User { }

Import nommé

import { PI, add } from './math.js';

Import par défaut

import User from './user.js';

Import avec alias

import { add as addition } from './math.js';
import * as math from './math.js';

Import dynamique

const module = await import('./heavy-module.js');

DOM

Sélectionner des éléments

document.querySelector('.classe');
document.querySelectorAll('div');
document.getElementById('monId');

Créer et ajouter un élément

const div = document.createElement('div');
div.textContent = 'Nouveau contenu';
document.body.appendChild(div);

Écouter un événement

button.addEventListener('click', (e) => {
  console.log('cliqué !', e.target);
});

Supprimer un écouteur

const handler = () => console.log('click');
button.addEventListener('click', handler);
button.removeEventListener('click', handler);

Manipuler les classes CSS

element.classList.add('active');
element.classList.remove('active');
element.classList.toggle('active');
element.classList.contains('active'); // true/false

Modifier le style

element.style.color = 'red';
element.style.display = 'none';

Attributs data

element.dataset.userId       // lit data-user-id
element.dataset.userId = '5' // écrit data-user-id="5"