Учебные заметки - Организация метода массива

Предисловие:

Определение: Массив — это упорядоченный набор значений.

JSМассив нетипизирован, элементы массива могут быть любого типа, а разные элементы одного массива также могут иметь разные типы, каждое значение называется элементом (элементом массива), и каждый элемент имеет позицию в массиве . массив в обычномcodingЭто более часто используемый формат данных, особенно при анализе фоновых данных. У меня есть пример для каждого метода.Я надеюсь, что благодаря анализу примера каждый сможет получить более четкое представление о методе. К тому же прямая цепочка методов строк и объектов ниже👇, можете подобрать сами. Я надеюсь, что смогу вам немного помочь, это будет для меня большой честью!

Дата обновления: 2021,11,03

Учебные заметки: строка - строка

Учебные заметки: объект - объект

1. Создайте массив `x=[ ]`

let a=["333","999"];        // 直接写在[ ]中

let aa=new Array(4,8,9);    // 通过实例传入Array中

let aaa=new Array(5);       // 生成[,,,,] 个数为5的空数组

    aaa[0]=6;               // 给aaa的第0个赋值为6

console.log(aaa);           //  [6,,,,,]

console.log(aa);            //  [4,8,9]

О создании массивовes6добавлено вArray.from()Основной метод заключается в преобразовании набора массивоподобных объектов и итерируемых объектов в настоящие массивы:адрес ссылки

2. Доступ к элементам массива`x.[index]`

let a=["333","999"];

let b=a[0];              // 访问数组的第一个元素

let c=a[a.length-1];     // 访问数组的最后一个元素

let f=a["1"]===a[1];     // a["1"]会自动转为数字1 

console.log(f);          //  true

Конечно, если мы получим к нему доступ следующими способами, он будет проанализирован как непрерывная операция для возврата последнего значения.

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

Массивы также являются особыми объектами, поэтому мы также можем получить к ним доступ в виде пар ключ-значение.

let arr9 = [];

    arr9.say = 'Hello';

console.log(arr9.say)    // Hello

3. Обходим массив`x.forEach(function(item,index,array){})`

es6写法 forEach((item,index)=>{dosomething.....})

let a=["333","999"];

   a.forEach(function (item,index,array) {

           console.log(item,index)

 });
       //333 0  999 1

В-четвертых, добавьте элементы в конец массива`x.push(...)`

let a=["333","999"];

    a.push("我是新元素","666");  

console.log(a);    //["333","999","我是新元素","666"]

console.log(a.push("我","690"),a.length,a);  //6,6,["333","666","我是新元素","666","我","690"]

//打印 console.log(a.push(xxx)) 会返回数组长度，而不是数组本身，所以上面返回了两次数组长度

//返回新数组长度6，会执行一次a.push

5. Удалить массив в конце (можно удалить только 1)`x.pop()`

let a=["333","999"];

    a.pop();

console.log(a);            // ["333"];  返回新数组

console.log( a.pop(),a);   //333 [] 

//会执行一次a.pop()，返回本次被删除元素

Шесть, удалите первый элемент массива`x.shift()`

let a=["333","999"];

    a.shift();

console.log(a);            //  ["999"]

console.log( a.shift());   //  "999"

  //返回被删除元素，不会执行a.shift()

Семь, добавить в начало массива (голова)`x.unshift("...")`

let a=["333","999"];

    a.unshift("000","888","777");

console.log(a);            

// ["000","888","777","333","999"]

console.log(a.unshift("111"),a.length,a); 

//["111","000","888","777","333","999"]
  
   //会执行一次a.unshift，返回数组长度,

8. Найдите индекс элемента в массиве`indexOf`

let a=["333","999"];

let d=a.indexOf("333");   // 通过元素查找在当前数组的索引值

console.log(d);           // 0

let e=a.indexOf("654");   // 如果查不到返回-1

console.log(e);           // -1

9. Глубокое копирование массива`slice()` , `Array.from()`,`[...]`

第一种方法：

let a=[1,2,[2],8]; 

let newArray=a.slice();

console.log(newArray);   //  [1,2,[2],8]  

-----------------------------------

第二种方法：

let newArray2=Array.from(a);

console.log(newArray2);  // [1,2,[2],8]

------------------------------------

第三种方法：

let newArray3=[...a];

console.log(newArray3);  // [1,2,[2],8]

10. Очистить массив

// 两种方法都可以实现，但第二种比较优雅

let arr=[1,2,3,3,4,5];

    arr=[];

console.log(arr)     //  []

------------------------------------

let arr=[888,99];

    arr.length=0;

console.log(arr)     //  []

11. Объединить массивы

let arr=[1];

let arr2=[2];

let arr3=[3];

let arr4=arr.concat(arr2,arr3) 

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

---------------------------------------
// 下面这个方法也可以实现，但只能合并两个数组

let arr1=[1,2,3];

let arr2=[4,5,6];

    arr1.push.apply(arr1,arr2);
   
console.log(arr1);   // [1, 2, 3, 4, 5, 6]

-------------------------------------
// ES6的数组合并：

const arr1 = ['a', 'b'];
const arr2 = ['c'];
const arr3 = ['d', 'e'];

[...arr1, ...arr2, ...arr3];    // [ 'a', 'b', 'c', 'd', 'e' ]

12. Найдите максимальное и минимальное значения в массиве

//方法1
let array1 = [1,2,3,4];

let array2 = Math.max.apply(null,array1);  // 最大值

let array3 = Math.min.apply(null,array1);  // 最小值

console.log(array2,array3);                // 4 ,1

--------------------------------------------------

//方法2
let array4 =Math.max(...array1);         // 最大值

let array5 =Math.min(...array1);         // 最小值

console.log(array4,array5);              // 4 ,1

Тринадцать, определите, является ли это массивом

// 在javascript中，如何判断一个变量是否是数组

(1)Array.isArray()方法

    var a = [0, 1, 2];

    console.log(Array.isArray(a));   // true

(2)typeof  toString 方法

из-за более низкой версииIEне поддерживаетсяES5, если совместимо, используйтеtypeof, мы все знаем, что массивы — это специальные объекты, поэтому массивыtypeofРезультат такжеobjectПотому чтоnullРезультат такжеobject, так что нужно судить, чтоobjectТакже исключитьnull, исключить чистые объекты, сначала судитьaне так лиobject,а такжеa!==nullА такжеtoString.callсудитьaравный[object Array]

let a = [0, 1, 2];  

console.log( typeof a ==='object' &&  a !==null  &&  Object.prototype.toString.call(a) ==='[object Array]');   //  true

14. Операции над массивами и другими значениями (использование «+» автоматически преобразует в`string`,"-" будут автоматически преобразованы в`number`)

// 数组和任何值相加都会将数组转换成字符串再进行拼接

console.log([1,2,3] + 6) ;       // "1,2,36"

console.log([1,2,3] + {}) ;      // "1,2,3[object Object]"

console.log([1,2,3] + [1,2,3])； // "1,2,31,2,3"
  
如果数组只有一个值，那么当这个数组和其他值相减相乘等时会被转换为数字，如果为空会被转换为0
    
console.log([5] - 2)          // 3

15. Дедупликация массива

`new Set`

Новая структура данных Set в ES6 похожа на массив, но элементы в ней уникальны, а ее конструктор может принимать массив в качестве параметра.

let arr1=[1,2,1,2,6,3,5,69,66,7,2,1,4,3,6,8,9663,8]

let set = new Set(arr1);  

console.log(set)       //  [ 1,2,6,3,5,69,66,7,4,8,9663,8]

`filter`

пройти черезfilterа такжеindexOfсотрудничество, первыйfilterВозвращает результат сравнения какtrueмассив ,indexOfОн заключается в том, чтобы сравнить, является ли позиция первого вхождения элемента каждого цикла в массиве текущей позицией.Если есть два одинаковых значения, первый индекс второго значения в исходном массиве не будет равен текущему индексу. Результат судебного разбирательстваfalse, он не будет добавлен вfilterНаконец вернемся к массиву.

function unique(arr) {
  return arr.filter(function(item, index, arr) {
    //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
    return arr.indexOf(item, 0) === index;
  });
}

const arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];

console.log(unique(arr))
//[1, "true", true, 15, false, undefined, null, "NaN", 0, "a", {}, {}]

`includes`

includesв сравнении сindexOfБолее элегантно, возвращаемое значение является логическим значением, которое добавляется один за другим, оценивая, есть ли элементы текущего цикла в новом массиве, нет ли добавления, есть ли пропуск.

  const test = (arr) => {
    let res =[]
   arr.forEach((item,) =>{
     if (!res.includes(item)) {
      res.push(item)
    }
   });
    return res
}

 test([1,1,'true','true',true,true,15,15,false,false])

Шестнадцать, перетасуйте порядок массива

let arr = [1,2,3,4,5,6];

function upsetArr(arr){
    return arr.sort(function(){ return Math.random() - 0.5});
}
upsetArr(arr) ; // [4, 1, 3, 2, 5, 6]

Анализ: следуйте оригиналуsortМетод а-б сначала генерирует случайное число, а затем сравнивает его со случайным числом.

Сравните, если Math.random() - 0.5 верно, верните первое, в противном случае сравните следующее

17. Реализация суммирует числа в массиве, игнорируя буквы.

let arr= ["a",3,4,5,9,"d"];
function sum (arr){
    let a=0;
    for(let i=0;i<arr.length;i++){
        if(typeof arr[i]==="number"){
            a+=arr[i]
        }
    }
    return a; 
}

sum(arr)  //21

Определите, является ли каждое значение в массиве числом, прокручивая его, и если да, назначьте его переменной для вычисления сложения.

18,`delete`,`splice`Удаляет указанное значение из массива.

использоватьdeleteПосле удаления проиндексированного значения в массиве исходный массив изменяется напрямую, а позиция удаленного значения сохраняется, т.е.undefined.

let arr=[1,2,3,45,5,2];

    delete arr[0]

console.log(arr,arr[0]).   // [empty,2,3,45,5],undefined

Если вы хотите удалить его полностью, вы можете использоватьsplice()метод

splice(开始位置，删除个数，添加的值), если нет третьего значения, вы можете передать только первые два значения

Пример двух значений:

let arr=[1,2,3,45,5,2];

    arr.splice(0,1)

console.log(arr)    //  [2, 3, 45, 5, 2]

Пример трех значений:

let arr=[1,2,3,45,5,2];

    arr.splice(0,1,100)

console.log(arr)     //  [100 ,2, 3, 45, 5, 2]

девятнадцать,`slice()`Обрежьте массив, выберите начальную позицию и конечную позицию

Array.slice(begin,end) получает два параметра: первый — начальная позиция, а второй — конечная позиция.

Скопируйте начальную позицию в конечную позицию, передняя и задняя часть не включены

еслиendопускается, тоsliceбудет извлекать весь путь до конца исходного массива.

еслиendбольше, чем длина массива,sliceтакже будет извлекаться в конец исходного массива

let arr=[1,2,3,45,5,2];

let arr1 = arr.slice(0,4)

console.log(arr1). //  [1, 2, 3, 45]

еслиslice()Если в скобках не передать никаких параметров, то они все будут перехвачены, то есть добиться копирования

let arr=[1,2,3,45,5,2];

let arr1 = arr.slice()

console.log(arr1).  //  [1, 2, 3, 45, 5, 2]

Двадцать, обратный порядок массива, также известный как инверсия массива

let arr=[1,2,3,45,5,2];

    arr.reverse()

console.log(arr)   // [2, 5, 45, 3, 2, 1]

двадцать один,`join()`Разбить массив на строки по значениям в скобках (не меняет исходный массив)

let arr=[1,2,3,45,5,2];

console.log(arr.join("_”));  //  "1_2_3_45_5_2"

console.log(arr);   //  [1, 2, 3, 45, 5, 2]

двадцать два,`sort()`Сортировка, сортировка значений в массиве, от большего к меньшему или от малого к большому (изменит исходный массив)

sortОригинальная функция сортировки может идентифицировать для сравнения только одиночные цифры, поэтому в расширении используются следующие методы: (Методов сортировки много, это самый традиционный, и он используется чаще, другие методы повторяться не будут)

let arr=[1,2,3,45,5,2];
    array=arr.slice();
    
    arr.sort(function(a,b){
        return a-b
    })   
   //  [1, 2, 2, 3, 5, 45]

查看此时的arr数组：
    console.log(arr)  //   [1, 2, 2, 3, 5, 45]

    arr.sort(function(a,b){
        return b-a
    })
  //  [45, 5, 3, 2, 2, 1]

查看此时的arr数组：
    console.log(arr)  //   [45, 5, 3, 2, 2, 1]

23. Array.protype.slice.call(arr,n,m) перехватывает массив и возвращает новый массив (исходный массив не изменится)

Параметры (передний пакет, задний не входит):

arr: перехваченный массивn: начальная позиция перехватаm: конечное положение перехвата

Узнал сегодня новый метод, всем рекомендую, в массивеslice.call()метод возвращает новый перехваченный массив (передний пакет, задний пакет). Затем мы вводим 🌰 для отображения:

1.向后截取，第二个参数 2 是指给定截取的位置，删除当前位置前的元素，返回包含第二个参数之后的数组副本。

let arr = [1,2,5,3,6];
console.log(Array.prototype.slice.call(arr,2)) // [5,3,6]

2.向前截取，首先找到截取位置为 2，然后找到截取截止位置 4，返回从首位数第二个参数开始，截止到第四个位置的数组副本:
let arr = [1,2,5,3,6];
console.log(Array.prototype.slice.call(arr,2,4)) // [5,3]

Методы итерации в массивах`filter()`, `every()`,`forEach()`,`map()`,`some()`,`reduce`

filter(): запустить данную функцию для каждого элемента в массиве, возврат функции вернетtrueМассив элементов.

every(): запустить данную функцию для каждого элемента в массиве, если функция возвращает значение для каждого элементаtrue, затем вернутьсяtrue.

forEach(): запустить данную функцию для каждого элемента в массиве. Этот метод не имеет возвращаемого значения.

map(): запустить данную функцию для каждого элемента в массиве, возвращая массив результатов каждого вызова функции.

some(): запустить данную функцию для каждого элемента в массиве, если функция возвращает значение для любого элементаtrue, возвращает истину.

Во-первых, метод итерации массива`filter()`

filterВозвращается массив, удовлетворяющий определенному условию, и возвращается новый массив, который не изменит исходный массив, а также может фильтровать ложные значения.

array.filter(function(item,index,array){
    
})

filterФункция обратного вызова получает три параметра, а именно текущий элемент индекса, индекс, исходный массив

item: текущий элемент индекса
index:показатель
array: исходный массив

let arr=[1,3,6,8,45,34,90,122,9,0];

let array = arr.filter(function(element){

        return element>10
    })
console.log(array)

//筛选数组中大于10的值， [45, 34, 90, 122]

//查看原数组，并没有改变

console.log(arr)    //  [1,3,6,8,45,34,90,122,9,0]

При обходе массива возвращаемое значение равноtrueМы можем использовать эту функцию, чтобы удалить некоторые ненужные элементы и отфильтровать ложные значения.

const compact = arr=> arr.filter(Boolean)
compact([0, 1, false, 2, '', 3, 'a', 'e' * 23, NaN, 's', 34])    // [1, 2, 3, "a", "s", 34]

Что касается этой ложной посадки фильтра, во многих библиотеках инструментов есть свои методы борьбы с ними, ниже мы обсудим методы в определенной библиотеке иfilterСделайте сравнение и посмотрите конкретную эффективность исполнения (серьезное лицо).

// 方法本身
function lodashCompact(array) {
  var index = -1,
    length = array == null ? 0 : array.length,
    resIndex = 0,
    result = [];

  console.time("lodashCompact");
  while (++index < length) {
    var value = array[index];
    if (value) {
      result[resIndex++] = value
    }
  }
  console.timeEnd("lodashCompact");
  return result;
}
// lodash 方法实现
function test() {
    lodashCompact(arr);
}
// filter 方法实现
function test2() {
    console.time("filter用时共计")
    const compacts = arr => arr.filter(Boolean)
    console.timeEnd("filter用时共计")
}

Приведенный выше расчет представляет собой чистое время выполнения,filterнамного больше, чем примерно в 7,6 раза, рекомендуется использоватьfilter!

Во-вторых, метод итерации массива`every()`

(Он в основном используется, чтобы судить о том, соответствуют ли значения в массиве определенному стандарту. Каждое значение должно быть выполнено перед возвратомtrue. в противном случае вернутьсяfalse)

let arr = [1,2,3,4,5,4,3,2,1]; 

let everyResult = arr.every(function(item, index, array){ 
    return (item > 2); 
}); 

//判断数组中所有的值是否都大于2，如果都大于2，返回true，反之返回false.

console.log(everyResult)     //false

В-третьих, метод итерации массива`forEach()`

(Цикл по массиву, запускающий данную функцию для каждого элемента массива. Этот метод не имеет возвращаемого значения.)

let arr=[1,3,6,8,45,34,90,122,9,0];

    arr.forEach(function(item,index,array){
        console.log(item,index,array)
    })
/*
 0 1 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 1 3 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 2 6 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 3 8 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 4 45 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 5 34 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 6 90 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 7 122 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 8 9 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 9 0 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
*/

В-четвертых, метод итерации массива`map()`

Цикл по массиву, запуск заданной функции для каждого элемента в массиве, возврат результата каждого вызова функции для формирования нового массива.

Перебирает массив, возвращая новый массив

array.map(function(item,index,array){
    })

mapФункция обратного вызова получает три параметра, а именно текущий элемент индекса, индекс, исходный массив

item: текущий элемент индекса
index:показатель
array: исходный массив

[1, 2, 3].map(v => v + 1) // -> [2, 3, 4]

let arr=[1,3,6,8,45,34,90,122,9,0];

    arr.map(function(item,index,array){
        console.log(index,item,array)
    })
 /*
 0 1 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 1 3 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 2 6 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 3 8 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 4 45 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 5 34 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 6 90 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 7 122 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 8 9 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 9 0 (10) [1, 3, 6, 8, 45, 34, 90, 122, 9, 0]
 */

Пять, метод итерации массива`some()`

(запускает данную функцию для каждого элемента в массиве и возвращает true, если функция возвращает true для любого элемента)

let numbers = [1,2,3,4,5,4,3,2,1]; 

let someResult = numbers.some(function(item, index, array){ 
    return (item > 2); 
}); 

//只要有一个返回true，则返回true

console.log(someResult); // true

шесть,уменьшить слияние: перебрать все значения в массиве, возвращая условное конечное значение.

reduce:

метод выполняетreducerФункция (выполняемая в порядке возрастания), которая объединяет свои результаты в одно возвращаемое значение. Используется для выполнения редукции, агрегирования, суммирования, усреднения

reducer 函数接收4个参数:

Accumulator (acc) (累计器)
Current Value (cur) (当前值)
Current Index (idx) (当前索引) 索引默认从1开始 可选
Source Array (src) (源数组)                 可选

 Array.reduce((Accumulator,Value,Index,Array)=>{
     //dosomething
 }

let values = [1,2,3,4,5]; 

let sum = reduce(function(prev, cur, index, array){ 
    return prev + cur; 
}); // 15

//第一次执行回调函数，prev 是1，cur 是2。第二次，prev 是3（1 加2 的结果），cur 是3（数组的第三项）。这个过程会持续到把数组中的每一项都访问一遍，最后返回结果。 
//通过循环遍历，返回数组中所有值的总和  15

сумма

let arr = [1,2,4,6,34,66];
let res = arr.reduce((tap,item,index)=>{
    console.log(`第${index}次:${tap}+${item}`);
    return tap+item
})
// 第1次:1+2 
// 第2次:3+4 
// 第3次:7+6 
// 第4次:13+34
// 第5次:47+66

console.log(res)  // 113

средний

let arr = [1,2,4,6,34,66];
let res = arr.reduce((tap,item,index)=>{
    if(index!==arr.length-1){
        return tap+item
    }else{
        return tap/(arr.length)
    }
});
console.log(res) // 7.833333333333333

reduceRight:

let values = [1,2,3,4,5]; 

let sum = reduceRight(function(prev, cur, index, array){ 
    return prev + cur; 
}); 

//第一次执行回调函数，prev 是5，cur 是4。第二次，prev 是9（5加4 的结果），cur 是3（数组的第三项）。这个过程会持续到把数组中的每一项都访问一遍，最后返回结果。 
//通过循环遍历，返回数组中所有值的总和  15

в ES6`find`: Найдите первое условие совпадения со значением в массиве.

Когда квалифицированный элемент соответствует в массиве, квалифицированный элемент будет возвращен, и функция выполнения не будет вызываться для последующих значений;
Если вы не соответствуете условиям возврата элементаundefined;

Уведомление:find()Для пустых массивов функция не будет выполняться.find()Исходное значение массива не изменяется.


 var arr = [1,2,3,4,5,6,7];
 var ar = arr.find((elem)=>{
    return elem>5
 })  // 6
 
 --------------------------------------
 
 var arr = [1,2,3,4,5,6,7];
 var ar = arr.find((elem)=>{
    return elem>10
 })  // undefined

Array.from в ES6: метод используется для преобразования двух типов объектов в настоящие массивы.

Array.fromметоды используются для превращения двух типов объектов в настоящие массивы: массивоподобные объекты（array-like object）и проходимый（iterable）Объекты (включая новую структуру данных ES6Set 和 Map).

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};

// ES5的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

Если аргумент является реальным массивом,Array.fromвернет идентичный новый массив.

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

Array.fromОн также может принимать второй параметр, который действует как массив.mapметод для обработки каждого элемента и помещения обработанного значения в возвращаемый массив.

Array.from(arrayLike, x => x * x);
// 等同于
Array.from(arrayLike).map(x => x * x);

// 
Array.from([1, 2, 3], (x) => x * x);   // [1, 4, 9]

В следующем примере элементы массива с логическим значением false преобразуются в 0.

Array.from([1, , 2, , 3], (n) => n || 0)   // [1, 0, 2, 0, 3]

Другой пример — тип, возвращающий различные данные.

function typesOf () {
  return Array.from(arguments, value => typeof value);
}
typesOf(null, [], NaN);    // ['object', 'object', 'number']

Array.prototype.flat() в ES6 используется для «выравнивания» вложенного массива в одномерный массив.

Этот метод возвращает новый массив и не влияет на исходные данные.

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

// 上面代码中，原数组的成员里面有一个数组，flat()方法将子数组的成员取出来，添加在原来的位置。

flat() будет "сглаживать" только один слой по умолчанию. Если вы хотите "сгладить" многослойный вложенный массив, вы можете записать параметр метода flat() как целое число, указывающее количество слоев, которые вы хотите flatten, который по умолчанию равен 1.

[1, 2, [3, [4, 5]]].flat();    // [1, 2, 3, [4, 5]]

[1, 2, [3, [4, 5]]].flat(2);   // [1, 2, 3, 4, 5]

В приведенном выше коде параметр flat() равен 2, что означает «выравнивание» двух уровней вложенных массивов. Если вы не знаете, сколько уровней вложенности вам нужно преобразовать в одномерный массив, вы можете использовать в качестве параметра ключевое слово Infinity.

[1, [2, [3]]].flat(Infinity);   // [1, 2, 3]

Если в исходном массиве есть пустые места, метод flat() пропустит пустые места.

[1, 2, , 4, 5].flat();  // [1, 2, 4, 5]

Нуль в ES6

Обработка вакансий в ES5 уже очень непоследовательна, и в большинстве случаев вакансии игнорируются.

forEach(), filter(), reduce(), every()а такжеsome()пропустит вакансию.

map()пропустит пробелы, но сохранит значение

join()а такжеtoString()будет рассматривать вакансии какundefined,а такжеundefinedа такжеnullбудет рассматриваться как пустая строка.

// forEach方法
[,'a'].forEach((x,i) => console.log(i)); // 1

// filter方法
['a',,'b'].filter(x => true) // ['a','b']

// every方法
[,'a'].every(x => x==='a') // true

// reduce方法
[1,,2].reduce((x,y) => x+y) // 3

// some方法
[,'a'].some(x => x !== 'a') // false

// map方法
[,'a'].map(x => 1) // [,1]

// join方法
[,'a',undefined,null].join('#') // "#a##"

// toString方法
[,'a',undefined,null].toString() // ",a,,"

ES6 явно конвертирует вакансии в undefined.

Ссылка: ES6 Учителя Руан Ифэн

    作者：晴天de雨滴    
    出处：https://juejin.im/post/6844903512493539341
    版权所有，欢迎保留原文链接进行转载：)

Если вас заинтересовала моя статья или у вас есть предложения, чтобы рассказать мне👂, вы также можете добавить WeChat!

Если вы считаете, что моя статья неплохая, можете добавить внимание!

最后：
        祝各位工作顺利！
                        -小菜鸟Christine

Предисловие:

1. Создайте массив x=[ ]

2. Доступ к элементам массиваx.[index]

3. Обходим массивx.forEach(function(item,index,array){})

В-четвертых, добавьте элементы в конец массиваx.push(...)

5. Удалить массив в конце (можно удалить только 1)x.pop()

Шесть, удалите первый элемент массиваx.shift()

Семь, добавить в начало массива (голова)x.unshift("...")

8. Найдите индекс элемента в массивеindexOf

9. Глубокое копирование массиваslice() , Array.from(),[...]