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

怕自己删东西把笔记删了，就整理到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() 会修改原数组，返回修改后的数组

var arr=['我','是','蛋','蛋','我','真','好','看'] // 默认按照数组元素第一位的ascll码从小到大排列

var arr1=arr.sort()

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

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

// 升序 只限数组中的数字或者数字字符串

var arr=[1,2,3,2,5,6,4,3,7,1,2]

var arr2=arr.sort(function(a,b){return a-b})

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

console.log(arr2); // [1, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7]

// 降序 只限数组中的数字或者数字字符串

var arr=[1,2,3,2,5,6,4,3,7,1,2]

var arr3=arr.sort(function(a,b){return b-a})

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

console.log(arr3); // [7, 6, 5, 4, 3, 3, 2, 2, 2, 1, 1]

// 随机打乱数组 数组中可以是任何数据类型

var arr=[1,2,3,2,5,6,4,3,7,1,2]

var arr4=arr.sort(function(){ return Math.random()>.5?1:-1 })

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

console.log(arr4); // [3, 1, 2, 3, 5, 2, 4, 2, 7, 1, 6]

查找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": "[email protected]" },
    { "name": "连连", "email": "[email protected]" },
    { "name": "薇薇", "email": "[email protected]" }
]
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'}}

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