Création de tableau

Array.of()

Utilise toutes les valeurs des arguments comme éléments pour former un tableau.

console.log(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4] //Les valeurs des arguments peuvent être de types différents. console.log(Array.of(1, '2', true)); // [1, '2', true] //Renvoie un tableau vide lorsqu'aucun argument n'est passé. console.log(Array.of()); // []

Array.from()

Convertit un objet semblable à un tableau ou un objet itérable en un tableau.

//Si l'argument est un tableau, renvoie un tableau identique au tableau d'origine. console.log(Array.from([1, 2])); // [1, 2] //Si l'argument contient des emplacements vides. console.log(Array.from([1, , 3])); // [1, undefined, 3]

Parameters

Array.from(arrayLike[, mapFn[, thisArg]])

La valeur de retour est le tableau converti.

arrayLike

L'objet semblable à un tableau ou l'objet itérable à convertir.

console.log(Array.from([1, 2, 3])); // [1, 2, 3]

mapFn

Facultatif. La fonction map, utilisée pour traiter chaque élément ; les éléments traités sont placés dans le tableau.

console.log(Array.from([1, 2, 3], (n) => n * 2)); // [2, 4, 6]

thisArg

Facultatif. Utilisé pour spécifier l'objet `this` lors de l'exécution de la fonction map.

let map = { do: function(n) { return n * 2; } } let arrayLike = [1, 2, 3]; console.log(Array.from(arrayLike, function (n){ return this.do(n); }, map)); // [2, 4, 6]

Objets de type tableau

Un objet de type tableau doit avoir une propriété `length`, et les noms des propriétés des éléments doivent être numériques ou des chaînes convertibles en nombres.

let arr = Array.from({ 0: '1', 1: '2', 2: 3, length: 3 }); console.log(arr); // ['1', '2', 3] //Si aucune propriété `length` n'existe, un tableau vide est renvoyé. let array = Array.from({ 0: '1', 1: '2', 2: 3, }); console.log(array); // [] //Si les noms de propriété des éléments ne sont pas numériques et ne peuvent pas être convertis en nombres, un tableau de longueur `length` avec des valeurs d'élément `undefined` est renvoyé. let array1 = Array.from({ a: 1, b: 2, length: 2 }); console.log(array1); // [undefined, undefined]

Conversion d'objets itérables

Conversion de Map

let map = new Map(); map.set('key0', 'value0'); map.set('key1', 'value1'); console.log(Array.from(map)); // [['key0', 'value0'],['key1', // 'value1']]

Conversion de Set

let arr = [1, 2, 3]; let set = new Set(arr); console.log(Array.from(set)); // [1, 2, 3]

Conversion de chaînes

let str = 'abc'; console.log(Array.from(str)); // ["a", "b", "c"]

Méthodes étendues

Find

find()

Trouve un élément dans le tableau qui remplit la condition ; s’il y a plusieurs éléments correspondants, renvoie le premier.

let arr = Array.of(1, 2, 3, 4); console.log(arr.find(item => item > 2)); // 3 //Les emplacements vides du tableau sont traités comme `undefined`. console.log([, 1].find(n => true)); // undefined

findIndex()

Trouve l'indice d'un élément du tableau qui remplit la condition ; s'il y a plusieurs éléments correspondants, renvoie l'indice du premier.

let arr = Array.of(1, 2, 1, 3); //Paramètre 1 : fonction de rappel //Paramètre 2 (facultatif) : spécifie la valeur `this` dans la fonction de rappel. console.log(arr.findIndex(item => item == 2)); // 1 //Les emplacements vides du tableau sont traités comme `undefined`. console.log([, 1].findIndex(n => vrai)); //0

Remplissage

fill()

Remplit les éléments du tableau dans une plage d'indices spécifiée avec une seule valeur spécifiée.

let arr = Array.of(1, 2, 3, 4); //Paramètre 1 : la valeur à utiliser pour le remplissage //Paramètre 2 : l'indice de début de remplissage //Paramètre 3 (facultatif) : l'indice de fin de remplissage, par défaut, la fin du tableau. console.log(arr.fill(0,1,2)); // [1, 0, 3, 4]

copyWithin()

Modifie les éléments du tableau dans une plage d'indices spécifiée en les remplaçant par les éléments d'une autre plage d'indices spécifiée du même tableau.

//Paramètre 1 : l'indice de début à modifier //Paramètre 2 : l'indice de début des données utilisées pour l'écrasement //Paramètre 3 (facultatif) : l'indice de fin des données utilisées pour l'écrasement, par défaut, la fin du tableau. console.log([1, 2, 3, 4].copyWithin(0,2,4)); // [3, 4, 3, 4] //Un paramètre négatif 1 indique que le comptage part de la fin. console.log([1, 2, 3, 4].copyWithin(-2, 0)); // [1, 2, 1, 2] console.log([1, 2, ,4].copyWithin(0, 2, 4)); // [, 4, , 4]

Itération

entries()

Itère sur les paires clé-valeur.

for(let [key, value] of ['a', 'b'].entries()){ console.log(key, value); } // 0 "a" // 1 "b" //N’utilise pas de boucle for...of. let entries = ['a', 'b'].entries(); console.log(entries.next().value); // [0, "a"] console.log(entries.next().value); // [1, "b"] //Le tableau contient des emplacements vides. console.log([...[,'a'].entries()]); // [[0, undefined], [1, "a"]]

keys()

Itère sur les clés.

for(let key of ['a', 'b'].keys()){ console.log(key); } // 0 // 1 //Le tableau contient des emplacements vides. console.log([...[,'a'].keys()]); // [0, 1]

values()

Itère sur les valeurs.

for(let value of ['a', 'b'].values()){ console.log(value); } // "a" // "b" //Le tableau contient des emplacements vides. console.log([...[,'a'].values()]); // [undefined, "a"]

Comprend

includes()

Indique si le tableau contient la valeur spécifiée.

Remarque : à distinguer des méthodes `has` de Set et Map ; la méthode `has` de Set sert à rechercher des valeurs ; la méthode `has` de Map sert à rechercher des clés.

//Paramètre 1 : la valeur spécifiée dont il faut vérifier l'inclusion [1, 2, 3].includes(1); // true //Paramètre 2 : facultatif, l'indice de départ pour la recherche, vaut 0 par défaut. [1, 2, 3].includes(1, 2); // false //Vérification de la présence de NaN [1, NaN, 3].includes(NaN); // true

Aplatir des tableaux imbriqués en tableaux unidimensionnels

flat()

console.log([1 ,[2, 3]].flat()); // [1, 2, 3] //Spécifiez le nombre de niveaux d'imbrication à aplatir. console.log([1, [2, [3, [4, 5]]]].flat(2)); // [1, 2, 3, [4, 5]] //Quel que soit le nombre de niveaux imbriqués. console.log([1, [2, [3, [4, 5]]]].flat(Infinity)); // [1, 2, 3, 4, 5] //Ignore automatiquement les emplacements vides. console.log([1, [2, , 3]].flat());<p> // [1, 2, 3]
flatMap()

Traite d'abord chaque élément du tableau, puis exécute la méthode flat() sur le tableau.

//Paramètre 1 : une fonction de rappel ; cette fonction de rappel peut accepter 3 paramètres : l'élément actuel, l'index de l'élément actuel et le tableau d'origine. //Paramètre 2 : spécifie la valeur `this` dans la fonction de rappel. console.log([1, 2, 3].flatMap(n => [n * 2])); // [2, 4, 6]

ArrayBuffer

Un ArrayBuffer est un segment d'adresses en mémoire.

La base des tableaux typés.

Le nombre réel d'octets est déterminé au moment de la création. Ensuite, seules les données qu'il contient peuvent être modifiées ; sa taille ne peut pas être modifiée.

Création d'un ArrayBuffer

Créé via le constructeur :

let buffer = new ArrayBuffer(10); console.log(buffer.byteLength); // 10Découpage d'un ArrayBuffer existantlet buffer = new ArrayBuffer(10); let buffer1 = buffer.slice(1, 3); console.log(buffer1.byteLength); // 2

Vue

Une vue est une interface utilisée pour manipuler la mémoire.

Une vue peut opérer sur un ArrayBuffer ou un sous-ensemble des octets de celui-ci, et lit et écrit des données selon l'un des types de données numériques.

Le type DataView est une vue générique d'ArrayBuffer qui prend en charge les 8 types de données numériques.

Création :

//Par défaut, une DataView peut opérer sur l'intégralité du contenu de l'ArrayBuffer. let buffer = new ArrayBuffer(10); dataView = new DataView(buffer); dataView.setInt8(0,1); console.log(dataView.getInt8(0)); // 1 //Spécifiez la plage d'octets sur laquelle le DataView peut opérer en définissant l'offset (paramètre 2) et la longueur (paramètre 3). let buffer1 = new ArrayBuffer(10); dataView1 = new DataView(buffer1, 0, 3); dataView1.setInt8(5,1); // RangeError

Tableaux typés

Vues d'un type spécifique pour l'ArrayBuffer.

Vous pouvez forcer l'utilisation d'un type de données spécifique au lieu d'utiliser un objet DataView générique pour manipuler l'ArrayBuffer.

Création

Généré à partir d'un ArrayBuffer.

let buffer = new ArrayBuffer(10), view = new Int8Array(buffer); console.log(view.byteLength); // 10

Par le constructeur.

let view = new Int32Array(10); console.log(view.byteLength); // 40 console.log(view.length); // 10 //Si aucun paramètre n'est passé, la longueur par défaut est 0. //Dans ce cas, aucun espace n'est alloué pour l'ArrayBuffer, et le tableau typé créé ne peut pas être utilisé pour stocker des données. let view1 = new Int32Array(); console.log(view1.byteLength); // 0 console.log(view1.length); // 0 //Les paramètres acceptables incluent les tableaux typés, les objets itérables, les tableaux et les objets de type tableau. let arr = Array.from({ 0: '1', 1: '2', 2: 3, length: 3 }); let view2 = new Int16Array([1, 2]), view3 = new Int32Array(view2), view4 = new Int16Array(new Set([1, 2, 3])), view5 = new Int16Array([1, 2, 3]), view6 = new Int16Array(arr); console.log(view2 .buffer === view3.buffer); // false console.log(view4.byteLength); // 6 console.log(view5.byteLength); // 6 console.log(view6.byteLength); // 6

Points à noter

La propriété `length` n'est pas accessible en écriture. Si vous essayez de modifier cette valeur, l'opération est silencieusement ignorée en mode non strict, et une erreur est levée en mode strict.

let view = new Int16Array([1, 2]); view.length = 3; console.log(view.longueur); // 2

Les tableaux typés peuvent être parcourus à l'aide de entries(), keys() et values().

let view = new Int16Array([1, 2]); for(let [k, v] of view.entries()){ console.log(k, v); } // 0 1 // 1 2

Des méthodes telles que find() peuvent également être utilisées sur les tableaux typés, mais les méthodes des tableaux typés vérifient en plus si le type numérique est sûr, et utilisent aussi Symbol.species pour confirmer que la valeur de retour de la méthode est un tableau typé plutôt qu'un tableau normal. La méthode concat() ne peut pas être utilisée sur les tableaux typés car le résultat de la fusion de deux tableaux typés est incertain ; de plus, comme la taille d'un tableau typé ne peut pas être modifiée, les méthodes qui peuvent modifier la taille d'un tableau, telles que splice(), ne s'appliquent pas aux tableaux typés.

let view = new Int16Array([1, 2]); view.trouver((n) > 1); // 2

Tous les tableaux typés contiennent des méthodes statiques of() et from(), dont le comportement est similaire à Array.of() et Array.from() respectivement. La différence est que les méthodes des tableaux typés renvoient un tableau typé, tandis que les méthodes des tableaux normaux renvoient un tableau normal.

let view = Int16Array.of(1, 2); console.log(view instanceof Int16Array); // true

Les tableaux typés ne sont pas des tableaux normaux et n'héritent pas de Array.

let view = new Int16Array([1, 2]); console.log(Array.isArray(view)); // false

Les tableaux typés ajoutent les méthodes set() et subarray(). La méthode set() sert à copier d'autres tableaux dans un tableau typé existant, et subarray() sert à extraire une partie d'un tableau typé existant pour former un nouveau tableau typé.

//méthode set //Paramètre 1 : un tableau typé ou un tableau normal. //Paramètre 2 : facultatif, le décalage, la position où commence l'insertion des données, 0 par défaut. let view= new Int16Array(4); view.set([1, 2]); view.set([3, 4], 2); console.log(view); // [1, 2, 3, 4] //méthode subarray //Paramètre 1 : facultatif, la position de départ. //Paramètre 2 : facultatif, la position de fin (non incluse). let view= new Int16Array([1, 2, 3, 4]), subview1 = view.subarray(), subview2 = view.subarray(1), subview3 = view.subarray(1, 3); console.log(subview1); // [1, 2, 3, 4] console.log(subview2); // [2, 3, 4] console.log(subview3); // [2, 3]

Opérateur de décomposition

Copie de tableaux

let arr = [1, 2], arr1 = [...arr]; console.log(arr1); // [1, 2] //Le tableau contient des emplacements vides. let arr2 = [1, , 3], arr3 = [...arr2]; console.log(arr3); [1, undefined, 3]

Fusion de tableaux

console.log([...[1, 2],...[3, 4]]); // [1, 2, 3, 4]