3 fonctionnalités de JavaScript que l'IA ne connaît pas

Cet article compile une liste de fonctionnalités utiles et récentes de JavaScript. Un agent IA ne les proposera pas forcément, car elles sont souvent absentes de leurs datasets d’entraînement. Mais la plupart des navigateurs sont déjà capables de les utiliser.

L’API Temporal

Si vous n’en avez pas entendu parler, Temporal est la nouvelle API standardisée pour gérer les dates et les temps en JavaScript. Les classes de l’API Temporal sont prévues pour remplacer l’objet Date. Ils sont immutables par défaut et ils gèrent les timezones et les heures d’été/d’hiver. Ils règlent aussi des problèmes de conception de l’objet Date.

// Par exemple, avec Date, les mois sont "zero-based", la date ci dessous est donc en avril :
const date = new Date(2026, 3, 1); // et non ce n'est pas un poisson d'avril !
 
// Avec Temporal, les mois sont "1-based", la date ci dessous est donc en avril :
const date = new Temporal.PlainDate(2026, 4, 1);
const date = Temporal.PlainDate.from("2026-04-01");
 
// contiendra l'heure "UTC"
const instant = Temporal.Now.instant();
// contiendra l'heure de l'utilisateur et l'information sur la timezone
const local = Temporal.Now.zonedDateTimeISO();
 
// Immutable, donc nouveaux objets à chaque modification :
const date1 = Temporal.PlainDate.from("2026-05-17");
const date2 = date1.add({ days: 7 }); // date1 n'a pas changé

Il y a beaucoup plus de choses à découvrir sur Temporal, cela pourrait être un article séparé. Pour plus d’informations, consultez la documentation MDN.

Opérations sur les Sets

Un ensemble (Set) est utile pour avoir une liste de valeurs uniques. Mais on veut souvent comparer ou effectuer des opérations sur un ou plusieurs sets. En demandant à l’IA, il y a de bonnes chances qu’elle génère un .reduce() ou un .filter() mais des opérations pratiques ont été standardisées récemment :

Set.union()

Retourne un nouveau Set contenant les éléments du Set courant et d’un autre ensemble.

const A = new Set(['a','b','c']);
const B = new Set(['b','c','d']);
 
const C = A.union(B); // {'a', 'b', 'c', 'd'}

Set.intersection()

Retourne un nouveau set contenant les éléments communs aux sets passés en paramètre.

const A = new Set(['a','b','c']);
const B = new Set(['b','c','d']);
 
const C = A.intersection(B); // {'b', 'c'}

Set.difference()

Retourne un nouveau set contenant les éléments qui ne sont présents dans le premier set, mais pas dans les autres.

const A = new Set(['a','b','c']);
const B = new Set(['b','c','d']);
 
const C = A.difference(B); // {'a'}

Set.symmetricDifference()

Retourne un nouveau set contenant les éléments qui sont présents dans au moins un des sets, mais pas dans les autres.

const A = new Set(['a','b','c']);
const B = new Set(['b','c','d']);
 
const C = A.symmetricDifference(B); // {'a', 'd'}

Set.isSubsetOf()

Vérifie si un set est un sous-ensemble d’un autre.

const A = new Set(['a','b','c']);
const B = new Set(['b','c','d']);
const C = new Set(['a']);
 
A.isSubsetOf(B); // false
C.isSubsetOf(A); // true: A contient C

Il y a aussi Set.isSupersetOf() et Set.isDisjointFrom(). Vous pouvez consulter une documentation plus détaillée sur MDN.

Promise.try

Lorsqu’on utilise les Promise, on cherche souvent à gérer les résultats et les erreurs de manière uniforme. Le problème : un callback peut être synchrone, asynchrone, ou lever une exception avant même de retourner une promesse. Par exemple :

function doSomething(action) {
  return Promise.try(action)
    .then((result) => ...)
    .catch((error) => console.error(error));
}
 
doSomething(() => "Sync result");
 
doSomething(() => {
  throw new Error("Sync error");
});
 
doSomething(async () => "Async result");
 
doSomething(async () => {
  throw new Error("Async error");
});

Dans cet exemple, on peut passer un callback à doSomething() mais on ne sait pas si la fonction sera synchrone ou asynchrone. Plutôt que d’écrire une gestion séparée pour les cas synchrones (avec try/catch) et asynchrones, on peut utiliser Promise.try() qui permet de gérer les erreurs de manière plus simple et uniforme.

Plus d’informations sur MDN.

On pourrait ajouter beaucoup d’autres fonctionnalités à cette liste, mais je pense que celles-ci sont les plus faciles pour le relecteur ou l’utilisateur à voir et à (faire) corriger.