数组、字符、对象、正则api总结

灰太狼 2023-10-15 08:06 83阅读 0赞

怕自己删东西把笔记删了，就整理到csdn上来了。是自己平时的学习笔记，可能有些许啰嗦……如有遗漏错误，麻烦路过的大佬指出哦！共同学习，共同进步！

## 数组 ##

### join ###

arr.join('连接符') **不会改变原数组**

用连接符把数组里面的元素连接成字符串，arr.join('')实现无缝连接

var arr=['我','是','蛋','蛋']
    
    var arr1=arr.join('-') console.log(arr1); // 我-是-蛋-蛋
    
    var arr2=arr.join('') console.log(arr2); // 我是蛋蛋

### concat ###

arr.concat('a','b',arr1) **不会改变原数组**

如果传给concat()的某个参数本身是一个数组，则会将该数组的元素衔接到arr中，而不是数组本身

var arr=['我','是','蛋','蛋']
    
    var arr1=['我','真','好','看']
    
    var arr2=arr.concat(arr1)
    
    console.log(arr2); // ['我', '是', '蛋', '蛋', '我', '真', '好', '看']
    
    var arr3=arr.concat(['呀',['哈','哈','哈']],arr1)
    
    console.log(arr3); // ['我', '是', '蛋', '蛋', '呀', ['哈', '哈', '哈'], '我', '真', '好', '看']
    
    console.log(arr); // ['我', '是', '蛋', '蛋']

### 截取sclice ###

arr.slice(start,end)/arr.slice(start) **不会改变原数组**

截取出来的数组含start不含end

如果省略end表示从start位置开始一直截取到末尾

支持负数，表示倒数第几个

var arr=['我','是','蛋','蛋']
    
    var arr1=arr.slice(1)
    
    console.log(arr1); // ['是', '蛋', '蛋']
    
    var arr2=arr.slice(2,4)
    
    console.log(arr2); // ['蛋', '蛋']
    
    var arr3=arr.slice(-3)
    
    console.log(arr3); // ['是', '蛋', '蛋']
    
    var arr4=arr.slice(-4,-2)
    
    console.log(arr4); // ['我', '是']
    
    console.log(arr); // ['我', '是', '蛋', '蛋']

### 删除、插入、替换splice ###

arr.splice(start,deleteCount,value1,value2……) **会修改原数组，返回被删除元素组成的子元素**

如果deleteCount是0，表示插入元素，插入的元素会排在start之前

如果是删除，从start开始，并包含start

如果是替换，参数1为替换元素的起始位置，参数2是需要替换元素的个数，参数3-n都是需要替换的元素

var arr=['我','是','蛋','蛋','我','真','好','看'] // 删除
    
    var arr1=arr.splice(0,2)
    
    console.log(arr1); // ['我', '是']
    
    console.log(arr); // ['蛋', '蛋', '我', '真', '好', '看']
    
    // 插入
    
    var arr2=arr.splice(2,0,'哈','哈')
    
    console.log(arr2); // []
    
    console.log(arr); // ['我', '是', '哈', '哈', '蛋', '蛋', '我', '真', '好', '看']
    
    // 替换 参数1：替换元素的起始位置，参数2：需要替换元素的个数，参数3……n：需要插入的元素
    
    var arr3=arr.splice(2,1,'哈','哈')
    
    console.log(arr3); // ['蛋']
    
    console.log(arr); // ['我', '是', '哈', '哈', '蛋', '我', '真', '好', '看']

### 翻转reverse ###

arr.reverse() **会修改原数组，返回修改后的数组**

var arr=['我','是','蛋','蛋','我','真','好','看'] 
    
    var arr1=arr.reverse() 
    
    console.log(arr1); // ['看', '好', '真', '我', '蛋', '蛋', '是', '我'] 
    
    console.log(arr); // ['看', '好', '真', '我', '蛋', '蛋', '是', '我']

### 排序sort ###

arr.sort() **会修改原数组，返回修改后的数组**

### 查找indexOf/lastIndexOf ###

arr.indexOf(value,searchStartIndex)/arr.lastIndexOf(value,searchStartIndex) **不会改变原数组**

indexOf是从前往后查，lastIndexOf是从后往前查，lastIndexOf的第二个参数也是从后往前数。

value为要查找的元素，searchStartIndex为规定在字符串中开始查找的位置。它的合法取值是 0 到 arr.length - 1。如省略该参数，则将从字符串的首字符开始查找

如果查到返回value在数组中的索引，没有查到返回-1

indexOf可以匹配指向同一地址的对象

var arr=['我','是','蛋','蛋','我','真','好','看']
    
    var element=arr.indexOf('真')
    
    var element1=arr.lastIndexOf('好')
    
    var element2=arr.indexOf('真',6)
    
    var element3=arr.lastIndexOf('好',3)
    
    console.log(arr); // ['我', '是', '蛋', '蛋', '我', '真', '好', '看']
    
    console.log(element); // 5
    
    console.log(element1); // 6
    
    console.log(element2); // -1
    
    console.log(element3); // -1

### 循环forEach ###

arr.forEach(function(value,index,arr)\{\}) **不会改变原数组，没有返回值**

value为每次循环的元素，index为循环元素的索引，arr为原数组

### 循环map ###

arr.map(function(value,index,arr)\{\}) **不会改变原数组，有返回值**

value为每次循环的元素，index为循环元素的索引，arr为原数组

// 求平方
    var data = [1, 2, 3, 4, 5]
    var newData = data.map(function (item) {
        return item * item
    })
    console.log(newData); // [1, 4, 9, 16, 25]
    // 箭头函数
    var newData1 = data.map(item => item * item)
    console.log(newData1); // [1, 4, 9, 16, 25]
    
    // 获取数组对象中的特定属性值
    var users = [
        { "name": "蛋蛋", "email": "dan@qq.com" },
        { "name": "连连", "email": "lian@qq.com" },
        { "name": "薇薇", "email": "wei@qq.com" }
    ]
    var newName = users.map(function (item) {
        return item.name
    })
    console.log(newName); // ['蛋蛋', '连连', '薇薇']
    
    // 第2种获取数组对象中的值
    let name = []
    users.map(function (item) {
        name.push(item.name)
    })
    console.log(name); // ['蛋蛋', '连连', '薇薇']
    
    // 用map()调用一个方法的使用
    // 字符串转整数
    let arrr = ['1', '2', '3']
    function returnInt(e) {
        return parseInt(e)
    }
    let newArr = arrr.map(returnInt)
    console.log(newArr); // [1, 2, 3]
    
    // 接口数据映射，从接口得到数据res
    let r = res.map(item => {
        return {
            title: item.name,
            sex: item.sex === 1 ? '男' : item.sex === 0 ? '女' : '保密',
            age: item.age,
            avatar: item.img
        }
    })
    
    // js模拟实现数组的map方法
    // 思路：直接Array.map()就可以调用map方法，它应该在原型连上，然后接收一个匿名函数作为参数，通过循环调用传入的匿名函数
    Array.prototype.newMap=function(e){
        let newArr=[]
        for(let i=0;i<this.length;i++){
            newArr.push(e(this[i],i,this))
        }
        return newArr
    }
    let arrData=['1','2','3']
    arrData.newMap((item,index,arr)=>{
        console.log(item,index,arr);
    })

### 数组转字符串toString/String ###

String(arr)/arr.toString() **不会改变原数组**

将数组的元素用逗号连接成字符串，类似于arr.join(',')

let tostring=[1,2,3,4]
    
    let newTostring=tostring.toString()
    
    console.log(newTostring); // 1,2,3,4
    
    console.log(tostring); // [1,2,3,4]
    
    let newTostring1=String(tostring)
    
    console.log(newTostring1); // 1,2,3,4
    
    console.log(tostring); // [1,2,3,4]

### 开头入栈unshift ###

arr.unshfit(value1,value2……)**改变原数组，返回新数组的length**

在数组最开头插入元素

var unshiftArr=[1,2,3,4]
    var unshiftArr1=unshiftArr.unshift(8,9)
    console.log(unshiftArr); // [8, 9, 1, 2, 3, 4]
    console.log(unshiftArr1); // 6
    
    var unshiftArr=[1,2,3,4]
    var unshiftArr2=unshiftArr.unshift([8,9])
    console.log(unshiftArr); // [[8,9], 1, 2, 3, 4]
    console.log(unshiftArr2);// 5

### 开头出栈shfit ###

arr.shfit() **改变原数组，返回被弹出的元素**

弹出数组最开头的元素

var shiftArr=[2,3,1,4,5] 
    
    var shiftArr1=shiftArr.shift() 
    
    console.log(shiftArr1); // 2 
    
    console.log(shiftArr); // [3, 1, 4, 5]

### 结尾入栈push ###

arr.push(value1,value2……) **改变原数组，返回新数组的length**

在数组末尾追加元素，追加进去的数组不会被打散

var pushArr=[1,2,3,4,5]
    var pushArr1=pushArr.push(2,3)
    console.log(pushArr); // [1, 2, 3, 4, 5, 2, 3]
    console.log(pushArr1); // 7
    
    var pushArr=[1,2,3,4,5]
    var pushArr2=pushArr.push([6,7])
    console.log(pushArr); // [1, 2, 3, 4, 5, [6,7]]
    console.log(pushArr2); // 6

### 结尾出栈pop ###

arr.pop() **改变原数组，返回被弹出的元素**

弹出数组最末尾的元素

var popArr=[1,2,3,7,4,5] 
    
    var popArr1=popArr.pop() 
    
    console.log(popArr); // [1, 2, 3, 7, 4] 
    
    console.log(popArr1); // 5

### Array.every ###

全部满足条件 **不改变原数组，返回布尔值**

var everyArr=[1,2,3,4,5]
     
    var everyArr1=everyArr.every(item=>{ return item>0 }) 
    
    var everyArr2=everyArr.every(item=>{ return item>3 }) 
    
    console.log(everyArr1); // true 
    
    console.log(everyArr2); // false

### Array.some ###

部分满足条件 **不改变原数组，返回布尔值**

判断数组中有没有符合条件的元素，只要遇到符合条件的就退出循环

var someArr=[1,2,3,4,5,6] 
    
    var someArr1=someArr.some(item=>{ return item>3 }) 
    
    var someArr2=someArr.some(item=>{ return item>6 }) 
    
    console.log(someArr1); // true 
    
    console.log(someArr2); // false

### Array.filter ###

按条件过滤 **不改变原数组，返回新数组，包含符合条件的元素**

const persons = [
        { name: 'Dandan', age: 18 },
        { name: 'Lianlian', age: 17 },
        { name: 'Weiwei', age: 20 }
    ]
    
    let filterArr=persons.filter(item=>{
        return item.age>=18
    })
    console.log(filterArr); // [{name: 'Dandan', age: 18},{name: 'Weiwei', age: 20}]

### Array.reduce ###

**不会改变原数组**

参数1：回调函数

函数参数：参数1：上一次循环返回的值，第一次循环的话为初始值

参数2：当前循环的值

参数3：当前值的索引

参数4：原数组

参数2：初始值，可选。当不指定初始值时，将会使用数组的第一个元素作为初始值

// 累加
    let reduceArr = [1, 2, 3, 4, 5, 6, 7]
    let reduceArr1 = reduceArr.reduce((total, value, index, arr) => {
        return total + value
    }, 0)
    console.log(reduceArr1); // 28
    
    // 第二种写法
    let reduceArr2 = reduceArr.reduce((x, y) => {
        return x + y
    })
    console.log(reduceArr2); // 28
    
    // 数组处理
    const people = [
        { name: 'Dandan', age: 18 },
        { name: 'Lianlian', age: 17 },
        { name: 'Weiwei', age: 20 }
    ]
    let names = people.reduce((total, value) => {
        if (value.age >= 18) {
            total.push(value.name)
        }
        return total
    }, [])
    console.log(names); // ['Dandan', 'Weiwei']
    
    // 将数组转化为对象
    const user = [
        { id: '1', name: 'Jim' },
        { id: '2', name: 'Lily' },
        { id: '3', name: 'Allen' }
    ]
    
    let obj=user.reduce((total,value)=>{
         return {...total,[value.id]:value}
    },{})
    console.log(obj);
    // {
    //    1:{id: '1', name: 'Jim'}
    //    2:{id: '2', name: 'Lily'}
    //    3:{id: '3', name: 'Allen'}
    // }
    
    // 将二维数组扁平化为一维数组
    const intro=[['我','是','蛋','蛋'],['我','真','好','看']]
    let intro1=intro.reduce((total,value)=>{
        return total.concat(value)
    },[])
    console.log(intro1); // ['我', '是', '蛋', '蛋', '我', '真', '好', '看']
    
    // 在一次遍历中进行多次计算
    // 寻找最大值最小值
    const read=[1,2,3,1,4,0.4,0.9,5.6]
    const initMinMax={
        min:Number.MAX_VALUE,
        max:Number.MIN_VALUE
    }
    const minMax=read.reduce((total,value)=>{
        return {
            min:Math.min(total.min,value),
            max:Math.max(total.max,value)
        }
    },initMinMax)
    console.log(minMax); // {min: 0.4, max: 5.6}
    
    // 获取数组中的最大值
    let maxArr=[12,13,24,45,23,56]
    let max=maxArr.reduce(function(x,y){
        return x>y?x:y
    })
    console.log(max); // 56

### Array.reduceRight ###

**不会改变原数组**

工作原理和reduce()一样，不同的是它按照数组所以你从高到低（从右往左）处理数组

var rightArr=[2,10,60]
    
    var rightArr1=rightArr.reduceRight(function(x,y){ return x/y })
    
    console.log(rightArr1); // 3

### Array.find ###

返回第一个符合条件的数组成员，没有找到返回undefined **不会改变原数组**

var findArr = [
        { id: 1, name: 'Dandan', age: 17 },
        { id: 2, name: 'Lianlian', age: 17 },
        { id: 3, name: 'Weiwei', age: 20 }
    ]
    var findArr1=findArr.find(item=>{
        return item.age===17
    })
    console.log(findArr1); // {id: 1, name: 'Dandan', age: 17}

### Array.findIndex ###

找到第一个符合条件的数组元素的索引，没有找到返回-1 **不会改变原数组**

var findIndexArr=[
        { id: 1, name: 'Dandan', age: 17 },
        { id: 2, name: 'Lianlian', age: 17 },
        { id: 3, name: 'Weiwei', age: 20 }
    ]
    let findIndexArr1=findIndexArr.findIndex(item=>{
         return item.age===17
    })
    console.log(findIndexArr1); // 0

### Array.includes ###

查找某个值是否包含在数组里面，不接受函数参数，包含返回true，不包含返回false **不会改变原数组**

let includesArr=[1,2,3,4]
    
    let includesArr1=includesArr.includes(2)
    
    console.log(includesArr1); // true

### Array.toLocaleString ###

将数组转换为本地化字符串。它受线调用所有数组元素的toLocaleString()方法，然后使用地区特定的分隔字符将结果字符串连接起来 **不会改变原数组**

### Array.from ###

Array.from(arr,f) **不会改变原数组**

只有参数1时，是将参数1转化为数组，参数2可以是一个回调函数，对数组元素进行计算或者条件筛选

var arr='dandan'
    var arr1=[1,2,3,4]
    var arr2=Array.from(arr)
    console.log(arr2); // ['d', 'a', 'n', 'd', 'a', 'n']
    var arr3=Array.from(arr1,x=>x+x)
    console.log(arr3); // [2, 4, 6, 8]
    console.log(arr); // dandan
    console.log(arr1); // [1, 2, 3, 4]

### Array.isArray ###

Array.isArray(arr)判断是否为数组 **不会改变原数组，返回布尔值**

var arr=[1,2,3]
    
    var arr1=Array.isArray(arr)
    
    console.log(arr1); //true
    
    var arr={name:'dandan'}
    
    var arr1=Array.isArray(arr)
    
    console.log(arr1); // false

### 多维数组转化为低维数组flat ###

arr.flat(index) 将多维数组转化为低维数组，index为展开层数，不传默认展开一层 **不会改变原数组**

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

### flatMap ###

arr.flatMap(currentValue,index,array) map,flat的结合，因为map处理不了多维数组 **不会改变原数组**

var arr = [1, [1, 2, 3], [2, 3, [4, 5, 6]]]
    var map = arr.flatMap((item) => item)
    console.log(map); // [1, 1, 2, 3, 2, 3, [4, 5, 6]] 展开一层
    console.log(arr); // [1, [1, 2, 3], [2, 3, [4, 5, 6]]]

**一个例子~**

// 需要把Authorized等于2的过滤掉，然后再转换成Select下拉组件需要的格式  
    // [
    //  {
    //      text: '公司名称',
    //      value: '公司ID'
    //  }
    // ]
    const studioList = [
        {
            Authorized: "2",
            CompanyType: "1",
            Id: "3729",
            Name: "哈哈哈哈哈",
            ServiceProviderId: "6",
            TenantId: "1",
        },
        {
            Authorized: "1",
            CompanyType: "1",
            Id: "3134",
            Name: "纳税统计-启用时间202101无期初",
            ServiceProviderId: "6",
            TenantId: "1",
        },
        {
            Authorized: "1",
            CompanyType: "1",
            Id: "427",
            Name: "美丽人生工作室",
            ServiceProviderId: "6",
            TenantId: "1",
        },
        {
            Authorized: "1",
            CompanyType: "1",
            Id: "410",
            Name: "凭证测试专用2",
            ServiceProviderId: "6",
            TenantId: "1",
        }
    ]
    // 方法1 filter+map
    const filterList = studioList.filter(r => r.Authorized === '1').map(i => ({ text: i.Name, value: i.Id }))
    console.log(filterList); // [{text: "纳税统计-启用时间202101无期初",value: "3134"},{text: "美丽人生工作室",value: "427"},{text: "凭证测试专用2",value: "410"}]
    
    // 方法2 flatMap
    const filterList1 = studioList.flatMap(r => r.Authorized === '1' ? [{text: r.Name, value: r.Id}] : [])
    console.log(filterList1); // [{text: "纳税统计-启用时间202101无期初",value: "3134"},{text: "美丽人生工作室",value: "427"},{text: "凭证测试专用2",value: "410"}]

### 总结 ###

#### 改变原数组的api ####

*  splice(删除、插入、替换)：返回删除的元素子数组
 *  reverse(翻转)：返回修改之后的数组
 *  sort(排序)：返回修改之后的数组
 *  unshfit(开头入栈)：返回修改之后的数组
 *  shfit(开头出栈)：返回修改之后的数组
 *  push(结尾入栈)：返回修改之后的数组
 *  pop(结尾出栈)：返回修改之后的数组

#### 不改变原数组的api ####

*  join(连接)：返回连接之后的字符串
 *  concat(拼接)：返回拼接之后的数组
 *  sclice(截取)：返回根据条件截取出来的子数组
 *  indexOf(查找)/lastIndexOf(从后往前查找)：
 *  forEach(循环)：无返回值
 *  map(循环)：有返回值
 *  toString/String(转化为字符串)：返回转化之后的字符串
 *  every(查找全部符合条件)：true/false
 *  some(查找部分符合条件)：true/false
 *  filter(过滤)：返回新数组，包含所有符合过滤条件的元素
 *  reduce(累加)：返回修改之后的新数组
 *  reduceRight(从后往前累加)：返回修改之后的新数组
 *  find(查找元素)：返回第一条符合条件的元素（返回数组形式）
 *  findIndex(查找元素索引)：范围第一条符合条件元素的索引
 *  includes(包含)：true/false
 *  toLocaleString()：将数组转换为本地化字符串
 *  isArray(判断数组)：判断是否为数组，返回布尔值
 *  from()：将字符串转化为数组，或者进行一些计算
 *  isArray(判断)：判断是否为数组，返回布尔值
 *  flat(降维)：多维数组转化为低维数组
 *  flatMap()：flat，map的结合

#### 不改变原数组生成新数组 ####

join、concat、sclice、map、every、some、filter、reduce、from、find

#### indexOf/lastIndexOf、find、findIndex对比 ####

*  indexOf/lastIndexOf：查找元素在数组中第一次出现的位置，参数1为需要查找的元素，参数2可以限制查找范围。如果查找到返回元素索引，找不到返回-1.
 *  find：返回第一条符合条件的元素，找不到返回undefined，参数为回调函数
 *  findIndex：返回第一条符合条件元素的位置，找不到返回-1，参数为回调函数

#### map、forEach、every、some、reduce对比 ####

*  forEach：只是一个简单的循环，没有返回值，参数为函数，函数有3个参数，参数1：当前值，参数2：当前值的索引，参数3：原数组
 *  map：返回一个新数组，参数为函数
 *  every：数组中所有元素符合条件返回true，只要有一个不符合条件返回false
 *  some：部分符合条件就返回true，全部都不符合才返回false
 *  reduce：可以对数组元素进行计算或者其他操作，返回操作结果

## 字符串 ##

### 创建a标签anchor ###

str.anchor(name) 创建一个a标签，str为a标签内容，name为a标签的name属性值

var str='我是a标签内容'
    var str1=str.anchor('name属性值')
    console.log(str1); // <a name="name属性值">我是a标签内容</a>

### 创建b标签bold ###

var str='Dandan'
    var str1=str.charAt()
    var str2=str.charAt(2)
    console.log(str1); // D
    console.log(str2); // n

### charAt ###

str.charAt(index) 查找指定位置的字符，index为查找字符的索引，不传索引默认为0

var str='Dandan'
    
    var str1=str.charAt()
    
    var str2=str.charAt(2)
    
    console.log(str1); // D
    
    console.log(str2); // n

### 拼接concat ###

str.concat(value1,value2……) 将多个字符串拼接在一起

var str ='Dan'
    
    var str1='dan'
    
    var str2='我是'.concat(str,str1,'!')
    
    console.log(str2); // 我是Dandan!

### endsWith ###

str.endsWith(value) 判断str是否以value结尾，返回true/false

var str='I am Dandan'
    
    var str1=str.endsWith('n')
    
    var str2=str.endsWith('an')
    
    var str3=str.endsWith('a')
    
    console.log(str1,str2,str3); // true true false

### startsWith ###

str.startssWith(value) 判断str是否以value开头，返回true/false

var str='I am Dandan'
    
    var str1=str.startsWith('I')
    
    var str2=str.startsWith('I ')
    
    var str3=str.startsWith('a')
    
    console.log(str1,str2,str3); // true true false

### 包含includes ###

str.includes() 判断字符串是否包含另一个字符串，返回true/false

var str='My name is Dandan'
    
    var str1=str.includes('name')
    
    var str2=str.includes('is Dandan')
    
    var str3=str.includes('you')
    
    console.log(str1,str2,str3); // true true false

### 查找indexOf ###

str.indexOf(value,index) 参数1：要查找的字符串；参数2：从第几位往后查找。返回字符串在原字符串中首次出现的索引，找不到返回-1

var str='My name is Dandan'
    
    var index=str.indexOf('name')
    
    var index1=str.indexOf(' is',2)
    
    var index2=str.indexOf('you')
    
    console.log(index,index1,index2); // 3 7 -1

### 查找lastIndexOf ###

str.lastIndexOf(value,index) 参数1：要查找的字符串；参数2：从第几位往前找。返回字符串在原字符串中最后一次出现的索引，找不到返回-1

var str='My name is Dandan'
    
    var index=str.lastIndexOf('name')
    
    var index1=str.lastIndexOf('name',9) // 从第9个开始往前查找首次出现name的位置
    
    var index2=str.lastIndexOf('you')
    
    console.log(index,index1,index2); // 3 3 -1

### 创建a标签link ###

str.link(linkLocation) 创建一个带link地址的a标签，linkLocation为链接地址

var str='这是一个带link的a标签'
    
    var str1=str.link('www.baidu.com')
    
    console.log(str1); // <a href="www.baidu.com">这是一个带link的a标签</a>

### padEnd ###

str.padEnd(lenght,str1) 参数1为目标字符串的期望长度，参数2是如果字符串长度没有达到期望长度，就用使用参数2循环添加到字符串尾部，直到达到期望长度

var str='dandan' var str1=str.padEnd(7) // 没有参数2就用空格代替
    
    var str2=str.padEnd(2,'haha') // 如果期望长度小于目标字符串，直接返回目标字符串，什么也不做
    
    var str3=str.padEnd(9,'12')
    
    var str4=str.padEnd(9,'12234567')
    
    console.log(str1); // dandan 后面有空格
    
    console.log(str2); // dandan
    
    console.log(str3); // dandan121
    
    console.log(str4); // dandan122

### padStart ###

str.padStart(lenght,str1) 参数1为目标字符串的期望长度，参数2是如果字符串长度没有达到期望长度，就用使用参数2循环添加到字符串开头，直到达到期望长度

var str='dandan'
    
    var str1=str.padStart(7) 
    
    var str2=str.padStart(2,'haha')
    
    var str3=str.padStart(9,'12')
    
    var str4=str.padStart(9,'12234567')
    
    console.log(str1); // 前面有个空格 dandan
    
    console.log(str2); // dandan
    
    console.log(str3); // 121dandan
    
    console.log(str4); // 122dandan

### 重复repeat ###

str.repeat(num) 重复字符串，num为重复次数，小数会向下取整，传入0返回空字符串

var str='dan'
    
    var str1=str.repeat(0) //
    
    var str2=str.repeat(2) // dandan
    
    var str3=str.repeat(3.5) // dandandan

### 查找search ###

str.search() 查找字符串首次出现的位置，找不到返回-1。可以传正则表达式

var str='My name is Dandan'
    
    var index=str.search('name')
    
    var index1=str.search('you')
    
    var index2=str.search(/is/)
    
    console.log(index,index1,index2); // 3 -1 8

### 截取sclice ###

str.sclice(index1,index2) 截取字符串，参数1：截取的开始位置；参数2：截取的结束位置。如果不传参数2，就截取到字符串末尾，如果参数2为负数，就截取到str.length+index2位置。

var str='My name is Dandan'
    
    var str1=str.slice(1)
    
    var str2=str.slice(1,7)
    
    var str3=str.slice(0,-1)
    
    console.log(str1); // y name is Dandan
    
    console.log(str2); // y name
    
    console.log(str3); // My name is Danda

### 分割split ###

str.split(value,index) 把字符串分割成数组。拿掉value字符串，以value为分割点，将原字符串分割为若干元素，index为数组保留元素个数。index可以不传。

var str='My name is Dandan'
    
    var str1=str.split()
    
    var str2=str.split(' ',3)
    
    var str3=str.split('m')
    
    var str4=str.split('name')
    
    console.log(str1); // ['My name is Dandan']
    
    console.log(str2); // ['My', 'name', 'is']
    
    console.log(str3); // ['My na', 'e is Dandan']
    
    console.log(str4); // ['My ', ' is Dandan']

### 截取substr ###

str.substr(index1,index2) 从指定位置开始到指定数量的字符串，如果开始位置也就是第一个字符串大于字符串长度，则返回一个空字符串第二个位置超出了字符串剩余长度，则默认为字符串剩余长度。为负数则是字符串长度加负数

var str='My name is Dandan'
    
    var str1=str.substr(3)
    
    var str2=str.substr(-3)
    
    var str3=str.substr(3,3)
    
    console.log(str1); // name is Dandan
    
    console.log(str2); // dan
    
    console.log(str3); // nam

### 截取substring ###

str.substring(index1,index2) 截取两个索引之间的字符串，index1，index2都是整数，小于0的会被转化为0.如果大于字符串长度会被转化为字符串长度，如果第二个参数大于第一个参数，则会默认调换两个参数的位置。

var str='My name is Dandan'
    
    var str1=str.substring(1,4)
    
    var str2=str.substring(4,1)
    
    console.log(str1); // y n
    
    console.log(str2); // y n

### 转小写toLocaleLowerCase ###

str.toLocaleLowerCase() 将字符串转化为小写

var str='My name is Dandan'
    
    var str1=str.toLocaleLowerCase()
    
    console.log(str1); // my name is dandan

### 转大写toLocaleUpperCase/toUpperCase ###

str.toLocaleUpper()/str.toUpperCase() 将字符串转化为大写

var str='My name is Dandan'
    
    var str1=str.toLocaleUpperCase()
    
    var str2=str.toUpperCase()
    
    console.log(str1); // MY NAME IS DANDAN
    
    console.log(str2); // MY NAME IS DANDAN

### toString ###

str.toString() 返回指定对象的字符串形式

var str='我是蛋蛋'
    
    var str1=str.toString()
    
    console.log(str1); // 我是蛋蛋

### trimLeft ###

str.trimLeft() 清除字符串左边的空格

### trimRight ###

str.trimRight() 清除字符串左边的空格

### 替换replace ###

str.replace(str1,str2) 替换匹配到的字符串，str1需要匹配的字符串，str2要替换的字符串，参数1可以是正则表达式 不会改变原字符串

var str='My name is Dandan'
    
    var str1=str.replace('Dandan','Lianlian')
    
    var str2=str.replace(/Dandan/,'Lianlian')
    
    console.log(str1); // My name is Lianlian
    
    console.log(str2); // My name is Lianlian

## 正则表达式 ##

### 修饰符 ###

/xxx/g：全局修饰符，默认情况下遇到第一个匹配的字符就会结束，g修饰符可以让其匹配到结束

/xxx/i：忽略大小写

/xxx/m：匹配多行文本，正则默认遇到换行符就停止，不能匹配多行文本

### 转义字符 ###

\\n（换行符）、\\r（回车符）、\\t（制表符，也就是tab键）、\\w（任何一个字母或者数字或者下划线）、\\W（任何一个字母或者数字或者下划线之外的字符）、\\s（空格）、\\S（非空格）、\\d（数字0-9）、\\D（非数字）、\\b（单词的边界）、\\B（非单词边界）、\\\\（\\本身）、.（除换行回车以外的任意字符）

### 字符集和 ###

\[\]：或者 \[abc\]表示匹配a或b或c

数字：\[/d\]、\[/0-9\]

字母：\[a-z\]、\[A-Z\]、\[a-zA-Z\]

取反：^ 放在\[\]里面是取反，放在外面是以……开头 \[^abc\]表示除了abc以外的任意字符，^\[abc\]表示匹配以a或b或c开头的字符串

### 字符边界 ###

$：匹配结尾 abc$表示匹配以abc结尾

\\b：单词的边界 abc\\b 表示以abc为边界的字符串 可以匹配abc，但不能匹配abcc

### 量词 ###

\{n\}：匹配n次 a\{2\}表示匹配aa

\{m,n\}：匹配m到n次 ，优先匹配n次 a\{1,3\}表示可以匹配aaa、aa、a

\{m,\}：匹配m到无限次，优先匹配无限次

？：匹配0或1次，优先匹配1次，相当于\{0,1\}

\+：相当于\{1,\}

\*：相当于\{0,\}

正则有贪婪模式，凡是表示范围的两次，都会优先匹配下线。在量词后面加？可以开启非贪婪模式，优先以下线开始匹配。

### 选择表达式 ###

|：表示分组 a|b表示a或者b，123|456|789表示匹配123或者456后者789

\[\]只能匹配单个字符，|可以匹配多个字符

### 分组与引用 ###

()：括号内的是一组 (abc)\{2\}表示匹配abcabc

分组不能放在\[\]里面，但是可以使用|选择表达式 (123|456)\{2\}匹配123123、456456、123456、456123

分组分为捕获分组和非捕获分组，默认是捕获的，在分组的(后面添加?:可以让分组变为非捕获分组，非捕获分组可以提高性能和简化逻辑

'123'.match(/(?123)/) 返回\['123'\]

'123'.match(/(123)/) 返回\['123','123'\]

引用：\\数字，数字表示引用前面第几个捕获分组，非捕获分组不能被引用

<([a-z]+)><\/\1> 表示匹配<span></span>、<div></div>

### 正则表达式方法 ###

test()：检索字符串中指定值，返回true或false

var pat=/my/ 
    
    var str='my name is Danger!' 
    
    console.log(pat.test(str)) // true

exec()：检索字符串中的指定值，返回值是被找到的值，如果没找到就返回null

var pat=/hello/ 
    console.log(pat.exec('hello my name is Dange')) // 返回hello

search()：字符串查找，和字符串api里面的方法一样，找到返回索引，找不到返回-1

match()：字符串匹配，以数组的形式返回找到的字符串

var str='1 plus 2 equal 3'
    
    console.log(str.match(/\d+/)) // [1]
    
    console.log(str.match(/\d+/g)) // [1,2,3]

## 对象方法 ##

### Object.is() ###

严格比较两个值是否相等

let obj1 = { name: 'dandan' }
    let obj = { name: 'dandan' }
    let is = Object.is(obj, obj1)
    let is1 = Object.is(obj, obj)
    let is2 = Object.is(obj.name, obj1.name)
    console.log(is); // false
    console.log(is1); // true
    console.log(is2); // true

### Object.assign(obj1,obj2) ###

合并对象，obj1有的属性，obj2没有就直接添加，如果两个都有该属性后面的会覆盖前面的

let name = {
        name: 'dandan'
    }
    let age = {
        age: 18
    }
    let ass = Object.assign(name, age)
    console.log(ass); // {name: 'dandan', age: 18}

### Object.keys() ###

遍历出对象所有的键名，只会遍历一层

let person = {
        name: 'dandan',
        age: 18,
        hobby: ['听歌', '追剧'],
        family: {
            name: 'chen'
        }
    }
    let key = Object.keys(person)
    console.log(key); // ['name', 'age', 'hobby', 'family']

### Object.values() ###

遍历出对象的所有值，只会遍历一层

let person = {
        name: 'dandan',
        age: 18,
        hobby: ['听歌', '追剧'],
        family: {
            name: 'chen'
        }
    }
    let value = Object.values(person)
    console.log(value); // ['dandan', 18, ['听歌','追剧'], {name:'chen'}]

### Object.entries() ###

遍历出对象所有键名和值

let person = {
        name: 'dandan',
        age: 18,
        hobby: ['听歌', '追剧'],
        family: {
            name: 'chen'
        }
    }
    let entrie = Object.entries(person)
    console.log(entrie); // [['name', 'dandan'],['age', 18],['hobby', ['听歌','追剧']],['family', {name:'chen'}]]

### Object.fromEntries() ###

是entries的逆操作，作用是将一个键值对数组转化为一个对象

// Object.fromEntries() 是entries的逆操作，作用是将一个键值对数组转化为一个对象
    let entrie=[['name', 'dandan'],['age', 18],['hobby', ['听歌','追剧']],['family', {name:'chen'}]]
    let from = Object.fromEntries(entrie)
    console.log(from); // {name:'dandan',age:18,hobby:['听歌','追剧'],family:{name:'chen'}}

如有遗漏错误，欢迎指正~