关于javascript:JavaScript-系列二数据类型

前言

在开始学习之前，咱们想要告诉您的是，本文章是对 JavaScript 语言常识中 “ 数据类型 ” 局部的总结，如果您已把握上面常识事项，则可跳过此环节间接进入题目练习

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

如果您对某些局部有些忘记，👇🏻 曾经为您筹备好了！

汇总总结

Boolean 类型

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

let xhsFound = true

let xhsLost = false

留神：布尔值字面量 true 和 false 是辨别大小写的（即不能应用 False 和 True）。

Boolean() 转型函数

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

let message = 'Hello world!'

let messageAsBoolean = Boolean(message) // true

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

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

了解以上转换十分重要，因为像 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"; // 语法错误：结尾和结尾的引号必须是同一种

字符字面量

语法

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

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

这些字符字面量能够呈现在字符串中的任意地位，且能够作为单个字符被解释：

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))

题目解析

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

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

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

二、
Answr：B

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

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

三、
toString() 办法将值都转化为字符串的形式输入。然而 null 和 undefined 没有 toString() 办法，能够应用 String() 间接转化为字符串。

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