Introduction aux méthodes de tableau inconnues en JavaScript

Cet article présente principalement certaines méthodes de tableau que vous ne connaissez pas sur JavaScript. Les amis qui en ont besoin peuvent s'y référer

concat

<.>

var a = [1,2,3];
a.concat([4,5,6],7,8);//[1,2,3,4,5,6,7,8]

Notez que le tableau a n'a pas changé, seul un nouveau tableau est renvoyé.

copyWithin

Il accepte trois paramètres.

cible (obligatoire) : commencez à remplacer les données à partir de cette position.

start (facultatif) : commencez à lire les données à partir de cette position, la valeur par défaut est 0. S'il s'agit d'une valeur négative, elle représente la valeur réciproque.
end (facultatif) : Arrêtez de lire les données avant d'atteindre cette position. La valeur par défaut est égale à la longueur du tableau. S'il s'agit d'une valeur négative, elle représente la valeur réciproque.

Ces trois paramètres doivent tous être des valeurs numériques. Sinon, ils seront automatiquement convertis en valeurs numériques

// 将 3 号位复制到 0 号位 
[1, 2, 3, 4, 5].copyWithin(0, 3, 4) 
// [4, 2, 3, 4, 5] 
// -2 相当于 3 号位， -1 相当于 4 号位 
[1, 2, 3, 4, 5].copyWithin(0, -2, -1) 
// [4, 2, 3, 4, 5] 
// 将 3 号位复制到 0 号位 
[].copyWithin.call({length: 5, 3: 1}, 0, 3) 
// {0: 1, 3: 1, length: 5} 
// 将 2 号位到数组结束，复制到 0 号位 
var i32a = new Int32Array([1, 2, 3, 4, 5]); 
i32a.copyWithin(0, 2); 
// Int32Array [3, 4, 5, 4, 5] 
// 对于没有部署 TypedArray 的 copyWithin 方法的平台 
// 需要采用下面的写法 
[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4); 
// Int32Array [4, 2, 3, 4, 5]

entrées<🎜. >

Renvoie un objet itérable

var a = [1,2,3];
var en = a.entries();
en.next().value;//[0.1];

chaque

Chaque élément renvoie vrai via la fonction de test, sinon il renvoie false

function isBigEnough(element, index, array) {
 return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is true

fill

Ce qui change, c'est le tableau lui-même

[1, 2, 3].fill(4)   // [4, 4, 4]
[1, 2, 3].fill(4, 1)   // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2)  // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1)  // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2) // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN) // [1, 2, 3]
Array(3).fill(4);   // [4, 4, 4]
[].fill.call({length: 3}, 4) // {0: 4, 1: 4, 2: 4, length: 3}

filter

Renvoie un nouveau tableau

function isBigEnough(value) {
 return value >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

findLa méthode renvoie le premier élément de le tableau qui satisfait à la fonction de test fournie La valeur d'un élément. Sinon, la méthode return undefind

function isBigEnough(element) {
 return element >= 15;
}
[12, 5, 8, 130, 44].find(isBigEnough); // 130

findIndexfindIndex() renvoie l'index du premier élément du tableau qui satisfait au test fourni fonction . Sinon, -1 est renvoyé.

function isBigEnough(element) {
 return element >= 15;
}
[12, 5, 8, 130, 44].findIndex(isBigEnough); // 3

forEach

rappel

let a = ['a', 'b', 'c'];
a.forEach(function(element) {
 console.log(element);
});
// a
// b
// c
//语法
array.forEach(callback(currentValue, index, array){
 //do something
}, this)
array.forEach(callback[, thisArg])

Remarque : il n'y a aucun moyen d'abandonner ou sortir de la boucle forEach, sauf en lançant une exception. Si vous en avez besoin, utiliser la méthode forEach() est erroné et vous pouvez utiliser une simple boucle à la place. Si vous testez si un élément d'un tableau répond à une certaine condition et devez renvoyer une valeur booléenne, utilisez Array.every,Array.some. Si disponibles, les nouvelles méthodes find() ou findIndex() peuvent également être utilisées pour terminer plus tôt les tests de vérité.

为数组中每个元素执行的函数，该函数接收三个参数：
currentValue(当前值)
数组中正在处理的当前元素。
index(索引)
数组中正在处理的当前元素的索引。
array
forEach()方法正在操作的数组。
thisArg可选
可选参数。当执行回调 函数时用作this的值(参考对象)

include

Parameters

arr.includes(searchElement)
arr.includes(searchElement, fromIndex)

searchElement

La valeur de l'élément à trouver.

fromIndex

Facultatif

Démarrez la recherche searchElement

à cet index. Si négatif, la recherche commence à l’index de array.length + fromIndex par ordre croissant. La valeur par défaut est 0.

Valeur de retour

Un booléen.

[1, 2, 3].includes(2);  // true
[1, 2, 3].includes(4);  // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

indexOf

Paramètres

arr.indexOf(searchElement)
arr.indexOf(searchElement[, fromIndex = 0])

searchElement

L'élément à trouver

fromIndex

La position pour commencer la recherche. Si la valeur de l'index est supérieure ou égale à la longueur du tableau, cela signifie que la recherche ne sera pas effectuée dans le tableau et -1 sera renvoyé. Si la valeur d'index fournie dans le paramètre est une valeur négative, elle est traitée comme un décalage par rapport à la fin du tableau, c'est-à-dire -1 signifie partir du dernier élément, -2 signifie commencer de l'avant-dernier élément, et ainsi de suite. . Remarque : Si la valeur d'index fournie dans le paramètre est une valeur négative, le tableau sera toujours interrogé d'avant en arrière. Si la valeur de l'index de décalage est toujours inférieure à 0, l'ensemble du tableau sera interrogé. Sa valeur par défaut est 0.

Valeur de retour

La position d'index du premier élément trouvé dans le tableau s'il n'est pas trouvé, -1 est renvoyé

< La méthode keys() renvoie une nouvelle itération Array. La méthode map() crée un nouveau tableau dont le résultat est le résultat de l'appel d'une fonction fournie sur chaque élément du tableau.

let a = [2, 9, 7, 8, 9]; 
a.indexOf(2); // 0 
a.indexOf(6); // -1
a.indexOf(7); // 2
a.indexOf(8); // 3
a.indexOf(9); // 1
if (a.indexOf(3) === -1) {
 // element doesn't exist in array
}

callbackUne fonction qui génère de nouveaux éléments de tableau, en utilisant trois paramètres :

currentValue

str = arr.join()
// 默认为 ","
str = arr.join("")
// 分隔符 === 空字符串 ""
str = arr.join(separator)
// 分隔符

Le premier paramètre de rappel, dans le tableau L'élément en cours de traitement. indexLe deuxième paramètre de rappel, l'index de l'élément actuel en cours de traitement dans le tableau.

array

let arr = ["a", "b", "c"];
let iterator = arr.keys();
// undefined
console.log(iterator);
// Array Iterator {}
console.log(iterator.next()); 
// Object {value: 0, done: false}
console.log(iterator.next()); 
// Object {value: 1, done: false}
console.log(iterator.next()); 
// Object {value: 2, done: false}
console.log(iterator.next()); 
// Object {value: undefined, done: true}

Le troisième paramètre du rappel, le tableau dans lequel la méthode map est appelée.

thisArgFacultatif. La valeur this utilisée lors de l'exécution de la fonction de rappel.

Valeur de retour

Un nouveau tableau, chaque élément est le résultat de la fonction de rappel. La méthode pop() supprime le dernier élément du tableau et renvoie la valeur de l'élément. Cette méthode modifie la longueur du tableau. La méthode

let array = arr.map(function callback(currentValue, index, array) { 
 // Return element for new_array 
}[, thisArg])
let numbers = [1, 5, 10, 15];
let doubles = numbers.map((x) => {
 return x * 2;
});
// doubles is now [2, 10, 20, 30]
// numbers is still [1, 5, 10, 15]
let numbers = [1, 4, 9];
let roots = numbers.map(Math.sqrt);
// roots is now [1, 2, 3]
// numbers is still [1, 4, 9]

push() ajoute un ou plusieurs éléments à la fin du tableau et renvoie la nouvelle longueur du tableau.

arr.push(element1, ..., elementN)

Fusionner deux tableaux

Cet exemple utilise apply() pour ajouter tous les éléments du deuxième tableau.

Notez qu'il ne faut pas utiliser cette méthode pour fusionner des tableaux lorsque le deuxième tableau (comme moreVegs dans l'exemple) est trop grand, car en fait il y a une limite au nombre de paramètres qu'une fonction peut accepter. Pour plus de détails, veuillez vous référer aux méthodes apply()

reduce et réduireRight

reduce() pour chaque élément de l'accumulateur. et tableau (de gauche à droite) Appliquer une fonction pour la réduire à une valeur unique.

array.reduce(function(accumulator, currentValue, currentIndex, array), initialValue)
var total = [0, 1, 2, 3].reduce(function(sum, value) {
 return sum + value;
}, 0);
// total is 6
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
 return a.concat(b);
}, []);
// flattened is [0, 1, 2, 3, 4, 5]

callback

执行数组中每个值的函数，包含四个参数

accumulator

上一次调用回调返回的值，或者是提供的初始值（initialValue）

currentValue

数组中正在处理的元素

currentIndex

数据中正在处理的元素索引，如果提供了 initialValue ，从0开始；否则从1开始

array

调用 reduce 的数组

initialValue

可选项，其值用于第一次调用 callback 的第一个参数。如果没有设置初始值，则将数组中的第一个元素作为初始值。空数组调用reduce时没有设置初始值将会报错。

PS: 与 reduceRight()和reduce() 的执行方向相反

reverse

reverse 方法颠倒数组中元素的位置，并返回该数组的引用。

shift与unshift

shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。

unshift() 方法将一个或多个元素添加到数组的开头，并返回新数组的长度。

slice

slice() 方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象。原始数组不会被修改。

arr.slice();
//[0,end];
arr.slice(start);
//[start,end];
arr.slice(start,end);
//[start,end];

slice不修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。原数组的元素会按照下述规则拷贝：

如果该元素是个对象引用 （不是实际的对象），slice会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数组中的这个元素也会发生改变。

对于字符串、数字及布尔值来说不是String、Number或者Boolean，slice会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响另一个数组。

如果向两个数组任一中添加了新元素，则另一个不会受到影响

some

some() 方法测试数组中的某些元素是否通过由提供的函数实现的测试。

const isBiggerThan10 = (element, index, array) => {
 return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10); 
// false
[12, 5, 8, 1, 4].some(isBiggerThan10); 
// true

toLocaleString与toString

toLocaleString() 返回一个字符串表示数组中的元素。数组中的元素将使用各自的 toLocaleString 方法转成字符串，这些字符串将使用一个特定语言环境的字符串（例如一个逗号 ","）隔开。

var number = 1337;
var date = new Date();
var myArr = [number, date, "foo"];
var str = myArr.toLocaleString(); 
console.log(str); 
// 输出 "1,337,2017/8/13 下午8:32:24,foo"
// 假定运行在中文（zh-CN）环境，北京时区
var a=1234
a.toString()
//"1234"
a.toLocaleString()
//"1,234"
//当数字是四位及以上时，toLocaleString()会让数字三位三位一分隔，像我们有时候数字也会三位一个分号
var sd=new Date()
sd
//Wed Feb 15 2017 11:21:31 GMT+0800 (CST)
sd.toLocaleString()
//"2017/2/15 上午11:21:31"
sd.toString()
//"Wed Feb 15 2017 11:21:31 GMT+0800 (CST)"

splice

splice() 方法通过删除现有元素和/或添加新元素来更改一个数组的内容。

array.splice(start)
array.splice(start, deleteCount) 
array.splice(start, deleteCount, item1, item2, ...)

start

指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从1计数）。

deleteCount 可选

整数，表示要移除的数组元素的个数。如果 deleteCount 是 0，则不移除元素。这种情况下，至少应添加一个新元素。如果 deleteCount 大于start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。

如果deleteCount被省略，则其相当于(arr.length - start)。

item1, item2, ... 可选

要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。

返回值

由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!