Résumé des méthodes de tableau JS array

1.ArrayMéthodes de tableau

• MutatorMéthodes——"Méthode de mutation" changera le tableau par lui-même value;

• AccessorMéthode - "Méthode d'accès" ne changera pas la valeur du tableau lui-même

• IterationMéthode— ———"Méthode de parcours";

2.MutatorMéthode

• ①[ ].push—作用 : Ajoutez un ou plusieurs éléments à la fin du tableau, 传参 : (un ou plusieurs éléments du tableau) ; 返回值 : La longueur du nouveau tableau

   //标准用法
   arr.push(el1, el2 ……elN)；
   //合并两个数组
   [].push.apply(arr1, arr2)

• ②[].pop(), 作用 : supprime le dernier élément, 传参 : aucun 返回值 : élément supprimé ;

  //标准用法
  let a = [1 ,2 ,3 ];
  a.pop();//3

• ③[ ].unshift—作用 : Ajoutez un ou plusieurs éléments au début du tableau, 传参 : (un ou plusieurs éléments du tableau);返回值 : la longueur du nouveau tableau ;

   //标准用法
   arr.unshift(el1, el2 ……elN)；

• ④[].shift(), 作用 : supprimer le premier élément, 传参 : aucun 返回值 : élément supprimé ; .

  //标准用法
  let a = [1 ,2 ,3 ];
  a.shift();//1

• ⑤[].reverse(), 作用 : position inversée des éléments du tableau, 传参 : Aucun 返回值 : tableau inversé.

  //标准用法
  arr.reverse()

• ⑥[].splice(), 作用 : position inversée des éléments du tableau, 传参 : (index, numéro à supprimer [select], élément à ajouter [select ] ); 返回值 : un tableau composé d'éléments supprimés.

  //标准用法
  array.splice(start)
  array.splice(start, deleteCount) 
  array.splice(start, deleteCount, item1, item2, ...)

• ⑦[].fill(), 作用 : Remplissez tous les éléments d'un tableau de l'index de début à l'index de fin avec une valeur fixe, 传参 : (Utilisez Pour remplissez la valeur de l'élément du tableau, commençant l'index [select], terminant l'index [select]); 返回值 : tableau modifié.

  //标准用法
  arr.fill(value) 
  arr.fill(value, start) 
  arr.fill(value, start, end)
  //例子
  [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]

• ⑧[].sort(), 作用 : Trier les éléments du tableau et renvoyer le tableau, 传参 : (fonction pour préciser l'ordre de tri [facultatif]) ; 返回值 : Tableau organisé.

  //标准用法
  arr.sort() 
  arr.sort(compareFunction)
  //例子
  var numbers = [4, 2, 5, 1, 3];
  numbers.sort(function(a, b) {
  return a - b;
  });// [1, 2, 3, 4, 5]

3.AccessorMéthode

• ①[ ].join— 作用 : Concatène tous les éléments d'un tableau (ou d'un objet de type tableau) en une chaîne. , 传参 : (spécifiez une chaîne pour séparer chaque élément du tableau [facultatif]) ; 返回值 : une chaîne reliant tous les éléments du tableau

  //标准用法
  var a = ['Wind', 'Rain', 'Fire'];
  var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"
  var myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"

• ②<🎜 ; >—[ ].concat : Union de deux ou plusieurs tableaux. , 作用 : (Connectez des tableaux et/ou des valeurs dans un nouveau tableau [facultatif]) ; 传参 : Tableau fusionné 返回值

  //标准用法
  var alpha = ['a', 'b', 'c'];
  var numeric = [1, 2, 3];
  alpha.concat(numeric);
  //['a', 'b', 'c', 1, 2, 3]

• ③

  — [ ].slice : La méthode renvoie une copie superficielle d'une partie du tableau sélectionné du début à la fin (exclusive) vers un nouveau tableau. , 作用 : (index de début [select], index de fin [select]); 传参 : tableau tronqué 返回值

  //标准用法
  var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
  var citrus = fruits.slice(1, 3);
  //['Orange','Lemon'] 
    //类数组转数组
  function list() {
   return [].slice.call(arguments)}
  var list1 = list(1, 2, 3); // [1, 2, 3]

• ④

  —[ ].toString : Renvoie une chaîne représentant le tableau spécifié et ses éléments, 作用 : (aucun) ; 传参 : chaîne convertie (返回值) =[].join()

  //标准用法
  var monthNames = ['Jan', 'Feb', 'Mar', 'Apr'];
  var myVar = monthNames.toString(); // assigns "Jan,Feb,Mar,Apr" to myVar.

• ⑤

  —[ ].includes : Détermine si un tableau contient une valeur spécifiée, 作用 : (l'élément à trouver) 传参 : vrai ou faux ; 返回值—

  : Le premier index où un élément donné peut être trouvé dans le tableau,

  //标准用法
  let a = [1, 2, 3];
  a.includes(2); // true 
  a.includes(4); // false

  : (l'élément à trouver
: Introuvable - 1. Rechercher l'index ;

• [ ].indexOf作用传参返回值4.

  Méthode

  var array = [2, 5, 9];
  array.indexOf(2);     // 0
  array.indexOf(7);     // -1

Iteration

• ①

  —
   : Chaque élément exécute la fonction fournie une fois,

   : (callback(current element, index, the Array));

• [ ].forEach②作用—传参 : renvoie la valeur du premier élément du tableau qui satisfait à la fonction de test fournie, 返回值 : (rappel (élément actuel , index, le tableau));

  : l'élément (

   //标准用法
   array.forEach(callback(currentValue, index, array){
   //do something
  }, this)

  renvoie l'index)

• [ ].find作用③传参 —返回值 : Créer un nouveau tableau contenant tous les éléments du test implémenté par la fonction fournie, [].findIndex(): (callback(current element, index, the array));

  : Une collection d'éléments qui réussissent le test Array of;

   //标准用法
   let arr = array. filter(callback(currentValue, index, array){
   //do something
   }, this)

• ④[ ].map—作用：创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。，传参：（callback(当前元素,索引，该数组)）；返回值：一个新数组，每个元素都是回调函数的结果；

   //标准用法
   var numbers = [1, 4, 9];
   var roots = numbers.map(Math.sqrt);
   // roots的值为[1, 2, 3], numbers的值仍为[1, 4, 9]

• ⑤[ ].every—作用：测试数组的所有元素是否都通过了指定函数的测试；传参：（callback(当前元素,索引，该数组)）；返回值：true或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

• ⑥[ ].some—作用：测试数组的某些元素是否都通过了指定函数的测试；传参：（callback(当前元素,索引，该数组)）；返回值：true或false；

     //标准用法
     function isBigEnough(element, index, array) {
      return (element >= 10);}
     var passed = [1, 5, 8, 3, 4].some(isBigEnough);// passed is false
     passed = [2, 4, 18, 13, 4].some(isBigEnough);// passed is true

• ⑦[ ].reduce—作用：对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个值；传参：（callback(累加器accumulator，当前元素,索引，该数组)）；返回值：函数累计处理的结果；

     //标准用法
     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]

• ⑧[ ].entries—作用：返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对；传参：（无)）；返回值：一个新的 Array 迭代器对象；

     //标准用法
     var arr = ["a", "b", "c"];
     var iterator = arr.entries();// undefined
     console.log(iterator);// Array Iterator {}
     console.log(iterator.next().value); // [0, "a"]
     console.log(iterator.next().value); // [1, "b"]
     console.log(iterator.next().value); // [2, "c"]

• ⑨[ ].values—作用：数组转对象；传参：（无)）；返回值：一个新的 Array 迭代器对象；

     //标准用法
     let arr = ['w', 'y', 'k', 'o', 'p'];
     let eArr = arr.values();// 您的浏览器必须支持 for..of 循环
     // 以及 let —— 将变量作用域限定在 for 循环中
    for (let letter of eArr) {
           console.log(letter);}

参考资料：https://developer.mozilla.org...




1.Array数组的方法

• Mutator方法————"突变方法"会改变数组自身的值；

• Accessor方法————"访问方法"不会改变数组自身的值；

• Iteration方法————"遍历的方法" ；

2.Mutator方法

• ①[ ].push—作用：将一个或多个元素添加到数组的末尾，传参：（单个或多个数组元素）；返回值：新数组的长度；

   //标准用法
   arr.push(el1, el2 ……elN)；
   //合并两个数组
   [].push.apply(arr1, arr2)

• ②[].pop()，作用：删除最后一个元素，传参：无；返回值：删除的元素。

  //标准用法
  let a = [1 ,2 ,3 ];
  a.pop();//3

• ③[ ].unshift—作用：将一个或多个元素添加到数组的开头，传参：（单个或多个数组元素）；返回值：新数组的长度；

   //标准用法
   arr.unshift(el1, el2 ……elN)；

• ④[].shift()，作用：删除第一个元素，传参：无；返回值：删除的元素。

  //标准用法
  let a = [1 ,2 ,3 ];
  a.shift();//1

• ⑤[].reverse()，作用：数组元素颠倒位置，传参：无；返回值：颠倒后的数组。

  //标准用法
  arr.reverse()

• ⑥[].splice()，作用：数组元素颠倒位置，传参：（索引，删除个数【选】，要添加的元素【选】）；返回值：被删除的元素组成的一个数组。

  //标准用法
  array.splice(start)
  array.splice(start, deleteCount) 
  array.splice(start, deleteCount, item1, item2, ...)

• ⑦[].fill()，作用：用一个固定值填充一个数组中从起始索引到终止索引内的全部元素，传参：（用来填充数组元素的值，起始索引【选】，终止索引【选】）；返回值：修改后的数组。

  //标准用法
  arr.fill(value) 
  arr.fill(value, start) 
  arr.fill(value, start, end)
  //例子
  [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]

• ⑧[].sort()，作用：对数组的元素进行排序，并返回数组，传参：（指定排列顺序的函数【选】）；返回值：排列后的数组。

  //标准用法
  arr.sort() 
  arr.sort(compareFunction)
  //例子
  var numbers = [4, 2, 5, 1, 3];
  numbers.sort(function(a, b) {
  return a - b;
  });// [1, 2, 3, 4, 5]

3.Accessor方法

• ①[ ].join—作用：将数组（或一个类数组对象）的所有元素连接到一个字符串中。，传参：（指定一个字符串来分隔数组的每个元素【选】）；返回值：一个所有数组元素连接的字符串；

  //标准用法
  var a = ['Wind', 'Rain', 'Fire'];
  var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"
  var myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"

• ②[ ].concat—作用：并两个或多个数组。，传参：（将数组和/或值连接成新数组【选】）；返回值：合并后的数组；

  //标准用法
  var alpha = ['a', 'b', 'c'];
  var numeric = [1, 2, 3];
  alpha.concat(numeric);
  //['a', 'b', 'c', 1, 2, 3]

• ③[ ].slice—作用：方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组。，传参：（开始索引【选】，结束索引【选】）；返回值：截去后的数组；

  //标准用法
  var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
  var citrus = fruits.slice(1, 3);
  //['Orange','Lemon'] 
    //类数组转数组
  function list() {
   return [].slice.call(arguments)}
  var list1 = list(1, 2, 3); // [1, 2, 3]

• ④[ ].toString—作用：返回一个字符串，表示指定的数组及其元素，传参：（无）；返回值：转化成的字符串；（=[].join()）

  //标准用法
  var monthNames = ['Jan', 'Feb', 'Mar', 'Apr'];
  var myVar = monthNames.toString(); // assigns "Jan,Feb,Mar,Apr" to myVar.

• ⑤[ ].includes—作用：判断一个数组是否包含一个指定的值，传参：（要查找的元素）；返回值：true或 false；

  //标准用法
  let a = [1, 2, 3];
  a.includes(2); // true 
  a.includes(4); // false

• ⑥[ ].indexOf—作用：在数组中可以找到一个给定元素的第一个索引，传参：（要查找的元素）；返回值：找不到-1，找得到索引；

  var array = [2, 5, 9];
  array.indexOf(2);     // 0
  array.indexOf(7);     // -1

4.Iteration方法

• 
  

• ①[ ].forEach—作用：每个元素执行一次提供的函数，传参：（callback(当前元素,索引，该数组)）；返回值：无；

   //标准用法
   array.forEach(callback(currentValue, index, array){
   //do something
  }, this)

• ②[ ].find—作用：返回数组中满足提供的测试函数的第一个元素的值，传参：（callback(当前元素,索引，该数组)）；返回值：该元素；（[].findIndex()返回索引）

   //标准用法
   array. find(callback(currentValue, index, array){
   //do something
  }, this)

• ③[ ].filter—作用：创建一个新数组, 其包含通过所提供函数实现的测试的所有元素，传参：（callback(当前元素,索引，该数组)）；返回值：通过测试的元素的集合的数组；

   //标准用法
   let arr = array. filter(callback(currentValue, index, array){
   //do something
   }, this)

• ④[ ].map—作用：创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。，传参：（callback(当前元素,索引，该数组)）；返回值：一个新数组，每个元素都是回调函数的结果；

   //标准用法
   var numbers = [1, 4, 9];
   var roots = numbers.map(Math.sqrt);
   // roots的值为[1, 2, 3], numbers的值仍为[1, 4, 9]

• ⑤[ ].every—作用：测试数组的所有元素是否都通过了指定函数的测试；传参：（callback(当前元素,索引，该数组)）；返回值：true或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

• ⑥[ ].some—作用：测试数组的某些元素是否都通过了指定函数的测试；传参：（callback(当前元素,索引，该数组)）；返回值：true或false；

     //标准用法
     function isBigEnough(element, index, array) {
      return (element >= 10);}
     var passed = [1, 5, 8, 3, 4].some(isBigEnough);// passed is false
     passed = [2, 4, 18, 13, 4].some(isBigEnough);// passed is true

• ⑦[ ].reduce—作用：对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个值；传参：（callback(累加器accumulator，当前元素,索引，该数组)）；返回值：函数累计处理的结果；

     //标准用法
     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]

• ⑧[ ].entries—作用：返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对；传参：（无)）；返回值：一个新的 Array 迭代器对象；

     //标准用法
     var arr = ["a", "b", "c"];
     var iterator = arr.entries();// undefined
     console.log(iterator);// Array Iterator {}
     console.log(iterator.next().value); // [0, "a"]
     console.log(iterator.next().value); // [1, "b"]
     console.log(iterator.next().value); // [2, "c"]

• ⑨[ ].values—作用：数组转对象；传参：（无)）；返回值：一个新的 Array 迭代器对象；

     //标准用法
     let arr = ['w', 'y', 'k', 'o', 'p'];
     let eArr = arr.values();// 您的浏览器必须支持 for..of 循环
     // 以及 let —— 将变量作用域限定在 for 循环中
    for (let letter of eArr) {
           console.log(letter);}






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!