JavaScript字符串操作和数组操作

接触前端有一段时间了，对于很多东西总是处在模糊知道，但实际上用起来还是要依靠百度和google才能不出错的状态，我觉得这种习惯很不好，因此我决定，把常用的东西记录下来，以便自己复习总结，并且要尽力直接记在脑子里，这样效率才能大大加快。

字符串常用操作方法：

---

split函数(将字符串分割为数组)

split单词本身的语义是“分隔，划分”的意思，所以不难想到split这个函数的作用就是是切割字符串。

• 用法：stringObject.split(separator,howmany)

参数	描述
separator	必需。字符串或正则表达式，从该参数指定的地方分割 stringObject
howmany	可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

• 返回值：返回的是一个数组，即切割后得到的很多小字符串。不改变原来的字符串。
• 常用用法：

//例1, 以空格分隔字符串。实际中，也通常会用","来分割字符串，用法一致。
var str = "I love you";
var strArr = str.split(" ");  // strArr = ["I", "love", "you"], str = "I love you"

//例2, 以空字符串分割, 得到原字符串的每一个字符。
var str = "Iloveyou";
var strArr = str.split("");  //["I","l","o","v",e","y","o","u"], str = "Iloveyou"

---

slice函数（切割字符串得到子串）

slice本身的语义是“切成薄片”的意思，所以slice函数的作用也是切割字符串。不同的是slice切割得到是一个字符串，而split得到的是一个数组。slice() 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。

• 用法：stringObject.slice(start,end)

  参数	描述
  start	要抽取的片断的起始下标。如果是负数，则该参数规定的是从字符串的尾部开始算起的位置。也就是说，-1 指字符串的最后一个字符，-2 指倒数第二个字符，以此类推。
  end	紧接着要抽取的片段的结尾的下标。若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。

• 返回值：一个新的字符串。包括字符串 stringObject 从 start 开始（包括 start）到 end 结束（不包括 end）为止的所有字符。不改变原本的字符串。
• 常用用法：

// 例1
var str="Hello happy world!";
var newStr = str.slice(6,11); // newStr = "happy"

---

substr函数（切割字符串得到子串）

substr从单词的含义上便能看得出，是找出字符串的子串。

• 用法：stringObject.substr(start,length)

  参数	描述
  start	必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。
  length	可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 stringObject 的开始位置到结尾的字串。

• 返回值：一个新的字符串，包含从 stringObject 的 start（包括 start 所指的字符） 处开始的 length 个字符。如果没有指定 length，那么返回的字符串包含从 start 到 stringObject 的结尾的字符。
• 常用用法：

// 例1
var str="Hello world!"
var newStr = str.substr(3,7) // newStr = "lo worl"

---

substring函数（切割字符串得到子串）

substring从单词的含义上便能看得出，是找出字符串的子串,它跟上面的substr函数有什么区别呢？下面解释：

• 用法：stringObject.substring(start,stop)

  参数	描述
  start	必需。一个非负的整数，规定要提取的子串的第一个字符在 stringObject 中的位置。
  end	可选。一个非负的整数，比要提取的子串的最后一个字符在 stringObject 中的位置多 1。 如果省略该参数，那么返回的子串会一直到字符串的结尾。

• 返回值：一个新的字符串，该字符串值包含 stringObject 的一个子字符串，其内容是从 start 处到 stop-1 处的所有字符，其长度为 stop 减 start。
• 注意：

  substring() 方法返回的子串包括 start 处的字符，但不包括 stop 处的字符。

  如果参数 start 与 stop 相等，那么该方法返回的就是一个空串（即长度为 0 的字符串）。如果 start 比 stop 大，那么该方法在提取子串之前会先交换这两个参数。

• 与 slice() 和 substr() 方法不同的是，substring() 不接受负的参数。

---

concat函数（将多个字符串连接起来）

concat暂时没找到对应的英文单词，所以暂时死记住concat的作用就是连接多个字符串。

• 用法：stringObject.concat(stringX,stringX,...,stringX)

  参数	描述
  stringX	必需。将被连接为一个字符串的一个或多个字符串对象。

• 返回值：返回连接后的新字符串，注意，stringObject 本身并没有被更改。
• 注意：concat() 方法将把它的所有参数转换成字符串，然后按顺序连接到字符串 stringObject 的尾部。
• 请注意，使用 " + " 运算符来进行字符串的连接运算通常会更简便一些。

---

trim函数（去除字符串首尾的空格）

trim的意思为“修剪、除去（不必要的部分）”，trim函数的作用是从一个字符串的两端删除空白字符。在这个上下文中的空白字符是所有的空白字符 (space, tab, no-break space 等) 以及所有行终止符字符（如 LF，CR）。

• 用法：string.trim()
• 返回值：返回的是一个新的字符串，不影响原字符串。
• 常用用法：

//例1
var orig = '   foo  ';
console.log(orig.trim()); // 'foo'

// 例2
var orig = 'foo    ';
console.log(orig.trim()); // 'foo'

---

charAt函数（得到指定位置的字符）

charAt() 方法可返回指定位置的字符。

• 用法：stringObject.charAt(index)

  参数	描述
  index	必需。表示字符串中某个位置的数字，即字符在字符串中的下标。

• 返回值：返回的字符是长度为 1 的字符串。
• 常用用法：

// 例1
var str="我爱你"
console.log(str.charAt(1));  // 爱

//例2
var str="Hello world!"
console.log(str.charAt(1));  // e

• 注意：可以用这个函数去遍历字符串的每个字符，数组可以用下标去遍历。

---

indexOf函数（得到指定字符串的在字符串中首次出现的位置）

index是“下标，索引”的意思，IndexOf返回某个指定的字符串值在字符串中首次出现的位置。

• 用法：stringObject.indexOf(searchvalue,fromindex)

  参数	描述
  searchvalue	必需。规定需检索的字符串值。
  fromindex	可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

• 返回值：返回某个指定的字符串值在字符串中首次出现的位置。
• 注意：

（1）indexOf() 方法对大小写敏感！

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

• 常用用法：

---

---

lastIndexOf函数（得到指定字符串的在字符串中最后一次出现的位置）

与indexOf函数相似，lastIndexOf返回某个指定的字符串值在字符串中最后一次出现的位置。

• 用法：stringObject.lastIndexOf(searchvalue,fromindex)

  参数	描述
  searchvalue	必需。规定需检索的字符串值。
  fromindex	可选的整数参数。规定在字符串中开始检索（倒序检索）的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。

• 返回值：返回查找的字符串最后出现的位置，如果没有找到匹配字符串则返回 -1。

• 常用用法：

// 例1，从第 20 个字符开始查找字符串 "runoob" 最后出现的位置,：
var str="I am from runoob，welcome to runoob site.";
var n=str.lastIndexOf("runoob", 20);  // n = 10

// 例2， 从第 10 个字符开始从后向前查找字符串 "runoob" 最后出现的位置：
var str="I am from runoob，welcome to runoob site.";
var n=str.lastIndexOf("runoob", 9); // n = -1

数组常用操作方法

---

splice函数（在数组中插入或者删除项目）

splice的单词含义为“连接，粘接”，所以splice函数肯定有连接数组的作用。splice() 方法向/从数组中添加/删除项目，然后返回修改后的数组。

• 用法：arrayObject.splice(index,howmany,item1,.....,itemX)

  参数	描述
  index	必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
  howmany	必需。要删除的项目数量。如果设置为 0，则不会删除项目。
  item1, ..., itemX	可选。向数组添加的新项目。

• 返回值：返回一个数组，该数组是被修改后的原数组。
• 常用用法：

// 例1
var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"

console.log(arr)   // George,John,Thomas,James,Adrew,Martin

arr.splice(2,0,"William");
console.log(arr)   // George,John,William,Thomas,James,Adrew,Martin


// 例2 
var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"

console.log(arr)   // George,John,Thomas,James,Adrew,Martin

arr.splice(2,3,"William")
console.log(arr)   // George,John,William,Martin

• 注意：

（1）splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。

（2）splice() 方法与 slice() 方法的作用是不同的，splice() 方法会直接对数组进行修改。

---

slice函数（切割得到子数组）
数组的slice函数和字符串的slice函数很相似。

• 用法：arrayObject.slice(start,end)

  参数	描述
  start	必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
  end	可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。

• 返回值：返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。不改变原数组。

• 注意：该方法并不会修改数组，而是返回一个子数组。如果想删除数组中的一段元素，应该使用方法 Array.splice()。

---

concat函数（连接多个数组）
数组的concat函数和字符串的concat函数很相似。concat() 方法用于连接两个或多个数组。

• 用法：arrayObject.concat(arrayX,arrayX,......,arrayX)

  参数	描述
  arrayX	必需。该参数可以是具体的值，也可以是数组对象。可以是任意多个。

• 返回值：返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。
• 注意：该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

---

map函数（得到将数组中的每个值都统一处理后的新数组）

map的意思是映射，数组的map函数的的作用是，根据映射关系，将当前数组的每一个值映射得到一个新值，从而生成一个新的数组。

• 用法：array.map(function(currentValue,index,arr), thisValue)

  参数	描述
  function(currentValue,index,arr)	必须。函数，数组中的每个元素都会执行这个函数。 函数参数: 参数 描述 currentValue 必须。当前元素的值 index 可选。当前元素的索引值 arr 可选。当前元素属于的数组对象
  thisValue	可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。

• 返回值：返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

• 注意：

（1）map() 不会改变原始数组。

（2）map() 方法按照原始数组元素顺序依次处理元素。

（3）map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

• 常用用法：

// 例1
var arr = [1, 2, 3];
var newArr = arr.map(function(val, index, arr){
    console.log(this);   //Window
    return val+10;
});
console.log(newArr);  //11, 12, 13
console.log(arr);  //1, 2, 3

---

5个迭代方法：forEach()、map()、filter()、some()、every()

这几个方法语法都一样，都不会改变原数组。

• forEach()：对数组进行遍历循环，对数组进行操作。这个方法没有返回值。

语法：array.forEach(function(currentValue , index , arr){//do something}, thisValue)

<script>
	var Arr = [1,4,7,10];
	Arr.forEach(function(currentValue, index, arr){
		console.log(index+"--"+currentValue+"--"+(arr === Arr));		
	})
	// 输出：
	// 0--1--true
	// 1--4--true
	// 2--7--true
	// 3--10--true	
</script>

• map()：指“映射”，方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

语法：array.map(function(currentValue , index , arr){//do something}, thisValue)  

<script>
    //map方法实现数组中每个数求平方：
    var arr = [1,4,8,10];
    var arr2 = arr.map(function(currentValue){
        return currentValue*currentValue;
    });
    console.log(arr2);  // [1, 16, 64, 100]
</script>

• filter()： “过滤”功能，方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

语法： array.filter(function(currentValue , index , arr){//do something}, thisValue) 

<script>
    //filter方法实现筛选排除掉所有小于5的元素：
    var arr = [1,4,6,8,10];
    var result1 = arr.filter(function(currentValue){
        return currentValue>5;
    });
    console.log(result1);  // [6, 8, 10]
    var result2 = arr.filter(function(currentValue){
        return currentValue>"5";
    });
    console.log(result2);  // [6, 8, 10]
</script>

• every()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。

语法： array.every(function(currentValue , index , arr){//do something}, thisValue) 

<script>
	var arr = [1,4,6,8,10];
	var result1 = arr.every(function(currentValue){
	    return currentValue< 12;
	});
	console.log(result1);  // true
	var result2 = arr.every(function(currentValue){
	    return currentValue> 1;
	});
	console.log(result2);  // false
</script>

• some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。

语法： array.some(function(currentValue , index , arr){//do something}, thisValue)

<script>
	var arr = [1,4,6,8,10];
	var result1 = arr.some(function(currentValue){
	    return currentValue> 10;
	});
	console.log(result1);  // false
	var result2 = arr.some(function(currentValue){
	    return currentValue> 5;
	});
	console.log(result2);  // true
</script>

---

join函数（将数组变成字符串）

join的意思是“加入，连接”，join函数的作用就是把数组的每一项连接起来，形成一个字符串。

• 用法：arrayObject.join(separator)

  参数	描述
  separator	可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

• 返回值：返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。
• 常用用法：

// 例1
var arr = new Array(3);
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
var str = arr.join();
console.log(str);  //George,John,Thomas

• 注意：

（1）split和join方法是一对相反的的方法。

---

push和pop函数（数组尾操作）

push()：方法可向数组的末尾添加一个或多个元素，并返回新的长度。

pop()：方法用于删除并返回数组的最后一个元素。

<script>
	var arr=[1,2,3,4];
	//push
	var push_arr=arr.push("Tom","Sun");
	console.log(arr); //[1,2,3,4,"Tom","Sun"];
	console.log(push_arr); // 6
	//pop
	var pop_arr=arr.pop();
	console.log(arr); //[1,2,3,4,"Tom"];
	console.log(pop_arr); // Sun	
</script>

• 注意：会改变原数组

---

shift和unshift函数（数组首操作）

shift()：方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。

unshift()：方法可向数组的开头添加一个或更多元素，并返回新的长度。

<script>
	var arr=[1,2,3,4];
	//shift
	var shift_arr=arr.shift();
	console.log(arr); // [2, 3, 4]
	console.log(shift_arr); // 1
	//unshift
	var unshift_arr=arr.unshift("Tom");
	console.log(arr); // ["Tom", 2, 3, 4]
	console.log(unshift_arr); // 4
</script>

注意：会改变原数组

---

sort()（排序）

方法用于对数组的元素进行排序。

<script>
	var arr=[1,100,5,20];
	console.log(arr.sort()); // [1, 100, 20, 5]
	console.log(arr); // [1, 100, 20, 5] (原数组改变)	
</script>

请注意，上面的代码没有按照数值的大小对数字进行排序，是按照字符编码的顺序进行排序，要实现这一点，就必须使用一个排序函数：

升序：

<script>
	var arr=[1,100,5,20];
	function sortNumber(a,b){return a - b};
	console.log(arr.sort(sortNumber)); //[1, 5, 20, 100]
	console.log(arr); //[1, 5, 20, 100] (原数组改变)
</script>

降序：

<script>
	var arr=[1,100,5,20];
	function sortNumber(a,b){return b - a};
	console.log(arr.sort(sortNumber)); // [100, 20, 5, 1]
	console.log(arr); // [100, 20, 5, 1] (原数组改变)
</script>

注意：会改变原数组

---

reverse() （反转数组）

方法用于颠倒数组中元素的顺序。

<script>
	var arr=[12,25,5,20];
	console.log(arr.reverse()); // [20, 5, 25, 12]
	console.log(arr); // [20, 5, 25, 12] (原数组改变)
</script>

注意：会改变原数组

---

reduce()和reduceRight()迭代方法

这两个方法都会迭代数组中的所有项，然后生成一个最终返回值。他们都接收两个参数，第一个参数是每一项调用的函数，函数接受四个参数分别是初始值，当前值，索引值，和当前数组，函数需要返回一个值，这个值会在下一次迭代中作为初始值。第二个参数是迭代初始值，参数可选，如果缺省，初始值为数组第一项，从数组第一个项开始叠加，缺省参数要比正常传值少一次运算。

reduce()方法从数组的第一项开始，逐个遍历到最后。而 reduceRight()则从数组的最后一项开始，向前遍历到第一项。

reduce()语法：arr.reduce(function(total , cur , index , arr){//do something}, initialValue)

reduceRight()语法：arr.reduceRight(function(total , cur , index , arr){//do something}, initialValue)

参数	描述
total	必需。初始值, 或者计算结束后的返回值。
cur	必需。当前元素。
index	可选。当前元素的索引。
arr	可选。当前元素所属的数组对象。
initialValue	可选。传递给函数的初始值。

//下面代码实现数组求和：
<script>
	var arr = [1,2,3,4,5];
	var result1 = arr.reduce(function(total,cur,index,arr){	
		console.log("total:"+total+",cur:"+cur+",index:"+index);
	    return total+cur;
	});
	console.log("结果："+result1);
	// 输出
	// total:1,cur:2,index:1
	// total:3,cur:3,index:2
	// total:6,cur:4,index:3
	// total:10,cur:5,index:4
	// 结果：15
	var result2 = arr.reduce(function(total,cur,index,arr){	
		console.log("total:"+total+",cur:"+cur+",index:"+index);
	    return total+cur;
	},10);
	console.log("结果："+result2);
	// 输出
	// total:10,cur:1,index:0
	// total:11,cur:2,index:1
	// total:13,cur:3,index:2
	// total:16,cur:4,index:3
	// total:20,cur:5,index:4
	// 结果：25
</script>

从上面代码我们可以看出，当我们不给函数传递迭代初始值时初始值 total 为数组第一项，函数从数组第二项开始迭代；若我们给函数传递迭代初始值，则函数从数组第一项开始迭代。

ES6数组新增方法（注意浏览器兼容）

---

Array.from() 

Array.from() 方法从一个类似数组或可迭代对象中创建一个新的，浅拷贝的数组实例。

• 语法：Array.from(arrayLike[, mapFn[, thisArg]])

参数	描述
arrayLike	想要转换成数组的伪数组对象或可迭代对象。
mapFn	可选。如果指定了该参数，新数组中的每个元素会执行该回调函数。
thisArg	可选。可选参数，执行回调函数 mapFn 时 this 对象。

let arr1 = Array.from('foo');  // ["f", "o", "o"]

let s = new Set(['foo', window]); 
let arr2 = Array.from(s);      // ["foo", window]

let json ={
	    '0':'卢',
	    '1':'本',
	    '2':'伟',
	    length:3
	}
let arr = Array.from(json);
console.log(arr); // ["卢", "本", "伟"]	

function f() {
  return Array.from(arguments);
}
f(1, 2, 3);         // [1, 2, 3]

//数组去重
let arr = [1, 2, 3, 4, 1, 2,3]; 
var arr5 = Array.from(new Set(arr));   //[1, 2, 3, 4]

---

find()（找到数组中符合条件的的第一个元素）

方法返回通过测试（函数内判断）的数组的第一个元素的值。方法为数组中的每个元素都调用一次函数执行。当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。如果没有符合条件的元素返回 undefined。

回调函数可以接收3个参数，依次为当前的值（currentValue）、当前的位置（index）、原数组（arr）

注意：find() 对于空数组，函数是不会执行的。find() 并没有改变数组的原始值。

<script>
    let Arr = [1,2,5,7,5,9];
    let result1 = Arr.find(function(currentValue,index,arr){            
        return currentValue>5;
    });
    let result2 = Arr.find(function(currentValue,index,arr){            
        return currentValue>9;
    });
    console.log(result1); // 7
    console.log(result2); // undefined
</script>

find()实现根据id取出数组中的对象

<script>
    let Arr = [
        {
            id:1,
            name:"张三"
        },
        {
            id:2,
            name:"李四"
        }        
    ];
    let obj = Arr.find(function(currentValue,index,arr){            
        return currentValue.id===1;
    });
    console.log(obj.name); // 张三
</script>

---

findIndex () （找到数组中符合条件的第一个元素的索引）

findIndex和find差不多，不过默认返回的是索引，如果没有符合条件的元素返回 -1

<script>
	let Arr = [1,2,5,7,5,9];
	let result1 = Arr.findIndex(function(currentValue,index,arr){			
		return currentValue>5;
	});
	let result2 = Arr.findIndex(function(currentValue,index,arr){			
		return currentValue>9;
	});
	console.log(result1); // 3
	console.log(result2); // -1
</script>

---

fill() （填充数组）

fill()方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。

语法：array.fill(value,  start,  end)

参数	描述
value	必需。填充的值。
start	可选。开始填充位置。如果这个参数是负数，那么它规定的是从数组尾部开始算起。
end	可选。停止填充位置 (默认为 array.length)。如果这个参数是负数，那么它规定的是从数组尾部开始算起。

<script>
    let arr = [1,2,3,4,5,6];
    arr.fill(0);  // [0, 0, 0, 0, 0, 0]
    arr.fill(0,1);  // [1, 0, 0, 0, 0, 0] 
    arr.fill(0,1,2);  // [1, 0, 3, 4, 5, 6]
    arr.fill(0,-1);  // [1, 2, 3, 4, 5, 0]
    arr.fill(0,1,-1);  // [1, 0, 0, 0, 0, 6]
</script>

---

遍历数组方法 keys()、values()、entries()

这三个方法都是返回一个遍历器对象，可用for...of循环遍历，唯一区别：keys()是对键名的遍历、values()对键值的遍历、entries()是对键值对的遍历。

• keys()

<script>
	let arr = ["a","b","c","d"];
	for(let i of arr.keys()){
		console.log(i);
	}
    //打印：
    // 0
    // 1
    // 2
    // 3
</script>

• values()

<script>
	let arr = ["a","b","c","d"];
	for(let i of arr.values()){
		console.log(i);
	}
    //打印：
    // a
    // b
    // c
    // d
</script>

• entries()

<script>
    let arr = ["a","b","c","d"];
    for(let i of arr.entries()){
        console.log(i);
    }
    //打印：
    // [0, "a"]
    // [1, "b"]
    // [2, "c"]
    // [3, "d"]
    for(let [idx,item] of arr.entries()){
        console.log(idx+":"+item);
    }
    //打印：
    // 0:a
    // 1:b
    // 2:c
    // 3:d
</script>

---

includes()（判断一个数组是否包含一个指定的值）

方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。跟ES5的indexOf很像，但indexOf返回的是索引值。

语法：arr.includes(searchElement ,  fromIndex)

参数	描述
searchElement	必须。需要查找的元素值。
fromIndex	可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。

<script>
	let arr = ["a","b","c","d"];
	let result1 = arr.includes("b");
	let result2 = arr.includes("b",2);
	let result3 = arr.includes("b",-1);
	let result4 = arr.includes("b",-3);
	console.log(result1);  // true
	console.log(result2);  // false
	console.log(result3);  // flase
	console.log(result4);  // true
</script>

---

copyWithin(拷贝本数组元素到本数组)

方法用于从数组的指定位置拷贝元素到数组的另一个指定位置中，会覆盖原有成员

语法：array.copyWithin(target ,  start ,  end)

参数	描述
target	必需。从该位置开始替换数据。
start	可选。从该位置开始读取数据，默认为 0 。如果为负值，表示倒数。
end	可选。到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。

<script>
	let arr = [1,2,3,4,5,6];
	let result1 = [1,2,3,4,5,6].copyWithin(0);
	let result2 = [1,2,3,4,5,6].copyWithin(0,1);
	let result3 = [1,2,3,4,5,6].copyWithin(1,3,5);
	let result4 = [1,2,3,4,5,6].copyWithin(1,2,-1);
	let result5 = [1,2,3,4,5,6].copyWithin(1,-4,6);
	console.log(result1);  // [1, 2, 3, 4, 5, 6]
	console.log(result2);  // [2, 3, 4, 5, 6, 6]
	console.log(result3);  // [1, 4, 5, 4, 5, 6]
	console.log(result4);  // [1, 3, 4, 5, 5, 6]
	console.log(result5);  // [1, 3, 4, 5, 6, 6]
</script>

---

字符串和数组都有的方法：

---

• slice
• concat
• indexOf
• lastIndexOf

字符串独有的方法：

---

• split
• substr
• substring
• charAt
• replace
• match
• search

数组独有的方法：

---

• splice
• pop
• push
• shift
• unshift
• map
• every
• some
• filter
• forEach
• reverse
• sort
• reduce()
• reduceRight()

ES6的数组新方法

参考文章

---

http://www.w3school.com.cn/

https://blog.csdn.net/qq_39132756/article/details/85007082