Math
Math对象是JavaScript的内置对象,提供一系列数学常数和数学方法。Math对象只提供了静态的属性和方法,所以使用时不用实例化
属性
Math对象提供以下一些只读的数学常数。
Math.E // 2.718281828459045
Math.LN2 // 0.6931471805599453
Math.LN10 // 2.302585092994046
Math.LOG2E // 1.4426950408889634
Math.LOG10E // 0.4342944819032518
Math.PI // 3.141592653589793
Math.SQRT1_2 // 0.7071067811865476
Math.SQRT2 // 1.4142135623730951
方法
round
round方法用于四舍五入
Math.round(0.1) // 0
Math.round(0.5) // 1
它对于负值的运算结果与正值略有不同,主要体现在对.5的处理
Math.round(-1.1) // -1
Math.round(-1.5) // -1
Math.round(-1.6) // -2
abs,max,min
abs方法返回参数值的绝对值
Math.abs(1) // 1
Math.abs(-1) // 1
max方法返回最大的参数,min方法返回最小的参数
Math.max(2, -1, 5) // 5
Math.min(2, -1, 5) // -1
floor(地板,往下降)方法返回小于参数值的最大整数
Math.floor(3.2) // 3
Math.floor(-3.2) // -4
ceil(天花板,往上升)方法返回大于参数值的最小整数
Math.ceil(3.2) // 4
Math.ceil(-3.2) // -3
pow,sqrt
pow方法返回以第一个参数为底数、第二个参数为幂的指数值
Math.pow(2, 2) // 4
Math.pow(2, 3) // 8
sqrt方法返回参数值的平方根。如果参数是一个负值,则返回NaN
Math.sqrt(4) // 2
Math.sqrt(-4) // NaN
log,exp
log方法返回以e为底的自然对数值
Math.log(Math.E) // 1
Math.log(10) // 2.302585092994046
求以10为底的对数,可以除以Math.LN10;求以2为底的对数,可以除以Math.LN2。
Math.log(100)/Math.LN10 // 2
Math.log(8)/Math.LN2 // 3
exp方法返回常数e的参数次方
Math.exp(1) // 2.718281828459045
Math.exp(3) // 20.085536923187668
random(最常用的Math方法)
该方法返回0到1之间的一个伪随机数,可能等于0,但是一定小于1
Math.random() // 0.7151307314634323
// 返回给定范围内的随机数
function getRandomArbitrary(min, max) {
return Math.random() * (max - min) + min;
}
// 返回给定范围内的随机整数[min,max]
function getRandomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
//得到50个由[min,max]之间随机数,组成的数组
function random(min,max){
return Math.floor(Math.random()*(max - min + 1)) + min
}
var arr = []
for(var i=0;i<50;i++){
arr.push(random(5,10))
//push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject,而不是创建一个新的数组。push() 方法和 pop() 方法使用数组提供的先进后出栈的功能。
}
//生成一个长度为 n 的随机字符串,字符串字符的取值范围包括0到9,a到 z,A到Z。
function random(a,b){
return a + Math.floor(Math.random()*(b-a))
}
function randomStr(len){
var dict = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
var str = ''
for(var i=0;i<len;i++){
str += dict[random(0,62)]
}
return str
}
//得到一个随机IP地址0.0.0.0 ~ 255.255.255.255
function random(a,b){
return a + Math.floor(Math.random()*(b-a))
}
function randomIP(){
var arr = []
for(var i=0;i<4;i++){
arr.push(random(0,256))
}
return arr.join('.')
}
三角函数
sin方法返回参数的正弦,cos方法返回参数的余弦,tan方法返回参数的正切。
asin方法返回参数的反正弦,acos方法返回参数的反余弦,atan方法返回参数的反正切。这三个方法的返回值都是弧度值。
数组
数组是值的有序集合,由于弱类型的原因,JavaScript中数组十分灵活、强大,不像是Java等强类型高级语言数组只能存放同一类型或其子类型元素,JavaScript在同一个数组中可以存放多种类型的元素,而且长度也是可以动态调整的,可以随着数据增加或减少自动对数组长度做更改。
使用字面量方式创建数组
1.使用方括号,创建空数组,等同于调用无参构造函数
var a4 = [];
2.使用中括号,并传入初始化数据,等同于调用带有初始化数据的构造函数
var a5 = [10];
注意:使用字面量方式,无论传入几个参数,都会把参数当作初始化内容
数组的索引与长度
数组的值可以通过自然数索引访问进行读写操作,
var a1 = [1,2,3,4];
console.log(a1[0]); //1
var i=1;
console.log(a1[i]); //2
console.log(a1[++i]); //3
数组也是对象,数组会把索引值转换为对应字符串(1=>”1”)作为对象属性名,所以其实负数,甚至非数字”索引“都是允许的,只不过这些会变成数组的属性,而不是索引
var a = new Array(1,2,3);
a[-10]="a[-10]";
a["sss"]="sss";
所有的索引都是属性名,但只有自然数(有最大值)才是索引,一般我们在使用数组的时候不会出现数组越界错误也正是因为此,数组的索引可以不是连续的,访问index不存在的元素的时候返回undefined
var a = new Array(1,2,3);
a[100] = 100;
console.log(a.length); //101
console.log(a[3]); //undefined
console.log(a[99]); //undefined
console.log(a[100]); 100
数组的length属性同样是个可写的属性,
当强制把数组的length属性值设置为小于等于最大index值时,数组会自动删除indexd大于等于length的数据
如果把length设置为大于最大index+1的值的时候,数组也会自动扩张,但是不会为数组添加新元素,只是在尾部追加空空间
a.length=5;
console.log(a); //[1,2] //后面没有3个undefined
元素添加/删除
1.基本方法
添加:直接使用索引就可以(index没必要连续)
var a=new Array(1,2,3);
a[3]=4;
console.log(a);//[1, 2, 3, 4]
删除:使用删除对象属性的方法,使用delete 删除数组元素
不改变数组长度,也不会改变其他数据的index和value对应关系
delete a[2];
2.栈方法
使用pop和push模拟堆栈,先入后出使用数组(从队尾添加,从队尾删除),(pop方法删除最后一个元素后,后面元素的index都自动减一,数组length同时减一)
var a = new Array(1,2,3);
a.push(4);
console.log(a);//[1, 2, 3, 4]
console.log(a.length);//4
console.log(a.pop());//4
console.log(a); //[1, 2, 3]
console.log(a.length);//3
3.队列方法
shift/unshift 实现从队头删除,从队头添加
故可使用shift/push模拟队列,先入先出使用数组(从队头删除,从队尾添加)
var a=new Array(1,2,3);
a.unshift(4);
console.log(a);//[4, 1, 2, 3]
console.log(a.shift());//4 从头删除,返回删除的值
console.log(a); //[1, 2, 3]
4.一次性解决数组添加、删除的终极神器:splice
JavaScript提供了一个splice方法用于一次性解决数组添加、删除(这两种方法一结合就可以达到替换效果),方法有三个参数
1.开始索引
2.删除元素的个数(更准确的说是删除动作执行了多少次)
3.增加的新元素,可以写多个
splice方法返回一个由删除元素组成的新数组,没有删除则返回空数组
var a = new Array(1,2,3,4,5);
console.log(a.splice(1,3));//[2, 3, 4]
console.log(a.length);//2
console.log(a);//[1,5]
join(char)
把数组元素(对象调用其toString()方法)使用参数作为连接符连接成一字符串,不会修改原数组内容
var a = new Array(1,2,3,4,5);
console.log(a.join(',')); //1,2,3,4,5
console.log(a.join(' ')); //1 2 3 4 5
slice(start,end)
用于返回数组中一个片段或子数组,slice不会改变原数组,而是返回一个新的数组,新数组内的值[start,end)
如果参数出现负数,则从数组尾部计数
concat(array)
用于拼接数组,a.concat(b)返回一个a和b共同组成的新数组
reverse()
将数组逆序,与之前不同的是它会修改原数组
sort
用于对数组进行排序,无参数时默认按字母表升序排序,会改变原数组
如果想按照自己定义方式排序,可以传一个排序方法进去
sort内部使用快速排序,当设置参数时,把正在比较的两个参数传入自定义方法并调用(正在比较的两个数会传给自定义方法的v1、v2),如果返回值大于0表示v1 > v2,如果等于0,表示v1 = v2,如果小于0,表示v1 < v2,其实我们传入的方法就是告诉sort怎么比较两个元素谁大谁小,至于排序移动元素过程人家写好了
//对数组a从小到大排列
var a = new Array(7,8,9,10,11);
a.sort(function(v1,v2){
return v1-v2;
});
console.log(a);//[7, 8, 9, 10, 11]
//对数组a从大到小排列
var a = new Array(7,8,9,10,11);
a.sort(function(v1,v2){
return v2-v1;
});
//对数组students按照age从小到大排序
var students = [
{name: 'a', age: 10},
{name: 'b', age: 18},
{name: 'c', age: 20},
{name: 'd', age: 22},
{name: 'e', age: 13}
]
students.sort(function(s1,s2){
return s1.age - s2.age
})
console.log(students)
//对数组students按照name从小到大排序
var students = [
{name: 'c', age: 10},
{name: 'b', age: 18},
{name: 'q', age: 20},
{name: 'a', age: 22},
{name: 'e', age: 13}
]
students.sort(function(s1,s2){
if(s1.name > s2.name){
return 1
}else{
return -1
}
})
console.log(students)
ES5 数组拓展(IE8)
Array.isArray(obj)
这是Array对象的一个静态函数,用来判断一个对象是不是数组
.indexOf(element) / .lastIndexOf(element)
用于查找数组内指定元素位置,查找到第一个后返回其索引,没有查找到返回-1,indexOf从头至尾搜索,lastIndexOf反向搜索。
.forEach(function(element, index, array){ })
遍历数组,参数为一个回调函数,回调函数有三个参数:
(当前元素e,当前元素索引值i,整个数组array)
var a = new Array(1,2,3,4,5,6);
a.forEach(function(e,i,array){
array[i]= e + 1;
});
console.log(a); //[2, 3, 4, 5, 6, 7]
.every(function(element, index, array)) /
.some(function(element, index, array))
这两个函数类似于逻辑判定,回调函数返回一个布尔值
every是所有函数的每个回调函数都返回true的时候才会返回true,当遇到false的时候终止执行,返回false
some函数是“存在”有一个回调函数返回true的时候终止执行并返回true,否则返回false
在空数组上调用every返回true,some返回false
var a=new Array(1,2,3,4,5,6);
console.log(a.every(function(e, i, arr){
return e < 5;
}));
console.log(a.some(function(e,i,arr){
return e > 4;
}));
.map(function(element))
与forEach类似,遍历数组,回调函数返回值组成一个新数组返回,新数组索引结构和原数组一致,原数组不变
var a = [1,2,3,4,5]
var aa = a.map(function(e){
return e*e
})
console.log(aa) //[1, 4, 9, 16, 25]
.filter(function(element))
返回数组的一个子集,回调函数用于逻辑判断是否返回,返回true则把当前元素加入到返回数组中,false则不加
新数组只包含返回true的值,索引缺失的不包括,原数组保持不变
var a = [1,2,-3,4,-5]
var aa = a.filter(function(e){
return e<0
})
console.log(aa); //[-3, -5]
//过滤出username中包含a的用户
var students = [
{username:'aa',age:20},
{username:'ba',age:10},
{username:'cc',age:20},
{username:'da',age:19},
{username:'fghjka',age:26},
{username:'oh',age:20},
]
students.filter(function(e){
return e['username'].indexOf('a') > -1
})
**.reduce(function(v1, v2), value) / .reduceRight(function(v1, v2), value)
遍历数组,调用回调函数,将数组元素组合成一个值,reduce从索引最小值开始,reduceRight反向,方法有两个参数
回调函数:把两个值合为一个,返回结果
value,一个初始值,可选
var a = new Array(1,2,3,4,5,6);
console.log(a.reduce(function(v1, v2){
return v1 + v2;
})); // 21
console.log(a.reduceRight(function(v1, v2){
return v1 - v2;
}, 100)); // 79