一、Array数组方法

本质上，数组属于一种特殊的对象。typeof运算符会返回数组的类型是object。
由于数组成员的键名是固定的（默认总是0、1、2...），因此数组不用为每个元素指定键名，而对象的每个成员都必须指定键名。JavaScript 语言规定，对象的键名一律为字符串，所以，数组的键名其实也是字符串。之所以可以用数值读取，是因为非字符串的键名会被转为字符串。

var arr = new Array()

length属性

数组的数字键不需要连续，length属性的值总是比最大的那个整数键大1。

var arr = ['a', 'b'];
arr.length // 2

arr[2] = 'c';
arr.length // 3

arr[9] = 'd';
arr.length // 10

arr[1000] = 'e';
arr.length // 1001

length属性是可写的。如果人为设置一个小于当前成员个数的值，该数组的成员会自动减少到length设置的值。清空数组的一个有效方法，就是将length属性设为0。

var arr = [ 'a', 'b', 'c' ];
arr.length // 3

arr.length = 2;
arr // ["a", "b"]

arr.length = 0;
arr // []

arr.filter(function)

返回的是数组中所有符合条件的元素,组成的一个新的数组；

例子：var arr=[{name:"jack",id:1},{name:"ken",id:2}]；

arr.filter(item=>item.id==1)  //[{name:"jack",id:1}]

arr.find(function)

返回的是数组中第一个符合条件的//元素；

例子：var arr=[{name:"jack",id:1},{name:"ken",id:2},{name:"jack",id:3}]；

arr.find(item=>item.name==="jack")  //{name:"jack",id:1}

arr.push()

把值追加到数组中,加到最后了---返回值也是追加数据之后的数组长度

arr.pop()

删除数组中最后一个元素,返回值就是删除的这个值

arr.shift()

删除数组中第一个元素,返回值就是删除的这个值

arr.unshift()

向数组的第一个元素前面插入一个新的元素,----返回值是插入后的长度

arr.forEach(function)

遍历数组用---相当于for循环,返回的是undefined,适用于不改变数据的情况，而只是想用数据做一些事情 – 比如存入数据库或则打印出来。

let arr = ['a', 'b', 'c', 'd'];
arr.forEach((letter) => {
 console.log(letter);
});
// a
// b
// c
// d

arr.map(function)

数组中的每个元素都要执行这个函数,把执行后的结果重新的全部的放在一个新的数组中。
map()适用于你要改变数据值的时候。不仅仅在于它更快，而且返回一个新的数组。这样的优点在于你可以使用复合(composition)(map(), filter(), reduce()等组合使用)来玩出更多的花样。

let arr = [1, 2, 3, 4, 5];
let arr2 = arr.map(value => value * value).filter(value => value > 10);
// arr2 = [16, 25]

arr.indexOf(元素值)

返回的是索引,没有则是返回-1

例子：比如我们设置白名单路由的时候，在白名单数组中的路由不需要判断是否有权限
const whiteList = ['user/login','user/indexPage'];
if(whiteList.indexOf(pathname)>-1) {
// 不需要判断权限访问
}

arr.join("拼接符")

返回的是一个字符串

arr.concat()

concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

var a = [1,2,3];
console.log(a.concat(4,5)); // [1,2,3,4,5]

var arr = ["George","John","Thomas"]
var arr2 = ["James","Adrew"]
var arr3 = ["William"]
console.log(arr.concat(arr2,arr3)) // [George,John,Thomas,James,Adrew,William]

arr.reverse()

反转数组

arr.sort()

排序的,从小到大排序

arr.slice(开始的索引,结束的索引)

把截取的数组的值放在一个新的数组中,但是不包含结束的索引对应的元素值。

arr.splice(开始的位置,要删除的个数,替换的元素的值)

一般是用于删除数组中的元素,或者是替换元素,或者是插入元素。

arr.some(function)和arr.every(function)

some方法,只要其中一个为true 就会返回true的，相反，every（）方法必须所有都返回true才会返回true，哪怕有一个false，就会返回false；
every（）和 some（）目的：确定数组的所有成员是否满足指定的条件

 //some()
     let b=numbers.some((item,index)=>{
          if(item%3===0){
            return true;
         }else{
             return false;
         }
     })
//every()
      let numbers = [2, 4, 10, 4, 8];
      let a = numbers.every((item,index)=>{
          if(item%2===0){
              return true;
          }else{
              return false;
          }
      });
     console.log(a)

arr.includes(searchElement, fromIndex)

includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true

arr.reduce()

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

arr.reduce(function(prev,cur,index,arr){
...
}, init);
arr 表示原数组；(可选)
prev 表示上一次调用回调时的返回值，或者初始值 init;（必需）
cur 表示当前正在处理的数组元素；（必需）
index 表示当前正在处理的数组元素的索引，若提供 init 值，则索引为0，否则索引为1；(可选)
init 表示初始值。(可选)

用法：

var arr = [3,9,4,3,6,0,9];

1. 求数组项之和

var sum = arr.reduce(function (prev, cur) {
    return prev + cur;
},0);

由于传入了初始值0，所以开始时prev的值为0，cur的值为数组第一项3，相加之后返回值为3作为下一轮回调的prev值，然后再继续与下一个数组项相加，以此类推，直至完成所有数组项的和并返回。
2. 求数组项最大值

var max = arr.reduce(function (prev, cur) {
    return Math.max(prev,cur);
});

由于未传入初始值，所以开始时prev的值为数组第一项3，cur的值为数组第二项9，取两值最大值后继续进入下一轮回调。
3. 数组去重

var newArr = arr.reduce(function (prev, cur) {
    //短路运算，找假，作用相当于if(prev.indexOf(cur) === -1){prev.push(cur)}
    //补充：if只有一个语句时，可简写成：if prev.indexOf(cur === -1) prev.push(cur)
    prev.indexOf(cur) === -1 && prev.push(cur);
    return prev;
},[]);

arr.fill(value, start, end)

fill() 方法用于将一个固定值来填充替换数组的某些元素。

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob", 2, 4);  // ["Banana", "Orange", "Runoob", "Runoob"],end为开区间

arr.flat()

flat()用于将嵌套的多维数组“拉平”，变成一维数组。

flat()默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想要拉平的层数，默认为1。如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。

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

Array和 Array.prototype

Array 对象是用于构造数组的全局对象，数组是类似于列表的高阶对象
Array.prototype 属性表示 Array 构造函数的原型，并允许您向所有Array对象添加新的属性和方法。

Array.prototype 的用法

1.给 Array 对象添加新的方法

//给数组添加一个自定义方法duplicator 
 Array.prototype.duplicator = function() {
 let s = this.concat(this) 
   return s
 }
 let t = [1,2,3,4,5].duplicator()
 console.log(t) // [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

2.把数组方法嫁接到“类似数组的对象”
典型的“类似数组的对象”是函数的arguments对象，以及大多数 DOM 元素集，还有字符串。

//把数组的forEach方法嫁接到字符串上使用
Array.prototype.forEach.call('abc', function (chr) {
  console.log(chr);
});
// a
// b
// c

注：数组的slice方法可以将“类似数组的对象”变成真正的数组。

var arr = Array.prototype.slice.call(arrayLike);

var Obj = function (p) {
this.p = p;
};
var o = new Obj('Hello World!');
o.p
Obj.p

二、String字符串的方法

万物皆对象，字符串和数组都是对象，字符串可以看作是字符组成的数组，数组是特殊形式的对象。

str.length

字符串的长度；

str.charAt(索引)

返回的是指定索引位置的字符串;

str.concat(字符串2，字符串3...)

返回的是拼接后的字符串；

str.indexOf(要找的字符串，开始查找的位置)

返回的是这个字符串第一个所在位置的索引值，没有则返回-1；

str.replace(原来的字符串，新的字符户串)

返回的是替换之后的字符串；

str.slice(开始的索引，结束的索引)

截取字符串，类似于数组方法，截取不到结束位置的字符串；

str.split("以什么为切割点"，返回的个数(默认返回所有))

   例子： var str = "a=1&b=2";

   str.split("&");  //["a=1","b=2"]

   str.split("&",1)  //["a=1"]

str.substr(开始的位置，个数)

也是用于截取字符串；

str.substring(开始的索引,结束的索引)

返回截取后的字符串,不包含结束的索引的字符串,与slice一样；

str.toLowerCase()

转小写;

str.toUpperCase()

转大写;

str.trim()

干掉字符串两端的空格。

str.startsWith()

检测字符串是否以某个字符开头

str.endsWith()

检测字符串是否以某个字符结尾

三、Object对象方法

Object.keys()

该方法返回一个数组，遍历对象所有的可枚举属性，类似于for in。

1.传入对象，返回属性名

var obj = {"a":"124","b":"345"}

console.log(Object.keys(obj))   //["a","b"]

2.传入字符串，返回索引

var str = 'ab123';

console.log(Object.keys(str))  //["0","1","2","3","4"]

3.传入数组，返回索引

var arr = ["a","b","c"];

console.log(Object.keys(arr));  //["0","1","2"]

Object.values()

返回一个给定对象自己的所有可枚举属性值的数组。

var obj1 = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.values(obj1)); // ['b', 'c', 'a']
 
var obj2 = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.values(obj2)); // ['a', 'b', 'c']

Object.assign()

语法： Object.assign(target, ...sources);sources对象可以有多个；用于将所有可枚举属性的值从一个或多个源对象合并到目标对象，如源对象中有与目标对象重复的值，则会覆盖目标对象的值。它将返回目标对象。

const object1 = {
  a: 1,
  b: 2,
  c: 3
};
const object2 = Object.assign({c: 4, d: 5}, object1);
console.log(object2); // { c:3, d:5，a:1, b:2 }

Object.getOwnPropertyNames()

// Object所有的属性方法
Object.getOwnPropertyNames(Object)
(24) ["length", "name", "prototype", "assign",
 "getOwnPropertyDescriptor", "getOwnPropertyDescriptors",
 "getOwnPropertyNames", "getOwnPropertySymbols", "is", 
"preventExtensions","seal", "create", "defineProperties", 
"defineProperty", "freeze", "getPrototypeOf", "setPrototypeOf", 
"isExtensible", "isFrozen", "isSealed", "keys", "entries", 
"fromEntries", "values"]
//Array所有的属性方法
Object.getOwnPropertyNames(Array.prototype)
(33) ["length", "constructor", "concat", "copyWithin", "fill",
 "find", "findIndex", "lastIndexOf", "pop", "push", "reverse", 
"shift", "unshift", "slice", "sort", "splice", "includes",
 "indexOf", "join", "keys", "entries", "values", "forEach", 
"filter", "flat", "flatMap", "map", "every", "some", "reduce",
 "reduceRight", "toLocaleString", "toString"]

Object.freeze()

Object.freeze()方法可以冻结一个对象。一个被冻结的对象再也不能被修改；
冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。
此外，冻结一个对象后该对象的原型也不能被修改。freeze() 返回和传入的参数相同的对象。

const obj = {
 property: 42
};
const obj2 = Object.freeze(obj);
obj.property = 33;// Throws an error in strict mode 会抛出异常
console.log(obj.property);// expected output: 42   值没有被改变

如果你有一个巨大的数组或Object，并且确信数据不会修改，使用Object.freeze()可以让性能大幅提升。