雖然Javascript是弱類型語言，但是，它也有自己的幾種數(shù)據(jù)類型，分別是：Number、String、Boolean、Object、Udefined、Null。其中，Object屬于復(fù)雜數(shù)據(jù)類型，Object   由無序的鍵值對組成。其余幾種都屬于簡單數(shù)據(jù)類型。注意：變量類型首字母大寫，而變量值首字母是小寫的。

JavaScript不支持自定義類型，所以JavaScript中的所有值都屬于這六種類型之一。
根據(jù)ECMAScript 5.1的規(guī)范，javascript中共有六種數(shù)據(jù)類型，分別為：Undefined, Null, Boolean,Number, String、Object。前五種屬于基本類型，最后一種屬于Object類型。

最新的ECMAScript 6 又加了一種類型：Symbol (ECMAScript 6 新定義)

基本數(shù)據(jù)類型

Undefined：只有一個值，為undefined，意味著“空值(no value)”，適用于所有數(shù)據(jù)類型。
Null：只有一個值，為null，意味著“空對象(no object)”，只適用于對象類型。（literal）
Boolean：有兩個值，為true與false
Number：的值是遵循IEEE 754標(biāo)準(zhǔn)的64位浮點數(shù)的集合，沒有整型數(shù)據(jù)結(jié)構(gòu)。此外還包含三個特殊的值：NaN、Infinity、-Infinity
String：值是有窮個Unicode字符的集合。必須用'或"括起來。

一、String

JavaScript的字符串類型用于表示文本數(shù)據(jù)。它是一組16位的無符號整數(shù)值的“元素”。在字符串中的每個元素占據(jù)了字符串的位置。第一個元素的索引為0，下一個是索引1，依此類推。字符串的長度是它的元素的數(shù)量

與 C 語言不同，JavaScript 中字符串是不可變的（譯注：如，JavaScript 中對字符串的操作一定返回了一個新字符串，原始字符串并沒有被改變）

Javascript中一切都是object-based

創(chuàng)建string，也有兩種類型

1、使用字面量方式創(chuàng)建的字符串，為基本類型的string //string

2、使用String()創(chuàng)建的字符串，為基本類型的string  // string

3、使用構(gòu)造函數(shù) new String()的方式創(chuàng)建的字符串，為對象類型的 //string

var str1 = "javascript"; //string
var str2 = String("javascript"); //string 不推薦
var str3 = new String('javascript'); //object

object 和 string也是有區(qū)別的

s1 = "2 + 2";               // creates a string primitive
s2 = new String("2 + 2");   // creates a String object
console.log(eval(s1));      // returns the number 4
console.log(eval(s2));      // returns the string "2 + 2"
字符串對象的轉(zhuǎn)換 valueof -》 string

console.log(eval(s2.valueOf())); // returns the number 4

二、boolean

不要將原始值true false,和值為true false的Boolean對象相混淆

1、如果Boolean構(gòu)造函數(shù)的參數(shù)不是一個布爾值,則該參數(shù)會被轉(zhuǎn)換成一個布爾值

2、如果參數(shù)是 0, -0, null,false, NaN, undefined, 或者空字符串 (""),生成的Boolean對象的值為false. 其他任何值,包括任何對象或者字符串"false", 都會創(chuàng)建一個值為true的Boolean對象

var x = new Boolean(false);
if(x){
 console.log(x.valueOf(),typeof x); // false object
}

上面會執(zhí)行，很神奇的代碼

不要通過新建Boolean對象的方法來將一個非布爾值轉(zhuǎn)化成布爾值. 直接使用Boolean函數(shù)才是正確的

var x = Boolean(expression);  // 這樣用
var x = new Boolean(expression); // 而不要這樣!
初始化的時候

//false
var bNoParam = new Boolean();
var bZero = new Boolean(0);
var bNull = new Boolean(null);
var bEmptyString = new Boolean("");
var bfalse = new Boolean(false);
//true
var btrue = new Boolean(true);
var btrueString = new Boolean("true");
var bfalseString = new Boolean("false");
var bSuLin = new Boolean("Su Lin");

三、Number

根據(jù) ECMAScript 標(biāo)準(zhǔn)，JavaScript 中只有一種數(shù)字類型：基于 IEEE 754 標(biāo)準(zhǔn)的雙精度 64 位二進(jìn)制格式的值（-(253 -1) 到 253 -1）。它并沒有為整數(shù)給出一種特定的類型。除了能夠表示浮點數(shù)外，還有一些帶符號的值：+Infinity，-Infinity 和 NaN (非數(shù)值，Not-a-Number)

數(shù)字類型只有一個整數(shù)，它有兩種表示方法： 0 可表示為 -0 和 +0（"0" 是 +0 的簡寫）。 在實踐中，這也幾乎沒有影響。 例如 +0 === -0 為真。 但是，你可能要注意除以0的時候：

42 / +0; // Infinity
42 / -0; // -Infinity

如果參數(shù)無法被轉(zhuǎn)換為數(shù)字，則返回 NaN。

在非構(gòu)造器上下文中 (如：沒有 new 操作符)，Number 能被用來執(zhí)行類型轉(zhuǎn)換

isNAN 類型判斷

Number.isNaN(NaN);  // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0)  // true
// e.g. these would have been true with global isNaN()
Number.isNaN("NaN");  // false
Number.isNaN(undefined); // false
Number.isNaN({});   // false
Number.isNaN("blabla"); // false
// These all return false
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");

原型鏈繼承的關(guān)系

console.log(Number.prototype.__proto__ == Object.prototype); //true
console.log(Number.prototype.__proto__.__proto__ == Object.prototype.__proto__);//true
console.log(Object.prototype.__proto__ === null);//true
console.log(typeof Number);//function

使用 Number 轉(zhuǎn)換 Date 對象

var d = new Date("December 17, 1995 03:24:00");
console.log(Number(d));

四、Null

null 是一個 JavaScript 字面量，表示空值（null or an "empty" value），即沒有對象被呈現(xiàn)（no object value is present）。它是 JavaScript 原始值 之一。

null 是一個字面量 (而不是全局對象的一個屬性，undefined 是 )

console.log(null); //null
console.log(undefined);//undefined
console.log(window.null);//undefined
console.log(window.undefined);//undefined

null與undefined的區(qū)別

console.log(foot);//Uncaught ReferenceError: foot is not defined
var foo;
console.log(foo);//undefined
var bar =null;
console.log(bar);//null
typeof null  // object (bug in ECMAScript, should be null)
typeof undefined // undefined
null === undefined // false
null == undefined // true

所以判斷null，可以判斷類型 + 值

五、Undefined

在JavaScript中,undefined這個詞有多重含義.首字母大寫的Undefined表示的是一種數(shù)據(jù)類型,小寫的undefined表示的是屬于這種數(shù)據(jù)類型的唯一的一個值.但這兩種undefined都只能存在于文檔或規(guī)范中,不能存在于JavaScript代碼中.在JavaScript代碼中,你看到的undefined最有可能是全局對象的一個屬性,該屬性的初始值是就是前面所說的原始值undefined,還有種情況就是,這個undefined是個局部變量,就像其他普通變量一樣,沒有任何特殊性,它的值不一定是undefined,但通常情況下都是的.下面我們所說的undefined,都指的是window.undefined這個屬性.

在ES3中(Firefox4之前),window.undefined就是一個普通的屬性,你完全可以把它的值改變成為任意的真值,但在ES5中((Firefox4之后),window.undefined成了一個不可寫,不可配置的數(shù)據(jù)屬性,它的值永遠(yuǎn)是undefined.

一個未初始化的變量的值為undefined,一個沒有傳入實參的形參變量的值為undefined,如果一個函數(shù)什么都不返回,則該函數(shù)默認(rèn)返回undefined.

你可以使用嚴(yán)格相等運算符來判斷一個值是否是undefined:

var foo;
console.log(foo === undefined);//true
console.log(typeof foo === 'undefined');//true
console.log(window.foo === undefined);//true
console.log(bar === undefined);//Uncaught ReferenceError: bar is not defined
console.log(typeof bar === 'undefined');//true
console.log(window.bar === undefined);//true
console.log(typeof undefined == 'undefined'); //true
console.log(typeof null == 'object');//true
console.log(null == undefined);//true
console.log(null === undefined);//false

總結(jié)

Null的值是null，表示一個空對象指針，沒有指向任何對象
Undefined的值是undefined，表示申明變量或?qū)ο蟮膶傩詤s未初始化
undefined值是派生自null的，所以對他們執(zhí)行相等測試會返回true
數(shù)值、布爾值、對象和字符串值都有toString()方法。但null和undefined值沒有這個方法
多數(shù)情況下，調(diào)用toString()方法不必傳遞參數(shù)。但是，在調(diào)用數(shù)值的toString()方法時，可以傳遞一個參數(shù)：輸出數(shù)值的基數(shù)

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

在不知道要轉(zhuǎn)換的值是不是null或undefined的情況下，還可以使用轉(zhuǎn)型函數(shù)String()，這個函數(shù)能夠?qū)⑷魏晤愋偷闹缔D(zhuǎn)換為字符串。String()函數(shù)遵循下列轉(zhuǎn)換規(guī)則：

　　● 如果值有toString()方法，則調(diào)用該方法（沒有參數(shù)）并返回相應(yīng)的結(jié)果

　　● 如果值是null，則返回"null"

　　● 如果值是undefined，則返回"undefined"

六、Object

Javascript中一切皆O(shè)bject

// Objects
typeof {a:1} === 'object';
// 使用Array.isArray或者Object.prototype.toString.call方法可以從基本的對象中區(qū)分出數(shù)組類型
typeof [1, 2, 4] === 'object';
typeof new Date() === 'object';
// 下面的容易令人迷惑，不要這樣使用！
typeof new Boolean(true) === 'object';
typeof new Number(1) ==== 'object';
typeof new String("abc") === 'object';
// 函數(shù)
typeof function(){} === 'function';
typeof Math.sin === 'function';

實例化一個空Object

var o = new Object();
var o = new Object(undefined);
var o = new Object(null);
var o = {};

原型

定義屬性為__proto__: 值 或 "__proto__": 值 時，不會創(chuàng)建名為__proto__屬性。如果給出的值是對象或者null，那么對象的[[Prototype]]會被設(shè)置為給出的值。（如果給出的值不是對象也不是null，那么對象的原型不會改變。）

var obj1 = {};
assert(Object.getPrototypeOf(obj1) === Object.prototype);
var obj2 = { __proto__: null };
assert(Object.getPrototypeOf(obj2) === null);
var protoObj = {};
var obj3 = { "__proto__": protoObj };
assert(Object.getPrototypeOf(obj3) === protoObj);
 var obj4 = { __proto__: "not an object or null" };
assert(Object.getPrototypeOf(obj4) === Object.prototype);
assert(!obj4.hasOwnProperty("__proto__"));

在對象字面值中，僅有一次變更原型的機會；多次變更原型，會被視為語法錯誤。

不使用冒號記法的屬性定義，不會變更對象的原型；而是和其他具有不同名字的屬性一樣是普通屬性定義。

var __proto__ = "variable";
var obj1 = { __proto__ };
assert(Object.getPrototypeOf(obj1) === Object.prototype);
assert(obj1.hasOwnProperty("__proto__"));
assert(obj1.__proto__ === "variable");
var obj2 = { __proto__() { return "hello"; } };
assert(obj2.__proto__() === "hello");
var obj3 = { ["__prot" + "o__"]: 17 };
assert(obj3.__proto__ === 17);

與JSON的區(qū)別

JSON 只允許"property": value syntax形式的屬性定義。屬性名必須用雙引號括起來。且屬性定義不允許使用簡便寫法。
JSON中，屬性的值僅允許字符串，數(shù)字，數(shù)組，true，false，或者其他JSON對象。
JSON中，不允許將值設(shè)置為函數(shù)。
 Date 等對象，經(jīng)JSON.parse()處理后，會變成字符串。
JSON.parse() 不會處理計算的屬性名，會當(dāng)做錯誤拋出。

defineProperty

Object.defineProperty() 方法直接在一個對象上定義一個新屬性，或者修改一個已經(jīng)存在的屬性， 并返回這個對象
// 使用 __proto__
Object.defineProperty(obj, "key", {
 __proto__: null, // 沒有繼承的屬性
 value: "static" // 沒有 enumerable
     // 沒有 configurable
     // 沒有 writable
     // 作為默認(rèn)值
});
// 顯式
Object.defineProperty(obj, "key", {
 enumerable: false,
 configurable: false,
 writable: false,
 value: "static"
});
// 回收同一對象
function withValue(value) {
 var d = withValue.d || (
 withValue.d = {
  enumerable: false,
  writable: false,
  configurable: false,
  value: null
 }
 );
 d.value = value;
 return d;
}
// ... 和 ...
Object.defineProperty(obj, "key", withValue("static"));
// 如果 freeze 可用, 防止代碼添加
// value, get, set, enumerable, writable, configurable
// 到對象原型上
(Object.freeze||Object)(Object.prototype);

configurable當(dāng)且僅當(dāng)這個屬性描述符值為 true 時，該屬性可能會改變，也可能會被從相應(yīng)的對象刪除。默認(rèn)為 false。

enumerabletrue 當(dāng)且僅當(dāng)該屬性出現(xiàn)在相應(yīng)的對象枚舉屬性中。默認(rèn)為 false。

value 與屬性相關(guān)的值?？梢允侨魏斡行У?JavaScript 值（數(shù)值，對象，函數(shù)等）。默認(rèn)為 undefined。

writable true 當(dāng)且僅當(dāng)可能用 賦值運算符 改變與屬性相關(guān)的值。默認(rèn)為 false。

存取描述符同時具有以下可選鍵值：

get 一個給屬性提供 getter 的方法，如果沒有 getter 則為 undefined。方法將返回用作屬性的值。默認(rèn)為 undefined。
set 一個給屬性提供 setter 的方法，如果沒有 setter 則為 undefined。該方法將收到作為唯一參數(shù)的新值分配給屬性。默認(rèn)為 undefined。

ps：js中的變量定義

    在JavaScript中，使用var來定義任何類型的變量，每一個變量只是用于保存數(shù)據(jù)的占位符。   

var temp;   //這句代碼定義了一個變量，但其類型是未知的，可以存放任何類型的值，沒有初始化的時候，test中存儲是undefined。 
var temp=2; //這句代碼定義了一個變量，并直接初始化為數(shù)值型。 
var temp="javascript"; // 這句代碼定義了一個變量，并直接初始化微string型，單引號和雙引號都可以，只要成對出現(xiàn)就行。 

2、變量的作用域

   在Javascript中，使用var定義的變量，其作用域是在定義該變量的方法或函數(shù)內(nèi)。也就是說，使用var定義的變量是局部變量。
   例：

   function test() 
   { 
　var temp="Hello, Javascript!"; 
 } 

test(); //方法調(diào)用的時候創(chuàng)建變量并初始化，執(zhí)行結(jié)束后變量被銷毀。 
alert(temp); //undefined。因為變量temp已經(jīng)被銷毀，所以是未定義（undefined）。  

  如果在定義變量時，不使用var，那么定義的變量是全局變量。

  例：

function test2() 
 { 
  temp2="Hello, Javascript!"; 
 } 
test2(); //調(diào)用方法時，創(chuàng)建變量并初始化，執(zhí)行結(jié)束后變量依然存在。 
alert(temp2); //Hello, Javascript! 變量值依然存在 

以上內(nèi)容是小編給大家介紹的Javascript中的數(shù)據(jù)類型之旅，希望大家喜歡。