Vous pensiez tout savoir sur JavaScript ? Détrompez-vous, ce langage cache encore plein de petites pépites que vous allez adorer découvrir ! Alors accrochez-vous, on vous dévoile 7 fonctionnalités JavaScript vraiment trop cool.
# 1. Array.prototype.flatMap()
Vous connaissez sûrement **map()** et **flat()**, mais **flatMap()** c'est encore mieux ! Cette méthode vous permet de transformer et aplatir un tableau en un seul coup. Fini les manipulations chiantes à la main !
```javascript
const numbers = [1, 2, 3, 4];
const doubledAndFlattened = numbers.flatMap(num => [num, num]);
console.log(doubledAndFlattened); // [1, 1, 2, 2, 3, 3, 4, 4]
```
# 2. Object.fromEntries()
Vous en avez marre de transformer manuellement des tableaux de paires clé/valeur en objets ? Avec **Object.fromEntries()**, c'est un jeu d'enfant !
```javascript
const pairs = [['a', 1], ['b', 2]];
const obj = Object.fromEntries(pairs);
console.log(obj); // { a: 1, b: 2 }
```
# 3. Opérateur Nullish Coalescing (?)
Vous connaissez sûrement l'opérateur ternaire **?:** pour gérer les valeurs nulles. Mais avec l'opérateur **??**, c'est encore plus puissant !
```javascript
const foo = null;
const bar = foo ?? 'default value';
console.log(bar); // 'default value'
```
# 4. Opérateur de Nullification Optionnelle (?).
Avec cet opérateur, vous pouvez accéder en toute sécurité à des propriétés d'objets même s'ils sont **null** ou **undefined**. Fini les erreurs désagréables !
```javascript
const user = { name: 'John' };
console.log(user?.name); // 'John'
console.log(user?.address?.city); // undefined (pas d'erreur)
```
# 5. Fonctions Asynchrones avec `/async/await
Les promesses, c'était déjà vachement mieux que les callbacks. Mais avec **async/await**, vous allez pouvoir écrire du code asynchrone ultra lisible et maintenable.
```javascript
async function fetchData() {
const response = await fetch('/api/data');
const data = await response.json();
console.log(data);
}
```
# 6. Opérateur de Propagation (...)
Que ce soit pour fusionner des objets, dupliquer des tableaux ou passer des arguments à une fonction, l'opérateur de propagation est devenu incontournable.
```javascript
const numbers1 = [1, 2, 3];
const numbers2 = [4, 5, 6];
const allNumbers = [...numbers1, ...numbers2];
console.log(allNumbers); // [1, 2, 3, 4, 5, 6]
```
## 7. Déstructuration
Avec la déstructuration, vous allez pouvoir extraire facilement les données dont vous avez besoin depuis des objets et des tableaux. Fini les lignes de code illisibles !
```javascript
const person = { name: 'John', age: 30 };
const { name, age } = person;
console.log(name, age); // 'John', 30
```
Voilà, vous connaissez maintenant 7 fonctionnalités JavaScript vraiment trop badass ! N'hésitez pas à les tester dans vos prochains projets, ça va vous faire gagner un temps fou. Et si vous avez d'autres trucs de ouf à nous partager, balance tout ça dans les commentaires !
Veuillez vous connecter à votre compte.
