La nouvelle fonctionnalité assertions d'importation permet aux instructions d'importation de module d'inclure des informations supplémentaires en plus du spécificateur de module. Une utilisation initiale de cette fonctionnalité est de permettre l'importation de documents JSON sous forme de modules JSON :

L'opérateur in peut être utilisé pour tester si l'objet donné (ou tout objet dans sa chaîne de prototypes) possède la propriété donnée :

const o1 = {'foo': 0};
console.log('foo' in o1); // true
const o2 = {};
console.log('foo' in o2); // false
const o3 = Object.create(o1);
console.log('foo' in o3); // true

La fonctionnalité des vérifications des marques privées étend l'opérateur in pour prendre en charge les champs privés des classes:

class A {
  static test(obj) {
    console.log(#foo in obj);
  }
  #foo = 0;
}

A.test(new A()); // true
A.test({}); // false

class B {
  #foo = 0;
}

A.test(new B()); // false; ce n'est pas le même #foo

Puisque les noms privés ne sont disponibles qu'à l'intérieur de la classe qui les définit, le test doit également avoir lieu à l'intérieur de la classe, par exemple dans une méthode comme static test ci-dessus.

Les instances de sous-classe reçoivent les champs privés de la classe parente en tant que propriétés propres :

class SubA extends A {};
A.test(new SubA()); // true

Mais les objets créés avec Object.create (ou dont le prototype est défini ultérieurement via le modificateur __proto__ ou Object.setPrototypeOf) ne reçoivent pas les champs privés en tant que propriétés propres. Comme la recherche de champs privés ne fonctionne que sur les propriétés propres, l'opérateur in ne trouve pas ces champs hérités :

La nouvelle syntaxe des blocs d'initialisation statiques des classes permet aux développeurs de regrouper le code qui doit s'exécuter une fois pour une définition de classe donnée dans un seul endroit. Considérons l'exemple suivant où un générateur de nombres pseudo-aléatoires utilise un bloc statique pour initialiser un pool d'entropie une fois, lorsque la définition de class MyPRNG est évaluée.

La fonctionnalité JS-BigInt-Integration permet de passer facilement des entiers 64 bits entre JavaScript et WebAssembly. Cet article explique ce que cela signifie et pourquoi c'est utile, y compris la simplification pour les développeurs, l'accélération de l'exécution du code, et également la réduction des temps de compilation.

Atomics.wait et Atomics.notify sont des primitives de synchronisation bas-niveau utiles pour implémenter des mutex et d’autres moyens de synchronisation. Cependant, étant donné que Atomics.wait est bloquant, il est impossible de l’appeler sur le thread principal (une tentative entraîne une TypeError).

JavaScript prend en charge une gamme d'opérateurs d'assignation combinés permettant aux programmeurs d'exprimer succinctement une opération binaire avec assignation. Actuellement, seules les opérations mathématiques ou binaires sont prises en charge.

Les applications Web destinées à un public mondial doivent afficher les noms des langues, des régions, des écritures et des devises dans de nombreuses langues. Les traductions de ces noms nécessitent des données disponibles dans le Unicode CLDR. L'intégration de ces données dans l'application engendre un coût en temps de développement. Les utilisateurs préfèrent généralement des traductions cohérentes des noms de langues et de régions, et la mise à jour de ces données en fonction des événements géopolitiques mondiaux nécessite un entretien constant.

SIMD signifie Single Instruction, Multiple Data. Les instructions SIMD sont une classe spéciale d'instructions qui exploitent le parallélisme des données dans les applications en effectuant simultanément la même opération sur plusieurs éléments de données. Les applications intensives en calcul comme les codecs audio/vidéo, les processeurs d'image, sont toutes des exemples d'applications qui tirent parti des instructions SIMD pour accélérer les performances. La plupart des architectures modernes supportent certains variantes d'instructions SIMD.

JavaScript est désormais doté d'une nouvelle amélioration des expressions régulières, appelée "indices de correspondance". Imaginez que vous souhaitez trouver des noms de variables invalides dans des codes JavaScript qui coïncident avec des mots réservés, et afficher un caret et un « soulignement » sous le nom de la variable, comme suit :

Si vous avez déjà travaillé avec des chaînes de caractères en JavaScript, il y a de fortes chances que vous ayez rencontré la méthode String#replace. String.prototype.replace(searchValue, replacement) renvoie une chaîne avec certains correspondances remplacées, en fonction des paramètres que vous spécifiez :