js中数字相关的内容

703 阅读8分钟

简介

&nbsp&nbsp数字(Number)也称为数值或数,是JavaScript的基础数据类型之一。当数字直接出现在程序中时,被称为数值直接量。在 JavaScript 程序中,直接输入的任何数字都被视为数值直接量。并且在JavaScript中,所有数字都是以 64 位浮点数形式存储,包括整数。例如,2 与 2.0 是同一个数。

类型

&nbsp&nbspJavaScript 不区分整数和浮点数,统一用 Number 表示数字类型,常见的数字类型如下:

// 以下使用 typeof 判断结果均为 number
typeof(96) // 整数
typeof(3.1415926) // 浮点数
typeof(1.23e456) // 科学计数法
typeof(0x123) // 十六进制
typeof(-1) // 负数
typeof(NaN) // 非数字 非正常数字表示或者 无法计算出结果的时候
typeof(Infinity) // 正无穷大 与之对应 -Infinity 是负无穷大

判断方法

&nbsp&nbsp在JavaScript当中,我们想要判断一个数值的类型为数字类型有着以下几种方法:

1.typeof && isNaN && isFinite

&nbsp&nbsp一般情况下我们口中的数字多指可以进行计算的数值,那么需要排除 NaN 和 Infinity 这两种特殊的数字类型。这里有一个函数,可以过滤 NaN 和 Infinity。
&nbsp&nbsp使用 isFinite 判定一个数字是否是有限数字。isFinite 方法检测它参数的数值。如果参数是 NaN,正无穷大或者负无穷大,会返回false,其他返回 true。如果只需要区分 NaN 使用 isNaN 就行

2.Object.prototype.toString.call

Object.prototype.toString.call 也是一种判断数据类型的比较常见的方法,在判断数字的时候可以用它替换 typeof:

function isNumber(target) {
  return Object.prototype.toString.call(target) === '[object Number]' && isFinite(target)
}

3.+

在需要判断的对象前面添加一个 + ,这样就转换为number类型,如果与自身相等则表示这个对象是一个数字。值得注意的是判断 Infinity 的时候还是返回 true 代码如下:

function isNumber(target) {
  return target === +target
}

4.正则

通过正则去判断,这里没有考虑科学计数法和一些其他进制的表示方式,而且没有数字字符 '123' 也会被认为是数字。

function isNumber(obj) {
  var reg = /^[0-9]+.?[0-9]*$/
  return reg.test(obj)
}

数字方法

1.Number()

Number() 可用于把 JavaScript 变量转换为数值,遇到无法转化的变量会转化为NaN:

x = true;
Number(x);        // 返回 1
x = false;     
Number(x);        // 返回 0
x = new Date();
Number(x);        // 返回 1404568027739
x = "10"
Number(x);        // 返回 10
x = "10 20"
Number(x);        // 返回 NaN

2.parseInt()、parseFloat()

parseFloat()和 parseInt()解析一段字符串并返回数值。允许空格。只返回首个数字,遇到无法转化的变量会转化为NaN:

parseInt("10");         // 返回 10      parseFloat("10");         // 返回 10
parseInt("10.33");      // 返回 10      parseFloat("10.33");      // 返回 10.33
parseInt("10 20 30");   // 返回 10      parseFloat("10 20 30");   // 返回 10
parseInt("10 years");   // 返回 10      parseFloat("10 years");   // 返回 10
parseInt("years 10");   // 返回 NaN     parseFloat("years 10");   // 返回 NaN

3.toFixed()

toFixed() 返回字符串值,它包含了指定位数小数的数字,toFixed(2) 非常适合处理金钱:

var x = 9.656;
x.toFixed(0);           // 返回 10
x.toFixed(2);           // 返回 9.66
x.toFixed(4);           // 返回 9.6560
x.toFixed(6);           // 返回 9.656000

4.Math

Math 对象用于执行数学任务,您无需创建它,通过把 Math 作为对象使用就可以调用其所有属性和方法,一些常用的Math方法如下:

Math.abs(x)   --------绝对值
Math.round(x)    --------四舍五入
Math.ceil(x)    --------向上取整
Math.floor(x)   --------向下取整
Math.max([val1[,val2[,...]]])   -------取最大值
Math.min([val1[,val2[,...]]])   -------取最小
Math.random   --------随机数(在0-1之间)
Math.cos(x)   --------余弦值
Math.exp(x)   --------ex
Math.log(x)   --------ey=x  返回y的值
Math.sqrt(x)   --------平方根
Math.pow(x,y)   --------x的y次方
Math.trunc(x)  --------去除一个数的小数部分,返回整数部分。
Math.sign(x)    --------判断一个数到底是正数、负数、还是零
Math.cbrt(x)    -------计算一个数的立方根

5.toString()

toString() 以字符串返回数值,所有数字方法可用于任意类型的数字(字面量、变量或表达式):

var x = 123;
x.toString();            // 从变量 x 返回 123
(123).toString();        // 从文本 123 返回 123
(100 + 23).toString();   // 从表达式 100 + 23 返回 123

6.toExponential()

以指数表示法返回该数值字符串表示形式,可接收一个参数指定小数点后几位数字。

let a = 99.6633;
let a1 = '字符串:' + a.toExponential(); // "字符串:9.96633e+1"
let a2 = '字符串:' + a.toExponential(2);// "字符串:9.97e+1"

7.toPrecision()

以指定的精度返回该数值对象的字符串表示,可接收一个参数,用来指定有效数个数的整数。

let a = 1.2345;
let a1 = '字符串:' + a.toPrecision(); // "字符串:1.2345"
let a2 = '字符串:' + a.toPrecision(1);// "字符串:1"
let a2 = '字符串:' + a.toPrecision(2);// "字符串:1.2"

8.Number.XXX

(1)、Number.MAX_VALUE

作用:表示在 JavaScript 里所能表示的最大数值;
语法:Number.MAX_VALUE;
返回值:返回一个js能表示的最大数值,接近于1.79E+308;

(2)、Number.MIN_VALUE

作用:表示在 JavaScript 里所能表示的最小数值;
语法:Number.MIN_VALUE;
返回值:返回一个js能表示的最大数值,接近于5e-324;

(3)、Number.isInteger

作用:用来判断给定的参数是否为整数;
语法:Number.isInteger(number);
返回值:返回boolean;

数值运算

运算符

1、定义

JavaScript中运算符主要用于连接简单表达式,组成一个复杂的表达式

2、加法运算符(Addition):x + y

加法运算符是在运行时决定,到底是执行相加,还是执行连接。也就是说,运算子的不同,导致了不同的语法行为,这种现象称为“重载”(overload)

(1)、在两个操作数都是数字的时候,会做加法运算

console.log(2+4);//6

(2)、两个参数都是字符串或在有一个参数是字符串的情况下,会把另外一个参数转换为字符串做字符串拼接

'3' + 4 + 5 // "345"
3 + 4 + '5' // "75"

(3)、在参数有对象的情况下

3.1首先自动调用对象的valueOf方法
一般来说,对象的valueOf方法总是返回对象自身,也可自定义
3.2再自动调用对象的toString方法,将其转为字符串(如果valueOf方法直接返回一个原始类型的值,就不会调用tostring)
对象的toString方法默认返回[object Object],也可自定义:

var obj = { p: 1 };
obj + 2 // "[object Object]2"

3.3自定义valueOf方法或toString方法,得到想要的结果

var obj = {
  valueOf: function () {
    return 1;
  }
};
obj + 2 // 3

3.其他算数运算符

对于其他运算符,在运算前都强制转换数字,再运算。对象就调用valueOf或者toString,如果不能转换的,输出NaN

减法运算符(Subtraction): x - y
乘法运算符(Multiplication): x * y
除法运算符(Division):x / y
余数运算符(Remainder):x % y
自增运算符(Increment):++x(先加后赋值) 或者 x++(先赋值后加)
自减运算符(Decrement):--x 或者 x--
求负运算符(Negate):-x
指数运算符 (index):x**y
数值运算符(Convert to number): +x

4.赋值运算符

赋值运算符用于给变量赋值,最常见的赋值运算符,当然就是等号,表达式x=y表示将y赋值给x。除此之外,JavaScript还提供其他11个赋值运算符。
运算时从右到左,如var z=y=x;

x += y // 等同于 x = x + y
x -= y // 等同于 x = x - y
x *= y // 等同于 x = x * y
x /= y // 等同于 x = x / y
x %= y // 等同于 x = x % y
x >>= y // 等同于 x = x >> y
x <<= y // 等同于 x = x << y
x >>>= y // 等同于 x = x >>> y
x &= y // 等同于 x = x & y
x |= y // 等同于 x = x | y
x ^= y // 等同于 x = x ^ y

5.位运算符

就是把两个做位运算的值,都按照二进制一位一位的按照符号规则进行运算
位运算符只对整数起作用,如果一个运算子不是整数,会自动转为整数后再执行

1、或运算(or):

符号为|,表示两个二进制位中有一个为1,则结果为1,否则为0。 0000 0010 | 0000 0001 就等0000 0011(3)

2、与运算(and):

符号为&,表示两个二进制位都为1,则结果为1,否则为0。 0000 0010 & 0000 0001 就等0000 0000(0)

3、否运算(not):

符号为~,表示将一个二进制位变成相反值。 ~ 0000 0010 就等于1111 1101

4、异或运算(xor):

符号为ˆ,表示两个二进制位中有且仅有一个为1时,结果为1,否则为0。

5、左移运算(left shift):

符号为<<

6、右移运算(right shift):

符号为>>

7、带符号位的右移运算(zero filled right shift):

符号为>>>

浮点数运算

在我们日常生活中,使用算数运算符,数值可以参与各种计算,如加、减、乘、除等运算操作。但是,因为JavaScript使用IEEE754格式来表示整数和浮点数值,用 IEEE 754(二进制浮点数算术标准) 标准的64 位双精度浮点数数做运算的时候经常有一些问题。 浮点数用二进制表达时是无穷的,因浮点数小数位的限制而截断的二进制数字,再转换为十进制,例如0.1+0.2就成了 0.30000000000000004,这个时候我们就需要一些特殊的方法来解决这个问题:

1.加法

Number.prototype.add = function(arg){
var r1,r2,m;
try{r1=this.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2))
return (this*m+arg*m)/m
}

2.减法

Number.prototype.sub = function(arg){
var r1,r2,m;
try{r1=this.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2))
return (this*m-arg*m)/m
}

3.乘法

Number.prototype.mul = function (arg) { 
var m=0,s1=this.toString(),s2=arg.toString(); 
try{m+=s1.split(".")[1].length}catch(e){} 
try{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}

4.除法

Number.prototype.div = function (arg){
var t1=0,t2=0,r1,r2;
try{t1=this.toString().split(".")[1].length}catch(e){}
try{t2=arg.toString().split(".")[1].length}catch(e){}
with(Math){
r1=Number(this.toString().replace(".",""))
r2=Number(arg.toString().replace(".",""))
return (r1/r2)*pow(10,t2-t1);
}
}