Undefined

Undefined 類型只有一個值，就是 undefined。聲明變量而沒有初始化時，這個值就是 undefined

// 聲明未初始化的變量，變量值默認為undefined
var message;
console.log(message === undefined) // true

// 初始化值為undefined
var message = undefined
console.log(message === undefined) // true

聲明未初始化的變量和未聲明的變量都返回 undefined

var message
typeof message // "undefined"
typeof age // "undefined"
// 基于此，我們應該顯示初始化變量，這樣子當使用typeof操作符返回undefined的時候，
// 我們就可以確定變量未聲明，而不是沒有初始化

Null

Null 類型只有一個值，就是 null

// null值表示指向空對象的指針，所以返回object
var car = null
typeof car // "object"

如果聲明變量用來保存對象，最好初始化為 null,可以用來判斷對象是否已經(jīng)保存了一個對象的引用

if(car != null){
    // 對 car 對象進行額外操作
}

undefined 派生于 null

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

Boolean

Boolean 類型具有兩個字面量值：true 和 false

將其他類型的值轉化為 Boolean 類型的值

var message = "Hello World"
var messageAsBoolean = Boolean(message)

各類型的值轉化為 Boolean 類型值的轉換規(guī)則

Number

整數(shù)

var intNum = 55; // 整數(shù)

var octalNum = 070 // 八進制的56

var hexNum = 0xA // 十六進制的10

浮點數(shù)

var floatNum = 1.1

// 對于極大或極小的數(shù)值采用科學計數(shù)法
var floatNum = 3.125e7 // 等于3.125 * 10的7次方 == 31250000
var floatNum = 3e-7 // 等于 3 * 10的-7次方 == 0.0000003

浮點數(shù)計算

// 基于IEEE754數(shù)值的浮點計算的通病
0.1 + 0.2 != 0.3 // 0.3000000000000004

// 變相的計算浮點數(shù)的值
(0.1 * 10 + 0.2 * 10) / 10 = 3

數(shù)值范圍

Number.MIN_VALUE // 5e-324
Number.MAX_VALUE // 1.7976931348623157e+308
// 如果計算超出JavaScript數(shù)值范圍，這個數(shù)值自動保存為Infinity或者-Infinity（正負∞）

isFinite 函數(shù)（位于最大和最小值之間的數(shù)會返回 true）用于檢測數(shù)值是否超出 JavaScript 數(shù)值范圍

var result = Number.MAX_VALUE * 2 // Infinity
isFinite(result) // false

NaN

NaN 非數(shù)值，用于表示本來要返回數(shù)值但未返回數(shù)值的情況（避免拋出錯誤）

// 任何數(shù)值 * 非數(shù)值都會返回NaN
1 * 'abc' // NaN

• NaN 涉及的操作都返回 NaN
• NaN 不等于任何值，包括 NaN 本身

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

isNaN

isNaN 函數(shù)用于幫助我們檢查參數(shù)是否為“非數(shù)值”（參數(shù)首先會自動轉化為數(shù)值，如果不能轉化，則返回 true）

// 數(shù)值
isNaN('') // false
isNaN('1') // false
isNaN(null) // false
isNaN(true) // false

// 非數(shù)值
isNaN('blue') // true
isNaN(NaN) // true
isNaN(undefined) // true

數(shù)值轉化

Number()用于任何數(shù)據(jù)類型的轉化

• Boolean 類型，true 轉化為 1，0 轉化為 false
• Number 類型，簡單的傳入和傳出
• null，返回 0
• undefined，返回 NaN
• Stirng
• • 只包含數(shù)字轉化為對應的整數(shù)或浮點數(shù)
• • 空字符串返回 0
• • 其他類型返回 NaN
• Object 調用 valueOf()然后依據(jù)前面的規(guī)則返回值，如果結果是 NaN，調用 toString()方法，依照前面規(guī)則轉換返回的值

Number("Hello World") // NaN
Number("123") // 123
Number(false) // 0
Number(null) // 0
Number(undefined) // NaN
Number(1.1) // 1.1

parseInt 和 parseFloat 用于將字符串轉化為數(shù)值

parseInt("1234blue") // 1234
parseInt(22.5) // 22
parseInt("") // NaN

parseFloat("1234blue") // 1234
parseFloat(22.5) // 22.5
parseFloat("") // NaN

String

聲明(單引號''或雙引號""都可以)

var firstName = 'Nicholas';
var lastName = "Zakas";

特殊字符字面量

字符串長度

var text = 'Hello World';
console.log(text.length); // 11

字符串的特點

字符串一旦創(chuàng)建，它們的值就不可改變。

var lang = 'Java'
lang = lang + 'Script'

image

原始值
存儲在棧（stack）中的簡單數(shù)據(jù)段，也就是說，它們的值直接存儲在變量訪問的位置。
引用值
存儲在堆（heap）中的對象，也就是說，存儲在變量處的值是一個指針（point），指向存儲對象的內存處。

基本類型的值不可改變，上面代碼中的變量 lang 只是重新指向了存儲值為“JavaScript”的地方。這也是很多低版本瀏覽器拼接字符串速度很慢的原因。

轉換為字符串

toString()

字符串、數(shù)值、布爾和對象都可以使用 toString() 轉化為 String,null 和 undefined 沒有這個方法

var str = "String",
  num = 2,
  flag = true,
  obj = { a: 1 };
str.toString(); // "String"
num.toString(); // "2"
flag.toString(); // "true"
obj.toString(); // "[object Object]"

toString 傳參轉化為不同進制的 Number

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

String()

String 可以轉化任意類型的值為 String，轉化規(guī)則如下

1. 如果轉化值有 toString 方法，則調用該方法返回相同的結果
2. 如果值是 null，則返回"null"
3. 如果值是 undefined，則返回"undefined"

var str = "String",
  num = 2,
  flag = true,
  obj = { a: 1 };
String(str) // "String"
String(num); // "2"
String(flag); // "true"
String(obj); // "[object Object]"

String(null) // "null"
String(undefined) // "undefined"

待轉化值+''

2 + '' // "2"
true +'' // "true"
'abc' + '' // "abc"
null + '' // "null"
undefined + '' // "undefined"
var a = {a : 1}
a + '' // "[object Object]"

Object

對象其實就是數(shù)據(jù)和功能的集合,Object 類型是所有實例的基礎，Object 具有的屬性和方法也存在于更具體的對象中。

創(chuàng)建對象

var o = new Object()

Object 實例具有的屬性和方法

• constructor: ? Object()
  用于創(chuàng)造該對象的函數(shù)

• hasOwnProperty: ? hasOwnProperty()
  用于檢查給定的屬性在當前對象實例中是否存在（非實例的原型中），如 o.hasOwnProperty('name')

    function Person(name){
        this.name = name
    }
    Person.prototype.age = 24
    var p = new Person('liuchang')
    p.name // "liuchang"
    p.age // 24
    p.hasOwnProperty('name') // true
    p.hasOwnProperty('age') // false
  

• isPrototypeOf: ? isPrototypeOf()
  用于檢查傳入的對象是否是當前對象的原型

    Object.prototype.isPrototypeOf(p) // true
    Person.prototype.isPrototypeOf(p) // true
  

• propertyIsEnumerable: ? propertyIsEnumerable()
  用于檢查給定的屬性是否能夠使用 for-in 語句來枚舉

    p.propertyIsEnumerable('name') // true
    p.propertyIsEnumerable('age') // false
  

• toLocaleString: ? toLocaleString()
  返回對象的字符串表示，該字符串執(zhí)行與執(zhí)行環(huán)境地區(qū)對應。

• toString: ? toString()
  返回對象的字符串表示

• valueOf: ? valueOf()
  返回對象的字符串、數(shù)值或布爾值表示

    p.valueOf() // {name: "liuchang"}