javascript数组常用方法(javascript保留两位小数)

　　javascript数组常用方法

数组供给了一些常用办法，可完成数组元素的增加、删去、替换以及排序等功用。
1)push(元素1,…,元素n)
push()办法可把参数指定的元素顺次增加到数组的结尾，并回来增加元素后的数组长度（该办法必须至少有一个参数）。示例如下：
vararr=[1,2,3];
alert(arr.push(4));//回来终究数组的长度:4
alert(arr);//回来：1,2,3,4
alert(arr.push(5,6,7));//回来终究数组的长度:7
alert(arr);//回来：1,2,3,4,5,6,7
2)unshift(元素1,…,元素n)
unshift()办法可把参数指定的元素顺次增加到数组的前面，并回来增加元素后的数组长度。该办法必须至少有一个参数。留意：IE6、IE7不支持办法的回来值。示例如下：
vararr=[1,2,3];
alert(arr.unshift(‘a’));//回来终究数组的长度:4
alert(arr);//回来：a,1,2,3
alert(arr.unshift(‘b’,’c’,’d’));//回来终究数组的长度:7
alert(arr);//回来：b,c,d,a,1,2,3
3)pop()
pop()办法可弹出（删去）数组终究一个元素，并回来弹出的元素。示例如下：
vararr=[‘A’,’B’,’C’,’D’];
alert(arr.pop());//回来：D
alert(arr);//回来：A,B,C
4)shift()
shift()办法可删去数组第一个元素，并回来删去的元素。示例如下：
vararr=[‘A’,’B’,’C’,’D’];
alert(arr.shift());//回来：A
alert(arr);//回来：B,C,D
5)splice(index,count[,元素1,…,元素n])
splic()办法功用比较强，它能够完成删去指定数量的元素、替换指定元素以及在指定方位增加元素。这些不同功用的完成需求结合办法参数来确定：
当参数只有index和count两个参数时，假如count不等于0，splice()办法完成删去功用，一起回来所删去的元素：从index参数指定方位开端删去count参数指定个数的元素；
当参数为3个以上，且count参数不为0时，splice()办法完成替换功用，一起回来所替换的元素：用第三个及其之后的参数替换index参数指定方位开端的count参数指定个数的元素；
当参数为3个以上，且count参数为0时，splice()办法的完成增加功用：用第三个及其之后的参数增加到index参数指定方位上。
splice()办法完成的各个功用示例如下。
①运用splice()从指定方位删去指定个数的元素：
vararr=[‘A’,’B’,’C’,’D’];
//2个参数，第二个参数不为0，完成删去功用
alert(arr.splice(0,2));
alert(arr);//回来C,D
②运用splice()用指定元素替换从指定方位开端的指定个数的元素：
vararr=[‘A’,’B’,’C’,’D’];
//3个参数，第二个参数不为0，完成替换功用：用a替换掉A，回来：A
alert(arr.splice(0,1,’a’));
alert(arr);//回来:a,B,C,D
alert(arr.splice(0,2,’aorb’));//用aorb替换掉a和B，回来a,B
alert(arr);//回来：aorb,C,D
③运用splice()在指定方位增加指定的元素：
vararr=[‘A’,’B’,’C’,’D’];
//4个参数，第二个参数为0，完成增加功用：在下标为1处增加aaa,bbb，没有回来值
alert(arr.splice(1,0,’aaa’,’bbb’));
alert(arr);//回来：A,aaa,bbb,B,C,D
【例1】运用splice()办法完成数组去重。
运用splice办法完成数组去重
上述代码运用了具有两个参数的splice()，完成了删去指定元素的功用。
6)slice(index1[,index2])
slice()办法回来包括从数组目标中的第index1～index2-1之间的元素的数组。index2参数能够省掉，省掉时表明回来从index1方位开端一向到终究方位的元素。需求留意的是，该办法只是读取指定的元素，并不会对原数组作任何修正。
示例如下：
vararr=[‘A’,’B’,’C’,’D’];
alert(arr.slice(0,3));//回来：A,B,C
alert(arr);//回来A,B,C,D
alert(arr.slice(0));//回来数组全部元素：A,B,C,D
alert(arr);//回来A,B,C,D
7)sort()、sort(compareFunction)
sort()办法用于按某种规矩排序数组：当办法的参数为空时，按字典序（即元素的Unicode编码从小到大排序顺序）排序数组元素；当参数为一个匿名函数时，将按匿名函数指定的规矩排序数组元素。sort()排序后将回来排序后的数组，示例如下。
①按字典序排序数组。
vararr=[‘c’,’d’,’a’,’e’];
alert(arr.sort());//回来排序后的数组：a,c,d,e
alert(arr);//回来排序后的数组：a,c,d,e
从上述代码，咱们可看到没有参数时，sort()按字典序摆放数组中的各个元素。
下面咱们再用元素的sort()对几个数字排序，看看成果如何：
vararr=[4,3,5,76,2,0,8];
arr.sort();
alert(arr);//回来排序后的数组：0,2,3,4,5,76,8
咱们看到排序后，成果并不是所预期的76最大应排在终究，反而是8排在终究，好像8在这些元素中是最大的，即元素并没按数字巨细进行排序。
为什么会呈现这样的成果呢？这是因为sort()默许是对每个元素按字符串进行排序，排序时会从左到右按位比较元素的每位字符，对应位的Unicode编码大的就意味着这个元素大，此刻将不再对后边的字符进行比较；对应位字符相一起才比较后边方位的字符。明显上述数组的排序运用了sort()的默许排序规矩。此刻要让数组中的元素按数字巨细进行排序，就必须经过匿名函数参数来修正排序规矩。
②按匿名函数参数指定的规矩排序数组。
下面经过界说匿名函数来修正sort()的默许排序规矩，完成对上面数字元素按数字巨细进行排序：
vararr=[4,3,5,76,2,0,8];
arr2.sort(function(a,b){
returna-b;//从小到大排序
//returnb-a;//从大到小排序
});
alert(arr);//回来排序后的数组：0,2,3,4,5,8,76
阐明：匿名函数中回来第一个参数减第二个参数的值，此刻将按元素数值从小到大的规矩排序各个元素：当两个参数的差为正数时，前后比较的两个元素将互换方位排序；不然元素不互换方位。假如回来第二个参数减第一个参数的值，则按元素数值从大到小的规矩排序各个元素，元素互换规矩和从小到大相似。
当数组元素的前缀为数字而后缀为字符串时，假如期望这些元素能按数字巨细进行排序，此刻需对匿名函数中的参数作一些变通处理。因为这些参数代表了数组元素，所以它们也是一个包括数字和字符的字符串，因此要按数字巨细来排序它们，就需求将参数解析为一个数字，然后再回来这些解析成果的差。
示例如下：
vararrWidth=[‘345px’,’23px’,’10px’,’1000px’];
arrWidth.sort(function(a,b){
returnparseInt(a)-parseInt(b);
});
alert(arrWidth);//排序后的成果为：10px,23px,345px,1000px
此外，咱们经过匿名函数，还能够完成随机排序数组元素。示例如下：
vararr=[1,2,3,4,5,6,7,8];
arr.sort(function(a,b){
returnMath.random()-0.5;//random()回来：0～1之间的一个值
});
alert(arr);//排序后的成果为：4,3,1,2,6,5,7,8。留意：每次履行的成果可能会不一样
上述代码中的匿名函数并没有回来两个参数的差值，而是回来Math目标中的random()随机函数和0.5的差值，这就使得元素的排序将不是依据元素巨细来排序。因为random()的值为0～1之间的一个随机值，所以它和0.5的差时正时负，这就导致数组元素方位的互换很随机，所以排序后的数组是随机排序的。
8)concat(数组1,…,数组n)
concat()将参数指定的数组和当时数组连成一个新数组。示例如下：
vararr1=[1,2,3];
vararr2=[4,5,6];
vararr3=[7,8,9];
alert(arr1.concat(arr2,arr3));//终究获得连接后的数组：1,2,3,4,5,6,7,8,9
9)reverse()
reverse()办法可回来当时数组倒序排序形式。示例如下：
1
2
vararr=[1,2,3,4,5,6];
alert(arr.reverse());//回来：6,5,4,3,2,1
10)join(分隔符)
join()办法可将数组内各个元素按参数指定的分隔符连接成一个字符串。参数能够省掉，省掉参数时，分隔符默许为“逗号”。
11)forEach()
forEach()办法用于对数组的每个元素履行一次回调函数。
语法如下：
1
array目标.forEach(function(currentValue[,index[,array]])[,thisArg])
forEach()办法的第一个参数为array目标中每个元素需求调用的函数。
forEach()办法中的各个参数阐明如下：
currentValue参数：必需参数，表明正在处理的数组元素（当时元素）；
index参数：可选参数，表明正在处理的当时元素的索引；
array参数：可选参数，表明办法正在操作的数组；
thisArg参数，可选参数，取值一般为this，为空时取值为undefined。
forEach()函数的回来值为undefined。示例如下：
varfruit=[“苹果”,”橙子”,”梨子”];
fruit.forEach(function(item,index){
console.log(“fruit[“+index+”]=”+item);
});
上述示例的运转后将在操控台中别离显现：fruit[0]=苹果、fruit[1]=橙子和fruit[2]=梨子。
12)filter()
filter()办法用于创立一个新的数组，其间的元素是指定数组中所有契合指定函数要求的元素。
语法如下：
1
array目标.filter(function(currentValue[,index[,array]])[,thisArg])
filter()办法的第一个参数为回调函数，array目标中每个元素都需求调用该函数，filter()会回来所有使回调函数回来值为true的元素。
filter()办法中的各个参数阐明如下：
currentValue参数：必需参数，表明正在处理的数组元素（当时元素）；
index参数：可选参数，表明正在处理的当时元素的索引；
array参数：可选参数，表明办法正在操作的数组；
thisArg参数，可选参数，取值一般为this，为空时取值为undefined。
filter()函数回来一个新数组，其间包括了指定数组中的所有契合条件的元素。假如没有契合条件的元素则回来空数组。
示例如下：
varnames1=[“张山”,”张小天”,”李四”,”张萌萌”,”王宁”,”陈浩”];//原数组
functioncheckName(name){//界说回调函数，判断姓名是否姓“张”
if(name.indexOf(“张”)!=-1){
returntrue;
}else{
returnfalse;
}
}
varnames2=names1.filter(checkName);//对names1履行回调用函数，回来所有姓张的姓名
names2.forEach(function(item,index){//遍历names2数组中的每个元素
console.log(“names2[“+index+”]=”+item);
});
上述示例运转后将在操控台中别离显现：names2[0]=张山、names2[1]=张小天和names2[2]=张萌萌。
13)map()
map()办法用于创立一个新的数组，其间的每个元素是指定数组的对应元素调用指定函数处理后的值。
语法如下：
1
array目标.map(function(currentValue[,index[,array]])[,thisArg])
map()办法的第一个参数为回调函数，array目标中每个元素都需求调用该函数。
map()办法中的各个参数阐明如下：
currentValue参数：必需参数，表明正在处理的数组元素（当时元素）；
index参数：可选参数，表明正在处理的当时元素的索引；
array参数：可选参数，表明办法正在操作的数组；
thisArg参数，可选参数，取值一般为this，为空时取值为undefined。
map()函数回来一个新数组，其间的元素为原始数组元素调用回调函数处理后的值。示例如下：
7
varnumber=[1,2,3];//原数组
varnum=number.map(function(item){//对原数组中的每个元素*2，将值别离存储在num数组中
returnitem*2;
});
num.forEach(function(item,index){//遍历num中的每个元素
console.log(“num[“+index+”]=”+item);
});
上述示例运转后将在操控台中别离显现：num[0]=2、num[1]=4和num[2]=6。
14)reduce()
reduce()用于运用回调函数对数组中的每个元素进行处理，并将处理进行汇总回来。语法如下：
1
array目标.reduce(function(result,currentValue[,index[,array]])[,initialValue])
reduce()办法的第一个参数为回调函数。
reduce()办法中的各个参数阐明如下。
result参数：必需参数，表明初始值或回调函数履行后的回来值。在第一次调用回调函数前，result参数表明初始值；在调用回调函数之后，result参数表明回调函数履行后的回来值。
需求留意的是，假如指定了initialValue参数，则初始值就是initialValue参数值，不然初始值为数组的第一个元素。
currentValue参数：必需参数，表明正在处理的数组元素（当时元素）。
需求留意的是，假如指定了initialValue参数，则第一次履行回调函数时的currentValue为数组的第一个元素，不然为第二个元素。
index参数：可选参数，表明正在处理的当时元素的索引。
array参数：可选参数，表明办法正在操作的数组。
initialValue参数，可选参数，作为第一次调用回调函数时的第一个参数的值。假如没有供给该参数，第一次调用回调函数时的第一个参数将运用数组中的第一个元素。
需求留意的是：对一个空数组调用reduce()办法时，假如没有指定initialValue参数此刻将会报错。
reduce()的运用示例如下：
varnum1=[1,3,6,9];
//reduce()没有initialValue参数
varnum2=num1.reduce(function(v1,v2){//①
returnv1+2*v2;//将当时元素值*2后和初始值或函数的前一次履行成果进行相加
});
console.log(“num2=”+num2);//输出：num2=37
//reduce()供给了initialValue参数
varnum3=num1.reduce(function(v1,v2){//②
returnv1+2*v2;//将当时元素值*2后和初始值或函数的前一次履行成果进行相加
},2);
console.log(“num3=”+num3);//输出：num3=40
上述示例中，①处调用的reduce()没有指定initialValue参数，因此初始值为数组的第一个元素，即1，此刻reduce()的履行进程等效于：1+2*3+2*6+2*9运算表达式的履行，成果回来37。②处调用的reduce()指定了值为2的initialValue参数，因此初始值为2，此刻reduce()的履行进程等效于：2+2*1+2*3+2*6+2*9运算表达式的履行，成果回来40。
15)find()
find()用于获取使回调函数值为true的第一个数组元素。假如没有契合条件的元素，将回来undefined。
语法如下：
1
array目标.find(function(currentValue[,index[,array]])[,thisArg])
filter()办法的第一个参数为回调函数，array目标中每个元素都需求调用该函数，filter()会回来所有使回调函数回来值为true的元素。
filter()办法中的各个参数阐明如下：
currentValue参数：必需参数，表明正在处理的数组元素（当时元素）；
index参数：可选参数，表明正在处理的当时元素的索引；
array参数：可选参数，表明办法正在操作的数组；
thisArg参数，可选参数，取值一般为this，为空时取值为undefined。
find()函数运用示例如下：
varnames=[“Tom”,”Jane”,”Marry”,”John”,”Marissa”];
//界说回调函数
functioncheckLength(item){
returnitem.length>=4;
}
varname=names.find(checkLength);//回来姓名数组中姓名长度大于或等于4的第一个姓名
console.log(“name:”+name);

javascript保留两位小数

Math.round()：根据“round”的字面意思“附近、周围”，可以猜测该函数是求一个附近的整数
小数点后第一位<5
正数：Math.round(11.46)=11
负数：Math.round(-11.46)=-11
小数点后第一位>5
正数：Math.round(11.68)=12
负数：Math.round(-11.68)=-12
小数点后第一位=5
正数：Math.round(11.5)=12
负数：Math.round(-11.5)=-11
总结：（小数点后第一位）大于五全部加，等于五正数加，小于五全不加
Math.ceil()：根据“ceil”的字面意思“天花板”去理解；
Math.ceil(11.46)=Math.ceil(11.68)=Math.ceil(11.5)=12
Math.ceil(-11.46)=Math.ceil(-11.68)=Math.ceil(-11.5)=-11
总结：只要后边有小数都是向上取整
Math.floor()：根据“floor”的字面意思“地板”去理解；
Math.floor(11.46)=Math.floor(11.68)=Math.floor(11.5)=11
Math.floor(-11.46)=Math.floor(-11.68)=Math.floor(-11.5)=-12
总结：只要是有小数，都是向下取证；
二js保留两位小数总结
1四舍五入型的
varnum=2.446242342;
//toFixed(要保留的小数点后边的位数)
num=num.toFixed(2);//输出结果为2.45返回的值是一个字符串类型
2不四舍五入型的
第一种，先把小数变整数：
Math.floor(15.7784514000*100)/100//输出结果为15.77
返回的是一个数字类型
第二种，当作字符串，使用正则匹配：
Number(15.7784514000.toString().match(/^\d+(?:\.\d{0,2})?/))
//输出结果为15.77,不能用于整数如10必须写为10.0000
返回的是一个数字类型
注意：如果是负数，请先转换为正数再计算，最后转回负数
三Js取float型小数点后两位数的方法
1处理会四舍五入
varnum=2.446242342;
num=num.toFixed(2);//输出结果为2.45
//toFixed(要保留的小数点后边的位数)
此处的toFixed()函数取到的值是一个string类型，而不是一个number类型；
处理不会四舍五入
1先把小数变整数
Math.floor(15.7784514000*100)/100//输出结果为15.77
此处的取到的值是一个number类型;
2当做字符串，使用正则匹配
Number(15.7784514000.toString().match(/^\d+(?:\.\d{0,2})?/))
//输出结果为15.77,不能用于整数如10必须写为10.0000
此处取到的值是一个number类型
注意：如果是负数，请先转为整数再计算，最后在转回负数；
<scripttype=”text/javascript”>
保留两位小数
1功能：将浮点数四舍五入，取小数点后2位
varnum=2.446242342;
functiontoDecimal(x){
varf=parseFloat(x);
if(isNaN(f)){
return;
}
f=Math.round(x*100)/100;
returnf;
}
toDecimal(num)//调用方法
varnums=toDecimal(num)//调用函数方法后，他不会改变原来那个变量所拥有的值，而是从新
替换成一个新值；
console.log(typeof(nums));
此处获取到的值是一个number类型
2制保留2位小数，如：2，会在2后面补上00.即2.00
//强制保留两位小数
functiontoDecimal2(x){
varf=parseFloat(x);
if(isNaN(f)){
returnfalse;
}
varf=Math.round(x*100)/100;
vars=f.toString();
varrs=s.indexOf(‘.’);
if(rs<0){
rs=s.length;
s+=’.’;
}
while(s.length<=rs+2){
s+=’0′;
}
returns;
}
此处获取到的是一个string类型的值；
3可选择要保留几位小数的方法
varnum=2.446242342;
functionfomatFloat(src,pos){//src是要保留小数的值，pos是要保留几位小数；
returnMath.round(src*Math.pow(10,pos))/Math.pow(10,pos);
}
varnums=fomatFloat(num,3)
console.log(nums);
console.log(typeof(nums));
此处获取到的是一个number类型的值；
4精确到n位，不含n位
varnum=2.446242342;
varnums=num.toPrecision(3);
console.log(nums);//2.45
console.log(typeof(nums));
此处获取到的是是一个String类型的值
5只保留整数部分
varnum=2.446242342;
varnums=parseInt(num);
console.log(nums);//2
console.log(typeof(nums));//number
6向上取整,有小数就整数部分加1
varnum=2.446242342;
varnums=Math.ceil(num);
console.log(nums);//3
console.log(typeof(nums));//number
7四舍五入.
varnum=2.446242342;
varnums=Math.round(num);
console.log(nums);//2
console.log(typeof(nums));//number
varnum=2.6788667778;
varnums=Math.round(num);
console.log(nums);//3
console.log(typeof(nums));//number
8向下取整
varnum=2.6788667778;
varnums=Math.floor(num)
console.log(nums);//2
console.log(typeof(nums));//number
9对于小数点位数大于2位的，用上面的函数没问题，但是如果小于2位的，比如：changeTwoDecimal(3.1)
，将返回3.1，如果你一定需要3.10这样的格式，那么需要下面的这个函数：
varnum=2.1;
functionchangeTwoDecimal_f(x){
varf_x=parseFloat(x);
if(isNaN(f_x)){
alert(‘function:changeTwoDecimal->parametererror’);
returnfalse;
}
varf_x=Math.round(x*100)/100;
vars_x=f_x.toString();
varpos_decimal=s_x.indexOf(‘.’);
if(pos_decimal<0){
pos_decimal=s_x.length;
s_x+=’.’;
}
while(s_x.length<=pos_decimal+2){
s_x+=’0′;
}
returns_x;
}
varnums=changeTwoDecimal_f(num);
console.log(nums);//2.10
console.log(typeof(nums));//string
功能：将浮点数四舍五入，取小数点后2位，如果不足2位则补0,
这个函数返回的是字符串的格式用法：
changeTwoDecimal_f(3.1415926)返回3.14
changeTwoDecimal_f(3.1)返回3.10
</script>