js中隐式类型转换测试

javascript数据类型：

使用typeof可以返回的数据类型有六种

"number" , "string" , "boolean" , "object" , "function", "symbol" 和 "undefined"

注：typeof在检测let定义的变量时如果当前状态还未定义变量会报错，不再可靠

number常见的类型包括：

　　Infinity 表示无穷大特殊值
　　NaN　　　　　　　　　　　　特殊的非数字值
　　Number.MAX_VALUE　　　　　可表示的最大数字
　　Number.MIN_VALUE　　　　　可表示的最小数字（与零最接近）
　　Number.NaN　　　　　　　　特殊的非数字值
　　Number.POSITIVE_INFINITY　表示正无穷大的特殊值
　　Number.NEGATIVE_INFINITY 表示负无穷大的特殊值

object类型会包括对象、数组和Null。

常见的全局对象有：JSON、Error、RegExp、Date、Math、Number、Boolean、String、Array、Function、Object、global(windows)

es6中：Proxy，Promise, ArrayBuffer, DataView, Reflect等等

undefined类型包括未定义的变量和undefined

一、相加符号下的转换

1.与字符串相加

　　在字符串与其他类型数据相加时，会产生相应的转换。

　　与数字、布尔,调用自身的toString()方法，产生字符串。：

console.log("hello" + 1) // "hello1"

console.log("hello" + true) // "hellotrue"

console.log('hello' + {})// "hello[object Object]"

console.log('hello' + Math)// "hello[object Math]"，全局对象中JSON，Math，window，Reflect

console.log('hello' + Number)// "hellofunction Number() { [native code] }"，Promise返回的是具体代码

console.log('hello' + null)// "hellonull"

console.log('hello' + undefined)// "helloundefined"

console.log('hello'+ NaN)// "helloNaN"

console.log('hello'+ Infinity)// "helloInfinity"

字符型：

	console.log(1+123)// 124

	console.log(1+'123') // "1123"

	console.log(1+ null) // 1

	console.log(1+ undefined)// NaN

	console.log(1+ NaN) // NaN

	console.log(1+ Infinity) // Infinity

	console.log(NaN + Infinity)// NaN

	console.log(NaN + NaN)// NaN

	console.log(Infinity + Infinity)// Infinity

	console.log(1+ true) // 2

	console.log(1+ false) // 1

	console.log(1+ function(){}) // "1function (){}"

	console.log(1+ []) // "1"

	console.log(1+ [1]) // "11"

	console.log(1+ {}) // "1[object Object]"

	console.log(1+ Math) // 1[object Math]

	console.log([]+[]) // ""

	console.log([]+[1]) // "1"

	console.log([]+null) // "null"

	console.log([] + undefined) // "undefined"

	console.log([] + {})// "[object Object]"

	console.log([] + true)// "true"

	console.log({} + true)// "[object Object]true"

	console.log({} + null)// "[object Object]null"

	console.log(null + null)// 0

	console.log(null + undefined)// NaN

	console.log(undefined + undefined)// NaN

	console.log(Infinity + null)// Infinity

	console.log(Infinity + undefined)// NaN

	console.log(NaN + undefined)// NaN

	console.log(NaN + null)// NaN

	Number(null)// 0

	Number(undefined)// NaN

	Number('')// 0

	var a={valueOf: function(){console.log('toValue');return 1}, toString: function(){console.log('toString');return '0'}}

	console.log(a+1)// toValue  2

	console.log(a+'1')// toValue   "11"

	String(a)// toString   "0"

	Number(a)// toValue  1

	String(null)// "null"

	+a// toValue  1

	console.log(+{})// NaN

	Number({})// NaN

	console.log(+ new Date())// 1478397365907

	Number(new Date())// 1478397717708

	console.log(+[])// 0

	Number([])// 0

	Number([1])// 1

	Number([1, 2])// NaN

	(new Date()).toValue()// Uncaught TypeError:

-

	console.log([] - [])// 0

	console.log('1' - [])// 1

	console.log(a-'1')// toValue   0

	'' * 1// 0

后缀运算符

	var a = '22'

	a++ // 23

	a++ // 24

	var a={valueOf: function(){console.log('toValue');return 1}, toString: function(){console.log('toString');return '0'}}

	console.log(a++);// toValue 1

	console.log(a) // 2

	typeof a // "number"

按位非

	a = '3';

	console.log(~~a)// 3

	a={a:1}

	console.log(~~a)// 0

	~~null// 0

	~~undefined// 0

	~~NaN // 0

逻辑非

	a = {}

	console.log(!a)// false

	var a={valueOf: function(){console.log('toValue');return null}, toString: function(){console.log('toString');return '0'}}

	!a // false

	~~a// toValue  0

	!false // true

	!''// true

	!null // true

	!undefined// true

	!0 // true

乘法

	var a = '2';

	console.log(a*3)// 6

	var a={}

	console.log(a*3)// NaN

	var a= ''

	console.log(a*3)// 0

除法

若两个操作数之一为NaN，结果为NaN。

假如两个操作数的正负号相同，结果就是正的，如果不同就是负的。

无穷大被零乘结果是NaN。

无穷大被无穷大除结果是NaN。

无穷大被零除结果是无穷大。符号按照前面说过的规则决定。

无穷大被非零有穷的值除结果是有正负号的无穷大。符号按照前面说过的规则决定。

有穷的非零值被无穷大除结果是零。符号按照前面说过的规则决定。

零被零除结果是NaN；零被其它有穷数除结果是零，符号按照前面说过的规则决定。

有穷的非零值被零除结果是有正负号的无穷大。符号按照前面说过的规则决定。

其它情况下，既没有无穷大也没有NaN参与运算，结果计算出来后会按照IEEE 754 round-to-nearest模式取到最接近的能表示的数。如果值过大不能表示，则结果为相应的正负无穷大。如果值过小不能表示，则结果为相应的正负零。ECMAScript要求支持IEEE 754规定的渐进下溢。

	console.log(Infinity * 0)// NaN

	console.log(Infinity / Infinity)// NaN

	console.log(Infinity / 0)// Infinity

	console.log(0 / Infinity)// 0

	console.log(Infinity / 11)// Infinity

	console.log(77 / Infinity)// 0

	console.log(0 / 0)// NaN

	console.log(22 / 0)// Infinity

	console.log(NaN / Infinity)// NaN

使用 % 运算符

左移<< - >> >>> 

比较运算符

	'1'<2// true

	'2'<1 // false

	'22'<100// true

	'22' < '100'// false

	2<NaN// false

	{} < {}// false

	{} > {}// false

	NaN > 0// false

in instanceof?

==

console.log('' ==0)// true

console.log('' == false)// true

console.log(0 == false)// true

console.log(0 == null)// false

console.log(0 == undefined)// false

console.log(null == undefined)//  true

var a={valueOf: function(){console.log('toValue');return 2}, toString: function(){console.log('toString');return '0'}}

a == 2//toValue  true

new String("a") == new String("a")为false。

console.log({} == {})// false

console.log(NaN == NaN)// false

巴特西

js中隐式类型转换测试

最新文章

热门文章