On parle souvent de cette monture datant de 2015. En effet, elle constitue un tournant important dans l’évolution de JavaScript. Elle vient enrichir le langage. ES6 ne se résume pas à l’arrivée des fonctions fléchées. Ceci est un peu réducteur ! Retraçons les concepts les plus importants qui ont été implémentés.
Let / const
Le mot-clé var a été le premier moyen de déclarer une variable en JavaScript, mais il a été remplacé par deux nouveaux mots-clés qui ont été introduits avec ES6, La principale différence entre let et const est que les variables déclarées avec let peuvent être réassignées, tandis que les variables déclarées avec const ne peuvent pas être réassignées. Par exemple :
let x = 10; x = 20; // valide const y = 10; y = 20; // invalide, affiche une erreur
Il y a quelques autres différences entre let et const :
leta une portée de bloc, ce qui signifie qu’elle n’est accessible que dans le bloc de code (par exemple, une boucleforou une conditionif) où elle a été déclarée.consta également une portée de bloc.letpeut être déclarée sans être initialisée, maisconstdoit être initialisée lors de sa déclaration.letpeut être utilisée pour déclarer une variable de n’importe quel type, tandis queconstne peut être utilisée que pour déclarer une constante qui ne peut pas être réassignée et doit être de type primitif (par exemple, nombre, chaîne, booléen).letetconstsont de meilleures pratiques de programmation quevar, car ils encouragent à être plus explicite quant à la portée et la mutabilité des variables.
Voici un exemple de l’utilisation de let et const :
for (let i = 0; i < 10; i++) {
console.log(i); // affiche les nombres de 0 à 9
}
console.log(i); // affiche une erreur, i n'est pas accessible ici
const PI = 3.14;
console.log(PI); // affiche 3.14
PI = 3.15; // affiche une erreur, PI ne peut pas être réassignéTemplate strings
Aussi appelés templates literals sont une syntaxe qui rend la création de chaînes de caractères multilignes et l’interpolation de valeurs plus facile. Ils sont définis avec des backticks (`) au lieu de guillemets ou d’apostrophes, et permettent d’inclure des expressions à l’intérieur de la chaîne de caractères en utilisant la syntaxe ${expression}.
Création de chaînes de caractères multilignes :
const html = `
<div>
<h1>Exemple</h1>
<p>Création de chaînes de caractères multilignes</p>
</div>
`;Interpolation de chaines :
const name = 'John';
const message = `Hello, ${name}!`;
console.log(message); // "Hello, John!"On peut également effectuer des opérations mathématiques :
let x = 10;
let y = 20;
console.log(`${x} + ${y} = ${x + y}`);// "10 + 20 = 30"Les templates literals sont très utiles lorsque vous avez besoin de créer des chaînes de caractères complexes ou de concaténer des valeurs de manière dynamique.
Fonctions fléchées
Les fonctions fléchées sont une syntaxe plus courte pour écrire des fonctions en JavaScript. Elles ont une syntaxe plus concise que les fonctions traditionnelles et sont souvent utilisées lorsque vous avez besoin de créer une fonction simple qui prend en entrée un ou plusieurs paramètres et retourne une valeur. Ces fonctions ne créent pas leur propre contexte d’exécution (comme les IIFE).
Voici comment écrire une fonction fléchée simple qui prend un nombre en entrée et retourne son carré :
const square = (x) => {
return x * x;
};
console.log(square(2)); // 4
console.log(square(3)); // 9Il y a quelque chose à noter sur les fonctions fléchées :
- La syntaxe est
(parameters) => {code}. Les paramètres sont déclarés entre parenthèses, suivis d’une flèche=>et enfin du corps de la fonction entre accolades{}. - Elles ne peuvent pas être utilisées comme constructeur
- Elles ne possèdent pas de propriété prototype
- Si vous avez une seule instruction dans le corps de la fonction, vous pouvez omettre les accolades et la clause
return. Les fonctions fléchées gère le return de deux manières : explicite ou implicite :
//return implicite :
let hello = firstName => `Hello ${firstName}`;
hello('Quentin'); //hello Quentin
//return explicite : attention à l'emploi des accolades !
let hello = firstName => {return `Hello ${firstName}`};
hello('Quentin'); //hello Quentin- Si vous n’avez pas de paramètres, vous devez utiliser des parenthèses vides:
() => {code}.
Voici un exemple de fonction fléchée avec plusieurs paramètres et une instruction de corps:
const add = (x, y) => {
return x + y;
};
console.log(add(2, 3)); // 5
console.log(add(3, 4)); // 7Les fonctions fléchées n’ont pas de métavariable this comme les fonctions traditionnelles. En effet, le this d’une fonction fléchée est défini par le contexte dans lequel la fonction est définie et non par l’objet qui appelle la fonction. Cela peut être utile dans certains cas, mais peut également être source de confusion dans d’autres cas. Exemple :
btn.addEventListener("click", () => {
console.log(this); //window
});Les générateurs
Les générateurs permettent de créer des fonctions qui peuvent être « mises en pause » à des points précis et reprises ultérieurement. Ils sont définis avec la syntaxe function* et utilisent l’opérateur yield pour « céder » le contrôle de la fonction. Exemple de générateur qui génère une suite de nombres entiers :
function* countUpFrom(n) {
for (let i = n; true; i++) {
yield i;
}
}
const counter = countUpFrom(1);
console.log(counter.next().value); // 1
console.log(counter.next().value); // 2
console.log(counter.next().value); // 3Les générateurs sont très utiles lorsque vous avez besoin de créer des itérateurs ou des fonctions qui doivent être exécutées de manière asynchrone. Ils permettent également de créer des fonctions qui peuvent être « mises en pause » à des points précis et reprises ultérieurement, ce qui peut être très utile pour implémenter des algorithmes plus complexes.
Paramètres par défaut
Les paramètres par défaut permettent de définir des valeurs par défaut pour les arguments d’une fonction qui ne sont pas fournis lors de l’appel de la fonction. Cette fonctionnalité a été introduite avec ES6 et permet de simplifier la déclaration de fonctions en évitant de devoir vérifier si chaque argument est défini avant de les utiliser.
function displayName(name = 'John') {
console.log(`Hello, ${name}!`);
}
displayName(); // "Hello, John!"
displayName('Mary'); // "Hello, Mary!"
Dans cet exemple, la fonction displayName() accepte un argument facultatif name, qui est défini par défaut à la valeur 'John'. Si l’argument name est fourni lors de l’appel de la fonction, sa valeur est utilisée, sinon la valeur par défaut est utilisée. Les paramètres par défaut sont très utiles lorsque vous voulez créer des fonctions flexibles qui peuvent être appelées de différentes manières.
Les itérateurs
Les itérateurs permettent de parcourir les éléments d’un objet de manière séquentielle. Ils sont utilisés avec les boucles for-of et sont implémentés en utilisant une méthode appelée Symbol.iterator.
Voici comment utiliser un itérateur :
let myArray = [1, 2, 3];
// Invocation de l'itérateur
let iterator = myArray[Symbol.iterator]();
// Utiliser l'itérateur
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: undefined, done: true }Sans le savoir peut-être, vous utilisez déjà des itérateurs avec la boucle for-of :
let myArray = [1, 2, 3];
for (let value of myArray) {
console.log(value); // 1, 2, 3
}Vous pouvez également définir votre propre itérateur en implémentant la méthode Symbol.iterator dans votre objet. Par exemple :
let myObject = {
a: 1,
b: 2,
c: 3,
[Symbol.iterator]() {
let properties = Object.keys(this);
let index = 0;
let isDone = false;
return {
next: () => {
if (index >= properties.length) {
isDone = true;
}
let value = this[properties[index]];
index++;
return { value, done: isDone };
}
}
}
};
for (let value of myObject) {
console.log(value); // 1, 2, 3
}Les modules
Les modules permettent de séparer votre code en plusieurs fichiers indépendants et de les importer dans d’autres fichiers lorsque vous en avez besoin. Cela permet de structurer votre code de manière plus organisée et de réutiliser du code à travers plusieurs fichiers et projets.
Il existe deux types de modules en JavaScript : les modules « ES » (ou « ESM ») et les modules « CommonJS ». Les modules « ES » sont basés sur la spécification ECMAScript et sont nativement pris en charge par les navigateurs modernes et les outils de build. Les modules « CommonJS » sont utilisés principalement avec Node.js et sont utilisés pour exporter et importer des objets en utilisant les mots-clés module.exports et require(). Voici un exemple de module « ES » qui exporte une fonction :
// file.js
export function add(x, y) {
return x + y;
}
export function subtract(x, y) {
return x - y;
}Pour importer ce module dans un autre fichier, vous pouvez utiliser l’instruction import :
// main.js
import { add, subtract } from './math';
console.log(add(1, 2)); // 3
console.log(subtract(1, 2)); // -1Les modules permettent de séparer votre code en plusieurs fichiers indépendants et de les importer dans d’autres fichiers lorsque vous en avez besoin. Ils sont particulièrement utiles lorsque vous travaillez sur des projets de grande taille ou lorsque vous voulez réutiliser du code à travers plusieurs projets.
Les classes
Les classes sont une syntaxe enveloppante pour les constructeurs de fonctions et les prototypes en JavaScript et ont pour but de rendre la création d’objets avec des méthodes et des propriétés partagées plus facile et plus lisible. Voici un exemple de classe qui définit une classe Person avec un constructeur et une méthode :
class Person {
constructor(name) {
this.name = name;
}
displayName() {
console.log(`Salut je m'appelle ${this.name}`);
}
}
const john = new Person('John');
john.displayName(); // "Salut je m'appelle John"
Dans cet exemple, la classe Person a un constructeur qui accepte un argument name et l’assigne à la propriété name de l’objet. Elle a également une méthode displayName() qui affiche un message de salutation en utilisant la propriété name. Pour créer un nouvel objet de la classe Person, vous pouvez utiliser l’opérateur new et fournir les arguments nécessaires au constructeur.
Les classes ont pour but de rendre la création d’objets avec des méthodes et des propriétés partagées plus facile et plus lisible.
Spread Operator : opérateurs de propagation
Opérateurs de trois points (...) qui permettent de décomposer ou d’étendre les objets itérables (comme les tableaux ou les objets « iterables ») et les objets non itérables (comme les objets littéraux).
Décomposition de tableaux :
const array1 = [1, 2, 3]; const array2 = [4, 5, 6]; const array3 = [...array1, ...array2]; console.log(array3); // [ 1, 2, 3, 4, 5, 6 ]
const firstName = ["John", "Jane", "Mary"]; const lastName = ["Doe", "Smith", "Doe"]; //sans le Spread Operator : const fullName1 = [firstName, lastName]; //Deux tableaux dans un tableau : console.log(fullName1); // [ [ 'John', 'Jane', 'Mary' ], [ 'Doe', 'Smith', 'Doe' ] ] //Avec le Spread Operator : const fullName2 = [...firstName, ...lastName]; //Les données sont stockées dans un unique tableau : console.log(fullName2); // [ 'John', 'Jane', 'Mary', 'Doe', 'Smith', 'Doe' ]
Décomposition d’objets :
const person = {
name: 'John',
age: 30,
job: 'developer'
};
const copy = { ...person };
console.log(copy); // { name: 'John', age: 30, job: 'developer' }Etendre les objets littéraux :
const defaults = {
width: 100,
height: 100
};
const options = {
width: 150,
color: 'red'
};
const config = { ...defaults, ...options };
console.log(config); // { width: 150, height: 100, color: 'red' }
Les opérateurs de propagation sont très utiles pour copier et fusionner des objets et des tableaux de manière simple et concise. Ils sont particulièrement utiles lorsque vous travaillez avec des fonctions qui prennent un nombre variable d’arguments ou lorsque vous voulez créer une nouvelle collection à partir de collections existantes.
La déstructuration
Technique qui vous permet de décomposer un objet ou un tableau en variables séparées. Cela peut être utile pour extraire facilement les valeurs que vous souhaitez d’un objet ou d’un tableau et les assigner à des variables.
Déstructuration d’un objet :
let obj = { a: 1, b: 2, c: 3 };
let { a, b, c } = obj;
console.log(a); // 1
console.log(b); // 2
console.log(c); // 3Déstructuration avec un tableau :
let arr = [1, 2, 3]; let [x, y, z] = arr; console.log(x); // 1 console.log(y); // 2 console.log(z); // 3
Déstructuration avec des valeurs par défaut :
let obj = { a: 1, b: 2 };
let { a, b, c = 3 } = obj;
console.log(a); // 1
console.log(b); // 2
console.log(c); // 3Déstructuration avec des alias de nom de variable :
let obj = { a: 1, b: 2 };
let { a: x, b: y } = obj;
console.log(x); // 1
console.log(y); // 2Les promesses
Les promesses sont une façon de gérer les opérations asynchrones de manière plus organisée et plus lisible. Elles permettent de représenter une valeur qui peut être disponible maintenant, dans le futur, ou jamais. Exemple :
let myPromise = new Promise((resolve, reject) => {
// Exécuter une opération asynchrone, puis appeler resolve si réussie, ou reject si elle échoue
setTimeout(() => resolve('Réussie !'), 1000);
});
myPromise.then((result) => {
// Cette fonction sera exécutée quand la promesse sera résolue
console.log(result); // "Réussie !"
});
myPromise.catch((error) => {
// Cette fonction sera exécutée quand la promesse sera rejetée
console.error(error);
});
Vous pouvez également utiliser la méthode Promise.all pour attendre que plusieurs promesses soient résolues :
let promise1 = Promise.resolve(1);
let promise2 = Promise.resolve(2);
let promise3 = Promise.resolve(3);
Promise.all([promise1, promise2, promise3]).then((results) => {
// Cette fonction sera exécutée quand toutes les promesses seront résolues
console.log(results); // [1, 2, 3]
});
Et vous pouvez utiliser la méthode Promise.race pour exécuter une fonction dès qu’une des promesses est résolue :
let promise1 = new Promise((resolve, reject) => {
setTimeout(() => resolve('Promesse 1 résolue'), 1000);
});
let promise2 = new Promise((resolve, reject) => {
setTimeout(() => resolve('Promesse 2 résolue'), 500);
});
Promise.race([promise1, promise2]).then((result) => {
// Cette fonction sera exécutée quand l'une des promesses sera résolue
console.log(result); // "Promesse 2 résolue"
});
Memoization : optimisation des appels terminaux
L’optimisation des appels terminaux en JavaScript consiste à minimiser le nombre de fois où un appel de fonction est effectué lors de l’exécution d’un programme. Cela peut être utile car les appels de fonction peuvent avoir un coût en termes de performance, en particulier lorsqu’ils sont effectués de manière répétée. Il existe plusieurs techniques pour optimiser les appels de fonction en JavaScript, notamment en utilisant des fonctions précompilées, en utilisant des méthodes de memoization et en évitant les appels de fonction inutiles. Voici un exemple simple d’utilisation de la technique de memoization pour optimiser les appels de fonction en JavaScript :
function add(a, b) {
return a + b;
}
// La fonction add peut être appelée de nombreuses fois avec les mêmes arguments.
// Par exemple, add(1, 2) peut être appelé plusieurs fois dans le même programme.
// Pour éviter de recalculer le résultat chaque fois, nous pouvons utiliser la memoization.
// La fonction suivante crée une nouvelle fonction qui mémorise les résultats de l'appel de la fonction add.
function memoizeAdd() {
// Créez un cache pour mémoriser les résultats des appels de la fonction add.
const cache = {};
return function(a, b) {
// Si les résultats de l'appel de la fonction add avec ces arguments ont déjà été mémorisés,
// retournez-les à partir du cache.
if (cache[a] && cache[a][b]) {
return cache[a][b];
}
// Sinon, calculez le résultat de l'appel de la fonction add et stockez-le dans le cache.
const result = add(a, b);
cache[a] = cache[a] || {};
cache[a][b] = result;
return result;
}
}
// Utilisez la fonction memoizeAdd pour créer une nouvelle fonction addMemoized qui mémorise les résultats des appels de la fonction add.
const addMemoized = memoizeAdd();
// Lorsque vous appelez addMemoized avec les mêmes arguments, le résultat est retourné à partir du cache au lieu d'être recalculé.
console.log(addMemoized(1, 2)); // 3
console.log(addMemoized(1, 2)); // 3 (le résultat est retourné à partir du cache)
Array.prototype.find()
La méthode find() appartient à l’objet Array. Elle permet de trouver un élément dans un tableau qui satisfait une condition donnée et retourne la première valeur trouvée. Si aucun élément n’est trouvé, elle retourne undefined :
const age = [32, 33, 16, 40, 14]; const firstChild = age.find((age) => age < 18); console.log(firstChild); //16 car seule la première valeur est retournée
La méthode find() prend en entrée une fonction qui est appelée pour chaque élément du tableau et qui doit retourner true si l’élément satisfait la condition, false dans le cas contraire. La fonction reçoit trois arguments : l’élément courant, l’index de l’élément et le tableau complet.
Array.prototype.findIndex()
La méthode findIndex() renvoie l’index du premier élément du tableau qui satisfait à la fonction de test fournie. Sinon, elle renvoie -1
const age = [32, 33, 16, 40, 14]; const firstChildIndex = age.findIndex((age) => age < 18); console.log(firstChildIndex);//2 car seul l'index de la première valeur est retourné
Array.prototype.fill()
Méthode de l’objet Array qui permet de remplir tous les éléments d’un tableau avec une valeur statique. Elle prend en argument la valeur à utiliser pour remplir le tableau, ainsi que facultativement l’index de départ et l’index de fin, qui indiquent à partir de quel index le tableau doit être rempli et jusqu’à quel index il doit être rempli. Si ces arguments ne sont pas fournis, le tableau sera rempli de la première à la dernière position.
const array = [1, 2, 3, 4, 5]; // Remplir le tableau avec la valeur 0 array.fill(0); console.log(array); // [0, 0, 0, 0, 0] // Remplir le tableau avec la valeur 0 à partir de l'index 2 jusqu'à l'index 4 array.fill(0, 2, 4); console.log(array); // [0, 0, 0, 4, 5]
Dans cet exemple, nous avons créé un tableau array avec cinq éléments. Nous avons ensuite utilisé la méthode fill() pour remplir tous les éléments du tableau avec la valeur 0. Nous avons également utilisé la méthode fill() avec des arguments de début et de fin pour remplir seulement une partie du tableau avec la valeur 0.
Notez que Array.prototype.fill() modifie le tableau original et renvoie le tableau modifié. Si vous souhaitez remplir un tableau sans modifier l’original, vous pouvez utiliser l’opérateur de spread (...) pour créer une copie du tableau avant de l’utiliser avec fill().
const array = [1, 2, 3, 4, 5]; // Créer une copie du tableau et la remplir avec la valeur 0 const filledArray = [...array].fill(0); console.log(array); // [1, 2, 3, 4, 5] console.log(filledArray); // [0, 0, 0, 0, 0]
Array.prototype.copyWithin()
Méthode de l’objet Array qui permet de copier des éléments d’un tableau vers un autre emplacement du même tableau. Elle prend en argument l’index de destination, ainsi que facultativement l’index de départ et l’index de fin, qui indiquent à partir de quel index le tableau doit être copié et jusqu’à quel index il doit être copié. Si ces arguments ne sont pas fournis, le tableau sera copié de la première à la dernière position.
const array = [1, 2, 3, 4, 5]; // Copier les éléments du tableau à partir de l'index 1 jusqu'à l'index 3 vers l'index 2 array.copyWithin(2, 1, 3); console.log(array); // Affiche [1, 2, 2, 3, 5] // Copier tous les éléments du tableau vers l'index 0 array.copyWithin(0); console.log(array); // [2, 3, 5, 3, 5]
Dans cet exemple, nous avons créé un tableau array avec cinq éléments. Nous avons ensuite utilisé la méthode copyWithin() pour copier les éléments du tableau à partir de l’index 1 jusqu’à l’index 3 vers l’index 2. Nous avons également utilisé la méthode copyWithin() sans arguments de début et de fin pour copier tous les éléments du tableau vers l’index 0.
Notez que Array.prototype.copyWithin() modifie le tableau original et renvoie le tableau modifié. Si vous souhaitez copier un tableau sans modifier l’original, vous pouvez utiliser l’opérateur de spread (...) pour créer une copie du tableau avant de l’utiliser avec copyWithin().
const array = [1, 2, 3, 4, 5]; // Créer une copie du tableau et copier les éléments vers l'index 0 const copiedArray = [...array].copyWithin(0); console.log(array); // [1, 2, 3, 4, 5] console.log(copiedArray); // [1, 2, 3, 4, 5]
String.prototype.startsWidth()
Méthode de l’objet String qui permet de déterminer si une chaîne de caractères commence par une sous-chaîne spécifiée. Elle prend en argument la sous-chaîne à chercher et renvoie true si la chaîne de caractères commence par cette sous-chaîne, et false sinon.
const string = 'Hello, world!';
console.log(string.startsWith('Hello')); // Affiche true
console.log(string.startsWith('world')); // Affiche false
console.log(string.startsWith('Hello', 1)); // Affiche falseDans cet exemple, nous avons créé une chaîne de caractères string contenant « Hello, world! ». Nous avons ensuite utilisé la méthode startsWith() pour vérifier si la chaîne de caractères commence par « Hello » ou par « world ». Nous avons également utilisé la méthode startsWith() avec un deuxième argument qui indique l’index de début de la recherche dans la chaîne de caractères.
Notez que String.prototype.startsWith() est sensible à la casse et ne prend pas en compte les diacritiques. Si vous souhaitez ignorer la casse ou tenir compte des diacritiques, vous pouvez utiliser la méthode String.prototype.toLowerCase() ou String.prototype.normalize() avant d’utiliser startsWith().
const string = 'Héllo, world!';
console.log(string.toLowerCase().startsWith('hello')); // Affiche true
console.log(string.normalize().startsWith('Héllo')); // Affiche trueString.prototype.endWidth()
Méthode de l’objet String en JavaScript qui permet de déterminer si une chaîne de caractères se termine par une sous-chaîne spécifiée. Elle prend en argument la sous-chaîne à chercher et renvoie true si la chaîne de caractères se termine par cette sous-chaîne, et false sinon.
const string = 'Hello, world!';
console.log(string.endsWith('world!')); // Affiche true
console.log(string.endsWith('Hello')); // Affiche false
console.log(string.endsWith('world!', 11)); // Affiche trueDans cet exemple, nous avons créé une chaîne de caractères string contenant « Hello, world! ». Nous avons ensuite utilisé la méthode endsWith() pour vérifier si la chaîne de caractères se termine par « world! » ou par « Hello ». Nous avons également utilisé la méthode endsWith() avec un deuxième argument qui indique l’index de fin de la recherche dans la chaîne de caractères.
String.prototype.includes()
Méthode de l’objet String qui indique si une chaîne de caractères donnée est incluse dans une autre chaîne de caractères. Cette méthode renvoie true si la chaîne de caractères se trouve dans la chaîne de caractères en question, et false dans le cas contraire.
const str = 'Ceci est une chaîne de caractères';
console.log(str.includes('chaîne')); // true
console.log(str.includes('Bonjour')); // falseLa méthode includes() prend un seul argument, qui est la chaîne de caractères à chercher dans la chaîne de caractères originale. Si la chaîne de caractères est trouvée, la méthode renvoie true, sinon elle renvoie false.
Il est également possible de spécifier un deuxième argument, qui indique l’index de départ de la recherche. Par exemple :
console.log(str.includes('chaîne', 10)); // falseDans cet exemple, la recherche commence à l’index 10 de la chaîne de caractères originale, ce qui signifie que la chaîne de caractères ‘chaîne’ n’est pas trouvée et que la méthode renvoie false.
Number.isFinite()
Méthode de l’objet Number qui indique si un nombre donné est un nombre fini ou non. Un nombre fini est un nombre qui n’est pas Infinity ni -Infinity.
console.log(Number.isFinite(15)); // true console.log(Number.isFinite(1/0)); // false console.log(Number.isFinite(-Infinity)); // false console.log(Number.isFinite(NaN)); // false
La méthode isFinite() prend un seul argument, qui est le nombre à tester. Si le nombre est fini, la méthode renvoie true, sinon elle renvoie false.
Il est important de noter que la méthode isFinite() ne peut être utilisée sur des valeurs qui ne sont pas des nombres. Si vous passez une chaîne de caractères ou un objet à la méthode isFinite(), elle renverra toujours false. Pour tester si une valeur peut être convertie en nombre fini, vous pouvez utiliser la fonction Number() comme ceci :
console.log(Number.isFinite(Number('15'))); // true
console.log(Number.isFinite(Number('hello'))); // falseLa fonction Number() essaie de convertir la valeur en nombre, et si cela réussit, la valeur convertie est passée à la méthode isFinite(). Si la conversion échoue, la fonction Number() renvoie NaN, qui est considéré comme non fini par la méthode isFinite().
Pour poursuivre vos recherches, vous trouverez d’autres informations sur le site officiel !