JavaScript 系列二：数据类型

时间 2021-05-09

标签 javascript java api 浏览器 app 函数学习测试编码指针栏目 JavaScript 繁體版

原文原文链接

前言

在开始学习以前，咱们想要告诉您的是，本文章是对JavaScript语言知识中"数据类型"部分的总结，若是您已掌握下面知识事项，则可跳过此环节直接进入题目练习javascript

Boolean 类型
null 类型
undefined 类型
Number 类型
String 类型
BigInt 类型
Symbol 类型
Object 类型
数值类型转换

若是您对某些部分有些遗忘，👇🏻 已经为您准备好了！java

汇总总结

Boolean 类型

Boolean(布尔值) 类型是 ECMAScript 中使用最频繁的类型之一，有两个字面值：true 和 false 。这两个布尔值不一样于数值，所以 true 不等于 1， false 不等于 0 。api

let xhsFound = true

let xhsLost = false

注意：布尔值字面量 true 和 false 是区分大小写的（即不能使用 False 和 True ）。

Boolean() 转型函数

该函数能够将一个其余类型的值转换为布尔值。浏览器

let message = 'Hello world!'

let messageAsBoolean = Boolean(message) // true

Boolean() 转型函数能够在任意类型的数据上调用，并且始终返回一个布尔值。什么值能转换为 true 或 false 的规则取决于数据类型和实际的值。app

不一样类型与布尔值之间的转换规则

数据类型	转换为 true 的值	转换为 false 的值
Boolean	true	false
String	非空字符串	""（空字符串）
Number	非零数值（包括无穷值）	0、NaN（参见后面的相关内容）
Object	任意对象	null
Undefined	N/A（不存在）	undefined

理解以上转换很是重要，由于像 if 等流控制语句会自动执行其余类型值到布尔值的转换，例如：函数

let message = 'Hello world!'

if (message) {
  console.log('Value is true')
}

在这个例子中，console.log 会输出字符串 "Value is true" ，由于字符串 message 会被自动转换为等价的布尔值 true。因为存在这种自动转换，理解控制语句中使用的是什么变量就很是重要。错误地使用对象而不是布尔值会明显改变应用程序的执行逻辑。学习

null 类型

null 类型一样只有一个值，即特殊值 null 。逻辑上讲，null 值表示一个空对象指针，这也是给 typeof 传一个 null 会返回 "object" 的缘由。测试

let xhsObject = null

console.log(typeof xhsObject) // "object"

在定义未来要保存对象值的变量时，建议使用 null 来初始化，不要使用其余值。这样，只要检查这个变量的值是否是 null 就能够知道这个变量是否在后来被从新赋予了一个对象的引用。编码

if (xhsObject != null) {
  // xhsNull 是一个对象的引用
}

undefined 值是由 null 值派生而来的，所以 ECMA-262 将它们定义为表面上相等指针

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

用等于操做符（==）比较 null 和 undefined 始终返回 true 。但要注意，这个操做符会为了比较而转换它的操做数。

即便 null 和 undefined 有关系，它们的用途也是彻底不同的。永远没必要显式地将变量值设置为 undefined 。但 null 不是这样的。任什么时候候，只要变量要保存对象，而当时又没有那个对象可保存，就要用 null 来填充该变量。这样就能够保持 null 是空对象指针的语义，并进一步将其与 undefined 区分开来。

null 是一个假值。所以，若是须要，能够用更简洁的方式检测它。不过要记住，也有不少其余可能的值一样是假值。因此必定要明确本身想检测的就是 null 这个字面值，而不只仅是假值。

let xhsMessage = null

let xhsAge

if (xhsMessage) {
  // 这个块不会执行
}
if (!xhsMessage) {
  // 这个块会执行
}
if (xhsAge) {
  // 这个块不会执行
}
if (!xhsAge) {
  // 这个块会执行
}

undefined 类型

undefined 类型只有一个值，就是特殊值 undefined 。当使用 var 或 let 声明了变量但没有初始化时，就至关于给变量赋予了 undefined 值。

let xhsMessage

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

在这个例子中，变量 xhsMessage 在声明的时候并未初始化。而在比较它和 undefined 的字面值时，二者是相等的。

let xhsMessage = undefined

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

这里，变量 message 显式地以 undefined 来初始化。但这是没必要要的，由于默认状况下，任何未经初始化的变量都会取得 undefined 值。

注意通常来讲，永远不用显式地给某个变量设置 undefined 值。增长这个特殊值的目的就是为了正式明确空对象指针（ null ）和未初始化变量的区别。

注意，包含 undefined 值的变量跟未定义变量是有区别的。请看下面的例子：

let xhsMessage // 这个变量被声明了，只是值为 undefined

// 确保没有声明过这个变量

// let xhsAge

console.log(xhsMessage) // "undefined"

console.log(xhsAge) // 报错

在上面的例子中，第一个 console.log 会指出变量 message 的值，即 "undefined" 。而第二个 console.log 要输出一个未声明的变量 age 的值，所以会致使报错。对未声明的变量，只能执行一个有用的操做，就是对它调用 typeof 。（对未声明的变量调用 delete 也不会报错，但这个操做没什么用，实际上在严格模式下会抛出错误。）

在对未初始化的变量调用 typeof 时，返回的结果是 "undefined" ，但对未声明的变量调用它时，返回的结果仍是 "undefined" ，这就有点让人看不懂了。

let xhsMessage // 这个变量被声明了，只是值为 undefined

// 确保没有声明过这个变量

// let xhsAge

console.log(typeof xhsMessage) // "undefined"

console.log(typeof xhsAge) // "undefined"

不管是声明仍是未声明，typeof 返回的都是字符串 "undefined" 。逻辑上讲这是对的，由于虽然严格来说这两个变量存在根本性差别，但它们都没法执行实际操做。

注意： 即便未初始化的变量会被自动赋予 undefined 值，但咱们仍然建议在声明变量的同时进行初始化。这样，当 typeof 返回 "undefined" 时，你就会知道那是由于给定的变量还没有声明，而不是声明了但未初始化。

undefined 是一个假值。所以，若是须要，能够用更简洁的方式检测它。不过要记住，也有不少其余可能的值一样是假值。因此必定要明确本身想检测的就是 undefined 这个字面值，而不只仅是假值。

let xhsMessage // 这个变量被声明了，只是值为 undefined

// xhsAge 没有声明

if (xhsMessage) {
  // 这个块不会执行
}

if (!xhsMessage) {
  // 这个块会执行
}

if (xhsAge) {
  // 这里会报错
}

Number 类型

Number 类型使用 IEEE 754 格式表示整数和浮点值（在某些语言中也叫双精度值）。

十进制整数

let xhsIntNum = 55 // 整数

整数也能够用八进制（以 8 为基数）或十六进制（以 16 为基数）字面量表示。

八进制整数

对于八进制字面量，第一个数字必须是零（0），而后是相应的八进制数字（数值 0~7）。若是字面量中包含的数字超出了应有的范围，就会忽略前缀的零，后面的数字序列会被当成十进制数。

let xhsOctalNum1 = 070 // 八进制的 56

let xhsOctalNum2 = 079 // 无效的八进制值，当成 79 处理

let xhsOctalNum3 = 08 // 无效的八进制值，当成 8 处理

十六进制整数

要建立十六进制字面量，必须让真正的数值前缀 0x（区分大小写），而后是十六进制数字（0~9 以及 A~F）。十六进制数字中的字母大小写都可。

let xhsHexNum1 = 0xa // 十六进制 10

let xhsHexNum2 = 0x1f // 十六进制 31

注意

使用八进制和十六进制格式建立的数值在全部数学操做中都被视为十进制数值。
因为 JavaScript 保存数值的方式，实际中可能存在正零（ +0 ）和负零（ -0 ）。正零和负零在全部状况下都被认为是等同的，这里特意说明一下。

浮点值

要定义浮点值，数值中必须包含小数点，并且小数点后面必须至少有一个数字。虽然小数点前面不是必须有整数，但推荐加上。

let xhsFloatOne = 1.11111

let xhsFloatTwo = 0.11111

let xhsFloatThree = 0.11111 // 有效，不推荐

由于存储浮点值使用的内存空间是存储整数值的两倍，因此 ECMAScript 老是千方百计把值转换为整数。在小数点后面没有数字的状况下，数值就会变成整数。

let xhsFloatOne = 1 // 小数点后面没有数字，当成整数 1 处理

let xhsFloatTwo = 2.0 // 小数点后面是零，当成整数 2 处理

对于很是大或很是小的数值，浮点值能够用科学记数法来表示。科学记数法用于表示一个应该乘以 10 的给定次幂的数值。ECMAScript 中科学记数法的格式要求是一个数值（整数或浮点数）后跟一个大写或小写的字母 e，再加上一个要乘的 10 的多少次幂。

let xhsFloat = 3.125e4 // 等于 31250

科学记数法也能够用于表示很是小的数值，例如 0.000 000 000 000 000 03。这个数值用科学记数法能够表示为 3e-17。

浮点值的精确度最高可达 17 位小数，但在算术计算中远不如整数精确。例如， 0.1 加 0.2 获得的不是 0.3 。因为这种微小的舍入错误，致使很难测试特定的浮点值。

if (a + b == 0.3) {
  //这样判断是错误的
  // 0.1 + 0.2 = 0.300 000 000 000 000 04
  console.log('输出 0.3 .')
}

这里检测两个数值之和是否等于 0.3。若是两个数值分别是 0.05 和 0.25，或者 0.15 和 0.15 ，那没问题。但若是是 0.1 和 0.2，如前所述，测试将失败。所以永远不要测试某个特定的浮点值。

值的范围

最大和最小值

因为内存的限制， ECMAScript 并不支持表示这个世界上的全部数值。

最 小 数值保存在 Number.MIN_VALUE 中，这个值在多数浏览器中是 5e-324
最 大 数值保存在 Number.MAX_VALUE 中，这个值在多数浏览器中是 1.797 693 134 862 315 7e+308

无穷大和无穷小

若是某个计算获得的数值结果超出了可表示的范围，那么这个数值会被自动转换为一个特殊的 Infinity（无穷）值。

任何没法表示的负数以-Infinity（负无穷大）表示
任何没法表示的正数以 Infinity（正无穷大）表示。

isFinite()函数

用于确认一个值是否是在有限数值范围以内（即最大值和最小值之间），不在 false ，再显示 true

let xhsResult = Number.MAX_VALUE + Number.MAX_VALUE

console.log(isFinite(xhsResult)) // false

注意

若是计算返回正 Infinity 或 负 Infinity，则该值将不能再进一步用于任何计算。这是由于 Infinity 没有可用于计算的数值表示形式。
使用 Number.NEGATIVE_INFINITY 和 Number.POSITIVE_INFINITY 也能够获取正、负 Infinity。没错，这两个属性包含的值分别就是 -Infinity 和 Infinity。
虽然超出有限数值范围的计算并很少见，但总归仍是有可能的。所以在计算很是大或很是小的数值时，有必要监测一下计算结果是否超出范围。

NaN

有一个特殊的数值叫 NaN ，意思是“不是数值”（ Not a Number ），用于表示原本要返回数值的操做失败了（而不是抛出错误）。好比，用 0 除任意数值在其余语言中一般都会致使错误，从而停止代码执行。但在 ECMAScript 中， 0、 +0 或 -0 相除会返回 NaN

console.log(0 / 0) // NaN

console.log(-0 / +0) // NaN

若是分子是非 0 值，分母是有符号 0 或无符号 0，则会返回 Infinity 或 -Infinity ：

console.log(1 / 0) // Infinity

console.log(1 / -0) // -Infinity

NaN 的独特属性

任何涉及 NaN 的操做始终返回 NaN（如 NaN/10），在连续多步计算时这多是个问题
NaN 不等于包括 NaN 在内的任何值。例如，下面的比较操做会返回 false ：

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

isNaN()函数

该函数接收一个参数，能够是任意数据类型，判断这个参数是否是“不是数值”。该函数会尝试把传入的参数转换为数值。能够转化为数值的则返回 false ，如字符串 "1" 或布尔值。不能转换为数值的值则返回 true .

console.log(isNaN(NaN)) // true

console.log(isNaN(1)) // false，1 是数值

console.log(isNaN('1')) // false，能够转换为数值 1

console.log(isNaN('blue')) // true，不能够转换为数值

console.log(isNaN(true)) // false，能够转换为数值 1

注意： 虽然不常见，但 isNaN() 能够用于测试对象。此时，首先会调用对象的 valueOf() 方法，而后再肯定返回的值是否能够转换为数值。若是不能，再调用 toString() 方法，并测试其返回值。

String 类型

String （字符串）数据类型表示零或多个 16 位 Unicode 字符序列。字符串可使用双引号（ "" ）、单引号（''）或反引号（ ` ` ）标示。

let xhsFirstName = 'John'

let xhsLastName = 'Jacob'

let xhsLastName = `Jingleheimerschmidt`

let xhsError = 'Nicholas"; // 语法错误：开头和结尾的引号必须是同一种

字符字面量

语法

字面量是由语法表达式定义的常量，或经过由必定字词组成的语词表达式定义的常量。

字符串数据类型包含一些字符字面量，用于表示非打印字符或有其余用途的字符。

字面量	含义
\n	换行
\t	制表
\b	退格
\r	回车
\f	换页
\	反斜杠（\）
\'	单引号（'），在字符串以单引号标示时使用，例如'He said, \'hey.\''
\"	双引号（"），在字符串以双引号标示时使用，例如"He said, \"hey.\""
\`	反引号（\`），在字符串以反引号标示时使用，例如\` He said, \` hey.\``
\xnn	以十六进制编码 nn 表示的字符（其中 n 是十六进制数字 0~F），例如\x41 等于"A"
\unnnn	以十六进制编码 nnnn 表示的 Unicode 字符（其中 n 是十六进制数字 0~F），例如\u03a3 等于希腊字符"Σ"

这些字符字面量能够出如今字符串中的任意位置，且能够做为单个字符被解释：

let text = 'This is the letter sigma: \u03a3.'

在这个例子中，即便包含 6 个字符长的转义序列，变量 text 仍然是 28 个字符长。由于转义序列表示一个字符，因此只算一个字符。

console.log(text.length) // 28   字符串的长度获取

这个属性返回字符串中 16 位字符的个数。

注意： 若是字符串中包含双字节字符，那么 length 属性返回的值可能不是准确的字符数。

字符串的特色

字符串是不可变的，意思是一旦建立，它们的值就不能变了。要修改某个变量中的字符串值，必须先销毁原始的字符串，而后将包含新值的另外一个字符串保存到该变量。

let lang = 'Java'

lang = lang + 'Script'

这里，变量 lang 一开始包含字符串"Java"。紧接着，lang 被从新定义为包含"Java"和"Script"的组合，也是"JavaScript"。整个过程首先会分配一个足够容纳 10 个字符的空间，而后填充上"Java"和"Script"。最后销毁原始的字符串"Java"和字符串"Script"，由于这两个字符串都没有用了。

字符串插值

模板字面量最经常使用的一个特性是支持字符串插值，也就是能够在一个连续定义中插入一个或多个值。技术上讲，模板字面量不是字符串，而是一种特殊的 JavaScript 句法表达式，只不过求值后获得的是字符串。模板字面量在定义时当即求值并转换为字符串实例，任何插入的变量也会从它们最接近的做用域中取值。

字符串插值经过在 ${} 中使用一个 JavaScript 表达式实现：

let value = 5

let exponent = 'second'

// 之前，字符串插值是这样实现的：

let interpolatedString = value + ' to the ' + exponent + ' power is ' + value * value

// 如今，能够用模板字面量这样实现：

let interpolatedTemplateLiteral = `${value} to the ${exponent} power is ${value * value}`

console.log(interpolatedString) // 5 to the second power is 25

console.log(interpolatedTemplateLiteral) // 5 to the second power is 25

全部插入的值都会使用 toString() 强制转型为字符串，并且任何 JavaScript 表达式均可以用于插值。

嵌套的模板字符串无须转义：

console.log(`Hello, ${`World`}!`) // Hello, World!

将表达式转换为字符串时会调用 toString() ：

let foo = { toString: () => 'World' }

console.log(`Hello, ${foo}!`) // Hello, World!

在插值表达式中能够调用函数和方法：

function capitalize(word) {
  return `${word[0].toUpperCase()}${word.slice(1)}`
}

console.log(`${capitalize('hello')}, ${capitalize('world')}!`) // Hello, World!

其余类型转换为字符串

有两种方式把一个值转换为字符串。首先是使用几乎全部值都有的 toString()方法。这个方法惟一的用途就是返回当前值的字符串等价物。

let xhsAge = 11
let xhsAgeAsString = xhsAge.toString() // 字符串"11"

let xhsFound = true
let xhsFoundAsString = xhsFound.toString() // 字符串"true"

toString()方法可见于数值、布尔值、对象和字符串值。（没错，字符串值也有 toString()方法，该方法只是简单地返回自身的一个副本。）null 和 undefined 值没有 toString() 方法。

多数状况下，toString() 不接收任何参数，默认状况下返回十进制，也能够经过参数来设置进制数。

let xhsNum = 10

console.log(xhsNum.toString()) // "10"

console.log(xhsNum.toString(2)) // "1010"

console.log(xhsNum.toString(8)) // "12"

console.log(xhsNum.toString(10)) // "10"

console.log(xhsNum.toString(16)) // "a"

注意，默认状况下（不传参数）的输出与传入参数 10 获得的结果相同。

若是你不肯定一个值是否是 null 或 undefined ，可使用 String() 转型函数，它始终会返回表示相应类型值的字符串。 String() 函数 遵循以下规则。

若是值有 toString() 方法，则调用该方法（不传参数）并返回结果。
若是值是 null ，返回 "null" 。
若是值是 undefined，返回 "undefined" 。

let xhsValue1 = 10
let xhsValue2 = true
let xhsValue3 = null
let xhsValue4

console.log(String(xhsValue1)) // "10"

console.log(String(xhsValue2)) // "true"

console.log(String(xhsValue3)) // "null"

console.log(String(xhsValue4)) // "undefined"

这里展现了将 4 个值转换为字符串的状况：数值、布尔值 、null 和 undefined 。

数值和 布尔值 的转换结果与调用 toString() 相同。由于 null 和 undefined 没有 toString() 方法，因此 String() 方法就直接返回了这两个值的字面量文本。

注意： 用加号操做符给一个值加上一个空字符串""也能够将其转换为字符串

BigInt 类型

BigInt 是一种内置对象，它提供了一种方法来表示大于 2^53 - 1 的整数。这本来是 Javascript 中能够用 Number 表示的最大数字。 BigInt 能够表示任意大的整数。

描述能够用在一个整数字面量后面加 n 的方式定义一个 BigInt ，如：10n，或者调用函数 BigInt() 。

const theBiggestInt = 9007199254740991n

const alsoHuge = BigInt(9007199254740991)
// ↪ 9007199254740991n

const hugeString = BigInt('9007199254740991')
// ↪ 9007199254740991n

const hugeHex = BigInt('0x1fffffffffffff')
// ↪ 9007199254740991n

const hugeBin = BigInt('0b11111111111111111111111111111111111111111111111111111')
// ↪ 9007199254740991n

它在某些方面相似于 Number ，可是也有几个关键的不一样点：不能用于 Math 对象中的方法；不能和任何 Number 实例混合运算，二者必须转换成同一种类型。在两种类型来回转换时要当心，由于 BigInt 变量在转换成 Number 变量时可能会丢失精度。

Symbol 类型

symbol 是一种基本数据类型（ primitive data type ）。 Symbol() 函数会返回 symbol 类型的值，该类型具备静态属性和静态方法。它的静态属性会暴露几个内建的成员对象；它的静态方法会暴露全局的 symbol 注册，且相似于内建对象类，但做为构造函数来讲它并不完整，由于它不支持语法："new Symbol()"。

每一个从 Symbol() 返回的 symbol 值都是惟一的。一个 symbol 值能做为对象属性的标识符；这是该数据类型仅有的目的。

语法

参数 description 可选

Symbol([description])

可选的，字符串类型。对 symbol 的描述，可用于调试但不是访问 symbol 自己。

描述

直接使用 Symbol() 建立新的 symbol 类型，并用一个可选的字符串做为其描述。

var sym1 = Symbol()
var sym2 = Symbol('foo')
var sym3 = Symbol('foo')

上面的代码建立了三个新的 symbol 类型。注意， Symbol("foo") 不会强制将字符串 “foo” 转换成 symbol 类型。它每次都会建立一个新的 symbol 类型：

Symbol('foo') === Symbol('foo') // false

下面带有 new 运算符的语法将抛出 TypeError 错误：

var sym = new Symbol() // TypeError

这会阻止建立一个显式的 Symbol 包装器对象而不是一个 Symbol 值。围绕原始数据类型建立一个显式包装器对象从 ECMAScript 6 开始再也不被支持。然而，现有的原始包装器对象，如 new Boolean 、 new String 以及 new Number ，由于遗留缘由仍可被建立。

若是你真的想建立一个 Symbol 包装器对象 ( Symbol wrapper object )，你可使用 Object() 函数：

var sym = Symbol('foo')
typeof sym // "symbol"
var symObj = Object(sym)
typeof symObj // "object"

Object 类型

ECMAScript 中的对象其实就是一组数据和功能的集合。对象经过 new 操做符后跟对象类型的名称来建立。开发者能够经过建立 Object 类型的实例来建立本身的对象，而后再给对象添加属性和方法.

let xhsO = new Object()

ECMAScript 中的 Object 是派生其余对象的基类。 Object 类型的全部属性和方法在派生的对象上一样存在。每一个 Object 实例都有以下属性和方法。

constructor ：用于建立当前对象的函数。在前面的例子中，这个属性的值就是 Object() 函数。
hasOwnProperty(*propertyName*) ：用于判断当前对象实例（不是原型）上是否存在给定的属性。要检查的属性名必须是字符串（如 o.hasOwnProperty("name") ）或符号。
isPrototypeOf(*object*) ：用于判断当前对象是否为另外一个对象的原型。
propertyIsEnumerable(*propertyName*) ：用于判断给定的属性是否可使用 for-in 语句枚举。与 hasOwnProperty() 同样，属性名必须是字符串。
toLocaleString() ：返回对象的字符串表示，该字符串反映对象所在的本地化执行环境。
toString() ：返回对象的字符串表示。
valueOf() ：返回对象对应的字符串、数值或布尔值表示。一般与 toString() 的返回值相同。

由于在 ECMAScript 中 Object 是全部对象的基类，因此任何对象都有这些属性和方法。

数值类型转换

有 3 个函数能够将非数值转换为数值： Number() 、 parseInt() 和 parseFloat() 。 Number() 是转型函数，可用于任何数据类型。后两个函数主要用于将字符串转换为数值。对于一样的参数，这 3 个函数执行的操做也不一样。

Number() 函数

基于以下规则执行转换。

布尔值， true 转换为 1 ， false 转换为 0 。
数值，直接返回。
null ，返回 0 。
undefined ，返回 NaN 。
字符串，应用如下规则。
- 若是字符串包含数值字符，包括数值字符前面带加、减号的状况，则转换为一个十进制数值。所以， Number("1") 返回 1 ， Number("123") 返回 123 ， Number("011") 返回 11 （忽略前面的零）。
- 若是字符串包含有效的浮点值格式如 "1.1" ，则会转换为相应的浮点值（一样，忽略前面的零）。
- 若是字符串包含有效的十六进制格式如 "0xf" ，则会转换为与该十六进制值对应的十进制整数值。
- 若是是空字符串（不包含字符），则返回 0 。
- 若是字符串包含除上述状况以外的其余字符，则返回 NaN 。
对象，调用 valueOf() 方法，并按照上述规则转换返回的值。若是转换结果是 NaN ，则调用 toString() 方法，再按照转换字符串的规则转换。

let xhsNum1 = Number('Hello world!') // NaN

let xhsNum2 = Number('') // 0

let xhsNum3 = Number('000011') // 11

let xhsNum4 = Number(true) // 1

parseInt() 函数

字符串最前面的空格会被忽略，从第一个非空格字符开始转换
若是第一个字符不是数值字符、加号或减号， parseInt() 当即返回 NaN
若是第一个字符是数值字符、加号或减号，则继续依次检测每一个字符，直到字符串末尾，或碰到非数值字符。好比， "1234blue" 会被转换为 1234 ，由于 "blue" 会被彻底忽略。相似地， "22.5" 会被转换为 22 ，由于小数点不是有效的整数字符。

假设字符串中的第一个字符是数值字符， parseInt() 函数也能识别不一样的整数格式（十进制、八进制、十六进制）。换句话说，若是字符串以 "0x" 开头，就会被解释为十六进制整数。若是字符串以 "0" 开头，且紧跟着数值字符，在非严格模式下会被某些实现解释为八进制整数。

let xhsNum1 = parseInt('1234blue') // 1234

let xhsNum2 = parseInt('') // NaN

let xhsNum3 = parseInt('0xA') // 10，解释为十六进制整数

let xhsNum4 = parseInt(22.5) // 22

let xhsNum5 = parseInt('70') // 70，解释为十进制值

let xhsNum6 = parseInt('0xf') // 15，解释为十六进制整数

parseInt() 也接收第二个参数，用于指定进制数。能够省略前面的 0x 或者 0

let xhsNum = parseInt('0xAF', 16) // 175

let xhsNum1 = parseInt('AF', 16) // 175

let xhsNum2 = parseInt('AF') // NaN

经过第二个参数，能够极大扩辗转换后得到的结果类型。

let xhsNum1 = parseInt('10', 2) // 2，按二进制解析

let xhsNum2 = parseInt('10', 8) // 8，按八进制解析

let xhsNum3 = parseInt('10', 10) // 10，按十进制解析

let xhsNum4 = parseInt('10', 16) // 16，按十六进制解析

注意： 多数状况下解析的应该都是十进制数，此时第二个参数就要传入 10 。

parseFloat() 函数

该函数的工做方式跟 parseInt() 函数相似，都是从位置 0 开始检测每一个字符。一样，它也是解析到字符串末尾或者解析到一个无效的浮点数值字符为止。这意味着第一次出现的小数点是有效的，但第二次出现的小数点就无效了，此时字符串的剩余字符都会被忽略。所以， "22.34.5" 将转换成 22.34 。

注意

它始终忽略字符串开头的零
十六进制数值始终会返回 0
若是字符串表示整数（没有小数点或者小数点后面只有一个零），则 parseFloat() 返回整数

let xhsNum1 = parseFloat('1234blue') // 1234，按整数解析

let xhsNum2 = parseFloat('0xA') // 0

let xhsNum3 = parseFloat('22.5') // 22.5

let xhsNum4 = parseFloat('22.34.5') // 22.34

let xhsNum5 = parseFloat('0908.5') // 908.5

let xhsNum6 = parseFloat('3.125e7') // 31250000

题目自测

一:null 和 undefined 的区别是什么？

二：如下代码，哪一个结果返回的是 NaN()

A. let a = Number('')

B. let b = Number('xhs')

C. let c = Number(true)

D. let d = Number(120);

三: 如下代码输出什么？

let a = 12
let b = false
let c = null
let d = undefined
console.log(typeof a.toString())
console.log(typeof b.toString())
console.log(String(c))
console.log(String(d))

题目解析

1、
null 和 undefined 都是基本的数据类型，它们都自己都只有一个值，就是 null 和 undefined 。 undefined 表示未定义，null 表示为空对象。

null == undefined // true
null === undefined // false

Number(null) // 0
Number(undefined) // NaN

2、
Answr：B

此处用到了数值类型转换中的 Number() 函数

A 为空字串，转换以后返回的是 0 , B 字符串中的其余类型，转化为 NaN ，C true 会先转化为 1 ，而后转化为数值，D 普通数值，返回原来的值，因此是 120

3、
toString() 方法将值都转化为字符串的方式输出。然而 null 和 undefined 没有 toString() 方法，可使用 String() 直接转化为字符串。

// 'string'
// 'string'
// 'null'
// 'undefined'