数值基础(回顾)

定义

数组是引用类型中的对象数据类型(特殊对象)
创建一个数组，要开辟堆内存，堆内存中存储数组中的键值对

一维数组

只有一级结构

[1, 2, 3]

多维数组

有两级或多级结构

[{ x: 100 }, { y: 200 }]

创建数组的3种方法

方式1：数组字面量 []

[1,2,]

方式2：数组构造函数

new Array(3);// [empty × 3]
new Array(3,2);// [3, 2]
Array(3);// [empty × 3]
Array(3,2);// [3, 2]

方式3：Array.of

Array.of(3);//[3]
Array.of(3,2);//[3,2]

特征

索引 - 数组是以数字为索引，索引从零开始递增的结构

length - 默认存在 length 属性，代表数组的长度

constructor - 引用数组对象的构造器

prototype - 原型对象

关于 length 的操作

arr[arr.length] = x 向数组末尾追加一个新项
arr.length-- 删除数组的最后一项

基本操作

增加数组 使用 [ ] 运算符指定一个新下标

删除数组 delete 数组名[下标]

遍历数组 for…in循环

稀松数组

定义：[empty × 3]
创建：当 new Array()，只传一个参数时，会生成稀松数组
稀松数组不能被ES5方法遍历

let arr = new Array(7);
let res = arr.map(function (v, i) {
  console.log(v, i); //未运行
  return i;
});
console.log(res);// [empty × 7]

判断是否为稀松数组

//  判断数组下标是否存在
function hasEmptyArray(arr) {
  for (var i = 0; i < arr.length; i++) {
    if (!(i in arr)) {
      return true
    }
  }
  return false
}

解决稀松数组

方式1：Array.of()

Array.of(2);//[2]

方式2：Array.fill()

new Array(2).fill();//[undefined, undefined]

数组去重的方法

方式1：Set构造函数
缺点：ES6语法，IE6~8不兼容

var arr = [1,1,2,3,2,3];
console.log([...new Set(arr)]);//[1,2,3]

方式2：利用对象的键值对
缺点：
1.如果数组出现对象，则出现问题(对象属性名不能是对象)
2.存在 2 与 ‘2’，会认为是重复(对象属性名数字和字符串没区别)
3.存在undefined ，也会出现问题

var arr = [1, 2, 3, 1, 2, 3, '2',{a:1},{a:2}];
let obj = {};
for (let i = 0; i < arr.length; i++) {
  let item = arr[i];
  if (obj[item] !== undefined) {
    arr[i] = arr[arr.length - 1];
    arr.length--;
    i--;
  }
 obj[item] = item;
}

方式3：利用 indexOf 和 filter 检测
缺点：IE6~8不兼容

var arr = [1, 2, 3, 1, 2, undefined, undefined, "2", 2];
let newArray = arr.filter((item, index, array) => {
    return array.indexOf(item) === index
})

方式4：双for循环
缺点：循环次数多，性能不好

var arr = [1, 2, 3, 1, 2, 3, 2];
for (let i = 0; i < arr.length - 1; i++) {
  let item = arr[i];
  for (let j = i + 1; j < arr.length; j++) {
    if (item === arr[j]) {
      arr[j] = arr[arr.length - 1];
      arr.length--;
      j--;
    }
 }
}

关于 set 去重对象数组

set去重的原理是判断两者所处的内存单元位置是否一样，所处位置一样才能去重。
基本类型数据都在栈，所以只要值相同就可以直接去重，引用类型存储在堆，引用类型值相同位置不同也无法去重。

let arr = [
    {a:1,b:2},
    {a:1,b:2}
]
let res = [...new Set(arr)]
console.log(arr) // let arr = [{a:1,b:2}, {a:1,b:2}]
let res = [...new Set(arr)]
console.log(arr)

• 解决方案：使用JSON

// 需要排除 undefined、任意函数、symbol、new Boolean、new Number、new String、不可枚举、循环引用的情况
let arr = [
    {a:1,b:2},
    {a:1,b:2},
    new Date()
]
let res = [...new Set(arr.map(item=> JSON.stringify(item)))].map(item =>JSON.parse(item))
console.log(res)