数组的方法和字符串的方法总结

数组中的方法

1. join()

join：就是把数组转换成字符串，然后给他规定个连接字符，默认的是逗号( , )

书写格式：join("")，括号里面写字符串 (“要加引号”),

代码如下（示例）：

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

2. push()和pop()

push(): 把里面的内容添加到数组末尾，并返回修改后的长度。

pop()：移除数组最后一项，返回移除的那个值，减少数组的length。

书写格式：arr.push("")，括号里面写内容 (“字符串要加引号”),

书写格式：arr.pop()
　　　
代码如下（示例）：

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

3. shift() 和 unshift()

shift()：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 。

unshift():将参数添加到原数组开头，并返回数组的长度 。

书写格式：arr.shift("")，括号里面写内容 (“字符串要加引号”),
　　　　
代码如下（示例）：

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

4. sort()

sort()：将数组里的项从小到大排序

书写格式：arr.sort()

代码如下（示例）：

var arr1 = ["a", "d", "c", "b"];
console.log(arr1.sort()); 　　　　　　　　　　// ["a", "b", "c", "d"]

sort()方法比较的是字符串，没有按照数值的大小对数字进行排序，要实现这一点，就必须使用一个排序函数

  function sortNumber(a, b) {
    return a - b
  }
  arr = [13, 24, 51, 3];
  console.log(arr.sort()); // [13, 24, 3, 51] 
  console.log(arr.sort(sortNumber)); // [3, 13, 24, 51](数组被改变)

  // 排序
  arr.sort(function (a, b) {
    return a - b; //从小到大排序
    return b - a; //从大到小排序
  });

5. reverse()

reverse()：反转数组项的顺序。

书写格式：arr.reverse()
　　　
代码如下（示例）：

var arr = [13, 24, 51, 3];
console.log(arr.reverse()); 　　　　　　　　//[3, 51, 24, 13]
console.log(arr); 　　　　　　　　　　　　　　//[3, 51, 24, 13](原数组改变)

6. concat()

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

书写格式：arr.concat()，括号里面写内容 (“字符串要加引号”)
　　　　
代码如下（示例）：

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

7. slice()

slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。

书写格式：arr.slice(1, 3)
　　　　
代码如下（示例）：

var arr = [1,3,5,7,9,11];
var arrCopy = arr.slice(1);
var arrCopy2 = arr.slice(1,4);
var arrCopy3 = arr.slice(1,-2);
var arrCopy4 = arr.slice(-4,-1);
console.log(arr); 　　　　　　　　　　　　　　//[1, 3, 5, 7, 9, 11](原数组没变)
console.log(arrCopy); 　　　　　　　　　　　 //[3, 5, 7, 9, 11]
console.log(arrCopy2); 　　　　　　　　　　　//[3, 5, 7]
console.log(arrCopy3); 　　　　　　　　　　　//[3, 5, 7]
console.log(arrCopy4); 　　　　　　　　　　　//[5, 7, 9]

arrCopy只设置了一个参数，也就是起始下标为1，所以返回的数组为下标1（包括下标1）开始到数组最后。

arrCopy2设置了两个参数，返回起始下标（包括1）开始到终止下标（不包括4）的子数组。

arrCopy3设置了两个参数，终止下标为负数，当出现负数时，将负数加上数组长度的值（6）来替换该位置的数，因此就是从1开始到4（不包括）的子数组。
arrCopy4中两个参数都是负数，所以都加上数组长度6转换成正数，因此相当于slice(2,5)。

8. splice()

splice()：删除、插入和替换。

删除：指定 2 个参数：要删除的第一项的位置和要删除的项数。

书写格式： arr.splice(1, 3)

插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。

书写格式：arr.splice(2, 0, 4, 6)
　　　　
替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。

书写格式：arr.splice(2, 0, 4, 6)
　　　　
代码如下（示例）：

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

9. indexOf()和 lastIndexOf() （ES5新增）

indexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。

书写格式：arr.indexof(5)

lastIndexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的末尾开始向前查找。

书写格式： arr.lastIndexOf(5, 4)
　　　　
代码如下（示例）：

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

10. forEach() （ES5新增）

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

书写格式：arr.forEach()
　　　　
代码如下（示例）：

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

11. map() （ES5新增）

map()：指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

字符串的方法

1、slice 和 substring

相同点：
都是用来提取字符串。接收两个参数，第一个是提取的开始位置，第二个是提取的结束位置（不包括该位置）。

不同点：

• slice

1. 如果参数是负数，表示从结尾开始倒数计算的位置，即该负值加字符串的长度。

javaScript'.slice(-6) // 'Script

2. 如果第一个参数大于第二个参数，slice方法返回空字符串

javaScript'.slice(4, 2) //''

• substring

1. 如果参数是负数，则会自动转为0

'javaScript'.substring(-2, 4) // 'java'

如果第一个参数大于第二个参数，会自动互换位置。

'javaScript'.substring(2, -5) // 'ja'

2. 由于这些规则违反直觉，因此不建议使用substring方法，应该优先使用slice。

2、substr

该方法也是用来提取字符串，参数一是开始位置，参数2是提取的子字符串的长度。

如果省略第二个参数，则表示子字符串一直到原字符串的结束。

'javaSctipr'.substr(4) // 'Script'

如果第一个参数是负数，表示倒数计算的字符位置。

'javaScript'.substr(-2) // 'pt'

如果第二个参数是负数，将被自动转为0，因此会返回空字符串。

'javaScript'.substr(2, -2) // ''

3、indexOf 和 lastIndexOf

相同点：

indexOf 和 lastIndexOf 都是获取字符在字符串中第一次出现的位置。均接收两个参数，第一个参数是要匹配的字符，第二个参数是开始位置。匹配不到返回-1.

• indexOf:

1. 获取子字符串在字符串中第一次出现的位置

'javaScript'.indexOf('Script') // 4

2. 接收第二个参数，表示从该位置开始向后匹配。

'javaScript'.indexOf('a', 2) // 3

• lastIndexOf:

1. 从尾部开始匹配’a’第一次出现的位置

'javaScript'.lastIndexOf('a') //  3

2. 接收第二个参数，表示从该位置向前匹配

'javaScript'.lastIndexOf('a', 2) // 1

不同点：

indexOf从头开始向后匹配，参数二表示从该位置向后匹配；

lastIndexOf 从尾部开始向前匹配，参数二表示从该位置向前匹配。

4. trim

去除字符串两边的空格，返回新字符串

' javascript    '.trim() // 'javascript'

5. toLowerCase() 和 toUpperCase()

toLowerCase用于将一个字符串全部转为小写，toUpperCase则是全部转为大写。它们都返回一个新字符串，不改变原字符串。

6. match()

match用于确定原字符串是否匹配某个子字符串，返回一个数组，成员为匹配的第一个字符串。如果没有找到匹配，则返回null。

'cui sina baidu'.match('sina') // ['sina']

数组还有index和input属性； index为匹配到字符的索引，input为原字符串

7. search 和 replace

search和match基本相同，不同之处是search接收正则作为参数。

replace接收两个参数，用于将匹配到的参数一替换成参数二。如果参数一是字符串，则只替换第一个匹配到的；参数一还可接收正则表达式，如果全部替换，可以使用g正则修饰符。

8. split()

用于将字符串根据给定规则切割成数组。

如果没有参数，则返回由原字符串作为唯一元素组成的数组。

9. includes()、startsWith() 和 endsWith()

ES6 提供了三种新方法来确定一个字符串是否包含在另一个字符串中。

includes():回布尔值，表示是否找到了参数字符串。
startsWith()：返回布尔值，表示参数字符串是否在原字符串的头部。
endsWith()：返回布尔值，表示参数字符串是否在原字符串的尾部。

'javascript'.includes('scr')     // true

'javascript'.startsWith('java')  // true

'javascript'.endsWith('script')  // true`

这三个方法都接收第二个参数，表示开始查找的位置：

'hello sina'.startsWith('s', 4)  // true
'hello sina'.endsWith('s', 3)    // false

10. repeat()

repeat() 方法返回新字符串，表示将原字符串重复n次。

'sina'.repeat(2) // 'sinasina'

1. 参数是小数，则向下取整。

'sina'.repeat(2.8) // 'sinasina'

2. 参数是NaN，则会转成0

'sina'.repeat(NaN) // ''

3. 参数是字符串，先转成数字

'sina'.repeat('2') // 'sinasina'
'sina'.repeat('h') // ''
'sina'.repeat('2h') // ''

4. 参数是 0 到-1 之间的小数，则等同于 0，这是因为会先进行取整运算。0 到-1 之间的小数，取整以后等于-0，repeat视同为 0。

'sina'.repeat(-0.9) // ''

5. 参数是负数或者Infinity，会报错。

'na'.repeat(Infinity) // RangeError
'na'.repeat(-1) //RangeError

11. padStart()，padEnd()

这两个方法为字符串补全功能。如果某个字符串不够指定长度，会在头部或尾部进行不全。padStart() 用于头部补全，padEnd() 用于尾部补全。

'sina'.padStart(8, 'ab')  // 'ababsina'
'sina'.padEnd(7, 'ab')    // 'sinaaba'

1. 如果原字符串的长度等于或大于最大长度，则补全无效，返回原字符串。

'sina'.padStart(4, 'ab')  // 'sina'

2. 如果用来补全的字符串与原字符串，两者的长度之和超过了最大长度，则会截去超出位数的补全字符串。

'sina'.padStart(10, 'hello beijing') // 'hello sina'

3. 如果省略第二个参数，默认使用空格补全长度。

'sian'.padStart(6)  // 'sina  '

padStart()的常见用途是为数值补全指定位数。

'1'.padStart(10, '0')  // '0000000001'

另一个用途是提示字符串格式。

'12'.padStart(10, 'YYYY-MM-DD')  // 'YYYY-MM-12'

12. trimStart()，trimEnd() ES2019新增

trimStart()消除字符串头部的空格，trimEnd()消除尾部的空格。它们返回的都是新字符串，不会修改原始字符串。
除了空格键，对tab键、换行符不可见的空白符也是有效的。

'  sina '.trimStart() // 'sina '
' sina   '.trimEnd()  // ' sina'