ECMAScriptjavascript类型系统——Number数字类型

面前的语

  javascript只发雷同栽数字型,它于里头被代表为64员的浮点数,和java的double数字型一样。与另外大部编程语言不同的凡,它从不分开出整数路,所以1及1.0底值相同。这提供了老大死之便民,避免了一样大堆因数字型导致的失实

  数字Number是javascript中着力的初数据类型,同时javascript也支撑Number对象,它是一个原始数值的包装对象。在待时,javascript会自行在原始形式以及目标形式中变换。本文将介绍数字Number原始类型及Number包装对象

 

定义

  javascript采用IEEE754格式来代表数字,不分整数和浮点数,javascript中的富有数字还用浮点数值表示

  由于浮点型数值需要的内存空间是保存整数值的个别倍,因此javascript会不失时机地用浮点数值转换成整数价,若有些数点后尚未跟其它数字要浮点值本身代表的就是是一个整数,这个数值会作为整数值来保存

    console.log(1.0,1.0===1);//1 true
    console.log(1.,1.===1);//1 true

  当一个数字一直出现在javascript程序中不时,称之为数字字面量(numeric
literal)。而当Number()使用new操作符用做构造函数时,称之为Number对象

 

整数

  javascript的平头表示共有四种植字面量格式是十进制、二进制、八进制、十六进制。但以展开算术计算时,所有因二进制、八进制和十六进制表示的数值最终都用受转换成为十进制数值

  【1】八上制字面值的第一位必须是0,然后是八进制数字序列(0-7)。如果字面值中之数值高于了限定,那么前导0将受忽视,后面的数值为看成十前进制数解析

  [注意]由于某些javascript的实现不支持八迈入制字面量,且八迈入制字面量在严峻模式下是废的,会造成javascript抛来荒谬。所以尽可能不使用八前进制字面量

  【2】十六向前制字面值的前方少号必须是0x,后以及十六进制数字序列(0-9,a-f),字母可生写不过稍许写。如果十六进制中配面值中之数值超出范围,如发生现g、h等会报错

  【3】二上制字面值的前方少位必须是0b,如果起除0、1以外的数字会报错

var num2 = 0b101;
console.log(num2);//5
var num2 = 0b2;
console.log(num2);//报错
var num8 = 012;
console.log(num8);//10
var num8 = 09;
console.log(num8);//9
var num16 = 0x11;
console.log(num16);//17
var num16 = 0xg;
console.log(num16);//报错

 

浮点数

  浮点数(floating-point
number)是依靠数值中必须带有一个聊数碰,且有些数点后面要至少发生雷同位数字。与整数支持多进制不同,一般地,浮点数只可用十进制表示

var num1 = 011.1;//报错
var num2 = 0x11.1;//报错
var num3 = 011e1;//报错
var num4 = 0x11e1;//出错,会被识别成整数,结果为4577

  [注意]尽管如此小数点前面可没有整数,但不引进

var num1 = 1.1;
var num2 = 1.;
var num3 = .1; 
console.log(num1,num2,num3);//1.1,1,0.1

  由于javascript采用IEEE754格式表示数字,浮点数不是标准值,所以涉及浮点数的可比和运算时如专门小心

console.log(0.1 + 0.2 === 0.3);// false
console.log(0.3 / 0.1);// 2.9999999999999996
console.log((0.3 - 0.2) === (0.2 - 0.1));// false

 

科学记数法

  对于庞或者极端小的数,可以用科学计数法e来代表的浮点数值来代表。科学计数法允许字母e或E的后边,跟着一个平头,表示是数值的指数部分

  以下简单种状态,javascript会活动将数值转为科学计数法表示

  【1】小于1还有些数点后面带有6个0以上的浮点数值

0.0000003 // 3e-7
0.000003 // 0.000003

  【2】整数员数字多于21位

1234567890123456789012 //1.2345678901234568e+21
1234567890123456789012.1 //1.2345678901234568e+21
123456789012345678901 //123456789012345680000

 

数值精度

  根据国际标准IEEE
754,javascript浮点数的64单二进制位,从太左边开始,是这么做的

第1位:        符号位,0表示正数,1表示负数
第2位到第12位: 储存指数部分
第13位到第64位:储存小数部分(即有效数字)

  符号位决定了一个频繁的老大,指数部分决定了数值的尺寸,小数部分决定了数值的精度

  IEEE
754确定,有效数字第一各默认总是1,不保险存在64个浮点数之中。也就是说,有效数字连续1.xx…xx的花样,其中xx..xx的有些保存在64号浮点数之中,最丰富或者为52各类

  因此,javascript提供的有效性数字最丰富吗53单二进制位

//javascript内部实际的表现形式
(-1)^符号位 * 1.xx...xx * 2^指数位

  精度最丰富呢53独二进制位,意味着绝对值仅次于2底53次方的平头,即-(253-1)到253-1,都好准确表示

Math.pow(2, 53)
// 9007199254740992

  所以换算成十进制,javascript数字最高精度是16各(若整屡次有也0,则意味着有点数点后16个;若整数部分非呢0,则表示完全保存16位)

Math.pow(2, 53)// 9007199254740992
Math.pow(2, 53) + 1// 9007199254740992
9007199254740993//9007199254740992
90071992547409921//90071992547409920
0.923456789012345678;//0.9234567890123456
9.23456789012345678;//9.234567890123456

 

数值范围

  根据专业,64各项浮点数的指数部分的尺寸是11独二进制位,意味着指数部分的无比大值是2047(211-1)。分出一半代表负数,则javascript能够代表的数值范围吗21024到2-1023,超出这范围之累无法表示

  21024 = 1.79769*10308

  javascript中能够代表的顶大值是+-1.79769*10308,而javascript能表示的尽小值是+-5*10-324

  javascript能够代表的整数范围是-253到253。如果跨越了此限制的整数,无法保证没有数字之精度

  javascript中的极度特别值保存在Number.MAX_VALUE中,而尽小值保存在Number.MIN_VALUE

console.log(Number.MIN_VALUE,Number.MAX_VALUE)//5e-324,1.7976931348623157e+308

  如果数字越最深价值,javascript会回到Infinity,这称之为正于溢出起(overflow);如果当还是越最小负值-1023(即大接近0),javascript会直接将这数转为0,这叫负向溢出起(underflow)

   如下所示,实际情况并非任何这么

Number.MAX_VALUE+1 === Number.MAX_VALUE;//true

  当数字最特别价值+1时,结果并不等于Infinity,而是依然当最充分价值。这是因精度受限,javascript中之贮存位置并未剩余位置去存储个号数1

  当运算数和数字最酷价值保持以平等精度维度上经常,才不过及数字最充分价值发生运算

Number.MAX_VALUE+1e291;//1.7976931348623157e+308
Number.MAX_VALUE+1e292;//Infinity

  类似地,与数字最小值的演算也生类同情况

Number.MIN_VALUE + 1;//1
Number.MIN_VALUE - 3e-324;//0
Number.MIN_VALUE - 2e-324;//5e-324

0.1+0.2!== 0.3

  不仅仅是javascript,在不少言语中0.1 + 0.2都见面获0.30000000000000004

  下面详细解释出现这个结果的故

  [注意]该有情节主要参考子迟兄的博文【0.1 + 0.2 =
0.30000000000000004】该如何理解?

  计算机中的数字还是因二进制存储的,如果只要算0.1 + 0.2
的结果,计算机会优先管0.1暨0.2分别转化成二进制,然后相加,最后更管相加得到的结果转为十进制

  把10进制的0.1转换成2进制,表示为0.0 0011 0011…(0011循环)

(0.1).toString(2);//"0.0001100110011001100110011001100110011001100110011001101"

  把10进制的0.2转换成2进制,表示为0.0011 0011…(0011循环)

(0.2).toString(2);//"0.001100110011001100110011001100110011001100110011001101"

  由于计算机只能保留最为充分53个精度,所以,用科学记数法表示

  0.1之二进制为1.1001100110011001100110011001100110011001100110011010e+4(52位小数)

  0.2底二进制为1.1001100110011001100110011001100110011001100110011010e+3(52各类小数)

  [注意]要是第52bit以及53bit都是 1,需要进位

1.1001100110011001100110011001100110011001100110011010e-4
+
1.1001100110011001100110011001100110011001100110011010e-3
--------------------------------------------------------------------------
0.1100110011001100110011001100110011001100110011001101e-3
+
1.1001100110011001100110011001100110011001100110011010e-3
--------------------------------------------------------------------------
10.0110011001100110011001100110011001100110011001100111e-3
--------------------------------------------------------------------------
1.0011001100110011001100110011001100110011001100110100e-2(52位小数)
--------------------------------------------------------------------------
0.010011001100110011001100110011001100110011001100110100
转换为十进制为0.30000000000000004

 

特数值

  javascript提供了几乎独特殊数值,包括Number.MAX_VALUE、Number.MIN_VALUE、Number.POSITIVE_INFINITY、Number.NEGATIVE_INFINITY、Number.MAX_SAFE_INTEGER、Number.MIN_SAFE_INTEGER、Number.NaN、+0、-0共9个

  其中,前7单奇特数值是Number对象的属性

最值

  前面早已介绍过Number.MAX_VALUE代表javascript最大值,Number.MIN_VALUE代表javascript最小在

console.log(Number.MIN_VALUE,Number.MAX_VALUE)//5e-324,1.7976931348623157e+308

  Number.MAX_SAFE_INTEGER代表最特别整数(253-1),Number.MIN_SAFE_INTEGER代表极度小平头-(253-1)

//9007199254740991 true
console.log(Number.MAX_SAFE_INTEGER,Number.MAX_SAFE_INTEGER===Math.pow(2, 53)-1)
//-9007199254740991 true
console.log(Number.MIN_SAFE_INTEGER,Number.MIN_SAFE_INTEGER===-(Math.pow(2, 53)-1))

Infinity

  Infinity是一个大局属性,用来存放在表示无穷大的特种数值。用for/in循环不可枚举Infinity属性,用delete操作符也无法抹其

  实际上,Number.POSITIVE_INFINITY对应之是Infinity,代表正无穷;而Number.NEGATIVE_INFINITY对应的凡-Infinity,代表负无穷

console.log(Number.POSITIVE_INFINITY,Number.NEGATIVE_INFINITY);//Infinity -Infinity

  Infinity有长之分

Math.pow(2,Math.pow(2,100));//Infinity
1/0;//Infinity
-0/0;//-Infinity
Infinity === -Infinity;//false

  Infinity参与的演算结果不得不是那自、0还是NaN

2 * Infinity;//Infinity
2 - Infinity;//-Infinity
2 + Infinity;//Infinity
2 / Infinity;//0
Infinity / 2;//Infinity

Infinity * Infinity;//Infinity
Infinity - Infinity;//NaN
Infinity + Infinity;//Infinity
Infinity / Infinity;//NaN

  可以由此isFinite()来规定一个数值是匪是来彻底的,包含在隐式类型转换Number()。如果是+-Infinity或NaN时回来false,否则也true

console.log(isFinite(Infinity))//false
console.log(isFinite(NaN))//false
console.log(isFinite(Number.MAX_VALUE))//true
console.log(isFinite(true))//true

NaN

  NaN(not a
number)表示不数字,NaN与任何价值都非等于,包括NaN本身,且任何关联NaN的操作都见面回NaN

5 - 'x'; //NaN
Math.acos(2); //NaN
0 / 0; //NaN

NaN == NaN;//false
NaN == Infinity;//false

[NaN].indexOf(NaN);// -1
Boolean(NaN); // false

  isNaN()来判断这数字是勿是NaN,包含在隐式类型转换Number()

console.log(isNaN(Infinity));//false
console.log(isNaN(0));//false
console.log(isNaN(NaN));//true
console.log(isNaN('Hello'));//true

  判断NaN更牢靠的不二法门是,利用NaN是javascript之中唯一无齐我的价值这个特点,进行判定

function myIsNaN(value) {
  return value !== value;
}

正负0

  以javascript内部,实际上存在2个0:一个凡是+0,一个凡是-0。它们是齐价格的

-0 === +0;// true
0 === -0;// true
0 === +0;// true

  一般地,+0和-0还见面吃当做0来对待,但是+0或-0当分母,返回的值是未抵的

console.log(1/+0);//Infinity
console.log(1/-0);//-Infinity
console.log((1/+0) === (1/-0));//false

 

转成数值

  有3独函数可以管非数值转换成数值:Number()、parseInt()和parseFloat()。其中Number()可以以随机档次的价值转化成屡价,而parseInt()和parseFloat()只下为字符串向数字之变

Number()

  当把Number()当作一个函数来调用,而非是作为构造器,它实施一个类型转换。使用Number()函数可以以随机档次的值转化成数值

// 数值:十进制数字
console.log(Number(11),Number(011),Number(0x11));//11 9 17

// undefined:转成 NaN
Number(undefined) // NaN

// null:转成0
Number(null) // 0

// 布尔值:true 转成1,false 转成0
console.log(Number(true),Number(false));//1 0

  Number()函数解析字符串时会见识别出字符串的置空格并夺丢

  【1】若字符串只含十进制或十六进制数字,则更改成十进制的数字

    [注意1]Number()不识别八进制数字之字符串,会按部就班十进制数字处理

    [注意2]字符串’1.2.’请勿会见报错,但数字1.2.会报错

  【2】若字符串为空字符串或空格字符串,则改变成0

  【3】其他情形的字符串,则转成NaN

console.log(Number('    123'));//123
console.log(Number('1.2.'));//NaN
console.log(Number(1.2.));//报错
console.log(Number(''),Number(' '));//0 0 
console.log(Number('11'),Number('011'),Number('0x11'));//11 11 17
console.log(Number('abc'));//NaN
console.log(Number('123abc'));//NaN

  Number()函数解析对象时,会按以下步骤进行拍卖 

  【1】调用对象的valueOf()方法,如果回去原始类型的价,则一直对该值使用Number()函数

  【2】如果valueOf()方法返回的抑对象,则调用对象的toString()方法,如果回去原始类型的价值,则对该值使用Number()函数

  【3】如果toString()方法返回的依然是目标,则结果是NaN

  在率先步着,由于只有时间Date()对象回来的凡原始类型的价值数字,所以Number(new
Date())返回现在届1970年1月1日00:00:00之数值类的毫秒数

Number(new Date())//1465976459108

  以第二步着,数组Array类型返回由数组中每个值的字符串形式拼接而成的一个缘逗号分隔的字符串,如果字符串中只有存在数字,则归数字,其他情形返回NaN;由于其余对象的toString()方法返回的字符串中未单独包括数字,所以回来NaN

Number([]);//0
Number([0]);//0
Number([-0]);//0
Number([10]);//10
Number([1,2]);//NaN
Number(其他对象);//NaN

parseInt()

  【1】parseInt()专门用来把字符串转换成整数。在转移字符串时,会忽视字符串前面的空格,直到找到第一独非空格字符。如果第一独字符不是数字字符或负号,parseInt()就会回NaN。如果是,则继续分析,直到解析完成或遇到不数字字符

console.log(parseInt('    123.8px'));//123
console.log(parseInt('   123.8   '));//123
console.log(parseInt(' -123.8px'));//-123
console.log(parseInt('a123.8px'));//NaN
console.log(parseInt('0 123.8px'));//0

  【2】parseInt()可以分辨出各种进制的数字,输出的凡运算后的十进制的数字,如1.0或者1.或者01晤为1输出。在解析八前行制字面量的字符串,ECMAScript3会晤分析八进制,但ECMAScript5尚无解析八进制的力

console.log(parseInt('11'));//11
console.log(parseInt(11));//11
console.log(parseInt('11.1'));//11
console.log(parseInt(11.1));//11
console.log(parseInt('011'));//11
console.log(parseInt(011));//9
console.log(parseInt('011.1'));//11
console.log(parseInt(011.1));//报错
console.log(parseInt('0x11'));//17
console.log(parseInt(0x11));//17
console.log(parseInt('0x11.1'));//17
console.log(parseInt(0x11.1));//报错

  [注意]对于那些会活动转为科学计数法的数字,parseInt会将科学计数法的象征方法就是字符串,因此导致有出乎意料之结果

console.log(parseInt(1000000000000000000000.5)); // 1
// 等同于
console.log(parseInt('1e+21')); // 1

console.log(parseInt(0.0000008)); // 8
// 等同于
console.log(parseInt('8e-7')); // 8

【3】parseInt()术还足以接受第二独参数(2至36中),表示为解析的值的进制,返回该值对应之十向前制数。默认情况下,parseInt的亚个参数为10,即默认是十进制转十进制

console.log(parseInt('11',2));//3
console.log(parseInt('11',8));//9
console.log(parseInt('11',10));//11
console.log(parseInt('11',16));//17

  如果第二独参数不是数值,会受活动转为一个整数。这个平头只有当2顶36之内,才会收获有意义的结果,超出这范围,则回NaN。如果第二单参数是0、undefined和null,则直接忽略

console.log(parseInt('10', 37)); // NaN
console.log(parseInt('10', 1)); // NaN
console.log(parseInt('10', 0)); // 10
console.log(parseInt('10', null)); // 10
console.log(parseInt('10', undefined)); // 10

  如果字符串包含对指定进制无意义的字符,则从嵩位开,只回可以变换的数值。如果最高位无法换,则直接回到NaN

console.log(parseInt('1546', 2)); // 1
console.log(parseInt('546', 2)); // NaN

  【4】parseInt()是特意用来拍卖字符串转换数字之,parseInt处理非字符串和数字型时输出NaN。但是,实际上parseInt()包含着隐式的toString()方法,所以parseInt([数字还是字符串])输出对应之数字

console.log(parseInt(null),parseInt(undefined));//NaN NaN
console.log(parseInt(true),parseInt(false));//NaN NaN
console.log(parseInt([]),parseInt(['2.5px']),parseInt([2.5]));//NaN 2 2
console.log(parseInt(''),parseInt(' '),parseInt({}));//NaN NaN NaN

parseFloat()

  【1】parseFloat()专门用于字符串转换浮点数。同样地,解析时会见忽视字符串前面的空格,直到找到第一只非空格字符,然后径直解析到字符串末尾或一个无效的浮点数字字符为止

console.log(parseFloat('    0123.px'));//123
console.log(parseFloat('    123.px'));//123
console.log(parseFloat('    123.1px'));//123.1
console.log(parseFloat('   123.1.2px   '));//123.1
console.log(parseFloat(' -123.0px'));//-123
console.log(parseFloat('.123.1px'));//0.123
console.log(parseFloat('0 123px'));//0

  [注意]如果字符串符合对计数法,则会进展对应的变

console.log(parseFloat('314e-2')); // 3.14
console.log(parseFloat('0.0314E+2')); // 3.14

  【2】parseFloat()可以辨认不同进制的数字,但只能解析十进制字符串

console.log(parseFloat('11'));//11
console.log(parseFloat(11));//11
console.log(parseFloat('11.1'));//11.1
console.log(parseFloat(11.1));//11.1
console.log(parseFloat('011'));//11
console.log(parseFloat(011));//9
console.log(parseFloat('011.1'));//11.1
console.log(parseFloat(011.1));//报错
console.log(parseFloat('0x11'));//0
console.log(parseFloat(0x11));//17
console.log(parseFloat('0x11.1'));//0
console.log(parseFloat(0x11.1));//报错

  【3】parseFloat()是特别为此来拍卖字符串转换浮点数的,parseFloat处理非字符串和数字型时输出NaN。但是,实际上parseFloat()包含着隐式的toString()方法,所以parseFloat([数字要字符串])输出对应之数字

console.log(parseFloat(null),parseFloat(undefined));//NaN NaN
console.log(parseFloat(true),parseFloat(false));//NaN NaN
console.log(parseFloat([]),parseFloat([2.1]),parseFloat(['2.1px']));//NaN 2.1 2.1 
console.log(parseFloat(''),parseFloat({}));//NaN NaN

  [注意]Number(”)的结果是0,parseInt(”)和parseFloat(”)的结果是NaN

 

实例方法

  关于Number()对象的实例方法总共有6只,分为两接近。包括toString()、toLocalString()、valueOf()这3种对象通用方以及toFixed()、toExponential()、toPrecision()这3栽转移数值显示形式并转换为字符串的计

  valueOf()方法返回对象的数字字面量

  toString()方法将数字转换为字符串

  toLocalString()方法以数字转换为本地惯例格式化数字的字符串

console.log(typeof 1.1.valueOf(),1.1.valueOf());//number 1.1
console.log(typeof 1.1.toString(),1.1.toString());//String '1.1'
console.log(typeof 1.1.toLocaleString(),1.1.toLocaleString());//String '1.1'

  [注意]假定数字不加括号,点会被javascript引擎解释成多少数触及,从而报错

console.log(typeof 1.valueOf(),1.valueOf());//报错
console.log(typeof 1.toString(),1.toString());//报错
console.log(typeof 1.toLocaleString(),1.toLocaleString());//报错

console.log(typeof (1).valueOf(),(1).valueOf());//number 1
console.log(typeof (1).toString(),(1).toString());//String '1'
console.log(typeof (1).toLocaleString(),(1).toLocaleString());//String '1'

  除了为数字增长括号,还得当数字背后加点儿个点,javascript会把第一单点清楚成稍数碰,把第二只点清楚成调用对象属性,从而获得不错结果

console.log(10..toString()); // "10"
console.log(10 .toString()); // "10"
console.log(10.0.toString()); // "10"

  toString()方法可以接受一个参数,该参数应当是2至36里边的整数,表示输出的进制。如果该参数不存,或者也undefined,默认将数值先转为十进制,再出口字符串

var num = 10;
console.log(num.toString());//'10'
console.log(num.toString(2));//'1010'
console.log(num.toString(8));//'12'
console.log(num.toString(10));//'10'
console.log(num.toString(16));//'a'    
console.log(num.toString(undefined));//'10'

  如果参数超出2-36的界定,或者也另外价值时,报错

console.log((10).toString(0));//报错
console.log((10).toString(null));//报错

toFixed()

  toFixed()方法按指定的稍数位返回数值四放弃五副后底字符串表示(常用于拍卖货币值)

  [注意]toFixed()里之参数就领0-20,若未传参或参数为undefined则一定给参数是0

var num = 10.456;
console.log(num.toFixed(2));//'10.46'
console.log(num.toFixed());//'10'
console.log(num.toFixed(0));//'10'
console.log(num.toFixed(undefined));//'10'
console.log(num.toFixed(-1));//报错

toExponential()

  toExponential()方法返回数值四放弃五顺应后的指数表示法(e表示法)的字符串表示,参数表示转换后的略数位数

  [注意]toExponential()方法里之参数就领0-20,但与toFxied()不同的凡,若无传参或参数为undefined,则保留尽可能多的卓有成效数字;若参数是0表示从未小数部分

var num = 10.456;
console.log(num.toExponential(2));//'1.05e+1'
console.log(num.toExponential());//'1.0456e+1'
console.log(num.toExponential(0));//'1e+1'
console.log(num.toExponential(undefined));//'1.0456e+1'
console.log(num.toExponential(-1));//报错

toPrecision()

  toPrecision()方法接收一个参数,即表示数值的所有数字之位数(不包括指数部分),自动调用toFixed()或toExponential()

  [注意]toPrecision()里之参数就领1-21,若不传参或参数为undefined则一定给调用toString()方法

var num = 10.1;
console.log(num.toPrecision(3));//'10.1'
console.log(num.toPrecision(2));//'10'       
console.log(num.toPrecision(1));//'1e+1'
console.log(num.toPrecision());//'10.1'
console.log(num.toPrecision(undefined));//'10.1'
console.log(num.toPrecision(0));//报错

  [注意]toFixed()、toExponential()、toPrecision()这三独法子以多少数位用于四放弃五可常还不绝可靠,跟浮点数不是纯正储存有关

console.log((12.25).toPrecision(3)); // "12.3"
console.log((12.25).toFixed(1)); // "12.3"
console.log((12.25).toExponential(2)); // "1.23e+1"
console.log((12.35).toPrecision(3)); // "12.3"
console.log((12.35).toFixed(1)); // "12.3"
console.log((12.35).toExponential(2)); // "1.23e+1"

 

参考资料

【1】 ES5/类型
https://www.w3.org/html/ig/zh/wiki/ES5/types\#Number\_.E7.B1.BB.E5.9E.8B
ES5/
ES5/标准内置对象
https://www.w3.org/html/ig/zh/wiki/ES5/builtins#Number_.E5.AF.B9.E8.B1.A1
【2】
阮一峰Javascript标准参照教程——基本语法之数值http://javascript.ruanyifeng.com/grammar/number.html
标准库Number对象http://javascript.ruanyifeng.com/stdlib/number.html
【3】 W3School-Javascript高级教程——ECMAScript原始类型
http://www.w3school.com.cn/js/pro_js_primitivetypes.asp
【4】《javascript权威指南(第6版本)》第3章 类型、值与变量
【5】《javascript高级程序设计(第3版本)》第3章节 基本概念 第5章节 引用类型
【6】《javascript语言精粹(修订版)》第2节 语法  第8段 方法
【7】《javascript DOM编程艺术(第2本)》第2回 Javascript语法
【8】《javascript启示录》 第11章 Number()