数组和字符串的方法总结

数组的方法大全

1. 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(值/变量)：接收任意数量的参数，并将它们添加到数组末尾，返回数组的最新长度

let colors = []; // 创建一个数组
let count = colors.push("red", "green"); // 推入两项
console.log(count) // 2

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

 var arr = ["Lily", "lucy", "Tom"];
    let s = arr.pop();
    console.log(s); //Tom
    console.log(arr); //["Lily","lucy"]

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

 var arr = ["Lily", "lucy", "Tom"];
    let s = arr.shift();
    console.log(s); //Lily
    console.log(arr); //["lucy","Tom"]

5. unshift(值/变量)：可向数组的开头添加一个或更多元素，并返回新的长度。

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

6. sort()：用于对数组的元素进行排序。

//默认排序顺序为按字母升序。
    var arr1 = ["a", "d", "c", "b"];
    console.log(arr1.sort()); // ["a", "b", "c", "d"]
    arr2 = [13, 24, 51, 3];
    console.log(arr2.sort()); // [3, 13, 24, 51]

7. reverse()：对列表中的元素进行反向排序

var arr = [3, 4, 5, 6];
console.log(arr.reverse()); //[6 , 5, 4 , 3]

8. 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](原数组未被修改)

9. slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。

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); //相当于arr.slice(1,4)
    var arrCopy4 = arr.slice(-4, -1); //相当于arr.slice(2,5)
    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]

10. splice()：很强大的数组方法，它有很多种用法，可以实现删除、插入和替换。

//删除元素,并返回删除的元素
    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]
    //向指定索引处添加元素,第二个参数是0就是插入，1就是替换
    var array1 = [22, 3, 31, 12];
    array1.splice(1, 0, 12, 35); //[]
    console.log(array1); // [22, 12, 35, 3, 31, 12]
    //替换指定索引位置的元素
    const array1 = [22, 3, 31, 12];
    array1.splice(1, 1, 8); //[3]
    console.log(array1); // [22, 8, 31, 12]

11. indexOf(元素)：要查找的项位置的索引。从数组的开头（位置 0）开始向后查找。

let arr = [1, 2, 3, 4, 5, 6];
console.log(arr.indexOf(1));//0

12. lastIndexOf(元素)：从数组的末尾开始向前查找。

let arr = ["a", "b", "c", "d", "c"];
console.log(arr.lastIndexOf("c")); //4
console.log(arr.indexOf("c"));//2

13. filter过滤：“过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(item =>{
return item >5 ;
});
console.log(arr2); //[6, 7, 8, 9, 10]

14. fill（值/变量）：能使用特定值填充数组中的一个或多个元素(es6新增)

//当只是用一个参数时，该方法会用该参数的值填充整个数组。
    let arr = [1, 2, 3, cc, 5];
    arr.fill(1);
    console.log(arr); //[1,1,1,1,1];
//个参数： 填充数值，起始位置参数，结束位置参数（不包括结束位置的那个元素）
    let arr1 = [1, 2, 3, arr, 5];
    arr1.fill(1, 2);
    console.log(arr1); //[1,2,1,1,1];
    arr1.fill(0, 1, 3);
    console.log(arr1); //[1,0,0,1,1];

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

var arr3 = [5, 6, 7, 8, 9]
      var bull = arr3.every((item) => {
        return item < 11
      })
      console.log(bull)    //true
      var bull = arr3.every((item) => {
        return item < 8
      })
      console.log(bull)     //false

29. includes()：用来判断一个数组是否包含一个指定的值，如果是返回 true，否则 false。

const array1 = [22, 3, 31, 12,  arr ];
const includes = array1.includes(31);
console.log(includes); // true
const includes1 = array1.includes(31, 3); // 从索引3开始查找31是否存在
console.log(includes1); // false

字符串的方法大全

1. str.concat()：用于将一个或多个字符串拼接起来，返回拼接后的新字符串

let str = "hello";
    console.log(str.concat("world"));
    //可以有多个，用来拼接到str上的字符串
    console.log(str.concat("my", "mother"));

2. str.slice():此方法用来提取一个字符串，并返回一个新的字符串,
   参数：beginIndex，表示从该索引处开始提取字符串的字符(包括)，如果为负数则从后开始计算 ,endIndex，表示从该索引处结束提取字符串(不包括)，如果省略则一直提取到字符串末尾，如果为负数从后开始计算

 let str = "hello world";
    //如果只有一个参数，则从字符串的第一个字符开始
    console.log(str.slice(6));
    //如果有两个参数
    console.log(str.slice(1, 4));
    //如果参数为负数，则是倒着数
    console.log(str.slice(-5, -3));

3. str.substring(startindex,endindex):如果为负数或者NaN则都会被当作0，如果大于字符串的长度则会被当做字符串的长度来计算，如果startindex,则substring的执行兄啊过就像两个参数被调换了一样

let str = 'hello world';
console.log(str.slice(6)) //'world'
console.log(str.slice(-5,-3)) //'wo'

4. str.trim()：删除一个字符串两端的空白字符，并返回删除后的新字符串，不会改变原有字符串

 let str = " hello world  ";
    console.log(str);
    console.log(str.trim());

5. str.toLowerCase()：此方法没有参数，会将调用该方法的字符串值转为小写形式，并返回

 let str = "ABC";
    console.log(str.toLocaleLowerCase()); //abc

6. str.toUpperCase()：此方法没有参数，会将调用该方法的字符串值转为大写形式，并返回

let str = "abc";
    console.log(str.toLocaleLowerCase()); //ABC

7. str.split()：用于把一个字符串分割成字符串数组

let str = "Hello";
let s = str.split("e");
console.log(str); //Hello
console.log(s); //[ 'H', 'llo' ]

8. str.replace(被替换的字符，替换的字符):可以将一个替换值替换字符串的一部分，返回替换后的新字符串。

let str = "abc";
    console.log(str.replace("a", "A")); //Abc

9. str.charAt()：可返回字符串中指定位置的字符

let str = "Hello";
let s = str.charAt(1);
console.log(s);//e

10. str.includes()：用于判断字符串是否包含指定的子字符串

let str = "Hello";
let s = str.includes("e");
console.log(s); //true

11. str.lastIndexOf()：返回某个子字符串在字符串中最后出现的位置

let str = "I love you";
    console.log(str.lastIndexOf("o")); //8

12. str.search():用于在整个字符串中搜索第一个匹配的值

let str = "123abc456";
    console.log(str.search("abc"));//3

13. str.match()：是用来查找字符的

 var str = "asdfghajkwyai";
 var result = str.match("a");
 console.log(result);