liang14658fox

Appearance

数组扁平化 ​

js

声明二维数组 ​

js

判断两个数组是否相等/比较两个数组 ​

js
function equalArrays(a, b) {
  if (a === b) return true;
  if (a.length !== b.length) return false;
  for (let i = 0; i < a.length; i++) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}
function equalArrays(a, b) {
  if (a === b) return true;
  if (a.length !== b.length) return false;
  for (let i = 0; i < a.length; i++) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}

求数组内全部元素的和 ​

  • 使用递归
js
function sum(arr) {
  var len = arr.length;
  if (len == 0) {
    return 0;
  } else if (len == 1) {
    return arr[0];
  } else {
    return arr[0] + sum(arr.slice(1));
  }
}
function sum(arr) {
  var len = arr.length;
  if (len == 0) {
    return 0;
  } else if (len == 1) {
    return arr[0];
  } else {
    return arr[0] + sum(arr.slice(1));
  }
}
  • 使用 for 循环
js
function sum(arr) {
  var s = 0;
  for (var i = arr.length - 1; i >= 0; i--) {
    s += arr[i];
  }
  return s;
}
function sum(arr) {
  var s = 0;
  for (var i = arr.length - 1; i >= 0; i--) {
    s += arr[i];
  }
  return s;
}
  • 函数式编程 map-reduce：
js
function sum(arr) {
  return arr.reduce(function (prev, curr, idx, arr) {
    return prev + curr;
  });
}
function sum(arr) {
  return arr.reduce(function (prev, curr, idx, arr) {
    return prev + curr;
  });
}
  • 使用 forEach 遍历
js
function sum(arr) {
  var s = 0;
  arr.forEach(function (val, idx, arr) {
    s += val;
  }, 0);

  return s;
}
function sum(arr) {
  var s = 0;
  arr.forEach(function (val, idx, arr) {
    s += val;
  }, 0);

  return s;
}
  • 使用 eval
js
function sum(arr) {
  return eval(arr.join("+"));
}
function sum(arr) {
  return eval(arr.join("+"));
}

数组排序 ​

  • sort()将数组进行排序(升序),返回新数组，原数组也会改变;
js
let arr=[2,3,5,1,4];
let newArr=arr.sort();
console.log(newArr,arr)；//newArr=[1,2,3,4,5]; arr r=[1,2,3,4,5]
let arr=[2,3,5,1,4];
let newArr=arr.sort();
console.log(newArr,arr)；//newArr=[1,2,3,4,5]; arr r=[1,2,3,4,5]
  • 对象数组排序
js
  • 根据日期排序
js

数组去空值 ​

  1. 数组去掉空值和空字符串
  • filter 过滤方法
js
var arr2 = ["a", "", "b", null, undefined, "c", "   "];
var r = arr2.filter(function (s) {
  return s && s.trim();
});
console.log(arr2);
console.log(arr2.length);
console.log(r);
console.log(r.length);
var arr2 = ["a", "", "b", null, undefined, "c", "   "];
var r = arr2.filter(function (s) {
  return s && s.trim();
});
console.log(arr2);
console.log(arr2.length);
console.log(r);
console.log(r.length);
  • splice 方法
js
function trimSpace(array) {
  for (var i = 0; i < array.length; i++) {
    if (array[i] == "" || array[i] == null || typeof array[i] == "undefined") {
      array.splice(i, 1);
      i = i - 1;
    }
  }
  return array;
}
console.log(trimSpace(arr2));
console.log(
  trimSpace(arr2).length +
    "，这个splice方法好像不能去掉数组中含有空格字符的部分"
);
function trimSpace(array) {
  for (var i = 0; i < array.length; i++) {
    if (array[i] == "" || array[i] == null || typeof array[i] == "undefined") {
      array.splice(i, 1);
      i = i - 1;
    }
  }
  return array;
}
console.log(trimSpace(arr2));
console.log(
  trimSpace(arr2).length +
    "，这个splice方法好像不能去掉数组中含有空格字符的部分"
);

判断一个数组是否包含另一个数组的全部元素 ​

js

反转数组一个数组 ​

  • 使用 For 循环反转数组：

我们将为这种方法使用递减循环，以迭代给定数组的每个元素。 数组的最后一个元素将是循环的起点(arr.length — 1) ，它将一直运行直到到达数组的起点(i ≥ 0)

js
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];

function reverseArray1(arr) {
  var newArr = [];
  for (let index = arr.length - 1; index >= 0; index--) {
    newArr.push(arr[index]);
  }
  return newArr;
}
console.log(reverseArray1(arr));
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];

function reverseArray1(arr) {
  var newArr = [];
  for (let index = arr.length - 1; index >= 0; index--) {
    newArr.push(arr[index]);
  }
  return newArr;
}
console.log(reverseArray1(arr));

reverseArray1 函数将一个数组( arr )作为参数，并通过向后循环遍历给定的数组，以相反的顺序创建一个相同元素的新数组( newArr )( let i = arr.length - 1; i >= 0; i – )。 此解决方案不会修改原始数组，因为它会将元素推入并存储在新数组中，这会占用额外的空间。

  • 使用 Unshift()方法反转数组：

这种方法与第一种方法没有很大不同，因为它还使用一个额外的变量来存储反向数组，因此，原始数组保持不变。

js
function reverseArray2(arr) {
  var newArr = [];
  arr.forEach((element) => {
    // unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
    newArr.unshift(element);
  });
  return newArr;
}
console.log(reverseArray2(arr));
function reverseArray2(arr) {
  var newArr = [];
  arr.forEach((element) => {
    // unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
    newArr.unshift(element);
  });
  return newArr;
}
console.log(reverseArray2(arr));

reverseArray2 函数从头到尾遍历给定数组( arr )。 它在新数组( newArr )上使用 unshift 方法，并将每个元素插入到数组的开始位置( newArr[0] )。 与第一个解决方案相比，第二个解决方案的空间效率也较低，因为它需要更多内存才能将反向数组存储在其他变量( newArr )中。

  • 就地反转阵列： （改变原数组）

与 reverse 方法类似，我们的最后一种方法也通过在原位反转其元素来修改原始数组。 这个解决方案； 与前两个解决方案相比， 就地反转数组要复杂得多。

js
function reverseArray3(arr) {
  for (let index = 0; index < Math.floor(arr.length / 2); index++) {
    // 借助第三方变量交换两个变量的值
    var temp = arr[index];
    arr[index] = arr[arr.length - 1 - index];
    arr[arr.length - 1 - index] = temp;
  }
  return arr;
}
console.log(reverseArray3(arr));
function reverseArray3(arr) {
  for (let index = 0; index < Math.floor(arr.length / 2); index++) {
    // 借助第三方变量交换两个变量的值
    var temp = arr[index];
    arr[index] = arr[arr.length - 1 - index];
    arr[arr.length - 1 - index] = temp;
  }
  return arr;
}
console.log(reverseArray3(arr));

在上面的代码中，我们使用 Math.floor 向下舍入( i < Math.floor(arr.length/2) ) i < Math.floor(arr.length/2)给定数组的一半元素。 然后将数组的元素放在第一位和最后一位，第二位与第二位到最后一位，依此类推。 代替使用局部绑定，我们使用数组解构来交换其元素。

  • 直接调用 reverse()：
js
console.log(["a", "b", "c", "d"].reverse());
console.log(["a", "b", "c", "d"].reverse());

求最值 ​

  • 求最大值
js
var arr = [10, 35, 765, 21345, 678, 89];
var max = arr[0];
for (var i = 0; i < arr.length; i++) {
  if (max < arr[i]) {
    max = arr[i];
  }
}
console.log("最大值:" + max);
var arr = [10, 35, 765, 21345, 678, 89];
var max = arr[0];
for (var i = 0; i < arr.length; i++) {
  if (max < arr[i]) {
    max = arr[i];
  }
}
console.log("最大值:" + max);
  • 求最小值
js
var arr = [10, 35, 765, 21345, 678, 89];
var max = arr[0];
for (var i = 0; i < arr.length; i++) {
  if (max > arr[i]) {
    max = arr[i];
  }
}
console.log("最小值:" + max);
var arr = [10, 35, 765, 21345, 678, 89];
var max = arr[0];
for (var i = 0; i < arr.length; i++) {
  if (max > arr[i]) {
    max = arr[i];
  }
}
console.log("最小值:" + max);

合并两个数组 ​

  • concat()合并数组或元素，返回新的数组,原数组不会改变
js
let arr = [1, 2, 3, 4, 5];
let newArr = arr.concat([6, 7, 8], 9, 10);
console.log(newArr, arr);
let arr = [1, 2, 3, 4, 5];
let newArr = arr.concat([6, 7, 8], 9, 10);
console.log(newArr, arr);

newArr 的值为[1,2,3,4,5,6,7,8,9,10];

arr 的值还是原来的[1,2,3,4,5];

concat()还可以复制一个新数组;

let copyArr=arr.concat();//copyArr 的值和 arr 的相同

  • 使用 for 循环

会变更原数组，当然也可以写成生成新数组的形式。

经读者提点，数组不建议使用 for…in，具体可参考 MDN for…in

js
let arr = [1, 2];
let arr2 = [3, 4];

for (let i = 0; i < len(arr2); i++) {
  arr.push(arr2[i]);
}

console.log(arr);
// [1, 2, 3, 4]
let arr = [1, 2];
let arr2 = [3, 4];

for (let i = 0; i < len(arr2); i++) {
  arr.push(arr2[i]);
}

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

arr.concat(arr2) 会生成新的数组。

js
let arr = [1, 2];
let arr2 = [3, 4];

arr = arr.concat(arr2);

console.log(arr);
// [1, 2, 3, 4]
let arr = [1, 2];
let arr2 = [3, 4];

arr = arr.concat(arr2);

console.log(arr);
// [1, 2, 3, 4]
  • arr.push.apply(arr, arr2)

第一种 for 循环就是使用的 push 来实现的。

因为 push 是可以接收多个参数的，所以我们可以使用 apply 来实现。

会变更原数组。

js
let arr = [1, 2];
let arr2 = [3, 4];

arr.push.apply(arr, arr2);

console.log(arr);
// [1, 2, 3, 4]
let arr = [1, 2];
let arr2 = [3, 4];

arr.push.apply(arr, arr2);

console.log(arr);
// [1, 2, 3, 4]
  • […arr, …arr2]

会生成新的数组。

js
let arr = [1, 2];
let arr2 = [3, 4];

arr = [...arr, ...arr2];

console.log(arr);
// [1, 2, 3, 4]
let arr = [1, 2];
let arr2 = [3, 4];

arr = [...arr, ...arr2];

console.log(arr);
// [1, 2, 3, 4]
  • push(…arr) push 结合 ...[] 来实现。

会变更原数组。

js
let arr = [1, 2];
let arr2 = [3, 4];

arr.push(...arr2);

console.log(arr);
// [1, 2, 3, 4]
let arr = [1, 2];
let arr2 = [3, 4];

arr.push(...arr2);

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

使用数组的 slice()方法添加或删除元素 ​

splice();在任意位置添加或删除元素,返回删除或被替换的值，如果没有被删除或替换则返回空数组;

splice()方法会修改原数组的值;

只有一个值时，从当前位置删除到数组末尾

js
let arr=[1,2,3,4,5]；
let num1=arr.splice(1)
console.log(num1;arr)//num=[2,3,4,5];arr=[1];
let arr=[1,2,3,4,5]；
let num1=arr.splice(1)
console.log(num1;arr)//num=[2,3,4,5];arr=[1];

有两个值时，第一个值为删除的位置，第二个值为删除的个数;

js
let arr=[1,2,3,4,5]；
let num1=arr.splice(2,3)//删除从索引值2开始的3个元素
console.log(num1;arr);// num1=[3,4,5],arr=[1,2]
let arr=[1,2,3,4,5]；
let num1=arr.splice(2,3)//删除从索引值2开始的3个元素
console.log(num1;arr);// num1=[3,4,5],arr=[1,2]

有三个或者多个值时，第一个值为插入元素的位置，第二个值为替换的个数，后面的值都为插入的新元素；

js
let arr=[1,2,3,4,5]；
let num2=arr.splice(2,1,6,7,8);//从索引值2开始替换掉1个元素，并且插入6,7,8

//如果第二个值为0，则不替换，直接插入6,7,8;
console.log(num2;arr);//被替换的值num2=[3]; arr=[1,2,6,7,8,4,5]
let arr=[1,2,3,4,5]；
let num2=arr.splice(2,1,6,7,8);//从索引值2开始替换掉1个元素，并且插入6,7,8

//如果第二个值为0，则不替换，直接插入6,7,8;
console.log(num2;arr);//被替换的值num2=[3]; arr=[1,2,6,7,8,4,5]

截取复制数组指定位置的内容 ​

slice(开始位置，结束位置)；第二个参数不写默认到尾部,只能从前往后截取；返回的值为截取到的内容形成的新数组;

js
let copyArr=arr.slice(); // slice()或者slice(0)都可以复制数组；
let arr=[1,2,3,4,5]；
let newArr=arr.slice(1,3);//截取索引1到索引3(不包括3)的值;
console.log(newArr,arr)；//newArr=[2,3];arr=[1,2,3,4,5];
let copyArr=arr.slice(); // slice()或者slice(0)都可以复制数组；
let arr=[1,2,3,4,5]；
let newArr=arr.slice(1,3);//截取索引1到索引3(不包括3)的值;
console.log(newArr,arr)；//newArr=[2,3];arr=[1,2,3,4,5];

slice()方法不会更改到原数组的值

指定字符连接字符串 ​

 join();数组的每个元素以指定的字符连接形成新字符串返回;
js
let arr=[1,2,3,4,5];

let newArr=arr.join()//默认用逗号连接
console.log(newArr);//newArr=1,2,3,4,5;

//如果连接符为空字符串，则会无缝连接
console.log(arr.join(“”));//输出为12345；
let arr=[1,2,3,4,5];

let newArr=arr.join()//默认用逗号连接
console.log(newArr);//newArr=1,2,3,4,5;

//如果连接符为空字符串，则会无缝连接
console.log(arr.join(“”));//输出为12345；

其他高阶遍历 ​

https://segmentfault.com/a/1190000020233039

```

```
```

```