大家好,上次给大家分享的文章,里面讲到了java学习中需要掌握的重要的知识点:变量和类型,上次讲到的是前半部分,这次我把剩下的给大家一次说完,让我们头脑风暴开始吧!
一、不老实的Number类型
为什么说Number
类型不老实呢,相信大家都多多少少的在开发中遇到过小数计算不精确的问题,比如0.1+0.2!==0.3
,下面我们来追本溯源,看看为什么会出现这种现象,以及该如何避免。
下面是我实现的一个简单的函数,用于判断两个小数进行加法运算是否精确:
function judgeFloat(n, m) {
const binaryN = n.toString(2);
const binaryM = m.toString(2);
console.log(`${n}的二进制是 ${binaryN}`);
console.log(`${m}的二进制是 ${binaryM}`);
const MN = m + n;
const accuracyMN = (m * 100 + n * 100) / 100;
const binaryMN = MN.toString(2);
const accuracyBinaryMN = accuracyMN.toString(2);
console.log(`${n}+${m}的二进制是${binaryMN}`);
console.log(`${accuracyMN}的二进制是 ${accuracyBinaryMN}`);
console.log(`${n}+${m}的二进制再转成十进制是${to10(binaryMN)}`);
console.log(`${accuracyMN}的二进制是再转成十进制是${to10(accuracyBinaryMN)}`);
console.log(`${n}+${m}在js中计算是${(to10(binaryMN) === to10(accuracyBinaryMN)) ? '' : '不'}准确的`);
}
function to10(n) {
const pre = (n.split('.')[0] - 0).toString(2);
const arr = n.split('.')[1].split('');
let i = 0;
let result = 0;
while (i < arr.length) {
result += arr[i] * Math.pow(2, -(i + 1));
i++;
}
return result;
}
judgeFloat(0.1, 0.2);
judgeFloat(0.6, 0.7);
复制代码
1.1 精度丢失
计算机中所有的数据都是以二进制
存储的,所以在计算时计算机要把数据先转换成二进制
进行计算,然后在把计算结果转换成十进制
。
由上面的代码不难看出,在计算0.1+0.2
时,二进制
计算发生了精度丢失,导致再转换成十进制
后和预计的结果不符。
1.2 对结果的分析—更多的问题
0.1
和0.2
的二进制都是以1100无限循环的小数,下面逐个来看JS帮我们计算所得的结果:
0.1的二进制:
0.0001100110011001100110011001100110011001100110011001101
复制代码
0.2的二进制:
0.001100110011001100110011001100110011001100110011001101
复制代码
理论上讲,由上面的结果相加应该::
0.0100110011001100110011001100110011001100110011001100111
复制代码
实际JS计算得到的0.1+0.2的二进制
0.0100110011001100110011001100110011001100110011001101
复制代码
看到这里你可能会产生更多的问题:
为什么 js计算出的 0.1的二进制 是这么多位而不是更多位???
为什么 js计算的(0.1+0.2)的二进制和我们自己计算的(0.1+0.2)的二进制结果不一样呢???
为什么 0.1的二进制 + 0.2的二进制 != 0.3的二进制???
1.3 js对二进制小数的存储方式
小数的二进制
大多数都是无限循环的,JavaScript
是怎么来存储他们的呢?
在ECMAScript®语言规范中可以看到,ECMAScript
中的Number
类型遵循IEEE 754
标准。使用64位固定长度来表示。
事实上有很多语言的数字类型都遵循这个标准,例如JAVA
,所以很多语言同样有着上面同样的问题。
所以下次遇到这种问题不要上来就喷JavaScript
...
有兴趣可以看看下这个网站0.30000000000000004.com/,是的,你没看错,就是0.30000000000000004.com/!!!
1.4 IEEE 754
IEEE754
标准包含一组实数的二进制表示法。它有三部分组成:
-
符号位
-
指数位
-
尾数位
三种精度的浮点数各个部分位数如下:
JavaScript
使用的是64位双精度浮点数编码,所以它的符号位
占1
位,指数位占11
位,尾数位占52
位。
下面我们在理解下什么是符号位
、指数位
、尾数位
,以0.1
为例:
它的二进制为:0.0001100110011001100...
为了节省存储空间,在计算机中它是以科学计数法表示的,也就是
1.100110011001100...
X 2-4
如果这里不好理解可以想一下十进制的数:
1100
的科学计数法为11
X 102
所以:
符号位
就是标识正负的,1
表示负
,0
表示正
;
指数位
存储科学计数法的指数;
尾数位
存储科学计数法后的有效数字;
所以我们通常看到的二进制,其实是计算机实际存储的尾数位。
1.5 js中的toString(2)
由于尾数位只能存储52
个数字,这就能解释toString(2)
的执行结果了:
如果计算机没有存储空间的限制,那么0.1
的二进制
应该是:
0.00011001100110011001100110011001100110011001100110011001...
复制代码
科学计数法尾数位
1.1001100110011001100110011001100110011001100110011001...
复制代码
但是由于限制,有效数字第53
位及以后的数字是不能存储的,它遵循,如果是1
就向前一位进1
,如果是0
就舍弃的原则。
0.1的二进制科学计数法第53位是1,所以就有了下面的结果:
0.0001100110011001100110011001100110011001100110011001101
复制代码
0.2
有着同样的问题,其实正是由于这样的存储,在这里有了精度丢失,导致了0.1+0.2!=0.3
。
事实上有着同样精度问题的计算还有很多,我们无法把他们都记下来,所以当程序中有数字计算时,我们最好用工具库来帮助我们解决,下面是两个推荐使用的开源库:
1.6 JavaScript能表示的最大数字
由与IEEE 754
双精度64位规范的限制:
指数位
能表示的最大数字:1023
(十进制)
尾数位
能表达的最大数字即尾数位都位1
的情况
所以JavaScript能表示的最大数字即位
1.111...
X 21023 这个结果转换成十进制是1.7976931348623157e+308
,这个结果即为Number.MAX_VALUE
。
1.7 最大安全数字
JavaScript中Number.MAX_SAFE_INTEGER
表示最大安全数字,计算结果是9007199254740991
,即在这个数范围内不会出现精度丢失(小数除外),这个数实际上是1.111...
X 252。
我们同样可以用一些开源库来处理大整数:
其实官方也考虑到了这个问题,bigInt
类型在es10
中被提出,现在Chrome
中已经可以使用,使用bigInt
可以操作超过最大安全数字的数字。
二、还有哪些引用类型
在
ECMAScript
中,引用类型是一种数据结构,用于将数据和功能组织在一起。
我们通常所说的对象,就是某个特定引用类型的实例。
在ECMAScript
关于类型的定义中,只给出了Object
类型,实际上,我们平时使用的很多引用类型的变量,并不是由Object
构造的,但是它们原型链的终点都是Object
,这些类型都属于引用类型。
Array
数组Date
日期RegExp
正则Function
函数
2.1 包装类型
为了便于操作基本类型值,ECMAScript
还提供了几个特殊的引用类型,他们是基本类型的包装类型:
Boolean
Number
String
注意包装类型和原始类型的区别:
true === new Boolean(true); // false
123 === new Number(123); // false
'ConardLi' === new String('ConardLi'); // false
console.log(typeof new String('ConardLi')); // object
console.log(typeof 'ConardLi'); // string
复制代码
引用类型和包装类型的主要区别就是对象的生存期,使用new操作符创建的引用类型的实例,在执行流离开当前作用域之前都一直保存在内存中,而自基本类型则只存在于一行代码的执行瞬间,然后立即被销毁,这意味着我们不能在运行时为基本类型添加属性和方法。
var name = 'ConardLi'
name.color = 'red';
console.log(name.color); // undefined
复制代码
2.2 装箱和拆箱
-
装箱转换:把基本类型转换为对应的包装类型
-
拆箱操作:把引用类型转换为基本类型
既然原始类型不能扩展属性和方法,那么我们是如何使用原始类型调用方法的呢?
每当我们操作一个基础类型时,后台就会自动创建一个包装类型的对象,从而让我们能够调用一些方法和属性,例如下面的代码:
var name = "ConardLi";
var name2 = name.substring(2);
复制代码
实际上发生了以下几个过程:
- 创建一个
String
的包装类型实例 - 在实例上调用
substring
方法 - 销毁实例
也就是说,我们使用基本类型调用方法,就会自动进行装箱和拆箱操作,相同的,我们使用Number
和Boolean
类型时,也会发生这个过程。
从引用类型到基本类型的转换,也就是拆箱的过程中,会遵循ECMAScript规范
规定的toPrimitive
原则,一般会调用引用类型的valueOf
和toString
方法,你也可以直接重写toPeimitive
方法。一般转换成不同类型的值遵循的原则不同,例如:
- 引用类型转换为
Number
类型,先调用valueOf
,再调用toString
- 引用类型转换为
String
类型,先调用toString
,再调用valueOf
若valueOf
和toString
都不存在,或者没有返回基本类型,则抛出TypeError
异常。
const obj = {
valueOf: () => { console.log('valueOf'); return 123; },
toString: () => { console.log('toString'); return 'ConardLi'; },
};
console.log(obj - 1); // valueOf 122
console.log(`${obj}ConardLi`); // toString ConardLiConardLi
const obj2 = {
[Symbol.toPrimitive]: () => { console.log('toPrimitive'); return 123; },
};
console.log(obj2 - 1); // valueOf 122
const obj3 = {
valueOf: () => { console.log('valueOf'); return {}; },
toString: () => { console.log('toString'); return {}; },
};
console.log(obj3 - 1);
// valueOf
// toString
// TypeError
复制代码
除了程序中的自动拆箱和自动装箱,我们还可以手动进行拆箱和装箱操作。我们可以直接调用包装类型的valueOf
或toString
,实现拆箱操作:
var num =new Number("123");
console.log( typeof num.valueOf() ); //number
console.log( typeof num.toString() ); //string
复制代码
三、类型转换
因为JavaScript
是弱类型的语言,所以类型转换发生非常频繁,上面我们说的装箱和拆箱其实就是一种类型转换。
类型转换分为两种,隐式转换即程序自动进行的类型转换,强制转换即我们手动进行的类型转换。
强制转换这里就不再多提及了,下面我们来看看让人头疼的可能发生隐式类型转换的几个场景,以及如何转换:
3.1 类型转换规则
如果发生了隐式转换,那么各种类型互转符合下面的规则:
3.2 if语句和逻辑语句
在if
语句和逻辑语句中,如果只有单个变量,会先将变量转换为Boolean
值,只有下面几种情况会转换成false
,其余被转换成true
:
null
undefined
''
NaN
0
false
复制代码
3.3 各种运数学算符
我们在对各种非Number
类型运用数学运算符(- * /
)时,会先将非Number
类型转换为Number
类型;
1 - true // 0
1 - null // 1
1 * undefined // NaN
2 * ['5'] // 10
复制代码
注意+
是个例外,执行+
操作符时:
- 1.当一侧为
String
类型,被识别为字符串拼接,并会优先将另一侧转换为字符串类型。 - 2.当一侧为
Number
类型,另一侧为原始类型,则将原始类型转换为Number
类型。 - 3.当一侧为
Number
类型,另一侧为引用类型,将引用类型和Number
类型转换成字符串后拼接。
123 + '123' // 123123 (规则1)
123 + null // 123 (规则2)
123 + true // 124 (规则2)
123 + {} // 123[object Object] (规则3)
复制代码
3.4 ==
使用==
时,若两侧类型相同,则比较结果和===
相同,否则会发生隐式转换,使用==
时发生的转换可以分为几种不同的情况(只考虑两侧类型不同):
- 1.NaN
NaN
和其他任何类型比较永远返回false
(包括和他自己)。
NaN == NaN // false
复制代码
- 2.Boolean
Boolean
和其他任何类型比较,Boolean
首先被转换为Number
类型。
true == 1 // true
true == '2' // false
true == ['1'] // true
true == ['2'] // false
复制代码
这里注意一个可能会弄混的点:
undefined、null
和Boolean
比较,虽然undefined、null
和false
都很容易被想象成假值,但是他们比较结果是false
,原因是false
首先被转换成0
:
undefined == false // false
null == false // false
复制代码
- 3.String和Number
String
和Number
比较,先将String
转换为Number
类型。
123 == '123' // true
'' == 0 // true
复制代码
- 4.null和undefined
null == undefined
比较结果是true
,除此之外,null、undefined
和其他任何结果的比较值都为false
。
null == undefined // true
null == '' // false
null == 0 // false
null == false // false
undefined == '' // false
undefined == 0 // false
undefined == false // false
复制代码
- 5.原始类型和引用类型
当原始类型和引用类型做比较时,对象类型会依照ToPrimitive
规则转换为原始类型:
'[object Object]' == {} // true
'1,2,3' == [1, 2, 3] // true
复制代码
来看看下面这个比较:
[] == ![] // true
复制代码
!
的优先级高于==
,![]
首先会被转换为false
,然后根据上面第二点,false
转换成Number
类型0
,左侧[]
转换为0
,两侧比较相等。
[null] == false // true
[undefined] == false // true
复制代码
根据数组的ToPrimitive
规则,数组元素为null
或undefined
时,该元素被当做空字符串处理,所以[null]、[undefined]
都会被转换为0
。
所以,说了这么多,推荐使用===
来判断两个值是否相等...
3.5 一道有意思的面试题
一道经典的面试题,如何让:a == 1 && a == 2 && a == 3
。
根据上面的拆箱转换,以及==
的隐式转换,我们可以轻松写出答案:
const a = {
value:[3,2,1],
valueOf: function () {return this.value.pop(); },
}
复制代码
四、判断JavaScript数据类型的方式
4.1 typeof
适用场景
typeof
操作符可以准确判断一个变量是否为下面几个原始类型:
typeof 'ConardLi' // string
typeof 123 // number
typeof true // boolean
typeof Symbol() // symbol
typeof undefined // undefined
复制代码
你还可以用它来判断函数类型:
typeof function(){} // function
复制代码
不适用场景
当你用typeof
来判断引用类型时似乎显得有些乏力了:
typeof [] // object
typeof {} // object
typeof new Date() // object
typeof /^\d*$/; // object
复制代码
除函数外所有的引用类型都会被判定为object
。
另外typeof null === 'object'
也会让人感到头痛,这是在JavaScript
初版就流传下来的bug
,后面由于修改会造成大量的兼容问题就一直没有被修复...
4.2 instanceof
instanceof
操作符可以帮助我们判断引用类型具体是什么类型的对象:
[] instanceof Array // true
new Date() instanceof Date // true
new RegExp() instanceof RegExp // true
复制代码
我们先来回顾下原型链的几条规则:
- 1.所有引用类型都具有对象特性,即可以自由扩展属性
- 2.所有引用类型都具有一个
__proto__
(隐式原型)属性,是一个普通对象 - 3.所有的函数都具有
prototype
(显式原型)属性,也是一个普通对象 - 4.所有引用类型
__proto__
值指向它构造函数的prototype
- 5.当试图得到一个对象的属性时,如果变量本身没有这个属性,则会去他的
__proto__
中去找
[] instanceof Array
实际上是判断Array.prototype
是否在[]
的原型链上。
所以,使用instanceof
来检测数据类型,不会很准确,这不是它设计的初衷:
[] instanceof Object // true
function(){} instanceof Object // true
复制代码
另外,使用instanceof
也不能检测基本数据类型,所以instanceof
并不是一个很好的选择。
4.3 toString
上面我们在拆箱操作中提到了toString
函数,我们可以调用它实现从引用类型的转换。
每一个引用类型都有
toString
方法,默认情况下,toString()
方法被每个Object
对象继承。如果此方法在自定义对象中未被覆盖,toString()
返回"[object type]"
,其中type
是对象的类型。
const obj = {};
obj.toString() // [object Object]
复制代码
注意,上面提到了如果此方法在自定义对象中未被覆盖
,toString
才会达到预想的效果,事实上,大部分引用类型比如Array、Date、RegExp
等都重写了toString
方法。
我们可以直接调用Object
原型上未被覆盖的toString()
方法,使用call
来改变this
指向来达到我们想要的效果。
4.4 jquery
我们来看看jquery
源码中如何进行类型判断:
var class2type = {};
jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
function( i, name ) {
class2type[ "[object " + name + "]" ] = name.toLowerCase();
} );
type: function( obj ) {
if ( obj == null ) {
return obj + "";
}
return typeof obj === "object" || typeof obj === "function" ?
class2type[Object.prototype.toString.call(obj) ] || "object" :
typeof obj;
}
isFunction: function( obj ) {
return jQuery.type(obj) === "function";
}
复制代码
原始类型直接使用typeof
,引用类型使用Object.prototype.toString.call
取得类型,借助一个class2type
对象将字符串多余的代码过滤掉,例如[object function]
将得到array
,然后在后面的类型判断,如isFunction
直接可以使用jQuery.type(obj) === "function"
这样的判断。
文中如有错误,欢迎在评论区指正,如果这篇文章帮助到了你,欢迎点赞和关注。
学习java想更快更专业的入门,我推荐观看尚学堂高淇老师主讲的java300集,本套课程专为初学者而著!适合准备入行开发的零基础员学习java。每一个知识点都讲解的通俗易懂,知识点编排循序渐进,对每个知识点讲解都很细腻,非常适合大学在读学生、非计算机专业出身想学java的朋友或者想java基础知识更扎实的朋友。B站搜索尚学堂教育即可找到,好不好,有没有用,您看了才知道。