
  
   
    
     
    
    
     
      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() Y

(Y：表示会改变原数组)

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

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

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

　　　 书写格式：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() (和上面的push，pop相反，针对第一项内容) Y

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. reverse() Y

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

　　　 书写格式：arr.reverse( )


  
   
    
     
    
    
     
      var arr = [
      13, 
      24, 
      51, 
      3]; 
     
    
   
    
     
    
    
     
      console.log(arr.reverse()); 　　　　　　　　
      //[3, 51, 24, 13]

5. indexOf() 和 lastIndexOf()

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

6. every()

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

　　　　书写格式：arr.every()


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

7. some()

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

　　　　书写格式：arr.some()


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

8. toString() 和 toLocaleString()

toString(): 将参数转换为字符串。以逗号( ，)分隔。

　　　　书写格式：arr.toString()

toLocalString(): 将参数转换为字符串。

　　　　书写格式：arr.toLocalString()

这二者的区别主要有两点：

传入一串数字时，toLocaleString() 会在每三位之间加一个逗号
传入一个日期时，toLocaleString() 会以更简便的方式打印日期


  
   
    
     
    
    
     
      // 区别一：
     
    
   
    
     
    
    
     
      var a=
      1234
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      console.log(a.toString())        
      // "1234"
     
    
   
    
     
    
    
     
      console.log(a.toLocaleString())  
      // "1,234"
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      // 区别二：
     
    
   
    
     
    
    
     
      var sd=
      new 
      Date()
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      console.log(sd)                  
      // Wed Feb 15 2017 11:21:31 GMT+0800 (CST)
     
    
   
    
     
    
    
     
      console.log(sd.toLocaleString()) 
      // "2017/2/15 上午11:21:31"
     
    
   
    
     
    
    
     
      console.log(sd.toString())       
      // "Wed Feb 15 2017 11:21:31 GMT+0800 (CST)"

9. sort() Y

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

　　　 书写格式：arr.sort( )

将一个函数作为参数时，sort()排序内部每次比较两个元素，形参 p、l 表示两个元素的前一个元素和后一个元素。最终的排序方式就和 return 中 p、l 的顺序有关。

注意，不能以0作为参考的分界线，也就是说，不是说 p-l>0 就是降序，p-l<0 就是升序。

简单的概括sort()函数的排序方式：先拿数组中前两个元素比较大小，并进行排序，然后前三个，前四个...每当新加入一个元素时，先通过折半查找找到中间的元素，然后和这个新加的元素进行比较，然后再折半，再比较。直到找到合适的位置。可以参考一下这篇文章：JS数组方法 sort() 排序规则解析。

对比下面案例的后两个例子，可以看到：当 p、l 以顺序相减时（形参是先 p 后 l，所以顺序对应也就是 p - l），数组是以升序排序；p、l逆序相减时（l - p），数组是以降序排序。这个时候，我们就可以将" - "看做为" < "，

return p - l; 就可以理解为return p < l，也就是前一个元素小于后一个元素，那么元素就是以升序排列；
return l - p; 就可以理解为return l < p，也就是前一个元素大于后一个元素，所以此时元素就是以降序排列；


  
   
    
     
    
    
     
      // 【案例一：】
     
    
   
    
     
    
    
     
      var arr = [
      20, 
      13, 
      11, 
      8, 
      0, 
      11]; 
     
    
   
    
     
    
    
     
      console.log(arr1.sort()); 　　　　　　　
      // [0, 8, 11, 11, 13, 20]
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      // 【案例二：】升序
     
    
   
    
     
    
    
     
      arr.sort(
      function(p, l){
     
    
   
    
     
    
    
     	
      return p - l; 
     
    
   
    
     
    
    
     
      });
     
    
   
    
     
    
    
     
      console.log(arr);                     
      // [0, 8, 11, 11, 13, 20]; 
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      // 【案例三：】降序
     
    
   
    
     
    
    
     
      arr.sort(
      function(p, l){
     
    
   
    
     
    
    
     	
      return l - p; 
     
    
   
    
     
    
    
     
      });
     
    
   
    
     
    
    
     
      console.log(arr2);                     
      // [20, 13, 11, 11, 8, 0];

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

11. slice()

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

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

简单总结：

当没有第二个参数时，就是从第一个参数对应的下标到最后一个元素，
当有第二个参数时，获取的就是数组中从两个参数对应位置之间的元素。
- 前闭后开，
- 正数看的就是下标，
- 负数就是从后往前数，-1就表示最后一个元素，-2就表示倒数第二个元素。


  
   
    
     
    
    
     
      var arr = [
      1,
      3,
      5,
      7,
      9,
      11]; 
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      console.log(arr.slice(
      1));            
      //[3, 5, 7, 9, 11] 
     
    
   
    
     
    
    
     
      console.log(arr.slice(
      1,
      4));          
      //[3, 5, 7] 
     
    
   
    
     
    
    
     
      console.log(arr.slice(
      1,
      -2));         
      //[3, 5, 7] 
     
    
   
    
     
    
    
     
      console.log(arr.slice(
      -4,
      -1));        
      //[5, 7, 9]

12. splice() Y

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]

13. forEach()

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

　　　　书写格式：arr.forEach()


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

14. map()

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

　　　　书写格式：arr.map()


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

15. filter()

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

　　　　书写格式：arr.filter()


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

16. reduce() 和 reduceRight()

reduce()：“计算功能”，数组中的每一项通过函数中的计算方法，将每一次计算的结果保存在函数的一个参数中，返回这个最终的运算结果。

　　　　书写格式：arr.reduce()

pre 表示上一次运算的结果，
cur 表示在数组中遍历到的当前的值，
index 表示当前元素的下标，
arr 表示调用方法的数组。

reduceRight()：同reduce，只不过变成了由右至左遍历。


  
   
    
     
    
    
     
      var arr = [
      1, 
      2, 
      3, 
      4, 
      5]; 
     
    
   
    
     
    
    
     
      var res= arr.reduce(
      function(pre, cur, index, arr) { 
     
    
   
    
     
    
    
       
      console.log(pre+
      "|"+cur+
      "|"+index+
      "|"+arr)
     
    
   
    
     
    
    
       
      return pre+cur; 
     
    
   
    
     
    
    
     
      }, 
      10); 
     
    
   
    
     
    
    
     
      console.log(arr2); 　　　　　　　
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      // 输出为： 
     
    
   
    
     
    
    
     
      // 10|1|0|1, 2, 3, 4, 5
     
    
   
    
     
    
    
     
      // 11|2|1|1, 2, 3, 4, 5
     
    
   
    
     
    
    
     
      // 13|3|2|1, 2, 3, 4, 5
     
    
   
    
     
    
    
     
      // 16|4|3|1, 2, 3, 4, 5
     
    
   
    
     
    
    
     
      // 20|5|4|1, 2, 3, 4, 5
     
    
   
    
     
    
    
     
      // 25

字符串的常用方法：

注意：字符串的所有方法均不会影响原字符串，均是生成一个副本，对副本进行操作。

1. toLowerCase() 和 toUpperCase()

toLowerCase(): 把字符串转为小写，返回新的字符串。

　　　　书写格式：str.toLowerCase()

toUpperCase(): 把字符串转为大写，返回新的字符串。

　　　　书写格式：str.toUpperCase()


  
   
    
     
    
    
     
      var str = 
      "Hello World";
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      console.log(str.toLowerCase());             
      // hello world
     
    
   
    
     
    
    
     
      console.log(str.toUpperCase());             
      // HELLO WORLD

2. charAt()

charAt(): 返回指定下标位置的字符。如果 index 不在 0-str.length (不包含 str.length )之间，返回空字符串。

　　　　书写格式：str.charAt()


  
   
    
     
    
    
     
      var str = 
      "hello world";
     
    
   
    
     
    
    
     
      console.log(str.charAt(
      6));              
      // w

3. charCodeAt()

charCodeAt(): 返回指定下标位置的字符的 unicode 编码,这个返回值是 0 - 65535 之间的整数。

　　　　书写格式：str.charCodeAt()


  
   
    
     
    
    
     
      var str = 
      "hello world";
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      console.log(str.charCodeAt(
      1));                 
      // 101 
     
    
   
    
     
    
    
     
      console.log(str.charCodeAt(
      -2));                
      // NaN

注意：如果 index 不在 0-str.length (不包含str.length)之间，返回NaN。

4. indexOf() 和 lastIndexOf()

indexOf(): 返回某个指定的子字符串在字符串中第一次出现的位置。

　　　　书写格式：str.indexOf()

lastIndexOf(): 返回某个指定的子字符串在字符串中最后一次出现的位置。

　　　　书写格式：str.lastIndexOf()


  
   
    
     
    
    
     
      var str = 
      "Hello World";
     
    
   
    
     
    
    
     
      var str1 = str.indexOf(
      "o");
     
    
   
    
     
    
    
     
      console.log(str1);                                  
      // 4 
     
    
   
    
     
    
    
     
      console.log(str.indexOf(
      "world"));                  
      // -1
     
    
   
    
     
    
    
     
      console.log(str.indexOf(
      "o",str1+
      1));               
      // 7
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      var str2 = str.lastIndexOf(
      "o");
     
    
   
    
     
    
    
     
      console.log(str2);                                  
      // 7 
     
    
   
    
     
    
    
     
      console.log(str.lastIndexOf(
      "world"));              
      // -1
     
    
   
    
     
    
    
     
      console.log(str.lastIndexOf(
      "o",str2
      -1));           
      // 4

注意：

indexOf()、lastIndexOf()方法对大小写敏感，
如果子字符串没有找到，返回-1。
第二个参数表示从哪个下标开始查找，没有写则默认从下标0开始查找。

5. slice() 和 substring() 和 substr()

相同点：

前闭后开
返回字符串中提取的子字符串，
第二个参数均可以省略，省略时表示到字符串末尾。

不同点：

参数特点：
- slice(startIndex, endIndex) 第一个参数指定字符串的开始位置，第二个参数指定字符串的结束位置；
- substring(index0, index1) 会将小的参数作为开始位置，大的作为结束位置；
- substr(startIndex, num) 第一个参数指定字符串的开始位置，第二个参数要返回的字符个数；
参数为负：
- slice参数为负值时，表示从后往前数，例如-1表示最后一个字符，-2表示倒数第二个字符；
- substring参数为负值时，会将所有的负值参数转换成0；
- substr第一个参数为负时也是表示从后往前数，第二个参数为负直接转换为0。


  
   
    
     
    
    
     
      var str = 
      "Hello World";
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      // slice
     
    
   
    
     
    
    
     
      console.log(str.slice(
      2));                   
      // llo World 
     
    
   
    
     
    
    
     
      console.log(str.slice(
      2,
      7));                 
      // llo W
     
    
   
    
     
    
    
     
      console.log(str.slice(
      -7,
      -2));               
      // o Wor
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      // substring
     
    
   
    
     
    
    
     
      console.log(str.substring(
      2,
      2));             
      // "" 空串
     
    
   
    
     
    
    
     
      console.log(str.substring(
      7,
      2));             
      // llo W
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      // substr
     
    
   
    
     
    
    
     
      console.log(str.substr(
      1,
      3));                
      // ell
     
    
   
    
     
    
    
     
      console.log(str.substr(
      -3,
      2));               
      // rl

6. split()

split(): 把字符串分割成字符串数组。

　　　　书写格式：str.split()

第二个参数表示返回的元素的最大个数。


  
   
    
     
    
    
     
      var str1 = 
      "AA BB CC DD";
     
    
   
    
     
    
    
     
      var str2 = 
      "1:2:3:4:5";
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      console.log(str1.split());            
      // ["AA BB CC DD"]
     
    
   
    
     
    
    
     
      console.log(str1.split(
      ""));          
      // ["A", "A", " ", "B", "B", " ", "C", "C", " ", "D", "D"]
     
    
   
    
     
    
    
     
      console.log(str1.split(
      " "));         
      // ["AA" "BB" "CC" "DD"]
     
    
   
    
     
    
    
     
      console.log(str1.split(
      "",
      4));        
      // ["A", "A", " ", "B"]
     
    
   
    
     
    
    
     
      console.log(str2.split(
      ":"));         
      // ["1", "2", "3", "4", "5"]

7. replace()

replace(): 在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

　　　　书写格式：str.replace(reg, "string")


  
   
    
     
    
    
     
      var str = 
      "hello WORLD";
     
    
   
    
     
    
    
     
      var reg = 
      /o/ig;                  
     
    
   
    
     
    
    
     
      var str1 = str.replace(reg, 
      "**")
     
    
   
    
     
    
    
     
      console.log(str1);              
      // hell** W**RLD

8. match()

match(): 返回所有查找的关键字内容的数组。

　　　　书写格式：str.match(reg)


  
   
    
     
    
    
     
      var str = 
      "To be or not to be";
     
    
   
    
     
    
    
     
      var reg = 
      /to/ig;
     
    
   
    
     
    
    
     
      var str1 = str.match(reg);
     
    
   
    
     
    
    
     
      console.log(str1);                 
      // ["To", "to"]
     
    
   
    
     
    
    
     
      console.log(str.match(
      "Hello"));   
      // null

转载：https://blog.csdn.net/qq_44647809/article/details/116485148

查看评论

飞道的博客

飞道的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章

JavaScript 数组和字符串常用方法总结

数组常用方法：

1. join()

2. push() 和 pop() Y

3. shift() 和 unshift() (和上面的push，pop相反，针对第一项内容) Y

4. reverse() Y

5. indexOf() 和 lastIndexOf()

6. every()

7. some()

8. toString() 和 toLocaleString()

9. sort() Y

10. concat()

11. slice()

12. splice() Y

13. forEach()

14. map()

15. filter()

16. reduce() 和 reduceRight()

字符串的常用方法：

1. toLowerCase() 和 toUpperCase()

2. charAt()

3. charCodeAt()

4. indexOf() 和 lastIndexOf()

5. slice() 和 substring() 和 substr()

6. split()

7. replace()

8. match()

* 以上用户言论只代表其个人观点，不代表本网站的观点或立场

飞道的博客

飞道的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章

JavaScript 数组 和 字符串 常用方法总结

数组常用方法：

1. join()

2. push() 和 pop() Y

3. shift() 和 unshift() (和上面的push，pop相反，针对第一项内容) Y

4. reverse() Y

5. indexOf() 和 lastIndexOf()

6. every()

7. some()

8. toString() 和 toLocaleString()

9. sort() Y

10. concat()

11. slice()

12. splice() Y

13. forEach()

14. map()

15. filter()

16. reduce() 和 reduceRight()

字符串的常用方法：

1. toLowerCase() 和 toUpperCase()

2. charAt()

3. charCodeAt()

4. indexOf() 和 lastIndexOf()

5. slice() 和 substring() 和 substr()

6. split()

7. replace()

8. match()

* 以上用户言论只代表其个人观点，不代表本网站的观点或立场

JavaScript 数组和字符串常用方法总结