- 数组常用方法
1.合并数组concat
concat() 方法用于连接两个或多个数组。
该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
var a=[1,2,3]
var b=a.concat(4)
b //[1, 2, 3, 4]
a //[1, 2, 3]2.切割数组
slice() 方法可从已有的数组中返回选定的元素。
slice(start, end) 含头不含尾，原数组不变
var a=[0,1,2,3,4]
var b=a.slice(1,3)//从0开始，含头不含尾，原数组不变
b //[1, 2]splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目
splice(start, n, add)
var a=[0,1,2,3,4]
var b=a.splice(1,3,5)//[1,2,3]
a//[0,5,4]改变原数组，参数：从几开始，截取几项，截取部位增加元素3.数组变字符串格式
join() 方法用于把数组中的所有元素放入一个字符串。
元素是通过指定的分隔符进行分隔的。
var a=[1,2,3]
var b=a.join(',')
b
"1,2,3"4.数组排序
var c=[1,4,10,3,2,10000]
var d=c.sort(function(a,b){return a-b})
d // [1, 2, 3, 4, 10, 10000]，原数组c也会变为[1, 2, 3, 4, 10, 10000]5.数组尾首添加
尾：push pop
var a=[1,2,3]
var b=a.push(4)//b 4 注意，如果是直接使用a.push(s),返回的值是s
a // [1, 2, 3, 4]首：unshift shift
6. 翻转数组reverse
var a=[1,2,3]
var b=a.reverse()//b [3, 2, 1]
a // [3, 2, 1]- filter() 传入一个返回值为布尔类型的函数
var grade=[]
for(var i=0;i<20;i++){grade[i]=Math.floor(Math.random()*101)}//生成随机数
grade;// [57, 66, 44, 48, 0, 72, 36, 97, 58, 13, 55, 77, 54, 31, 1, 54, 11, 4, 68, 93]
function f(n){return n>60}
grade.filter(f);//[66, 72, 97, 77, 68, 93]- reduce()
reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。对空数组是不会执行回调函数的。
语法：array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
var num = [1,2,3,4];
var res = num.reduce(function(total,num){
return total+num;
});
console.log(res)；//10hash数组定义
JavaScript中的关联数组，关联数组因为有key值的索引，所以在数组查找中比较便利，同时也使得相应的代码算法实现显得更清晰，易读易维护.
var myhash = new Array();
向Hash关联数组添加键值：
myhash[‘new’] = ‘newval’;
myhash[‘new2’] = ‘newval_2’;
访问Hash关联数组：
myhash[‘new’]; // 跟上键名就能访问
删除Hash数组已有键值：
delete myhash[‘new’];
遍历Hash数组：
for(key in myhash){ console.log(key); //key 获取的是键名 myhash[key]; // 获取值}- 字符串常用方法
substring() 方法用于提取字符串中介于两个指定下标之间的字符。与 slice() 和 substr() 方法不同的是，substring() 不接受负的参数。
var str="abcdef"
var b=str.substring(1,3)//从0开始，含头不含尾，原字符串不变
b //"bc"split() 方法用于把一个字符串分割成字符串数组。
var str="a,bc,def"
var a=str.split(',')// ["a", "bc", "def"]题目：将字符串“a,bc,def”
var str="a,bc,def"
var a=str.split(',')// ["a", "bc", "def"]
var c="abcde"
var b=c.replace(/^[a-z]/, (L) => L.toUpperCase());
b
"Abcde"题目：
对象数组多条件排序，（此例如果sortNo相同，则按sortNo2从大到小）
var arr= [
{ 'sortNo': 2, 'sortNo2': 3},
{ 'sortNo': 1, 'sortNo2': 3},
{ 'sortNo': 5, 'sortNo2': 3},
{ 'sortNo': 6, 'sortNo2': 3},
{ 'sortNo': 7, 'sortNo2': 3},
{ 'sortNo': 3, 'sortNo2': 4},
{ 'sortNo': 3, 'sortNo2': 2},
{ 'sortNo': 3, 'sortNo2': 1},
{ 'sortNo': 3, 'sortNo2': 3},
{ 'sortNo': 8, 'sortNo2': 3},
{ 'sortNo': 4, 'sortNo2': 1},
{ 'sortNo': 4, 'sortNo2': 2}
];
arr.sort(function(a, b){
if (a.sortNo === b.sortNo) {
return b.sortNo2 - a.sortNo2;
} else {
return a.sortNo - b.sortNo;
}
});
console.log(arr);
//输出结果
//{ 'sortNo': 1, 'sortNo2': 3}
//{ 'sortNo': 2, 'sortNo2': 3}
//{ 'sortNo': 3, 'sortNo2': 4}
//{ 'sortNo': 3, 'sortNo2': 3}
//{ 'sortNo': 3, 'sortNo2': 2}
//{ 'sortNo': 3, 'sortNo2': 1}
//{ 'sortNo': 4, 'sortNo2': 2}
//{ 'sortNo': 4, 'sortNo2': 1}
//{ 'sortNo': 5, 'sortNo2': 3}
//{ 'sortNo': 6, 'sortNo2': 3}
//{ 'sortNo': 7, 'sortNo2': 3}
//{ 'sortNo': 8, 'sortNo2': 3}题目：
取出字符串数组种每个元素的第一个字母
var arr=["amy","sheldon","howard"]
var arr2 = arr.map((v)=>v[0]);// ["a", "s", "h"]
arr2.join();//"ash"题目：
判断回文字符串,（"12321"是回文，"abcba"也是回文，如果将一个字符串翻转过来，能和原字符串完全相等，那么就可以称之为“回文”）
var arr=["a","b","c","c","b","a"]
var str="abccba"
function f(x){[a,b,c,c,b,a]
x+='';
return x===x.split('').reverse().join('')
}
f(arr);//true
f(str);//true这种方法很方便，但效率不高，字符串分割，倒转，聚合都需要很多额外的操作。
最好的方法，是从字符串头部和尾部，逐次向中间检测。
var arr=["a","b","c","c","b","a"]
var str="abccba"
function f(x){
x+='';
for(var i=0,j=x.length-1;i<j;i++,j--){
if(x[i]!==x[j]){return false}
}
return true;
}
f(arr);//true
f(str);//true题目：
js实现数组内元素随机排序
如 arr = [1,2,3,4,5,6,7,8]随机排列
var arr = [1,2,3,4,5,6,7,8];
function f(a,b){
return Math.random()>0.5?1:-1
}
arr.sort(f)或 不用sort()函数
function randomSort(a){
var arr = a,
random = [],
len = arr.length;
for (var i = 0; i < len; i++) {
var index = Math.floor(Math.random()*(len - i));//数组中随机取一个
random.push(a[index]);
arr.splice(index,1);//从数组中移除这个值，剩余值再随机选
}
return random;
}
var a = [1,2,3,4,5,6,7,8,9,10];
console.log(randomSort(a));JSON.parse()和JSON.stringify()
转自：
parse用于从一个字符串中解析出json对象,如
var str = '{"name":"huangxiaojian","age":"23"}'
结果：
JSON.parse(str)
Object
age: “23”
name: “huangxiaojian”
proto: Object注意：单引号写在{}外，每个属性名都必须用双引号，否则会抛出异常。
stringify()用于从一个对象解析出字符串，如
var a = {a:1,b:2}
结果：
JSON.stringify(a)
“{“a”:1,“b”:2}”
题目：
数组去重，var arr = [1,2,3,3,2,4,5]
用ES6的Set就可以： […new Set(arr)]
使用hash数组的话hash[v]var arr=[2,2,2,2,3,4,5,4,3,1,4,4,100,100];
function f(arr){
var i,b=[];
var length=arr.length;
var hash=[]
for(i=0;i<length;i++){
if(!hash[arr[i]]){
hash[arr[i]]=true;
b.push(arr[i])
}
}
return b;
}
f(arr)题目：
js数组中出现次数最多和第二多的元素
方法一：可以用哈希数组（只能统计整形数组，如var arr=[2,2,2,2,3,4,5,4,3,1,4,4,100,100];）
function f(arr){
var i;
var length=arr.length;
var hash=[];//使用哈希数组
for(i=0;i<length;i++){
if(!hash[arr[i]])hash[arr[i]]=1;//没有初始化的数组元素为undefined，undefined++为NaN
else hash[arr[i]]++;
}
var max=0;//最多的次数
var maxV;//出现最多的元素
var second=0;//第二多的次数
var secondV;//出现第二多的元素
hash.forEach(function(item,index){//forEach函数会跳过空元素
if(item>max){
second=max;
secondV=maxV;
max=item;
maxV=index;//用索引来保存原数组的值
}else if(item>second){
second=item;
secondV=index;
}
});
return {max,maxV,second,secondV};
}
var arr=[2,2,2,2,3,4,5,4,3,1,4,4,100,100];
var {max,maxV,second,secondV}=f(arr);//ES的元素解构赋值
console.log(max,maxV,second,secondV);单纯只取数量最多的
var arr = [1,2,3,3,2,3,4,5]
function f(arr){
var hash = []
arr.forEach((value, index)=>{
if(!hash[value]){
hash[value] = 1
}else{
hash[value]++
}
})//hash [1:1,2:2,3:3,4:1,5:1]
var max=0;
var maxV;
hash.forEach((value, index)=>{
if(value>max){
max=value;
maxV=index
}
})
return {max,maxV}
}
f(arr)用对象保存值和次数，这种方法不仅可以用于整型数组的统计，还能用于字符数组的统计，
主要是两次排序：var arr2 = [“a”,“b”,“c”,“c”,“b”,“b”,“b”,“b”,“a”]
第一次arr.sort() //[“a”, “a”, “b”, “b”, “b”, “b”, “b”, “c”, “c”]
遍历比较前后两个值是否相同，塑形对象数组temp //[{value:“a”, “index”:2}, {value:“b”, “index”:5}…]
第二次temp.sort((a,b)=>a.value-b.value)，由大到小排序，取第一个即为最大值function f(arr){
var temp=[];//对象数组
var i;
temp[0]={value:arr[0],index:1};//保存数组元素出现的次数和值
arr.sort();
for(i=1;i<arr.length;i++){
if(arr[i]==arr[i-1]){
temp[temp.length-1].index++;
}else{//不相同则新增一个对象元素
temp.push({index:1,value:arr[i]});
}
}
temp.sort(function(a,b){//按照出现次数从大到小排列
return a.index<b.index;
})
var max=temp[0].index;
var maxV=temp[0].value;
var second=temp[1].index;
var secondV=temp[1].value;
return {max,maxV,second,secondV};
}
var arr=[2,2,3,4,5,100,100,,3,1,4,4,100,100];
var {max,maxV,second,secondV}=f(arr);
console.log(max,maxV,second,secondV);题目：字符串首字母转大写
var str = ‘it_is_my_cat’;
var arr = str.split("") ; // [“it”, “is”, “my”, “cat”]
var arr2 = arr.map((value,item)=>value.replace(/1/,(x)=>x.toUpperCase())) //[“It”, “Is”, “My”, “Cat”]
arr2.join("") //“It_Is_My_Cat”，成功- a-z ↩︎
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
