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 的規則取決於數據類型和實際的值。

不一樣類型與布爾值之間的轉換規則

數據類型	轉換爲 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'