JS常用字符串、数组的方法（备查）

 字符串

charAt() 返回在指定位置的字符。
charCodeAt() 返回在指定的位置的字符的 Unicode 编码。
concat() 连接字符串。
indexOf() 检索字符串。
match() 找到一个或多个正则表达式的匹配。
replace() 替换与正则表达式匹配的子串。
search() 检索与正则表达式相匹配的值。
slice() 提取字符串的片断，并在新的字符串中返回被提取的部分。
split() 把字符串分割为字符串数组。

padStart()，padEnd()  字符串补全长度的功能。padStart()用于头部补全，padEnd()用于尾部补全，返回新的字符串
repeat() 方法返回一个新字符串，表示将原字符串重复n次。

trimStart()，trimEnd()  它们的行为与trim()一致，trimStart()消除字符串头部的空格，trimEnd()消除尾部的空格。它们返回的都是新字符串，不会修改原始字符串。

includes()：返回布尔值，表示是否找到了参数字符串。
startsWith()：返回布尔值，表示参数字符串是否在原字符串的头部。
endsWith()：返回布尔值，表示参数字符串是否在原字符串的尾部。

toLocaleLowerCase()、toLowerCase() 区别：

toLocaleUpperCase()、toUpperCase() 区别：

toLocaleLowerCase()、toLocaleUpperCase()  是针对特定地区的实现。针对地区的方法与其通用方法得到的结果相同，但少数语言(如土耳其语言)会为Unicode大小写转换应用特殊的规则，这时候就必须使用针对地区的方法来保证实现正确的转换。 

 

substr、substring区别：

substr(start [，length]) 第一个字符的索引是0，start开始后length位          “goodboy”.substr(3,4);   //dboy

substring(start [, end]) 第一个字符的索引是0，start到end（不包含end） “goodboy”.substring(3,4);  //d

 

repeat(num) es6语法 字符串重复num次

isNaN()判断值是否是数字

parseInt与Number的区别：parseInt会返回其中是数字的部分

'123a'，parseInt（）返回是123，Number（）返回是NaN；
'123.456'，parseInt（）返回是123，Number() 返回是123.456；
null或''，parseInt（）返回是NaN，Number()返回是 0

数组
slice[start,end) 返回从原数组中指定开始下标到结束下标之间的项组成的新数组  （返回新数组）
. 1个参数：n.即：n到末尾的所有
. 2个参数：[start,end]（不包括end）
splice()： 向/从数组中添加/删除项目,然后返回被删除的项目。（返回被删内容，会改变原数组）
. 删除：2个参数，起始位置，删除的项数
. 插入：3个参数，起始位置，删除的项数，插入的项
. 替换：任意参数，起始位置，删除的项数，插入任意数量的项

delete: 只是被删除的元素变成了 undefined 其他的元素的键值还是不变。数组长度不变，delete arr[2] 
pop() 删除数组的最后一个元素，减少数组的长度，返回删除的值。（无参）
push() 将参数加载到数组的最后，返回新数组的长度。 （参数不限）
shift() 删除数组的第一个元素,数组长度减1，返回删除的值。 （无参）
unshift() 向数组的开头添加一个或更多元素，并返回新的长度。（参数不限）
sort() 按指定的参数对数组进行排序 ，返回的值是经过排序之后的数组（无参/函数） （数字可直接写return a-b，字符串 if(a>b) return 1）
concat(3,4) 把两个数组拼接起来。 返回的值是一个副本 （参数不限）
join() 将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符
indexOf() 从数组开头向后查找，接受两个参数，要查找的项(可选)和查找起点位置的索引
lastIndexOf() 从数组末尾开始向前查找，接受两个参数，要查找的项(可选)和查找起点位置的索引
filter() 对数组中的每一项运行给定函数，返回该函数会返回true的项组成数组。
forEach() 对数组的每一项运行给定函数，这个方法没有返回值。
map() 对数组的每一项运行给定函数，返回每次函数调用的结果组成的数组。
reduce()和reduceRight() 缩小数组的方法，这两个方法都会迭代数组的所有项，然后构建一个最终返回的值。

reverse()数组颠倒顺序

取数组最大值 1、Math.max(...arr)   （es6） 2、arr.sort((a,b)=>{return b-a}) arr[0]

初始化数组 用ES6中的fill()方法

var arr = new Array(10).fill(0);

every和some的区别

every() 方法使用指定函数检测数组中的所有元素：

• 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
• 如果所有元素都满足条件，则返回 true。

some() 方法会依次执行数组的每个元素：

• 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
• 如果没有满足条件的元素，则返回false。

find和filter区别

find返回的是对象，查询到一个即返回；filter返回的是数组，返回所有的查询结果。如果返回值是对象，修改对象值会改变原数组

//find
let list=[{"name":"小花","age":20},{"name":"小明","age":22},{"name":"李莎","age":18}]
let info=list.find((one)=>one.age>19);
console.log(info);//{"name":"小花","age":20}

//filter
info=list.filter((one)=>one.age>19);
console.log(info);//[{"name":"小花","age":20},{"name":"小明","age":22}]

 

初始化长度为n全是0的数组   

 var arr=new Array(5).fill(0);   //[0,0,0,0,0]

初始化二维数组 

 var arr=new Array(3).fill(new Array(2).fill(0));  //[[0,0],[0,0],[0,0]]

替换数字和字母

s.replace(/[^0-9a-zA-Z]/g,'') 

 

 

Map对象常用方法

//创建map
let myMap=new Map([
    ['A',"1"],
    ['B',"2"],
    ['C',"3"]
])
//设置值
myMap.set("D","4") 

//获取值
myMap.get("A") //"1"

//判断值是否存在、
myMap.has("E") //false

//删除某个值
map.delete("A") // true

//获取Map对象长度
myMap.size //3

//Map对象转换成数组
Array.from(myMap) //[['A':"1"],['B':"2"],['C':"3"]]
[...map]

//数组转Map对象
new Map(arr)

//Map对象遍历
forEach()
myMap.forEach((value, key)=>{})
for of   
for (var [key, value] of myMap) 

 

Math
abs(x) 绝对值。

ceil(x) 尽可能取最大。
floor(x) 尽可能取最小。
round(x) 把数四舍五入为最接近的整数。
max(x,y) 返回 x 和 y 中的最高值。
min(x,y) 返回 x 和 y 中的最低值。
pow(x,y) 返回 x 的 y 次幂。
random() 返回 0 ~ 1 之间的随机数。
sqrt(x) 返回数的平方根。

最大公约数

function gcd(a,b){
    var temp;
    while(b != 0){
       temp = a % b;
       a = b;
       b = temp;
    }
    return a;
}

最小公倍数

function scm(a,b){
    return (a*b)/gcd(a,b);
}

正则
compile 编译正则表达式。
exec 检索字符串中指定的值。返回找到的值，并确定其位置。
test 检索字符串中指定的值。返回 true 或 false。
search 检索与正则表达式相匹配的值。
match 找到一个或多个正则表达式的匹配。
replace 替换与正则表达式匹配的子串。
split 把字符串分割为字符串数组。

数组去重

方法一 reduce

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。reduce() 方法接受四个参数：初始值（或者上一次回调函数的返回值），当前元素值，当前索引，调用 reduce() 的数组

let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4];
let result = arr.sort().reduce((init, current) => {
    if (init.length === 0 || init[init.length - 1] !== current) {
        init.push(current);
    }
    return init;
}, []);
console.log(result); //[1,2,3,4,5]

引申：reduce其他用法

数组求和

var total = [ 0, 1, 2, 3 ].reduce(( acc, cur ) => {
    return acc + cur
}, 0);
console.log(total)   // 6

二维数组转为一维数组

var array = [[1, 2], [3, 4], [5, 6]].reduce(( acc, cur ) => {
    return acc.concat(cur)
}, []);
console.log(array)  // [ 0, 1, 3, 4, 5, 6 ]

方法二

当然，对于数组去重，也可以直接使用es6的…[拓展运算符] + Set 实现：

// console.log(...new Set([1,2,3,4,5,2,4,1]))
const dedupe = (array) => {
    return Array.from(new Set(array));
}
console.log(dedupe([1, 1, 2, 3])) //[1,2,3]

方法三 forEach、indexOf

array.forEach(function(curr) {
    if (newArray.indexOf(curr) === -1) {
        newArray.push(curr);
    }
})

查找数组最大值 

var a=[1,2,3,5];
alert(Math.max.apply(null, a));//最大值

var a=[1,2,3,[5,6],[1,4,8]];
var ta=a.join(",").split(",");//转化为一维数组
alert(Math.max.apply(null,ta));//最大值

Math.max(...arr) //es6用法

 

Map对象排序

var arrayObj=Array.from(map);//转化为数组

arrayObj.sort(function(a,b){return a[1]-b[1]})//排序

 

 

二维数组去重

var obj={}
res.forEach(item=>obj[item]=item);
res=Object.values(obj);//一个包含对象自身的所有可枚举属性值的数组。
return res;

 

 

 转换方法

 

数字转字符串 number.toString();

字符串转数字 parseInt(str); Number(str);+str

 

对象value转数组 Object.values(obj)

对象key转数组 Object.keys(obj) 

1：对象转换数组

　　let obj = {'val1':1, 'val2':2, 'val3':3, 'val4':4};
　　var arr = []
　　for (let i in obj) {　　//取键
　　　　let o = {};
　　　　o[i] = obj[i];　　//寻找键值对赋值
　　　　arr.push(o)
　　}
　　console.log(arr);　　//[ { val1: 1 }, { val2: 2 }, { val3: 3 }, { val4: 4 } ]

2：数组转字符串

　　let a = [123,432,42,5,344,5]

　　1) toString()

　　　　console.log(a.toString())　　//123,432,42,5,344,5

　　2)  join('')

　　　　console.log(a.join('-'))　　//123-432-42-5-344-5

3：字符串转数组

　　let str = 'daw2312-daw=+'
　　console.log(str.split(''))　　//[ 'd', 'w', '2', '2', '-', 'a', 'w', '=' ]