常用js的数组方法和对象方法

数组的方法

1.Array.map()

此方法是给数组中的每项数据都添加一个方法，结果作为一个新的数组返回，不会改变原来的数组。

  let arr = [1,2,3,4,5,6];
      let newArr = arr.map(v =>{
        return v * 2
      })
      console.log(arr);  //1,2,3,4,5,6
      console.log(newArr); // 2, 4, 6, 8, 10, 12

map与forEach的用法一样，正常情况下需要配合return使用，返回一个新数组

2.Array.forEach()

此方法是给数组的每一项数据循环添加一个方法，和map不同的是，forEach改变原数组，没有返回值。

let arr = [1,2,3,4,5,6];
      arr.forEach( (item, index) =>{
        console.log(item);  //1,2,3,4,5,6
        console.log(index)  // 0 1 2 3 4 5
      }) 

 let arr = [1,2,3,4,5,6];
      arr.forEach( (item, index) =>{
        arr = item * 2
        console.log(item)  //1 2 3 4 5 6
      }) 

3.Array.filter()

此方法类似于筛选向方法中传入一个判断条件，将满足条件的值变成一个新的数组返回。

let arr = [1,2,3,4,5,6];
     let newArr = arr.filter(v =>{
       return v > 3;
     })
     console.log(newArr);  // 4 5 6 
     console.log(arr); //1 2 3 4 5 6

4.Array.every

此方法是将所有元素进行判断返回一个布尔值，如果所有元素都满足判断条件的话，则返回true，如果不满足就返回 false。
遍历数组每一项，若全部为true，才返回true ,否则返回false;

 let arr = [1,2,3,4,5,6];
     let newArr = arr.every(v =>{
       return v < 7;
     })
     console.log(newArr)  // true  全部都满足，才是true；
    let newArr1 = arr.every( v =>{
      return v < 3;
    })
    console.log(newArr1);  //false 有一个不满足，false

5.Array.some()

此方法和every类似，唯一区别就是some遍历数组中的每一项，若其中一项为true,则返回值是true，every遍历数组每一项，若全部为true，才返回true ,否则返回false。

let arr = [1,2,3,4,5,6];
    let newArr = arr.some( v =>{
      return v < 3;
    })
    console.log(newArr);  //有一项满足，返回true

6.Array.reduce()

reduce 为数组中的每一个元素依次执行回调函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：初始值（或者上一次回调函数的返回值），当前元素值，当前索引，调用 reduce 的数组。可以用来写求和求积。

 let arr = [1,2,3];
    let newArr = (a, b) => a + b;
    let sum = arr.reduce(newArr);
    console.log(sum);  //6

7.Array.push()

此方法用来向数组末尾添加一个或多个元素，返回新增后数组的长度。改变原数组；

let arr = [1,2,3,4,5];
     let newArr = arr.push(10,11);
     console.log(newArr);  //7
     console.log(arr);  // 1,2,3,4,5,10,11

8.Array.pop()

此方法删除数组中的最后一位元素，并返回数组，改变数组的长度。

let arr = [1,2,3,4,5];
     arr.pop();
     console.log(arr);  // 1,2,3,4  删掉了最后一位

9.Array.shift()

此方法删除数组中的第一个元素，并返回数组，此方法会改变数组长度。

let arr = [1,2,3,4,5];
     arr.shift();
     console.log(arr);  // 2,3,4，5  删掉了第一位

10.Array.unshift()

此方法向数组前添加一个或多个元素，并返回数组，此方法会改变数组长度。

let arr = [1,2,3,4,5];
     arr.unshift(10, 11, 12);
     console.log(arr);  // 10,11, 12,1,2,3,4,5

11.Array.isArray()

此方法是用来判断一个对象是不是数组，是的话返回true，不是返回false。

let arr = [1,2,3,4,5];
     let str = 'hello';
     let bol = Array.isArray(arr);
     let stri = Array.isArray(str);
     console.log(bol);  //true  是数组返回true
     console.log(stri);  //false  非数组，返回false

12.Array.concat()

此方法是一个可以将多个数组合并成一个数组的方法。

let arr = [1,2,3,4,5];
     let arr1 = [10,11];
     let arr2 = arr.concat(arr1);
     console.log(arr2);  //1,2,3,4,5,10,11

13.Array.toString()

此方法是用来将数组转变为字符串格式；

let arr = [1,2,3,4,5];
     let str = arr.toString();
     console.log(typeof str);  //string字符串

14.Array.join()

此方法也是将数组转换为字符串，但和toString不同的是join可以设置元素之间的间隔。

 let arr = [1,2,3,4,5];
     let str = arr.join('-');
     console.log(typeof str);  //string字符串
     console.log(str)  //1-2-3-4-5

15.Array.splice(开始位置， 删除的个数，元素)对数组进行截取

万能的方法可以实现数组的增、删、改。
删数组内的元素：
splice改变原数组。
slice不改变原数组。

代码之后再补充；

 语法1： 数组.splice(开始的索引， 截取多少个)
          	直接改变原始数组
          	返回值： 以数组的形式返回截取出来的内容
          			（不管截取多少个内容，都是以数组的形式返回）
          
  var arr = ['hello', 'world', '你好', '世界']
  var res = arr.splice(1, 1)
  
  console.log(arr)  打印结果： ["hello", "你好", "世界"] //直接改变原始数组
  console.log(res)  打印结果： ["world"] //截取出来的内容
  
  
 语法2： 数组.splice(只传一个参数)
 			当第二个参数不传递的时候，就是从哪个索引开始截取的到数组的末尾
          	直接改变原始数组
          	返回值： 以数组的形式返回截取出来的内容
          			（不管截取多少个内容，都是以数组的形式返回）
          
  var arr = ['hello', 'world', '你好', '世界']
  var res = arr.splice(2)
  
  console.log(arr)  打印结果： ['hello', 'world'] //直接改变原始数组
  console.log(res)  打印结果： ['你好', '世界'] //截取出来的内容
    
    
 语法3： 数组.splice(开始的索引， 截取多少个，值1，值2)
 			从第三个参数开始，都是替换掉截取的位置
          	直接改变原始数组
          	返回值： 以数组的形式返回截取出来的内容
          			（不管截取多少个内容，都是以数组的形式返回）
  var arr = ['hello', 'world', '你好', '世界']
  var res = arr.splice(2,1,'新值1','新值2')
  
  console.log(arr)  打印结果： ["hello", "world", "新值1", "新值2", "世界"] //直接改变原始数组
  console.log(res)  打印结果： ['你好'] //截取出来的内容
  

16.Array.slice() 截取数组中的值

此方法返回从原数组中指定开始下标到结束下标之间的项，组成的新数组截取数组。不改变原数组。

  let arr = [1,2,3,4,5];
     let arr1 = arr.slice(0,2);
     console.log(arr1);  //1,2 截取下标0到下标2，不包含2
     console.log(arr);  // 1,2,3,4,5
     

 语法1： 数组.slice(开始的索引，结束的索引) 💢注：包前不包后
          	不改变原始数组
          	返回值： 以数组的形式返回截取的内容
          
  var arr = ['h', 'e', 'l', 'y', 'o', 'w', 'x']
  var res = arr.slice(1, 5)
  
  console.log(arr)  打印结果： ['h', 'e', 'l', 'y', 'o', 'w', 'x'] //不改变原始数组
  console.log(res)  打印结果： ["e", "l", "y", "o"] //截取出来的内容
  
  
 语法2： 数组.splice(只传一个参数)
 			当第二个参数不传递的时候，就是从哪个索引开始截取的到数组的末尾
          	          	不改变原始数组
          	返回值： 以数组的形式返回截取的内容
          
  var arr = ['h', 'e', 'l', 'y', 'o', 'w', 'x']
  var res = arr.slice(3)
  
  console.log(arr)  打印结果： ['h', 'e', 'l', 'y', 'o', 'w', 'x'] //不改变原始数组
  console.log(res)  打印结果： ["y", "o", "w", "x"] //截取出来的内容
    

17.Array.includes()

includes 可以判断一个数组中是否包含某一个元素，并返回true 或者false

let arr = [1,2,3,4,5];
     let result = arr.includes(3);
     console.log(result);  //true

includes可以包含两个参数，第二个参数表示判断的起始位置；

let arr = [1,2,3,4,5,3];
     let result = arr.includes(3, 4);
     console.log(result);  //true 从小标4开始找元素3

18.Array.indexOf()

indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
接受两个参数，要查找的项(必须)和查找起点的位置索引（非必须）；

提示和注释
注释：indexOf() 方法对大小写敏感！

注释：如果要检索的字符串值没有出现，则该方法返回 -1。

 let str = 'hello world';
     document.write(str.indexOf('hello') + '</br>');  //0  下标
     document.write(str.indexOf('Hello') + '<br>');  // -1  检索不到
     document.write(str.indexOf('world'))  //6  下标

19.Array.sort()

按指定的参数对数组进行排序，返回的值是经过排序后的数组（无参，函数）

let arr = [1,2,3,'d','f','e',22,10];
     console.log(arr.sort()); //[1, 10, 2, 22, 3, "d", "e", "f"]
     

对象的方法

1.Object.assign()

此方法用于克隆对象，传入两个参数，第一个参数为原对象，第二个参数为需要克隆的对象。会合并为一个新的对象，改变第一个参数的对象。

let obj = {name:'xiaoxiao', age: 12};
     let obj2 = {like:'basketball'};
     let object = Object.assign(obj, obj2);
     console.log(obj);  //{name: "xiaoxiao", age: 12, like: "basketball"}
     console.log(obj2);  //{like: "basketball"}
     console.log(object); {name: "xiaoxiao", age: 12, like: "basketball"}
    //  obj第一个参数的，原值被改变

2.Object.is()

此方法是用来比较的接受两个参数，第一个参数是需要比较的第一个值，第二个参数是需要比较的第二个值。
返回值：布尔值，如果两个值相同返回true，不相同返回false。
注意，该函数与运算符不同，不会强制转换任何类型，
应该更加类似于**=，但值得注意的是它会将+0和-0视作不同值**

let obj = 1;
     let obj1 = 1;
     let object = Object.is(obj, obj1);
     console.log(object);  //true

3.Object.keys()

此方法是用来获取对象的key值的。返回一个包含key值的数组。

 let obj = {name:'xiaoxiao', age:12};
     let object = Object.keys(obj);
     console.log(object);  //(2) ["name", "age"]

记录真实项目中，需要遍历出来对象的key值，使用的是 for(let key in obj)

let obj = {name:'xiaoxiao', age:12};
      for(let key in obj){
         if(key="name"){//处理该处的业务逻辑}
         if(key="age"){}

}

4.Object.defineProperty()

defineProperty为设置对象的属性的属性特征 value设置属性名，enumerable设置该属性是否可以被枚举。未设置的枚举的属性不能被for in遍历和keys获取。
该方法接受三个参数，第一个参数为要加入属性的对象，第二个参数为属性的key值，第三个参数为一个对象

let a = {};
     let b = {};
     Object.defineProperty(a, 'name',{ //a是对象，name是传入的属性的名字
       value:'xiaoxiao',  // 属性name的value；
       enumerable: true  // 该属性是否可枚举
     })
     console.log(a);  //{name: "xiaoxiao"}
     console.log(b);  //{}

5.Object.defineProperties()

可添加多个属性,与Object.defineProperty()对应。

 let a = {};
      let b = {};
      Object.defineProperties(a, {
        name: {
          value: "xiaoxiao",
          enumerable: true,
        },
        age: {
          value: 12,
          enumerable: true,
        },
      });
      console.log(a); //{name: "xiaoxiao", age: 12}
      console.log(b); //{}

6.Object.isPrototypeOf()

此方法是用来检查一个对象是否存在另一个对象的原型链中。

 function Obj(){}  //创建一个构造函数
      let b = new Obj();   //new一个新对象赋值给b
      console.log(Obj.prototype.isPrototypeOf(b));  //true

参考原文链接：https://blog.csdn.net/qq_44890872/article/details/103324937