Array常用方法

push

在数组末端添加一个或多个元素，返回数组新长度

  1. var arr = [1, 2, 3, 4];
  2. var push_arr = arr.push("Sun");
  3. console.log(arr); //[1,2,3,4,"Sun"];
  4. console.log(push_arr); // 5

pop

删除数组最后一个元素，返回该元素

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

shift

删除数组第一个元素，返回该元素

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

unshift

在数组第一个位置添加元素，返回数组新长度

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

join

以参数作为分隔符，把数组分隔成字符串，默认逗号

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

concat

将多个数组合并，返回新数组，原数组不变！

  1. var arr = [1, 2, 3, 4];
  2. var arr2 = [11, 12, 13];
  3. var arr3 = arr.concat(arr2);
  4. console.log(arr3); // [1, 2, 3, 4, 11, 12, 13]
  5. console.log(arr); // [1, 2, 3, 4] (原数组未改变)

reverse

颠倒数组顺序，返回改变后的数组

  1. var arr=[12,25,5,20];
  2. console.log(arr.reverse()); // [20, 5, 25, 12]
  3. console.log(arr); // [20, 5, 25, 12] (原数组改变)

slice

截取数组，提取原数组的一部分，返回新数组，原数组不变
arr.slice(start , end);
start：必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
end：可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素

  1. var arr = [1, 4, 6, 8, 12];
  2. var arr1 = arr.slice(1);
  3. var arr2 = arr.slice(0, 4);
  4. var arr3 = arr.slice(1, -2);
  5. var arr4 = arr.slice(-5, 4);
  6. var arr5 = arr.slice(-4, -1);
  7. console.log(arr1); // [4, 6, 8, 12]
  8. console.log(arr2); // [1, 4, 6, 8]
  9. console.log(arr3); // [4, 6]
  10. console.log(arr4); // [1, 4, 6, 8]
  11. console.log(arr5); // [4, 6, 8]
  12. console.log(arr); // [1, 4, 6, 8, 12] (原数组未改变)

splice

删除原数组的一部分，可以在删除的位置添加，返回被删除的元素,改变原数组！

  1. var arr = [1, 2, 3, 4, 5, 6];
  2. var arr1 = arr.splice(2, 1);
  3. console.log(arr1); // 3
  4. console.log(arr); // [1, 2, 4, 5, 6] 改变原数组！

sort

将数组排序

  1. // 按照字符编码的顺序进行排序
  2. var arr = [1, 100, 5, 20];
  3. console.log(arr.sort()); // [1, 100, 20, 5]
  4. console.log(arr); // [1, 100, 20, 5] (原数组改变)
  6. // 升序
  7. var arr = [1, 100, 5, 20];
  8. function sortNumber(a, b) {
  9.   return a - b;
  10. }
  11. console.log(arr.sort(sortNumber)); //[1, 5, 20, 100]
  12. console.log(arr); //[1, 5, 20, 100] (原数组改变)
  14. // 降序
  15. var arr = [1, 100, 5, 20];
  16. function sortNumber(a, b) {
  17.   return b - a;
  18. }
  19. console.log(arr.sort(sortNumber)); // [100, 20, 5, 1]
  20. console.log(arr); // [100, 20, 5, 1] (原数组改变)

indexOf

返回给定元素在数组中第一次出现的位置，没有返回-1
array.indexOf(**item,start**) （从数组的开头（位置 0）开始向后查找）
item**： 必须。查找的元素。
start**：可选的整数参数。规定在数组中开始检索的位置。如省略该参数，则将从**array[0]**开始检索。

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

lastIndexOf

返回给定元素在数组中最后一次出现的位置，没有返回-1
array.lastIndexOf(**item,start**) （从数组的末尾开始向前查找）
it**em**： 必须。查找的元素。
start**：可选的整数参数。规定在数组中开始检索的位置。如省略该参数，则将从`array[array.length-1]**`开始检索。

  1. var arr = [1, 4, 7, 10, 7, 18, 7, 26];
  2. console.log(arr.lastIndexOf(7)); // 6
  3. console.log(arr.lastIndexOf(7, 2)); // 2

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

这几个方法语法都一样，都不会改变原数组。
currentValue** : 必需。当前元素
index**： 可选。当前元素的索引值。
arr **: **可选。当前元素所属的数组对象。

forEach

对数组进行遍历循环，这个方法没有返回值。

  1. var Arr = [1, 4, 7, 10];
  2. Arr.forEach(function (currentValue, index, arr) {
  3.   console.log(index, currentValue, arr === Arr);
  4. });
  5. // 0 1 true
  6. // 3 1 4 true
  7. // 3 2 7 true
  8. // 3 3 10 true

map

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

  1. var arr = [1, 4, 8, 10];
  2. var arr2 = arr.map(function (currentValue) {
  3.   return currentValue * currentValue;
  4. });
  5. console.log(arr2); // [1, 16, 64, 100]

filter

数组过滤器

  1. var arr = [1, 4, 6, 8, 10];
  2. var result1 = arr.filter(function (currentValue) {
  3.   return currentValue > 5;
  4. });
  5. console.log(result1); // [6, 8, 10]

some

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

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

every

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

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

2个归并方法：reduce()、reduceRight()

  1. arr.reduce(function (total, cur, index, arr) {}, initialValue);

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

reduce

依次处理数组每个成员，从左到右

  1. var arr = [1, 2, 3, 4, 5];
  2. var result1 = arr.reduce(function (total, cur, index, arr) {
  3.   console.log("total:" + total + ",cur:" + cur + ",index:" + index);
  4.   return total + cur;
  5. });
  6. console.log("结果：" + result1);
  7. // 输出
  8. // total:1,cur:2,index:1
  9. // total:3,cur:3,index:2
  10. // total:6,cur:4,index:3
  11. // total:10,cur:5,index:4
  12. // 结果：15
  13. var result2 = arr.reduce(function (total, cur, index, arr) {
  14.   console.log("total:" + total + ",cur:" + cur + ",index:" + index);
  15.   return total + cur;
  16. }, 10);
  17. console.log("结果：" + result2);
  18. // 输出
  19. // total:10,cur:1,index:0
  20. // total:11,cur:2,index:1
  21. // total:13,cur:3,index:2
  22. // total:16,cur:4,index:3
  23. // total:20,cur:5,index:4
  24. // 结果：25

reduceRight

依次处理数组每个成员，从右到左

字符串常用方法

length

获取字符串的长度

  1. var myString = "hello kitty";
  2. myString.length;  // 11

chatAt

返回指定位置的字符

  1. var myString = "hello world";
  2. myString.charAt(0); // h
  3. myString.charAt(3); // l
  4. myString.charAt(6); // w

concat

连接字符串,返回连接后的新字符串。

  1. var str1 = "hello";
  2. var str2 = "World";
  3. var str3 = str1.concat(str2);
  4. console.log(str3);

slice

提取字符串并返回，不改变原字符串！不包含第二个参数的位置

  1. var myString = "hello world";
  2. myString.slice(0, 5); // hello
  3. myString.slice(6); // world
  4. myString.slice(3, -1); // lo worl

split

分割成字符串数组

  1. var myString = "hello world";
  2. myString.split(""); // ["h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d"]
  4. var str = "How,are,you,doing,today?";
  5. str.split(","); // ["How", "are", "you", "doing", "today?"]

substring

提取字符并返回，不改变原字符串！

  1. var myString = "hello world";
  2. myString.substring(0, 5); // hello
  3. myString.substring(6); // world
  4. myString.substring(3, -1); // hel

substr

提取字符串并返回，不改变原字符串

  1. var myString = "hello world";
  2. myString.substr(3, 5); // lo wo
  3. myString.substr(6); // world

replact

替换字符串

  1. var str = "do you love me";
  2. str.replace('love','hate'); // "do you hate me"

indexOf

返回字符串第一次出现的位置，没有返回-1

  1. var myString = "hello world";
  2. myString.indexOf("e"); // 1
  3. myString.indexOf("o"); // 4
  4. myString.indexOf("o", 6); // 7

lastIndexOf

返回字符串最后一次出现的位置，没有返回-1

  1. var myString = "hello world";
  2. myString.indexOf("e"); // 1
  3. myString.indexOf("o"); // 7
  4. myString.indexOf("l"); // 9

trim

去除空格

  1. var str = ' abc ';
  2. str.trim(); // 'abc'
  3. console.log(str); // ' abc '

toLowerCase

全部转为小写，返回新字符串，不改变原字符串

  1. var myString = "HELLO WORLD";
  2. var myString1 = myString.toLowerCase()
  3. console.log(myString1); // hello world

toUpperCase

全部转为大写，返回新字符串，不改变原数组

  1. var myString = "hello world";
  2. var myString1 = myString.toUpperCase()
  3. console.log(myString1); // HELLO WORLD

match

匹配字符串，返回一个数组，没有返回null

search

返回匹配的第一个位置，没有返回-1