js中字符串常用方法、数组常用方法

字符串

1.indexOf/lastIndexOf

        const str = 'kdwofwad'
        let index = str.indexOf('w')
        console.log(index)
        let index1 = str.lastIndexOf('w')
        console.log(index1)
        let index2 = str.indexOf('w',3)//找出索引为3位置之后出现w字符串的位置
        console.log(index2)//5
        let index3 = str.indexOf('w',6)//找出索引为6位置之后出现w字符串的位置
        console.log(index3)//-1
        let index4 = str.lastIndexOf('w',1)//找出索引为3位置之后出现w字符串的位置
        console.log(index4)//-1

2.slice()：截取字符串

//需求：手机号的迷糊处理
const str = '17698451396'
let res1 = str.substr(0,3)
let res2 = str.slice(str.length-4)
console.log(res1+'*'.repeat(4)+res2)//176****1396

数组

1.Array.of()：返回具有可变数量参数的新数组实例。

     const arr = new Array(3)//数组中会创建3个元素,但是都是空的[empty × 3]
     console.log(arr.length)//3
     console.log(arr[0],arr[1],arr[2])//undefined undefined undefined

     const arr1 = Array.of(3)//只会创建一个元素,就是[3]
     console.log(arr1)//[3]
     const arr2 = Array.of('f','g','h')//创建三个元素
     console.log(arr2)//["f", "g", "h"]

2.Array.from()：将具有length属性的类数组对象转为数组。转为数组还有更简单的一种写法：[...XXX]

      let spans = document.querySelectorAll('span')
      let spansArr = Array.from(spans)
      console.log(spansArr)//[span,span]

      let str = '时间多我发'
      let res = Array.from(str)
      console.log(res)//["时", "间", "多", "我", "发"]

3.concat(arr2):将两个一维数组合并为一个数组，二维数组不行。

var arr3 = [1,2,3]
var arr2 = [1,2,3]
var arr4 = arr3.concat(arr2)
console.log(arr4)

4.slice(start,[end])：截取数组的一部分或者复制整个数组，返回新数组。

var arr = [1,2,3,4,5,6]
var arr1 = arr.slice(1,4)
console.log(arr1)//[2,3,4]
----------------------------------
var arr2 = arr.slice()
console.log(arr2)// [1,2,3,4,5,6]

5.splice(start,howmany,[item1,item2,...])：截取数组一部分或者替换数组元素、添加新的数组元素。

var arr = [1,2,3,4]
var arr1 = arr.splice(1,3)//截取一部分
console.log(arr1)//[2,3,4]
-----------------------------------
var arr= [1,2,3,4]
arr.splice(2,1,'嘿')//替换数组中某元素
console.log(arr)//[1, 2, "嘿", 4]
--------------------------------------
var arr = [1,2,3,4]
arr.splice(2,0,'嘿')//插入新元素
console.log(arr)//[1, 2, "嘿", 3, 4]

封装一个可以移动数组内元素位置的函数。

      function arrayMove(array,from,to){
        if(from < 0 || to > array.length){
            return
        }
        const newArray = [...array]
        let item = newArray.splice(from,1)
        newArray.splice(to,0,...item)
        return newArray
      }
      const arr1 = ['解读为','都还好','待会代付','还无法']
      let newarray = arrayMove(arr1,0,2)
      console.log(newarray)

6.sort():对数组元素进行排序

6.1 sort()在没有参数时,参数在比较前都会通过toString()方法转换为字符串,按照Ascii进行排序？
const arr = [10,5,40,25,1000,1]
console.log(arr.sort())//[1, 10, 1000, 25, 40, 5]
6.2很明显上面不是我想要的排序结果
const arr = [10,5,40,25,1000,1]
function sortNumber(a,b){ //比较函数作为sort()的参数,如果a<b,则a排在b的前面,如果a>b,则a排在b的后面
    return a - b
}
console.log(arr.sort(sortNumber)) //[1, 5, 10, 25, 40, 1000]
console.log(arr.sort((a,b) => a - b))//[1, 5, 10, 25, 40, 1000]

6.3 sort()的简单实现原理
  function sort(array,callback){
      for(let n in array){
        for(let m in array){
          if(callback(array[n],array[m])<0){
            let temp = array[m]
            array[m] = array[n]
            array[n] = temp
          }
        }
      }
      return array
    }
   const arr = [8,3,7,21,89,45,12]
   console.log(sort(arr,function(a,b){
     return a - b
   }))//[3, 7, 8, 12, 21, 45, 89]

数组排序的方法有很多：冒泡排序(也叫选择排序)、快速排序、插入排序。
冒泡排序：这种排序思想是将大的元素移动到数组末尾。

  function maoPaoSort(arr) {
        if(arr.length <=1) return arr
        for(j = 0;j<arr.length;j++){
            let isOk = true
            for(let i = 0;i < arr.length-1-j;i++){ //一次for循环能把一个最大值确定出来
                let a = arr[i]
                let b = arr[i+1]
                if(a>b){
                    arr[i] = b
                    arr[i+1] = a
                    isOk = false
                }
            }
            if(isOk){ //排序完成后，结束循环
                break
            }
        }
        return arr
    }
   const arr = [6,2,5,1,10,7,3,4]
    console.log(maoPaoSort(arr))
      //j=0,i=0,a=6,b=2,(a>b)=>arr=[2,6,5,1,10,7,3,4]
      //j=0,i=1,a=6,b=6,(a>b)=>arr=[2,5,6,1,10,7,3,4]
      //j=0,i=2,a=6,b=1,(a>b)=>arr=[2,5,1,6,10,7,3,4]
      //j=0,i=3,a=6,b=10,(a<10)=>arr=[2,5,1,6,10,7,3,4]
      //j=0,i=4,a=10,b=7,(a>b)=>arr=[2,5,1,6,7,10,3,4]
      //j=0,i=5,a=10,b=3,(a>b)=>arr=[2,5,1,6,7,3,10,4]
      //j=0,i=6,a=10.b=4,(a>b)=>arr=[2,5,1,6,7,3,4,10]
      //j=0,i=7,内部第一次for循环结束,此次循环找出了数组中的最大值,并且把最大值排在了数组的最后
      //再次进行循环,步骤同第一次循环,找出剩余数组中的最大值,并排在数组的最后
      //直至所有元素排序结束
      //如果此时外部for循环未结束,为了保证性能,需要创建一个标识isOk停止外部的for循环

快速排序：不理解，没学会

 function quickSort(arr) {
        if(!Array.isArray(arr)){
          return
        }
        var len = arr.length;
        //结束递归的条件
        if (len <= 1) return arr;
        var left = [];
        var right = [];
        var res = []
        //中间基数
        var midindex = Math.floor(len / 2);
        var mid = arr[midindex];
        for (var i = 0; i < len; i++) {
            if (arr[i] == mid) continue;
            else if (arr[i] < mid) left.push(arr[i]);
            else right.push(arr[i]);
        }
        let l1 = quickSort(left)
        let r1 = quickSort(right)
        return res.concat(l1,mid,r1)
      }

      const arr = [6,2,5,1,10,7,3,4]
      console.log(quickSort(arr))

插入排序：这种思路是将小的元素往前移。

function insertSort(arr) {
        var len = arr.length;
        for (var i = 0; i < len; i++) {
            var k = i;
            while (k - 1 >= 0 && arr[k] < arr[k - 1]) {
                var temp = arr[k];
                arr[k] = arr[k - 1];
                arr[k - 1] = temp;
                k--;
            }
        }
        return arr;
    }
    const arr = [23, 12,32,5,21]
    console.log(insertSort(arr))
// arr = [a,b,c,d,e,f]
//思路：首先前两个数组元素比较大小,如果b<a,则a和b互换。此时,新数组为[b,a,c,d,e,f]。反之,不用换
//然后,拿c与a比较,如果c<a,则c与a互换,数组变为[b,c,a,d,e,f]。反之,不用换
//继续拿c与b比较,如果c<b,则c与b再互换,数组变为[c,b,a,d,e,f]。反之,不用换。至此,当前排序完成一部分
//继续完成剩余排序
//比较d与a的大小,如果d<a,则d与a互换位置,反之不用换。
//剩下的比较思路都是一样的。

7.shift()：获取数组的第一个元素或者说是删除数组的第一个元素。

8.pop()：获取数组的最后一个元素或者说是删除数组的最后一个元素。

9.unshift(元素):往数组的开头添加新的元素，返回值是新数组的长度。

10.indexOf()/lastIndexOf()：同字符串的用法

 const arr = [1,2,3,45,293,2,83,3,4,3]
      let index1 = arr.indexOf(3,4)
      console.log(index1)
      let index2 = arr.indexOf(2,4)
      console.log(index2)