ES6 常用数组方法，对象方法，字符串方法

目录

1.数组方法

2.对象方法

3.字符串方法

---

1.数组方法

(1) forEach()遍历数组，对数组的每个元素执行一次给定的函数。

const array1 = [1, 2, 3];
//item是数组的每一项，index是每一项在数组中的索引值
array1.forEach((item,index) => console.log(item,index));

(1) map()方法和forEach方法很像，都是遍历数组，不同的是map是有返回值的。

let array1 = [1, 2, 3];
//item是数组的每一项，index是每一项在数组中的索引值
let arr = array1.map((item,index) => item);
console.log(arr); // [1, 2, 3]

(1) filter()方法过滤出数组中符合条件的每一项。

let arr = [{name:1,status:false},{name:2,status:true},{name:3,status:false}]
let filteredList = arr.filter((item,index)=>item.status==true)
console.log(filteredList ); //[{name:2,status:true}]

(1) find() 方法返回数组中满足提供的测试函数的第一个元素的值,否则返回undefind。

const array1 = [5, 12, 8, 130, 44];
const found = array1.find((element) => element > 10);
const found1 = array1.find((element) => element > 131);
console.log(found)  //12
console.log(found1 )  //undefind

(1) findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1。

const array1 = [5, 12, 8, 130, 44];
const found = array1.findIndex((element) => element > 10);
const found1 = array1.findIndex((element) => element > 131);
console.log(found)  // 3
console.log(found1 )  // -1

(1) indexOf()方法返回数组中第一次出现给定元素的下标，如果不存在则返回 -1。

const arr = ['哈哈', '嘻嘻', '嘎嘎', '唧唧', '弟弟'];
console.log(arr .indexOf('嘎嘎'));  // 2
console.log(arr .indexOf('啦啦'));  // -1

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

const array1 = [1, 2, 3];
console.log(array1.includes(2)); //true
console.log(array1.includes(4)); //false

(1) every()方法测试一个数组内的所有元素是否都能通过指定函数的测试,返回true，反之false。

const array1 = [1, 30, 39, 29, 10, 13];
console.log(array1.every(item=>item>10));  //false
console.log(array1.every(item=>item>0));  //true

(1) from()方法创建一个新的浅拷贝的数组实例。

console.log(Array.from('foo')); // ['f', 'o', 'o']

(1) push()

let arr = ['小明','小黑','小红']
arr.push('鸭蛋')
console.log(arr) // ['小明', '小黑', '小红'，'鸭蛋']

(1) pop()

let arr = ['小明','小黑','小红']
arr.pop()
console.log(arr) // ['小明','小黑']

(1) shift()方法删除数组第一个元素。

let arr = ['小明','小黑','小红']
arr.shift()
console.log(arr) // ['小黑', '小红']

(1) unshift()方法将指定元素添加到数组的开头。

let arr = ['小明','小黑','小红']
arr.unshift('鸭蛋')
console.log(arr) 

(1) some()方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试就回返回true，反之返回false

let arr = ['小明','小黑','小红']
let a = arr.some(item=> item == '小黑')
let b = arr.some(item=> item == '小资')
console.log(a) //true
console.log(b) //false

(1) splice()方法通过移除或者替换已存在的元素和/或添加新元素。

splice(索引，删除个数)
let arr = ['小明','小黑','小红']
arr.splice(0,2)
console.log(arr) //['小红']


splice(索引，替换个数，替换值)
let arr = ['小明','小黑','小红']
arr.splice(0,2,'小单')
console.log(arr) //['小单', '小红']

(1) reverse()反转数组，简单来说就是让数组中的正序变倒序。

let arr = ['小明','小黑','小红']
arr.reverse()
console.log(arr) //['小红', '小黑', '小明']

(1) join()可以把数组转换成字符串

const elements = ['Fire', 'Air', 'Water'];
console.log(elements.join()) //Fire,Air,Water

(1) flat()方法创建一个新的数组，并根据指定深度递归地将所有子数组元素拼接到新的数组中，俗称 ‘拍平数组’

const arr = [0, 1, 2, [[[3, 4]]]];
console.log(arr.flat());
console.log(arr.flat(2));

(1) for...of() 循环数组

const array1 = [1, 2, 3];
for (const item of array1) {
  console.log(item); // 1 2 3
}

(1) lastIndexOf() 方法返回数组中给定元素最后一次出现的索引，如果不存在则返回 -1。

let arr = [1,2,3,4,1]
let num = arr.lastIndexOf(1)
console.log('能找到返回最后一个索引',num) //4
let num1 = arr.lastIndexOf(5)
console.log('找不到返回负一',num1) //-1

2.对象方法

（1）Object.assign() 方法将一个或者多个对象中所有属性复制到目标对象，并返回修改后的目标对象，简单说就是合并对象。

let obj = {id:1,name:'哈哈'}
let obj2 = Object.assign({},obj)
console.log(obj2) //{id: 1, name: '哈哈'}

（1）for...in 语句可以遍历对象，可以做对象中的参数校验

var obj = { a: 1, b: 2, c: 3 };

for (var prop in obj) {
  console.log("obj." + prop + " = " + obj[prop]);
}

（1）扩展运算符三个点 ... 用于取出参数对象中的所有可遍历属性，拷贝到当前对象之中

let obj = { a: 1, b: 2 };
let obj1 = { ...obj};
console.log(obj1) //{ a: 1, b: 2 }

或者
let obj= {a: 1, b: 2};
let obj1 = {c:2, d: 4}
let obj2= {...obj, ...obj1}
console.log(obj2) //{a: 1, b: 2, c: 2, d: 4}

合并两个对象时，俩对象中有相同属性，后者会覆盖前者
let obj= {a: 1, b: 2};
let obj1 = {a:2, b: 4}
let obj2= {...obj, ...obj1}
console.log(obj2) //{a: 2, b: 4}

也可以合并数组对象
let obj= [{a: 1}, {b: 2}];
let obj1 = [{c:2}, {d: 4}]
let obj2= [...obj,...obj1]
console.log(obj2)

3.字符串方法

（1）slice() 方法截取字符串，可以有俩参数也可以一个参数，一个参数时可以为负值。

let str = '123456'
console.log('截取范围不包括结束索引',str.slice(0,2)) // 12
console.log('包括当前索引截取往后所有',str.slice(1)) //23456
console.log('字符串最后一位往前截取',str.slice(-2)) //56

（2）trim() 方法从字符串的两端清除空格，返回一个新的字符串。

const str = '   我的 中间 有空格   ';
console.log(str); //我的中间有空格

（3）concat() 方法将字符串参数连接到调用的字符串，并返回一个新的字符串.

let str = '123'
let str1 = '456'
let str3 = str.concat(str1)
console.log(str3) //123456

 （4）for循环方法可以遍历字符串字符串，（也可以遍历数组）

let str = 'asdfgh'
for(var i=0;i< str.length;i++){
        console.log(i);//0 1 2 3 4 5 6
   }

 （5）for...in 语句遍历字符串（可以遍历对象）

 let str = '123456'
 for(var i=0;i< str.length;i++){
        //根据字符串类对象所使用的方法来获取每一个字符
        console.log(str[i]);//1 2 3 4 5 6
    }

 （6）indexOf() 方法在字符串中搜索指定子字符串，并返回其第一次出现的位置索引，否则返回-1。

let str = 'asdcfg'
console.log('查找到',str.indexOf('a')) //0
console.log('未查到',str.indexOf('k')) //-1

 （7）lastIndexOf() 方法在字符串中搜索指定子字符串，并返回其最后一次出现的位置索引，否则返回-1。

let str = 'asdcfga'
console.log('查找到',str.lastIndexOf('a')) //6
console.log('未查到',str.lastIndexOf('k'))//-1

 （8）replace(要查找的字符串,替换的值) 方法可以替换指定位置字符串，删除字符串。

替换
let str = '1234565'
let str1 = str.replace(5,'a')
console.log(str1) //1234a65
删除
let str = '1234565'
let str1 = str.replace(5,'')
console.log(str1) //123465

 （9）substring(开始索引,结束索引) 截取部分字符串。

let str = '1234565'
let str1 = str.substring(3,5)
console.log(str1) //45

 （10）for...of() 方法遍历字符串（也可以遍历数组）。

const str = '123';
for (const item of str) {
  console.log(item); // 1 2 3
}

 （10）split('隔开的条件') 方法可以把字符串转为数组  。

let str = '1%2%65454%8';
let str1 = str.split('%');
console.log(str1); //['1', '2', '65454', '8']