JavaScript 教程学习笔记3-数据类型概述、undefined、null、布尔值、数值、字符串

1.简介

JavaScript 语言的每一个值，都属于某一种数据类型。JavaScript 的数据类型，共有六种。（ES6 新增了第七种 Symbol 类型的值。）

• 数值（number）：整数和小数（比如1和3.14）
• 字符串（string）：文本（比如Hello World）。
• 布尔值（boolean）：表示真伪的两个特殊值，即true（真）和false（假）
• undefined：表示“未定义”或不存在，即由于目前没有定义，所以此处暂时没有任何值
• null：表示空值，即此处的值为空。
• 对象（object）：各种值组成的集合。

通常，数值、字符串、布尔值这三种类型，合称为原始类型（primitive type）的值，即它们是最基本的数据类型，不能再细分了。对象则称为合成类型（complex type）的值，因为一个对象往往是多个原始类型的值的合成，可以看作是一个存放各种值的容器。至于undefined和null，一般将它们看成两个特殊值。

对象是最复杂的数据类型，又可以分成三个子类型。

• 狭义的对象（object）
• 数组（array）
• 函数（function）

狭义的对象和数组是两种不同的数据组合方式，函数其实是处理数据的方法，可以赋值给变量，这为编程带来了很大的灵活性，也为 JavaScript 的“函数式编程”奠定了基础。

2.typeof 运算符

JavaScript 有三种方法，可以确定一个值到底是什么类型。

• typeof运算符
• instanceof运算符
• Object.prototype.toString方法

typeof运算符可以返回一个值的数据类型。

数值、字符串、布尔值分别返回number、string、boolean，函数返回function。

typeof123// "number"typeof'123'// "string"typeoffalse// "boolean"functionf(){}typeof f// "function"

undefined返回undefined。

typeof undefined// "undefined"

利用这一点，typeof可以用来检查一个没有声明的变量，而不报错。实际编程中，这个特点通常用在判断语句。

// 错误的写法if(v){// ...}// ReferenceError: v is not defined// 正确的写法if(typeof v==="undefined"){// ...}

对象返回object。

typeof window// "object"typeof{}// "object"typeof[]// "object"，数组本质上只是一种特殊的对象。instanceof运算符可以区分数组和对象。var o={};var a=[];
oinstanceofArray// false
ainstanceofArray// true

null返回object。

typeofnull// "object"

null的类型是object，这是由于历史原因造成的。1995年的 JavaScript 语言第一版，只设计了五种数据类型（对象、整数、浮点数、字符串和布尔值），没考虑null，只把它当作object的一种特殊值。后来null独立出来，作为一种单独的数据类型，为了兼容以前的代码，typeof null返回object就没法改变了。

3.null 和 undefined

3.1 概述

null与undefined都可以表示“没有”，含义非常相似。将一个变量赋值为undefined或null，语法效果几乎没区别。在if语句中，它们都会被自动转为false，相等运算符（==）甚至直接报告两者相等。

var a= undefined;// 或者var a=null;

if(!undefined){
  console.log('undefined is false');// undefined is false}if(!null){
  console.log('null is false');// null is false}
undefined==null// true

null和undefined的区别：看这里。

3.2 用法和含义

对于null和undefined，大致可以像下面这样理解。

null表示空值，即该处的值现在为空。调用函数时，某个参数未设置任何值，这时就可以传入null，表示该参数为空。比如，某个函数接受引擎抛出的错误作为参数，如果运行过程中未出错，那么这个参数就会传入null，表示未发生错误。

undefined表示“未定义”，下面是返回undefined的典型场景。

// 变量声明了，但没有赋值var i;
i// undefined// 调用函数时，应该提供的参数没有提供，该参数等于 undefinedfunctionf(x){return x;}f()// undefined// 对象没有赋值的属性var  o=newObject();
o.p// undefined// 函数没有返回值时，默认返回 undefinedfunctionf(){}f()// undefined

4.布尔值

布尔值代表“真”和“假”两个状态。“真”用关键字true表示，“假”用关键字false表示。布尔值只有这两个值。

下列运算符会返回布尔值：

• 前置逻辑运算符：! (Not)
• 相等运算符：===，!==，==，!=
• 比较运算符：>，>=，<，<=

如果 JavaScript 预期某个位置应该是布尔值，会将该位置上现有的值自动转为布尔值。转换规则是除了下面六个值被转为false，其他值都视为true。

• undefined
• null
• false
• 0
• NaN
• ""或''（空字符串）

注意，空数组（[]）和空对象（{}）对应的布尔值，都是true。

5.数值

5.1 概述

5.1.1 整数和浮点数

JavaScript 内部，所有数字都是以64位浮点数形式储存，即使整数也是如此。所以，1与1.0是相同的，是同一个数。

1===1.0// true

这就是说，JavaScript 语言的底层根本没有整数，所有数字都是小数（64位浮点数）。容易造成混淆的是，某些运算只有整数才能完成，此时 JavaScript 会自动把64位浮点数，转成32位整数，然后再进行运算。
由于浮点数不是精确的值，所以涉及小数的比较和运算要特别小心。

0.1+0.2===0.3// false0.1*100+0.2*100===0.3*100// true0.3/0.1// 2.9999999999999996(0.3-0.2)===(0.2-0.1)// false

关于为什么0.1 + 0.2 !== 0.3，请参考此文：为什么0.1 + 0.2 !== 0.3

5.1.2 数值精度

根据国际标准 IEEE 754，JavaScript 浮点数的64个二进制位，从最左边开始，是这样组成的。

• 第1位：符号位，0表示正数，1表示负数
• 第2位到第12位（共11位）：指数部分
• 第13位到第64位（共52位）：小数部分（即有效数字）

符号位决定了一个数的正负，指数部分决定了数值的大小，小数部分决定了数值的精度。有效数字这时总是1.xx...xx的形式，其中xx…xx的部分保存在64位浮点数之中，最长可能为52位。因此，JavaScript 提供的有效数字最长为53个二进制位。

(-1)^符号位*1.xx...xx*2^指数部分

精度最多只能到53个二进制位，这意味着，绝对值小于2的53次方的整数，即-253到253，都可以精确表示。

Math.pow(2,53)// 9007199254740992

Math.pow(2,53)+1// 9007199254740992

Math.pow(2,53)+2// 9007199254740994

Math.pow(2,53)+3// 9007199254740996

Math.pow(2,53)+4// 9007199254740996

上面代码中，大于2的53次方以后，整数运算的结果开始出现错误。

5.1.3 数值范围

根据标准，64位浮点数的指数部分的长度是11个二进制位，意味着指数部分的最大值是2047（2的11次方减1）。也就是说，64位浮点数的指数部分的值最大为2047，分出一半表示负数，则 JavaScript 能够表示的数值范围为21024到2-1023（开区间），超出这个范围的数无法表示。

如果一个数大于等于2的1024次方，那么就会发生“正向溢出”，即 JavaScript 无法表示这么大的数，这时就会返回Infinity。

Math.pow(2,1024)// Infinity

如果一个数小于等于2的-1075次方（指数部分最小值-1023，再加上小数部分的52位），那么就会发生为“负向溢出”，即 JavaScript 无法表示这么小的数，这时会直接返回0。

Math.pow(2,-1075)// 0

JavaScript 提供Number对象的MAX_VALUE和MIN_VALUE属性，返回可以表示的具体的最大值和最小值。

Number.MAX_VALUE// 1.7976931348623157e+308
Number.MIN_VALUE// 5e-324

5.2数值的表示法

JavaScript 的数值有多种表示方法，可以用字面形式直接表示，比如35（十进制）和0xFF（十六进制）。

数值也可以采用科学计数法表示，下面是几个科学计数法的例子。

123e3// 123000123e-3// 0.123-3.1E+12.1e-23

科学计数法允许字母e或E的后面，跟着一个整数，表示这个数值的指数部分。

以下两种情况，JavaScript 会自动将数值转为科学计数法表示，其他情况都采用字面形式直接表示。

（1）小数点前的数字多于21位。

1234567890123456789012// 1.2345678901234568e+21123456789012345678901// 123456789012345680000

（2）小数点后的零多于5个。

// 小数点后紧跟5个以上的零，// 就自动转为科学计数法0.0000003// 3e-7// 否则，就保持原来的字面形式0.000003// 0.000003

5.3数值的进制

使用字面量（literal）直接表示一个数值时，JavaScript 对整数提供四种进制的表示方法：十进制、十六进制、八进制、二进制。

• 十进制：没有前导0的数值。
• 八进制：有前缀0o或0O的数值，或者有前导0、且只用到0-7的八个阿拉伯数字的数值。
• 十六进制：有前缀0x或0X的数值。
• 二进制：有前缀0b或0B的数值。

默认情况下，JavaScript 内部会自动将八进制(0-8)、十六进制(0-9,a-f)、二进制(0-1)转为十进制。下面是一些例子。

0xff// 255		 15*16 + 150o377// 255   	3*8*8 + 7*8 + 70b11// 3 		2*1 + 1

如果八进制、十六进制、二进制的数值里面，出现不属于该进制的数字，就会报错。

0xzz// 报错0o88// 报错0b22// 报错

通常来说，有前导0的数值会被视为八进制，但是如果前导0后面有数字8和9，则该数值被视为十进制。

0888// 8880777// 511

前导0表示八进制，处理时很容易造成混乱。ES5 的严格模式和 ES6，已经废除了这种表示法，但是浏览器为了兼容以前的代码，目前还继续支持这种表示法。

5.4特殊数值

5.4.1 正零和负零

前面说过，JavaScript 的64位浮点数之中，有一个二进制位是符号位。这意味着，任何一个数都有一个对应的负值，就连0也不例外。
JavaScript 内部实际上存在2个0：一个是+0，一个是-0，区别就是64位浮点数表示法的符号位不同。它们是等价的。

-0===+0// true0===-0// true0===+0// true

几乎所有场合，正零和负零都会被当作正常的0。

+0// 0-0// 0(-0).toString()// '0'(+0).toString()// '0'

唯一有区别的场合是，+0或-0当作分母，返回的值是不相等的。

1/+0//+Infinity1/-0//-Infinity// 所以(1/+0)===(1/-0)// false

5.4.2 NaN

（1）含义
NaN是 JavaScript 的特殊值，表示“非数字”（Not a Number），主要出现在将字符串解析成数字出错的场合。

5-'x'// NaN

上面代码运行时，会自动将字符串x转为数值，但是由于x不是数值，所以最后得到结果为NaN，表示它是“非数字”（NaN）。

Math.acos(2)// NaN
Math.log(-1)// NaN
Math.sqrt(-1)// NaN0/0// NaN

需要注意的是，NaN不是独立的数据类型，而是一个特殊数值，它的数据类型依然属于Number，使用typeof运算符可以看得很清楚。

typeofNaN// 'number'

（2）运算规则
NaN不等于任何值，包括它本身。

NaN===NaN// false

数组的indexOf方法内部使用的是严格相等运算符，所以该方法对NaN不成立。

[NaN].indexOf(NaN)// -1

NaN在布尔运算时被当作false。

Boolean(NaN)// false

NaN与任何数（包括它自己）的运算，得到的都是NaN。

NaN+32// NaNNaN-32// NaNNaN*32// NaNNaN/32// NaN

5.4.3 Infinity

（1）含义
Infinity表示“无穷”，用来表示两种场景。一种是一个正的数值太大，或一个负的数值太小，无法表示；另一种是非0数值除以0，得到Infinity。

// 场景一，表达式的计算结果太大
Math.pow(2,1024)// Infinity// 场景二0/0// NaN1/0// Infinity

Infinity有正负之分，Infinity表示正的无穷，-Infinity表示负的无穷。

Infinity===-Infinity// false

1/-0// -Infinity，非零正数除以-0-1/-0// Infinity，负数除以-0

Infinity大于一切数值（除了NaN），-Infinity小于一切数值（除了NaN）。

Infinity>1000// true-Infinity<-1000// true

Infinity与NaN比较，总是返回false。

Infinity>NaN// false-Infinity>NaN// falseInfinity<NaN// false-Infinity<NaN// false

（2）运算规则
Infinity的四则运算，符合无穷的数学计算规则。

5*Infinity// Infinity5-Infinity// -InfinityInfinity/5// Infinity5/Infinity// 00*Infinity// NaN0/Infinity// 0Infinity/0// InfinityInfinity+Infinity// InfinityInfinity*Infinity// InfinityInfinity-Infinity// NaNInfinity/Infinity// NaN

Infinity与null计算时，null会转成0，等同于与0的计算。

// null会转成0，等同于与0的计算null*Infinity// NaNnull/Infinity// 0Infinity/null// Infinity

Infinity与undefined计算，返回的都是NaN。

5.5与数值相关的全局方法

5.5.1 parseInt()

（1）基本用法

parseInt方法用于将字符串转为整数。

parseInt('123')// 123parseInt('   81')// 81，字符串头部有空格，空格会被自动去除// parseInt的参数不是字符串，则会先转为字符串再转换parseInt(1.23)// 1// 等同于parseInt('1.23')// 1

字符串转为整数的时候，是一个个字符依次转换，如果遇到不能转为数字的字符，就不再进行下去，返回已经转好的部分。

parseInt('8a')// 8parseInt('12**')// 12parseInt('12.34')// 12parseInt('15e2')// 15parseInt('15px')// 15

如果字符串的第一个字符不能转化为数字（后面跟着数字的正负号除外），返回NaN。

parseInt('abc')// NaNparseInt('.3')// NaNparseInt('')// NaNparseInt('+')// NaNparseInt('+1')// 1

所以，parseInt的返回值只有两种可能，要么是一个十进制整数，要么是NaN。

如果字符串以0x或0X开头，parseInt会将其按照十六进制数解析。

parseInt('0x10')// 16

如果字符串以0开头，将其按照10进制解析。

parseInt('011')// 11

（2）进制转换
parseInt方法还可以接受第二个参数（2到36之间），表示被解析的值的进制，返回该值对应的十进制数。默认情况下，parseInt的第二个参数为10，即默认是十进制转十进制。
注意：第二个参数之前不懂，刷题时曾出现错误

parseInt('1000')// 1000// 等同于parseInt('1000',10)// 1000

下面是转换指定进制的数的例子。

parseInt('1000',2)// 8，2^3 + 0 + 0 + 0parseInt('1000',6)// 216，6^3 + 0 + 0 + 0parseInt('1000',8)// 512，8^3 + 0 + 0 + 0

如果第二个参数不是数值，会被自动转为一个整数。这个整数只有在2到36之间，才能得到有意义的结果，超出这个范围，则返回NaN。如果第二个参数是0、undefined和null，则直接忽略。

parseInt('10',37)// NaN，不在2~36之间parseInt('10',1)// NaNparseInt('10',0)// 10parseInt('10',null)// 10parseInt('10', undefined)// 10

如果字符串包含对于指定进制无意义的字符，则从最高位开始，只返回可以转换的数值。如果最高位无法转换，则直接返回NaN。

parseInt('1546',2)// 1，5 4 6均无意义，返回 1*2^0parseInt('546',2)// NaN

前面说过，如果parseInt的第一个参数不是字符串，会被先转为字符串。这会导致一些令人意外的结果。

parseInt(0x11,36)// 43，parseInt(0x11,2)// 1// 等同于parseInt(String(0x11),36)parseInt(String(0x11),2)// 等同于parseInt('17',36)parseInt('17',2)// 7无意义

这种处理方式，对于八进制的前缀0，尤其需要注意。

parseInt(011,2)// NaN// 等同于parseInt(String(011),2)// 等同于parseInt(String(9),2)parseInt('011',2)// 3，1*2^1 + 1*2^0 = 3，'011'为字符串，不用转换

JavaScript 不再允许将带有前缀0的数字视为八进制数，而是要求忽略这个0。但是，为了保证兼容性，大部分浏览器并没有部署这一条规定。

5.5.2 parseFloat()

parseFloat方法用于将一个字符串转为浮点数。

parseFloat('3.14')// 3.14

如果字符串符合科学计数法，则会进行相应的转换。

parseFloat('314e-2')// 3.14parseFloat('0.0314E+2')// 3.14

如果字符串包含不能转为浮点数的字符，则不再进行往后转换，返回已经转好的部分。

parseFloat('3.14more non-digit characters')// 3.14

parseFloat方法会自动过滤字符串前导的空格。

parseFloat('\t\v\r12.34\n ')// 12.34

如果parseFloat参数不是字符串，或者字符串的第一个字符不能转化为浮点数，则返回NaN。

parseFloat([])// NaNparseFloat('FF2')// NaNparseFloat('')// NaN

上面代码中，尤其值得注意，parseFloat会将空字符串转为NaN。

这些特点使得parseFloat的转换结果不同于Number函数。

parseFloat(true)// NaNNumber(true)// 1parseFloat(null)// NaNNumber(null)// 0parseFloat('')// NaNNumber('')// 0parseFloat('123.45#')// 123.45Number('123.45#')// NaN

5.5.3 isNaN()

注意注意注意，之前忘记了isNaN方法。
isNaN方法可以用来判断一个值是否为NaN。

isNaN(NaN)// trueisNaN(123)// false

但是，isNaN只对数值有效，如果传入其他值，会被先转成数值。比如，传入字符串的时候，字符串会被先转成NaN，所以最后返回true，这一点要特别引起注意。也就是说，isNaN为true的值，有可能不是NaN，而是一个字符串。

isNaN('Hello')// true// 相当于isNaN(Number('Hello'))// true

出于同样的原因，对于对象和数组，isNaN也返回true。

isNaN({})// true// 等同于isNaN(Number({}))// trueisNaN(['xzy'])// true// 等同于isNaN(Number(['xzy']))// true

但是，对于空数组和只有一个数值成员的数组，isNaN返回false。

isNaN([])// falseisNaN([123])// falseisNaN(['123'])// false// 原因Number([123]// 123Number(['123']// 123

因此，使用isNaN之前，最好判断一下数据类型。

functionmyIsNaN(value){returntypeof value==='number'&&isNaN(value);}

判断NaN更可靠的方法是，利用NaN为唯一不等于自身的值的这个特点，进行判断。

functionmyIsNaN(value){return value!== value;}

5.5.4 isFinite()

isFinite方法返回一个布尔值，表示某个值是否为正常的数值。

isFinite(Infinity)// falseisFinite(-Infinity)// falseisFinite(NaN)// falseisFinite(undefined)// false// 除了上述四个，isFinite对于其他的数值都会返回trueisFinite(null)// trueisFinite(-1)// true

6.字符串

6.1 定义

字符串就是零个或多个排在一起的字符，放在单引号或双引号之中。

'abc'"abc"

单引号字符串的内部，可以使用双引号。双引号字符串的内部，可以使用单引号。eg：

'key = "value"'"It's a long journey"

如果要在单引号字符串的内部，使用单引号，就必须在内部的单引号前面加上反斜杠，用来转义。双引号字符串内部使用双引号，也是如此。

'Did she say \'Hello\'?'// "Did she say 'Hello'?""Did she say \"Hello\"?"// "Did she say "Hello"?"

字符串默认只能写在一行内，分成多行将会报错。

'a
b
c'// SyntaxError: Unexpected token ILLEGAL

如果长字符串必须分成多行，可以在每一行的尾部使用反斜杠。

var longString='Long \
long \
long \
string'