对象、数组的基本方法

对象

方括号访问对象属性名称

let nestedObject = {
  id: 28802695164,
  date: 'December 31, 2016',
  data: {
    totalUsers: 99,
    online: 80,
    onlineStatus: {
      active: 67,
      away: 13
    }
  }
};
//访问方法：
nestedObject.data.onlineStatus.away
nestedObject['data']['onlineStatus']['away']

• 方括号符号让我们能用一个变量作为属性名来访问对象的属性，若我们在方括号中不写引号而直接写data，JavaScript 引擎会将其看作一个变量。
• 如果对象的属性名在运行之前是不确定的，或者需要动态地访问对象的属性，就可使用方括号符号。

增删改查对象中的属性

• 点符号
• 方括号符号
• delete

检测属性

• hasOwnProperty()：检测自有属性
• propertyIsEnumerable()：检测可枚举的自有属性
• in运算符：可检测继承属性
• ‘!==undefined’：Obj.key !==undefined

枚举属性

• for/in : for(var in Obj)statement
  可遍历对象中所有可枚举的属性（包括自有的和继承的属性）
• Object.keys(obj)
  可遍历对象中可枚举的自有属性，并返回其属性名称组成的数组
• Object.getOwnPropertyNames()
  遍历对象中所有的自有属性

数组

1. 基础方法

添加

push()

• 向数组的末尾添加一个或多个元素，并返回新的长度。
• 直接修改原数组。

unshift()

• 向数组的开头添加一个或更多元素，并返回新的长度。
• 直接修改原数组。

删除

pop()

• 删除一个数组中的最后的一个元素，并且返回这个元素。
• 直接修改原数组。

 // 1. 获取用户信息
    const token = String(req.headers.authorization || '').split(' ').pop()
    将字符串分割为数组后，将删除最后一个元素保存下来

• String.prototype.split()
• 用指定的分隔符字符串将一个String对象分割成子字符串数组

shift()

• 删除数组的第一个元素，并返回这个元素。
• 直接修改原数组。

合并

concat()

• 合并两个或多个数组，返回一个新数组。
• 如果参数自身是数组，则连接的是数组的元素，而非数组本身。
• 但concat()不会递归扁平化嵌套的数组。

var a = [1,2,3]
a.concat(4,5)   // 返回[1,2,3,4,5]
a.concat([4,5])   // 返回[1,2,3,4,5]
// 嵌套的数组
a.concat(4,[5,[6,7]])   // 返回[1,2,3,4,5,[6,7]]

扩展运算符 …

• 将一个数组转为用逗号分隔的参数序列
• 注意，只有函数调用时，扩展运算符才可以放在圆括号中，否则会报错。

let a = [2, 3, 4, 5]
let b = [4, ...a, 4, 4]
console.log(a, b); //  [2, 3, 4, 5] [4,2,3,4,5,4,4]

反转 reverse()

• 颠倒数组中元素的顺序，返回逆序的数组
• 直接修改原数组。

排序 sort()

• 排序数组中的元素，按照Unicode编码排序
• 默认排序是升序，返回排序后的数组
• 直接修改原数组
• arr.sort([compareFunction(a, b)])
• 函数返回值 >= 0 则交换位置，函数返回值 < 0 则位置不变

// 1. 升序
array.sort((a, b) => a - b );
// 2. 降序
array.sort((a, b) => b - a );

随机数组
const randomCats = cats.slice(0).sort((a,b) => (Math.random() - 0.5))

slice()

• 返回指定数组的一个片段或子数组
• 返回的数组包括开始位置到结束位置之间的所有元素（不含结束位置元素）
• 不修改原数组
• 指定一个参数，则从指定位置到结尾
• 参数为负数，则表示相对于数组中最后一个元素的位置

arr.slice(5)
取出从第5个元素到后面的所有元素，即跳过数组前5个数据

splice()

• 在数组中添加或删除元素
• 直接修改原数组
• 返回由删除元素组成的数组
• array.splice(index,howmany,item1,.....,itemX)
• 参数：
  index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
  howmany：可选。要删除的项目数量。如果设置为 0，则不会删除项目。
  item1, …, itemX： 可选。向数组添加的新项目。

join() toString()

• 把数组中的所有元素通过指定的分隔符进行分隔放入一个字符串
• 返回生成的字符串
• array.join(str) 指定要使用的分隔符，默认使用逗号作为分隔符，分隔符要用引号包裹
• array.toString() 无参数，默认逗号分隔符

var a = [1,2,3]
a.jion()  // 返回'1,2,3'
a.jion('')  // 返回'123'

显示数组中的对象的某个属性值[{name:a,parent:b},{name:c,parent:d}]
arr.map(v= > v.name)    ==> ["a""c"]
arr.map(v= > v.name).join('/')  ==> a/c

• String.split()，使用指定的分隔符字符串将一个String对象分割成子字符串数组
• 以一个指定的分割字串来决定每个拆分的位置。

const str = 'The quick brown fox jumps over the lazy dog.';

const words = str.split(' ');
console.log(words[3]);
// expected output: "fox"

fill()

• 用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。
• arr.fill(value[, start[, end]])
• 参数：
  value：用来填充数组元素的值
  start：起始索引，默认值为0
  end：终止索引，默认值为 this.length

[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]

添加对象元素
new Array.fill({}).map(() => ({
        categoryName: 'news'})

includes()

• 判断一个数组是否包含一个指定的值，返回布尔值
• 可代替 indexOf 方法查找数组中的元素（不需要索引时）
• arr.includes(valueToFind[, fromIndex])
• 不能添加回调函数，所以只能判断简单数组元素

2. 数组的遍历

for()

• for(1初始化；2检测；4更新){ 3语句 }
• 当数组较大时优化效果比较明显
• 可使用 break 和 return 退出循环

forEach()

• 从头到尾地遍历数组，为每个元素调用指定的函数
• 没有返回值，直接改变原数组

arr.forEach(callback(currentValue [, index [, array]])[, thisArg])

for of

• 可以正确响应break、continue和return语句

let arr = [2, 6, 22, 45, 134]
for (let item of arr) {  item为数组的元素
    if(item > 30) break;
    console.log(i);
}
// 2, 6, 22

for in

for(let key in Array) key 为数组的索引
for(left item of Array) item 为数组的元素

map()

• 调用数组中的每个元素传递给指定的函数
• 不修改原数组，返回新数组

var new_array = arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array 
}[, thisArg])

filter()

• 返回的数组元素是调用的数组的一个子集
• 不会改变原始数组，返回新数组

every()

• 对数组元素应用指定的函数进行判定，所有元素为 true 时，返回 true
• 确认返回值后就会停止遍历数组。

some()

• 对数组元素应用指定的函数进行判定，任一元素为 true 时，返回 true
• 确认返回值后就会停止遍历数组。

find()

• 找出第一个符合条件的数组成员
• 找到后，立即返回这个元素的值，否则返回 undefined
• 找到一个便停止遍历

findIndex()

• 返回数组中满足提供的测试函数的第一个元素的索引,若没有找到对应元素则返回-1
• 如果找到这样的元素，则立即返回该元素的索引

indexOf()

• 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1

lastIndexOf()

• 方法返回指定元素在数组中的最后一个的索引，如果不存在则返回 -1。
• 从后往前查找

总结

1. 会改变原数组的方法：

arr.push()
arr.pop()
arr.sort()
arr.unshift()
arr.shift()
arr.splice()
arr.reverse()
arr.fill()
arr.forEach()

2. 不改变原数组的方法：

arr.slice()
arr.concat()
arr.map()
arr.every()
arr.some()
arr.find()
arr.filter()
arr.reduce()
arr.entries()