1. Utiliser la déstructuration pour échanger des variables

let a = 1, b = 2;
[a, b] = [b, a];
console.log(a, b); // 2 1

Pourquoi : fournit un moyen simple et simple d'échanger des valeurs de variable sans variable temporaire.

2. Utiliser des littéraux de modèle pour l'interpolation de chaînes

const name = "Alice";
console.log(`Hello, ${name}!`); // Hello, Alice!

Pourquoi : rend la concaténation de chaînes plus lisible et moins sujette aux erreurs que les méthodes traditionnelles.

3. Utilisez l'opérateur de fusion nul (??) pour les valeurs par défaut

const value = null;
const defaultValue = value ?? "Default";
console.log(defaultValue); // "Default"

Pourquoi : fournit un moyen concis de gérer les valeurs nulles ou non définies, en les distinguant des valeurs fausses telles que 0 ou une chaîne vide.

4. Utilisez le chaînage facultatif (?.) pour un accès sécurisé à la propriété

const obj = { nested: { property: "value" } };
console.log(obj?.nested?.property); // "value"
console.log(obj?.nonexistent?.property); // undefined

Pourquoi : évite les erreurs lors de l'accès à des propriétés imbriquées qui pourraient ne pas exister, réduisant ainsi le besoin de vérifications détaillées.

5. Utilisez l'opérateur de propagation (...) pour la manipulation de tableaux

const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const combined = [...arr1, ...arr2];
console.log(combined); // [1, 2, 3, 4, 5, 6]

Pourquoi : simplifie les opérations sur les tableaux telles que la combinaison, la copie ou l'ajout d'éléments, rendant le code plus concis et plus lisible.

6. Utilisez Array.from() pour créer des tableaux à partir d'objets de type tableau

const arrayLike = { 0: "a", 1: "b", 2: "c", length: 3 };
const newArray = Array.from(arrayLike);
console.log(newArray); // ["a", "b", "c"]

Pourquoi : convertit facilement les objets ou itérables de type tableau en véritables tableaux, permettant l'utilisation de méthodes de tableau.

7. Utilisez Object.entries() pour une itération d'objet facile

const obj = { a: 1, b: 2, c: 3 };
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key}: ${value}`);
}

Pourquoi : fournit un moyen simple de parcourir simultanément les clés et les valeurs d'un objet.

8. Utilisez Array.prototype.flat() pour aplatir les tableaux imbriqués

const nestedArray = [1, [2, 3, [4, 5]]];
console.log(nestedArray.flat(2)); // [1, 2, 3, 4, 5]

Pourquoi : simplifie le travail avec des tableaux imbriqués en les aplatissant à une profondeur spécifiée.

9. Utilisez async/await pour un code asynchrone plus propre

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error:', error);
  }
}

Pourquoi : donne au code asynchrone l'apparence et le comportement d'un code synchrone, améliorant ainsi la lisibilité et la gestion des erreurs.

10. Utilisez Set pour les valeurs uniques dans un tableau

const numbers = [1, 2, 2, 3, 4, 4, 5];
const uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

Pourquoi : fournit un moyen efficace de supprimer les doublons d'un tableau sans boucle manuelle.

11. Utilisez Object.freeze() pour créer des objets immuables

const frozenObj = Object.freeze({ prop: 42 });
frozenObj.prop = 100; // Fails silently in non-strict mode
console.log(frozenObj.prop); // 42

Pourquoi : empêche les modifications d'un objet, utile pour créer des constantes ou garantir l'intégrité des données.

12. Utilisez Array.prototype.reduce() pour de puissantes transformations de tableaux

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((acc, curr) => acc   curr, 0);
console.log(sum); // 15

Pourquoi : permet d'effectuer des opérations de tableau complexes en un seul passage, souvent plus efficacement que les boucles.

13. Utilisez l'opérateur logique AND (&&) pour l'exécution conditionnelle

const isTrue = true;
isTrue && console.log("This will be logged");

Pourquoi : fournit un moyen rapide d'exécuter du code uniquement si une condition est vraie, sans instruction if explicite.

14. Utilisez Object.assign() pour fusionner des objets

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = Object.assign({}, obj1, obj2);
console.log(merged); // { a: 1, b: 3, c: 4 }

Pourquoi : simplifie la fusion d'objets, utile pour combiner des objets de configuration ou créer des copies d'objets avec des remplacements.

15. Utilisez Array.prototype.some() et Array.prototype.every() pour array

checking
const numbers = [1, 2, 3, 4, 5];
console.log(numbers.some(n => n > 3)); // true
console.log(numbers.every(n => n > 0)); // true

Pourquoi : fournit des moyens concis de vérifier si un ou tous les éléments d'un tableau remplissent une condition, en évitant les boucles explicites.

16. Utilisez console.table() pour une meilleure journalisation des données tabulaires

const users = [
  { name: "John", age: 30 },
  { name: "Jane", age: 28 },
];
console.table(users);

Pourquoi : améliore la lisibilité des données enregistrées au format tabulaire, particulièrement utile pour les tableaux d'objets.

17. Utilisez Array.prototype.find() pour obtenir le premier élément correspondant

const numbers = [1, 2, 3, 4, 5];
const found = numbers.find(n => n > 3);
console.log(found); // 4

Pourquoi : recherche efficacement le premier élément d'un tableau qui satisfait une condition, arrêtant l'itération une fois trouvé.

18. Utilisez Object.keys(), Object.values() et Object.entries() pour l'objet

manipulation
const obj = { a: 1, b: 2, c: 3 };
console.log(Object.keys(obj)); // ["a", "b", "c"]
console.log(Object.values(obj)); // [1, 2, 3]
console.log(Object.entries(obj)); // [["a", 1], ["b", 2], ["c", 3]]

Pourquoi : fournit des moyens simples d'extraire et d'utiliser les propriétés et les valeurs d'objets, utiles pour de nombreuses opérations sur les objets.

19. Utilisez l'API Intl pour l'internationalisation

const number = 123456.789;
console.log(new Intl.NumberFormat('de-DE').format(number)); // 123.456,789

Pourquoi : simplifie le formatage des nombres, des dates et des chaînes selon les règles spécifiques aux paramètres régionaux sans implémentation manuelle.

20. Utilisez Array.prototype.flatMap() pour le mappage et l'aplatissement en une seule étape

const sentences = ["Hello world", "How are you"];
const words = sentences.flatMap(sentence => sentence.split(" "));
console.log(words); // ["Hello", "world", "How", "are", "you"]

Pourquoi : combine efficacement les opérations de mappage et d'aplatissement, ce qui est utile pour les transformations qui produisent des résultats imbriqués.