Guide Complet ES2025 - Nouvelles Fonctionnalités JavaScript
Mis à jour en octobre 2026 · ECMAScript 2025, avec ce qu'a ajouté ECMAScript 2026
JavaScript évolue constamment, et ES2025 apporte des fonctionnalités concrètes qui améliorent votre productivité quotidienne. Iterator Helpers, Set Methods natifs, Promise.try(), import JSON... Découvrez les vraies nouveautés confirmées plus les propositions futures prometteuses.
ES2025 est la 16e édition de la norme ECMA-262, publiée en juin 2025. La 17e édition, ES2026, est sortie en juin 2026 : ses nouveautés sont résumées dans « Et depuis : ES2026 ».
1. Iterator Helpers - La vraie star d'ES2025
Les Iterator Helpers sont LA fonctionnalité majeure d'ES2025. Ils apportent des méthodes comme
filter(), map(), take() directement sur tous les itérables, avec évaluation
paresseuse pour des performances optimales.
ℹ️ Méthodes standardisées en ES2025 : map, filter,
take, drop, flatMap, reduce, toArray,
forEach, some, every, find et
Iterator.from().
Remarque : des noms comme .batch() ne font pas partie de la norme.
Iterator Helpers - Traitement paresseux révolutionnaire
// ✅ Iterator Helpers avec lazy evaluation
function* numbers() {
let i = 0;
while (i < 1000000) {
console.log(`Generating: ${i}`); // Pour voir l'évaluation paresseuse
yield i++;
}
}
// Chaîne de traitement paresseuse - rien n'est calculé encore
const result = numbers()
.filter(n => n % 2 === 0) // Nombres pairs
.map(n => n * n) // Carrés
.take(5); // Prendre seulement 5
// Seuls les 5 premiers résultats sont calculés
for (const value of result) {
console.log(value); // 0, 4, 16, 36, 64
}
// ✅ Méthodes utiles natives
const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// reduce() pour agrégation
const sum = data.values()
.filter(n => n % 2 === 0)
.reduce((acc, n) => acc + n, 0);
console.log(sum); // 30 (2+4+6+8+10)
// some() et every()
const hasEven = data.values().some(n => n % 2 === 0); // true
const allPositive = data.values().every(n => n > 0); // true
// find() (il n’y a pas de findIndex côté iterators)
const firstEven = data.values().find(n => n % 2 === 0); // 2
// ✅ Performance - traitement de gros datasets
function* hugeDataset() {
for (let i = 0; i < 1000000; i++) {
yield { id: i, value: Math.random(), active: i % 3 === 0 };
}
}
// Traitement efficace - seuls les éléments nécessaires sont générés
const activeItems = hugeDataset()
.filter(item => item.active)
.map(item => item.value)
.take(100) // Arrêt après 100 éléments
.toArray(); // Conversion finale en array
console.log(`Processed ${activeItems.length} items`);
2. Set Methods Natives
Les opérations ensemblistes deviennent enfin natives ! Plus besoin de librairies externes pour les unions, intersections et différences entre Sets.
Set Methods - Exemples pratiques
// ✅ Nouvelles méthodes natives de Set en ES2025
const frontend = new Set(['JavaScript', 'TypeScript', 'React', 'Vue']);
const backend = new Set(['JavaScript', 'Python', 'Node.js', 'Go']);
// Union - Toutes les technologies
const allTechs = frontend.union(backend);
console.log(allTechs);
// Set(7) {'JavaScript', 'TypeScript', 'React', 'Vue', 'Python', 'Node.js', 'Go'}
// Intersection - Technologies communes
const commonTechs = frontend.intersection(backend);
console.log(commonTechs);
// Set(1) {'JavaScript'}
// Difference - Technologies uniquement frontend
const frontendOnly = frontend.difference(backend);
console.log(frontendOnly);
// Set(3) {'TypeScript', 'React', 'Vue'}
// ✅ Cas d'usage pratique - Gestion des permissions
const userPermissions = new Set(['read', 'write', 'delete']);
const requiredPermissions = new Set(['read', 'write']);
const canAccess = requiredPermissions.isSubsetOf(userPermissions);
console.log(canAccess); // true
const missingPermissions = requiredPermissions.difference(userPermissions);
console.log(missingPermissions); // Set(0) - aucune permission manquante
3. Promise.try()
Cette nouvelle méthode simplifie la gestion des erreurs en convertissant automatiquement le code synchrone susceptible de lever des exceptions en promesses rejetées.
Promise.try() - Gestion d'erreurs unifiée
// ✅ Promise.try() - Gestion unifiée sync/async
function riskyOperation(data) {
if (!data) {
throw new Error('Data is required'); // Erreur synchrone
}
if (data.async) {
return fetch('/api/data'); // Retour asynchrone
}
return data.value * 2; // Retour synchrone
}
// ✅ ES2025 - Promise.try() simplifie tout
async function handleNewWay(data) {
try {
const result = await Promise.try(() => riskyOperation(data));
return result;
} catch (error) {
console.error('Error:', error.message);
throw error;
}
}
// Usage pratique
Promise.try(() => riskyOperation({ value: 5 }))
.then(result => console.log('Success:', result)) // Success: 10
.catch(error => console.error('Caught:', error.message));
Promise.try(() => riskyOperation(null))
.then(result => console.log('Success:', result))
.catch(error => console.error('Caught:', error.message)); // Caught: Data is required
// ✅ Cas d'usage - API wrapper
class ApiClient {
async request(endpoint, options = {}) {
return Promise.try(() => {
// Validation synchrone qui peut lever des erreurs
if (!endpoint) throw new Error('Endpoint required');
if (typeof endpoint !== 'string') throw new Error('Invalid endpoint');
// Appel asynchrone
return fetch(endpoint, options).then(r => {
if (!r.ok) throw new Error(`HTTP ${r.status}`);
return r.json();
});
});
}
}
// Usage uniforme
const api = new ApiClient();
api.request('/users')
.then(users => console.log('Users:', users))
.catch(error => console.error('API Error:', error.message));
4. Import JSON Modules
Finies les gymnastiques avec fetch() et JSON.parse() ! ES2025 permet d'importer
directement des fichiers JSON comme des modules, simplifiant drastiquement la gestion de configuration.
Technique : l’import JSON s’appuie sur la fonctionnalité standardisée Import Attributes (Stage 4), désormais « Baseline » dans les navigateurs modernes.
Côté JavaScript : un module JSON exporte une seule valeur, l'objet entier, comme export par
défaut. import { database } from … ressemble à une décomposition mais n'en est pas une : c'est un
import d'export nommé, et le module n'en a aucun. On importe donc l'objet, puis on le décompose.
Import JSON - Simplification drastique
// ✅ ES2025 - Import direct
import config from './config.json' with { type: 'json' };
import translations from './i18n/fr.json' with { type: 'json' };
import apiEndpoints from './api-config.json' with { type: 'json' };
console.log(config.apiUrl); // Directement disponible
console.log(translations.welcome); // "Bienvenue"
// ❌ Pas d'import nommé : un module JSON n'a qu'un export par défaut (SyntaxError)
// import { database, cache } from './server-config.json' with { type: 'json' };
// ✅ Importer l'objet, puis le décomposer
import serverConfig from './server-config.json' with { type: 'json' };
const { database, cache } = serverConfig;
// Avant : charger le fichier à l'exécution
// const config = await fetch('./config.json').then(r => r.json());
Le fichier config.json importé :
{
"apiUrl": "https://api.example.com",
"version": "2.1.0",
"features": ["auth", "cache", "analytics"]
}
5. RegExp.escape() - Sécurité Renforcée
ES2025 apporte RegExp.escape() pour échapper automatiquement les caractères spéciaux dans les
entrées utilisateur. Cette méthode complète les améliorations Unicode du flag /v (déjà disponible
depuis ES2024).
RegExp ES2025 - Sécurité et Unicode
// ✅ NOUVEAUTÉ ES2025 - RegExp.escape()
const userInput = ".*+?^${}()|[]\\";
const escaped = RegExp.escape(userInput);
console.log(escaped); // \.\*\+\?\^\$\{\}\(\)\|\[\]\\
// Création sécurisée de regex
const searchTerm = "user@domain.com";
new RegExp(searchTerm).test("user@domainXcom"); // true : « . » accepte n'importe quel caractère
new RegExp(RegExp.escape(searchTerm)).test("user@domainXcom"); // false : le point est bien un point
// ℹ️ Le flag /v existe depuis ES2024 (rappel)
const unicodeRegex = /\p{Emoji}/v; // ES2024
console.log(unicodeRegex.test("Hello 👋 World")); // true
// ✅ Usage combiné pour sécurité maximale
function createSecureSearchRegex(userQuery) {
const escaped = RegExp.escape(userQuery); // ES2025
return new RegExp(escaped, 'giv'); // Combiné avec flag v (ES2024)
}
Deux autres nouveautés RegExp font partie d'ES2025, souvent oubliées :
// ✅ ES2025 - Modificateurs : un flag pour une partie du motif seulement
/^(?i:a)b$/.test("Ab"); // true : seul « a » ignore la casse
/^(?i:a)b$/.test("AB"); // false
// ✅ ES2025 - Le même nom de groupe dans deux alternatives
const date = /(?<year>\d{4})-\d{2}|\d{2}\/(?<year>\d{4})/;
"2025-06".match(date).groups.year; // "2025"
"06/2026".match(date).groups.year; // "2026"
6. Float16Array
JavaScript étend ses capacités mathématiques avec les float 16 bits, particulièrement utiles pour le machine learning et les calculs nécessitant une précision mémoire optimisée.
Nouveau type d'array typé pour les nombres 16 bits
const values = new Float16Array([1.5, 2.7, 3.14]);
console.log(values.byteLength); // 6 bytes (3 * 2)
Convertit un nombre vers le float16 le plus proche
console.log(Math.f16round(3.14159));
// 3.140625 (précision float16)
Idéal pour le ML et les gros datasets
// 50% moins de mémoire que Float32Array
const mlData = new Float16Array(1000000);
// Float64Array : 4x plus de mémoire (8 octets par valeur contre 2)
Graphics, IA, calculs scientifiques, WebGL
// Coordonnées pour rendu 3D
const vertices = new Float16Array([
-1.0, -1.0, 0.0, // vertex 1
1.0, -1.0, 0.0, // vertex 2
0.0, 1.0, 0.0 // vertex 3
]);
🔁 Compatibilité & Polyfills
- JSON imports (Import Attributes) : pris en charge dans tous les navigateurs modernes et dans Node.js récents.
- Iterator Helpers, Set Methods, Promise.try, RegExp.escape, Float16Array : inclus dans ES2025 ; l’implémentation navigateur/Node peut varier selon les versions.
- Stratégie : détection de fonctionnalités et chargement conditionnel (ex.
core-js/ Babel plugin quand disponible).
// Détection simple (extraits)
const supports = {
// globalThis.Iterator : sans globalThis, un Iterator absent lève une ReferenceError
iterHelpers: typeof globalThis.Iterator?.prototype?.take === 'function',
setUnion: typeof Set.prototype.union === 'function',
promiseTry: typeof Promise.try === 'function',
regexpEscape: typeof RegExp.escape === 'function',
float16: typeof Float16Array !== 'undefined'
};
if (!supports.iterHelpers) {
// Ex. import dynamique d'un polyfill ciblé
await import('./polyfills/iterator-helpers.js');
}
Côté JavaScript : ?. protège d'une valeur null ou
undefined, pas d'une variable qui n'existe pas. Si le moteur ne connaît pas Iterator,
Iterator?.prototype lève une ReferenceError avant même le test. Lu comme une
propriété de globalThis, il vaut simplement undefined. Set,
Promise et RegExp existent partout : seule leur méthode est à tester.
Astuce : vérifie la « Baseline » et les notes de versions de ton runtime (navigateur/Node) lors du déploiement.
7. Propositions Futures (En développement TC39)
Ces fonctionnalités passionnantes sont actuellement en développement par le comité TC39 mais ne font pas encore partie d'ES2025. Elles pourraient arriver dans les prochaines versions d'ECMAScript.
Futur Pattern Matching (Stage 1)
⚠️ Statut (octobre 2026) : proposition TC39 au Stage 1 depuis mai 2018. Elle n'est ni dans
ES2025 ni dans ES2026, et aucune date n'est annoncée. La syntaxe ci-dessous est celle de la proposition
aujourd'hui (when … :, default:) ; elle peut encore changer.
Cette fonctionnalité prometteuse permettrait d'analyser et décomposer des structures de données de manière
expressive, remplaçant avantageusement les longues chaînes de if/else.
Pattern Matching - Syntaxe proposée (pas encore standard)
// ✅ Syntaxe proposée (pas encore disponible)
function processApiResponse(response) {
return match (response) {
when { status: 200, data: { let user } }: `Bienvenue ${user.name}`;
when { status: 404 }: 'Ressource non trouvée';
when { status: 500, let error }: `Erreur serveur: ${error}`;
when { loading: true }: 'Chargement...';
default: 'État inconnu';
};
}
// En attendant, utiliser les approches classiques
function processApiResponseToday(response) {
if (response?.status === 200 && response.data?.user) {
return `Bienvenue ${response.data.user.name}`;
}
if (response?.status === 404) {
return 'Ressource non trouvée';
}
if (response?.status === 500) {
return `Erreur serveur: ${response.error}`;
}
if (response?.loading) {
return 'Chargement...';
}
return 'État inconnu';
}
Retirée Records & Tuples, remplacée par Composites (Stage 2)
⚠️ Statut : la proposition Records & Tuples (#{ } et #[ ]) a
été retirée en avril 2025. Le comité l'a remplacée par Composites, au
Stage 2 en octobre 2026. Beaucoup de tutoriels, et d'IA, la présentent encore comme « à venir » : la source
à consulter est le dépôt tc39/proposals.
Le besoin reste le même : comparer des données par leur contenu. Aujourd'hui, deux objets au contenu identique
sont différents pour ===, pour un Set et pour une clé de Map.
Composites propose des valeurs composites, comparées par contenu, sans nouvelle syntaxe.
Composites - API proposée (pas encore standard, « attendez-vous à des changements » selon ses auteurs)
// Aujourd'hui : deux objets identiques restent deux clés différentes
const p1 = { x: 1, y: 4 };
const p2 = { x: 1, y: 4 };
new Set([p1, p2]).size; // 2
// Proposé (Stage 2, pas encore disponible)
const pos1 = Composite({ x: 1, y: 4 });
const pos2 = Composite({ x: 1, y: 4 });
pos1 === pos2; // true
const positions = new Set();
positions.add(pos1);
positions.has(pos2); // true
// En attendant : une clé texte construite avec soin
const key = (p) => `${p.x},${p.y}`;
new Set([key(p1), key(p2)]).size; // 1
Côté JavaScript : ===, Set et Map comparent les objets
par référence (Set et Map utilisent l'algorithme SameValueZero). C'est ce
comportement que Composites veut compléter, et c'est aussi pour lui que React demande un nouvel objet à chaque
changement d'état.
📊 Statut des fonctionnalités (TC39)
| Fonctionnalité | Stade TC39 | Incluse ES2025 |
|---|---|---|
| Iterator Helpers | Stage 4 | ✅ |
| Set Methods | Stage 4 | ✅ |
| Promise.try() | Stage 4 | ✅ |
| Import JSON (via Import Attributes) | Stage 4 | ✅ |
| RegExp.escape() | Stage 4 | ✅ |
Modificateurs RegExp (?i: ) |
Stage 4 | ✅ |
| Groupes nommés dupliqués (RegExp) | Stage 4 | ✅ |
| Float16Array | Stage 4 (févr. 2025) | ✅ |
| Pattern Matching | Stage 1 | ❌ |
| Records & Tuples | Retirée (avril 2025) | ❌ |
| Composites (remplace Records & Tuples) | Stage 2 | ❌ |
Rappel : une proposition au Stage 4 entre dans l’édition annuelle suivante d’ECMA‑262. Statuts vérifiés en octobre 2026 sur tc39/proposals.
Et depuis : ES2026
L'essentiel : ES2026 (17e édition d'ECMA-262, juin 2026) ajoute sept propositions. Aucune ne change la façon d'écrire du JavaScript au quotidien, mais plusieurs remplacent du code qu'on recopiait de projet en projet.
Error.isError(valeur): dit si une valeur est une vraie erreur, même venue d'une autre iframe ou d'un autre contexte, là oùinstanceof Erroréchoue.Array.fromAsync(): construit un tableau à partir d'un itérable asynchrone (un générateurasync, un flux).Math.sumPrecise(): additionne une liste de nombres sans accumuler les erreurs d'arrondi d'une boucle+=.Uint8Array.fromBase64(),.toBase64()(et hexadécimal) : encodage Base64 natif des octets, sansbtoani bibliothèque.Map.prototype.getOrInsert()(proposition « Upsert ») : lit une clé ou l'insère si elle manque, en une seule opération.Iterator.concat(): enchaîne plusieurs itérateurs, dans la continuité des Iterator Helpers d'ES2025.JSON.rawJSON()et accès au texte source dansJSON.parse: lire et écrire des nombres trop grands pour unNumbersans perte.
Déjà au Stage 4 et prévus pour ES2027 : Temporal (dates et heures), Explicit Resource Management
(using), Atomics.pause et plusieurs Iterator Helpers (zip,
chunks, includes, join). La disponibilité dépend du moteur : Node 24, par
exemple, a Error.isError et Array.fromAsync, mais pas encore
Math.sumPrecise ni Map.prototype.getOrInsert.
8. Quiz par Niveau
Débutant Fonctionnalités ES2025
Comment importer directement un fichier JSON en ES2025 ?
💡 Réponse
import config from './config.json' with { type: 'json' };
Le mot-clé with { type: 'json' } est obligatoire
Comment fusionner deux Sets a et b en ES2025 ?
💡 Réponse
const result = a.union(b);
La méthode union() est native en ES2025
À quoi sert Promise.try() en ES2025 ?
💡 Réponse
Unifie la gestion d'erreurs sync/async
Promise.try(() => riskyFunction())
.then(result => console.log(result))
.catch(error => console.error(error));
Quel avantage des nouveaux Iterator Helpers ?
💡 Réponse
Évaluation paresseuse : Traitement à la demande
const result = data.values()
.filter(x => x > 100)
.map(x => x * 2)
.take(10); // Arrêt dès 10 éléments trouvés
Intermédiaire Applications pratiques
Pourquoi utiliser RegExp.escape() avec les entrées utilisateur ?
💡 Réponse
Sécurité : Évite les injections regex
// ❌ Dangereux
const userInput = ".*"; // Matcher tout !
const regex = new RegExp(userInput);
// ✅ Sécurisé
const escaped = RegExp.escape(userInput);
const safeRegex = new RegExp(escaped);
Quel avantage des Iterator Helpers sur Array.prototype ?
💡 Réponse
Évaluation paresseuse : Traitement à la demande
// Array - traite tout d'un coup
const result1 = hugeArray
.filter(x => x > 100)
.map(x => x * 2)
.slice(0, 10);
// Iterator - traite au fur et à mesure
const result2 = hugeIterator
.filter(x => x > 100)
.map(x => x * 2)
.take(10); // Arrêt dès 10 éléments trouvés
Dans quel contexte utiliser Float16Array ?
💡 Réponse
Machine Learning, Graphics, WebGL
50% moins de mémoire que Float32Array
// Pour des modèles ML avec millions de paramètres
const weights = new Float16Array(1000000);
// Float64Array = 4x plus de mémoire (8 octets contre 2)
Comment trouver les éléments qui ne sont que dans l'un des deux Sets ?
💡 Réponse
Utiliser symmetricDifference()
const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);
const unique = setA.symmetricDifference(setB);
// Set(4) {1, 2, 4, 5}
Expert Architecture et optimisation
Quand privilégier Iterator Helpers à Array methods ?
💡 Réponse
Gros datasets, traitement partiel, chaînes longues
// ✅ Iterator pour gros datasets
function* processLargeFile() {
// yield millions de lignes
}
const result = processLargeFile()
.filter(line => line.includes('ERROR'))
.map(line => parseError(line))
.take(100) // Arrêt précoce = économie massive
.toArray();
// ❌ Array traiterait TOUT avant de prendre 100
Comment standardiser la gestion d'erreurs dans une API ?
💡 Réponse
class UnifiedApiHandler {
async handle(operation) {
return Promise.try(() => operation())
.catch(error => {
// Logging uniforme sync/async
this.logger.error('Operation failed', { error });
throw new ApiError(error.message);
});
}
}
// Usage uniforme pour toutes opérations
const api = new UnifiedApiHandler();
api.handle(() => syncValidation(data));
api.handle(() => fetch('/api/data'));
api.handle(() => complexAsyncOperation());
Comment migrer progressivement vers ES2025 ?
💡 Réponse
Phase 1 : Iterator Helpers et Set Methods (impact immédiat)
Phase 2 : Promise.try(), JSON imports
Phase 3 : Float16 selon besoins, RegExp.escape
// Détection progressive de support
const features = {
iteratorHelpers: typeof globalThis.Iterator?.prototype?.take === 'function',
setMethods: 'union' in Set.prototype,
promiseTry: 'try' in Promise
};
// Polyfills conditionnels
if (!features.setMethods) {
await import('./polyfills/set-methods');
}
Comment optimiser une pipeline de traitement de données ?
💡 Réponse
// ✅ Pipeline optimisée ES2025 (sans .batch non-standard)
class DataPipeline {
process(source) {
return source
.filter(item => this.isValid(item))
.map(item => this.normalize(item))
.take(this.batchSize) // Limitation du volume
.toArray(); // Matérialisation finale
}
// Traitement par chunks en pur ES2025
async *processStream(source, chunkSize = 1000) {
let buffer = [];
for (const item of source.filter(i => this.isValid(i))) {
buffer.push(item);
if (buffer.length >= chunkSize) {
// Uniformiser la gestion d'erreur (sync/async)
yield await Promise.try(() => this.processChunk(buffer));
buffer = [];
}
}
if (buffer.length) {
yield await Promise.try(() => this.processChunk(buffer));
}
}
}
📚 Ressources
- Iterator Helpers — TC39 (Stage 4, archivé) • Spécification rendue : tc39.es
- Set Methods — TC39 (Stage 4)
- Promise.try() — TC39 (Stage 4) • Spec : tc39.es
- Import Attributes / JSON modules — TC39 (Stage 4)
- RegExp.escape() — MDN • Proposition : TC39 (Stage 4)
- Float16Array — TC39 (Stage 4, févr. 2025) • Spec : tc39.es
- Processus TC39 (stades) — tc39.es/process-document
- ECMAScript 2025 (16e édition, juin 2025) — ECMA-262
- ECMAScript 2026 (17e édition, juin 2026) — ECMA-262
- Propositions terminées, par année — tc39/proposals
- Records & Tuples (retirée) — TC39 • Composites (Stage 2) — TC39
- Pattern Matching (Stage 1) — TC39
À Retenir - ES2025 en Action
- 🔄 Iterator Helpers : LA star d'ES2025, traitement paresseux natif pour tous les itérables avec performances optimales
- 🔧 Set Methods : Opérations ensemblistes natives (union, intersection, difference) pour simplifier la logique métier
- ⚡ Promise.try() : Gestion unifiée sync/async, transforme automatiquement les erreurs en rejets
- 📁 JSON Modules : Import direct avec
with { type: 'json' }, finies les acrobaties fetch/parse - 🛡️ RegExp.escape() : Sécurité automatique contre les injections regex avec les entrées utilisateur
- 💾 Float16Array : Optimisation mémoire pour ML/graphics, 50% moins d'espace que Float32Array
- 🔮 Propositions futures : Pattern Matching reste au Stage 1 ; Records & Tuples a été retirée en 2025 au profit de Composites (Stage 2). Vérifiez toujours un statut sur tc39/proposals.
- 📅 ES2026 :
Error.isError,Array.fromAsync,Math.sumPrecise, Base64 natif,Map.prototype.getOrInsert,Iterator.concat - ⏱️ Temps d'adoption : Iterator Helpers et Set methods en priorité (impact immédiat), Promise.try() ensuite
- 🚀 Impact développement : Code plus performant et expressif, réduction des bugs, maintenance simplifiée
- 📚 Formation équipe : Focus sur évaluation paresseuse et opérations ensemblistes pour maximum de valeur
🎓 ES2025 apporte des améliorations concrètes et immédiatement utilisables. Les Iterator Helpers révolutionnent le traitement de données, les Set Methods simplifient la logique complexe, et Promise.try() unifie la gestion d'erreurs. L'adoption progressive est recommandée en commençant par les fonctionnalités à fort impact comme les Iterator Helpers.
À retenir (déploiement) : ES2025 est publié annuellement (juin). Les features listées ici sont au Stage 4 et présentes dans l’édition 2025 d’ECMA-262 ; vérifie toutefois la disponibilité exacte dans ta cible (navigateur/Node) et active des polyfills si nécessaire.