join()

join(separator): 将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符，该方法只接收一个参数：即分隔符。

  1. var arr = [1,2,3];
  2. console.log(arr.join()); // 1,2,3
  3. console.log(arr.join("-")); // 1-2-3
  4. console.log(arr); // [1, 2, 3]（原数组不变）

通过join()方法可以实现重复字符串，只需传入字符串以及重复的次数，就能返回重复后的字符串，函数如下：

  1. function repeatString(str, n) {
  2. return new Array(n + 1).join(str);
  3. }
  4. console.log(repeatString("abc", 3)); // abcabcabc
  5. console.log(repeatString("Hi", 5)); // HiHiHiHiHi

push()和pop()

push(): 可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。
pop()：数组末尾移除最后一项，减少数组的 length 值，然后返回移除的项。

  1. var arr = ["Lily","lucy","Tom"];
  2. var count = arr.push("Jack","Sean");
  3. console.log(count); // 5
  4. console.log(arr); // ["Lily", "lucy", "Tom", "Jack", "Sean"]
  5. var item = arr.pop();
  6. console.log(item); // Sean
  7. console.log(arr); // ["Lily", "lucy", "Tom", "Jack"]

shift() 和 unshift()

shift()：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 。
unshift:将参数添加到原数组开头，并返回数组的长度 。
这组方法和上面的push()和pop()方法正好对应，一个是操作数组的开头，一个是操作数组的结尾。

  1. var arr = ["Lily","lucy","Tom"];
  2. var count = arr.unshift("Jack","Sean");
  3. console.log(count); // 5
  4. console.log(arr); //["Jack", "Sean", "Lily", "lucy", "Tom"]
  5. var item = arr.shift();
  6. console.log(item); // Jack
  7. console.log(arr); // ["Sean", "Lily", "lucy", "Tom"]

sort()

sort()：按升序排列数组项——即最小的值位于最前面，最大的值排在最后面。
在排序时，sort()方法会调用每个数组项的 toString()转型方法，然后比较得到的字符串，以确定如何排序。即使数组中的每一项都是数值， sort()方法比较的也是字符串，因此会出现以下的这种情况：

  1. var arr1 = ["a", "d", "c", "b"];
  2. console.log(arr1.sort()); // ["a", "b", "c", "d"]
  3. arr2 = [13, 24, 51, 3];
  4. console.log(arr2.sort()); // [13, 24, 3, 51]
  5. console.log(arr2); // [13, 24, 3, 51](元数组被改变)

为了解决上述问题，sort()方法可以接收一个比较函数作为参数，以便我们指定哪个值位于哪个值的前面。比较函数接收两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回 0，如果第一个参数应该位于第二个之后则返回一个正数。以下就是一个简单的比较函数：

  1. function compare(value1, value2) {
  2. if (value1 < value2) {
  3. return -1;
  4. } else if (value1 > value2) {
  5. return 1;
  6. } else {
  7. return 0;
  8. }
  9. }
  10. arr2 = [13, 24, 51, 3];
  11. console.log(arr2.sort(compare)); // [3, 13, 24, 51]

如果需要通过比较函数产生降序排序的结果，只要交换比较函数返回的值即可：

  1. function compare(value1, value2) {
  2. if (value1 < value2) {
  3. return 1;
  4. } else if (value1 > value2) {
  5. return -1;
  6. } else {
  7. return 0;
  8. }
  9. }
  10. arr2 = [13, 24, 51, 3];
  11. console.log(arr2.sort(compare)); // [51, 24, 13, 3]

concat()

concat() ：将参数添加到原数组中。这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。

  1. var arr = [1,3,5,7];
  2. var arrCopy = arr.concat(9,[11,13]);
  3. console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]
  4. console.log(arr); // [1, 3, 5, 7](原数组未被修改)

从上面测试结果可以发现：传入的不是数组，则直接把参数添加到数组后面，如果传入的是数组，则将数组中的各个项添加到数组中。但是如果传入的是一个二维数组呢？

  1. var arrCopy2 = arr.concat([9,[11,13]]);
  2. console.log(arrCopy2); //[1, 3, 5, 7, 9, Array[2]]
  3. console.log(arrCopy2[5]); //[11, 13]

上述代码中，arrCopy2数组的第五项是一个包含两项的数组，也就是说concat方法只能将传入数组中的每一项添加到数组中，如果传入数组中有些项是数组，那么也会把这一数组项当作一项添加到arrCopy2中。

indexOf()和 lastIndexOf()

indexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。
lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的末尾开始向前查找。
这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回-1。在比较第一个参数与数组中的每一项时，会使用全等操作符。

  1. var arr = [1,3,5,7,7,5,3,1];
  2. console.log(arr.indexOf(5)); //2
  3. console.log(arr.lastIndexOf(5)); //5
  4. console.log(arr.indexOf(5,2)); //2
  5. console.log(arr.lastIndexOf(5,4)); //2
  6. console.log(arr.indexOf("5")); //-1

forEach()

forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。

  1. var arr = [1, 2, 3, 4, 5];
  2. arr.forEach(function(x, index, a){
  3. console.log(x + '|' + index + '|' + (a === arr));
  4. });
  5. // 输出为：
  6. // 1|0|true
  7. // 2|1|true
  8. // 3|2|true
  9. // 4|3|true
  10. // 5|4|true

map()

map()：指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
下面代码利用map方法实现数组中每个数求平方。

  1. var arr = [1, 2, 3, 4, 5];
  2. var arr2 = arr.map(function(item){
  3. return item*item;
  4. });
  5. console.log(arr2); //[1, 4, 9, 16, 25]

every()

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

  1. var arr = [1, 2, 3, 4, 5];
  2. var arr2 = arr.every(function(x) {
  3. return x < 10;
  4. }); 
  5. console.log(arr2); //true
  6. var arr3 = arr.every(function(x) {
  7. return x < 3;
  8. }); 
  9. console.log(arr3); // false

some()

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

  1. var arr = [1, 2, 3, 4, 5];
  2. var arr2 = arr.some(function(x) {
  3. return x < 3;
  4. }); 
  5. console.log(arr2); //true
  6. var arr3 = arr.some(function(x) {
  7. return x < 1;
  8. }); 
  9. console.log(arr3); // false

reduce()和 reduceRight()

这两个方法都会实现迭代数组的所有项，然后构建一个最终返回的值。reduce()方法从数组的第一项开始，逐个遍历到最后。而 reduceRight()则从数组的最后一项开始，向前遍历到第一项。
这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。
传给 reduce()和 reduceRight()的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。
下面代码用reduce()实现数组求和，数组一开始加了一个初始值10。

  1. var values = [1,2,3,4,5];
  2. var sum = values.reduceRight(function(prev, cur, index, array){
  3. return prev + cur;
  4. },10);
  5. console.log(sum); //25

findIndex()方法

对数组执行遍历，查询对应值的下标

  1.         var arr = [1,2,3,2];
  2.         var index = arr.findIndex(item=>{
  3.             return item == 2;
  4.         })
  5.         console.log(index);

filter()方法

只要满足某个条件，返回数组

  1.         var arr = [1,2,3,4];
  2.         // var res = [];
  3.         // for(var i=0;i<arr.length;i++){
  4.         //     if(arr[i]>2){
  5.         //         res.push(arr[i]);
  6.         //     }
  7.         // }
  8.         // console.log(res)
  9.         var res = arr.filter(item=>item>2);
  10.         console.log(res);

reverse()方法

颠倒数组中元素的顺序

  1.         var arr = ["html","css","javascript"];
  2.         console.log(arr.reverse())

includes()方法

includes() 方法用于判断数组是否包含指定的值。
如果找到匹配的字符串则返回 true，否则返回 false。

  1.         var arr = [1,2,3,4];
  2.         console.log(arr.includes(4));

slice()方法

slice(start, end) 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。
使用 start（包含） 和 end（不包含） 参数来指定字符串提取的部分。
start 参数字符串中第一个字符位置为 0, 第二个字符位置为 1, 以此类推，如果是负数表示从尾部截取多少个字符串，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
end 参数如果为负数，-1 指字符串的最后一个字符的位置，-2 指倒数第二个字符，以此类推。

  1.         var str  ="hello";
  2.         console.log(str[0]);
  3.         console.log(str.slice(1,3))

示例1、

  1.         var str = "hello";
  2.         console.log(str.length)
  3.         var s = "故事的结尾，心上人";
  4.         console.log(handleStr(s))
  6.         function handleStr(value) {
  7.             if (value.length > 5) {
  8.                 return value.slice(0, 5) + "..."
  9.             }
  10.             return value;
  11.         }

substr()方法和substring()方法

splice()

splice()：很强大的数组方法，它有很多种用法，可以实现删除、插入和替换。
删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。例如， splice(0,2)会删除数组中的前两项。
插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。例如，splice(2,0,4,6)会从当前数组的位置 2 开始插入4和6。
替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如，splice (2,1,4,6)会删除当前数组位置 2 的项，然后再从位置 2 开始插入4和6。
splice()方法始终都会返回一个数组，该数组中包含从原始数组中删除的项，如果没有删除任何项，则返回一个空数组。

  1. var arr = [1,3,5,7,9,11];
  2. var arrRemoved = arr.splice(0,2);
  3. console.log(arr); //[5, 7, 9, 11]
  4. console.log(arrRemoved); //[1, 3]
  5. var arrRemoved2 = arr.splice(2,0,4,6);
  6. console.log(arr); // [5, 7, 4, 6, 9, 11]
  7. console.log(arrRemoved2); // []
  8. var arrRemoved3 = arr.splice(1,1,2,4);
  9. console.log(arr); // [5, 2, 4, 4, 6, 9, 11]
  10. console.log(arrRemoved3); //[7]

substr()可在字符串中抽取从 开始 下标开始的指定数目的字符。
substring()用于提取字符串中介于两个指定下标之间的字符。

  1.         var str = "hello";
  3.         console.log(str.substr(0,3));
  4.         console.log(str.substring(0,2))

charAt()方法

输出某一位下标值的字符

  1.         var str = "hello";
  2.         console.log(str.charAt(1))

示例liyi

例一、

  1.     <input type="text" id="txt">
  2.     <script>
  3.         /* 
  4.         filter
  5.         includes
  6.         slice()
  7.          */
  8.         var arr = [
  9.             {name:"你是谁,他在那里",id:1102},
  10.             {name:"圈住你在那里",id:1102},
  11.             {name:"hello在那里",id:1102},
  12.             {name:"怪你",id:1102},
  13.             {name:"world",id:1102},
  14.         ]
  15.         /* 1.enter回车获取关键字
  16.            2.使用关键字,对数据查询,得到一个新的数组
  17.            3.name的字符超过3位以...结尾
  18.          */
  19.          /* 1.enter回车获取关键字 */
  20.         var txt = document.getElementById("txt");
  21.         txt.onkeydown =  function(event){
  22.             if(event.keyCode == 13){
  23.                 var value = this.value;
  24.                 /*  2.使用关键字,对数据查询,得到一个新的数组 */
  25.                 if(value){
  26.                     // console.log(value)
  27.                     var res = arr.filter(item=>{
  28.                         return  item.name.includes(value);
  29.                     })
  30.                     /* 3.name的字符超过3位以...结尾 */
  31.                     res.map(item=>{
  32.                         if(item.name.length>3){
  33.                             return item.name = item.name.slice(0,3)+"..."
  34.                         }
  35.                     })
  36.                     console.log(res)
  37.                 }
  38.             }
  39.         }