1.JS有哪些數(shù)據(jù)類型有什么區(qū)別

答：JS共有八大數(shù)據(jù)類型，分別是：String、Number、Boolean、Object、Null、Undefined、Symbol、BigInt。其中Symbol（獨(dú)一無二不可變）和BigInt（任意精度的數(shù)字）是ES6中新加入的數(shù)據(jù)類型。這些數(shù)據(jù)類型可以分為原始數(shù)據(jù)類型（String、Number、Boolean、Null、Undefined）和引用數(shù)據(jù)類型（Object、數(shù)組、函數(shù)等）。

**區(qū)別：**存儲位置不同 原始數(shù)據(jù)類型直接存儲在棧（stack）中的簡單數(shù)據(jù)段，占據(jù)空間、大小固定，屬于被頻繁使用的數(shù)據(jù)，所以放在棧中存儲；引用數(shù)據(jù)類型存儲在堆中的對象，占據(jù)空間大、大小不固定，如果存儲在棧中，將會影響程序運(yùn)行的性能。

• 在數(shù)據(jù)結(jié)構(gòu)中，棧中數(shù)據(jù)的存取方式為先進(jìn)后出。
• 堆是一個優(yōu)先隊列，是按優(yōu)先級來進(jìn)行排序的，優(yōu)先級可以按照大小來規(guī)定。

2.數(shù)據(jù)類型檢測的方式

答：JavaScript有4種方法判斷變量的類型，分別是typeof、instanceof、Object.prototype.toString.call()（對象原型鏈判斷方法）、 constructor (用于引用數(shù)據(jù)類型) 。typeof：常用于判斷基本數(shù)據(jù)類型，對于引用數(shù)據(jù)類型除了function返回’function‘，其余全部返回’object’。 instanceof：主要用于區(qū)分引用數(shù)據(jù)類型，檢測方法是檢測的類型在當(dāng)前實(shí)例的原型鏈上，用其檢測出來的結(jié)果都是true，不太適合用于簡單數(shù)據(jù)類型的檢測，檢測過程繁瑣且對于簡單數(shù)據(jù)類型檢測不出來。 constructor：用于檢測所有數(shù)據(jù)類型，檢測方法是獲取實(shí)例的構(gòu)造函數(shù)判斷和某個類是否相同，如果相同就說明該數(shù)據(jù)是符合那個數(shù)據(jù)類型的，這種方法不會把原型鏈上的其他類也加入進(jìn)來，避免了原型鏈的干擾。 Object.prototype.toString.call()：適用于所有類型的判斷檢測，檢測方法是Object.prototype.toString.call(數(shù)據(jù)) 返回的是該數(shù)據(jù)類型的字符串。 這四種判斷數(shù)據(jù)類型的方法中，各種數(shù)據(jù)類型都能檢測且檢測精準(zhǔn)的就是Object.prototype.toString.call()這種方法。

加分回答 instanceof的實(shí)現(xiàn)原理：驗(yàn)證當(dāng)前類的原型prototype是否會出現(xiàn)在實(shí)例的原型鏈__proto__上，只要在它的原型鏈上，則結(jié)果都為true。因此，instanceof 在查找的過程中會遍歷左邊變量的原型鏈，直到找到右邊變量的 prototype，找到返回true，未找到返回false。 Object.prototype.toString.call()原理：Object.prototype.toString 表示一個返回對象類型的字符串，call()方法可以改變this的指向，那么把Object.prototype.toString()方法指向不同的數(shù)據(jù)類型上面，返回不同的結(jié)果

（1）typeof：返回數(shù)據(jù)的類型，但是數(shù)組、null、對象、函數(shù)，都只能返回object，所以typeof并不能區(qū)分出處理function的其他object中的幾種不同類型。

console.log(typeof 2);               // number
console.log(typeof true);            // boolean
console.log(typeof 'str');           // string
console.log(typeof []);              // object    
console.log(typeof function(){});    // function
console.log(typeof {});              // object
console.log(typeof undefined);       // undefined
console.log(typeof null);            // object

衍生問題：為什么typeof null 是obect ?

原因是：在JS的第一個版本中，所有值都存儲在32位的單元中，每個單元包含一個小的類型標(biāo)簽，以及當(dāng)前要存儲的真實(shí)數(shù)據(jù)，類型標(biāo)簽包括000（object）、1（int）、010（double）、100（string）、110（boolean）。而null的機(jī)器碼全是0，所以被認(rèn)為是object。

（2）instanceof：可以判斷instanceof后面的類型是否正確，返回true / false，內(nèi)部的運(yùn)行機(jī)制是看能不能在原型鏈中找到該類型的原型。但是instanceof只能判斷出引用數(shù)據(jù)類型，并且可以區(qū)分出數(shù)組、函數(shù)等，卻不能判斷基本數(shù)據(jù)類型。

console.log(2 instanceof Number);                    // false
console.log(true instanceof Boolean);                // false 
console.log('str' instanceof String);                // false 
console.log([] instanceof Array);                    // true
console.log(function(){} instanceof Function);       // true
console.log({} instanceof Object);                   // true

（3）constructor可以判斷數(shù)據(jù)類型，還可以訪問對象的構(gòu)造函數(shù)。constructor可以把object分開來判斷。分為（Array、Function、object）

console.log((2).constructor === Number); // true
console.log((true).constructor === Boolean); // true
console.log(('str').constructor === String); // true
console.log(([]).constructor === Array); // true
console.log((function() {}).constructor === Function); // true
console.log(({}).constructor === Object); // true

（4）Object.prototype.toString.call()：使用Object對象的原型方法toString來判斷數(shù)據(jù)類型

var a = Object.prototype.toString;
console.log(a.call(2));  //[object Number]
console.log(a.call(true)); //[object Boolean]
console.log(a.call('str')); //[object String]
console.log(a.call([])); //[object Array]
console.log(a.call(function(){})); //[object Function]
console.log(a.call({})); //[object Object]
console.log(a.call(undefined)); //[object Undefined]
console.log(a.call(null)); //[object Null]

3.判斷是否是數(shù)組的方法

var b = new Array();
console.log(b instanceof Array); //true
console.log(Object.prototype.toString.call(b)); //[object Array]
console.log(Array.isArray(b)); //true
console.log(b.constructor===Array); //true
console.log(b.__proto__===Array.prototype); //true
console.log(Array.prototype.isPrototypeOf(b)); //true

4.null和undefined的區(qū)別

答：undefind 是全局對象的一個屬性，當(dāng)一個變量沒有被賦值或者一個函數(shù)沒有返回值或者某個對象不存在某個屬性卻去訪問或者函數(shù)定義了形參但沒有傳遞實(shí)參，這時候都是undefined。undefined通過typeof判斷類型是’undefined’。undefined == undefined undefined === undefined 。 null代表對象的值未設(shè)置，相當(dāng)于一個對象沒有設(shè)置指針地址就是null。null通過typeof判斷類型是’object’。null === null null == null null == undefined null !== undefined undefined 表示一個變量初始狀態(tài)值，而 null 則表示一個變量被人為的設(shè)置為空對象，而不是原始狀態(tài)。在實(shí)際使用過程中，不需要對一個變量顯式的賦值 undefined，當(dāng)需要釋放一個對象時，直接賦值為 null 即可。 讓一個變量為null，直接給該變量賦值為null即可。typeof null是object。

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

5.手寫instanceof方法

function myInstanceof(left,right){
    let proto = Object.getPrototypeOf(left)
    let prototype = right.prototype;
    while(true){
        if(!proto) return false
        if(proto === prototype) return true
        proto = Object.getPrototypeOf(proto)
    }
}
console.log(myInstanceof("",Array)); //false
console.log(myInstanceof([1,2,3],Array)); //true

6.為什么0.1+0.2 !==0.3

答：首先要知道小數(shù)是如何轉(zhuǎn)為二進(jìn)制的，整數(shù)部分就是不斷除2取余，小數(shù)部分就是乘二取整，超過1以后還是用小數(shù)部分乘，如下所示：

//不斷的乘以二然后拿掉整數(shù)部分，直到積為0。
//但是結(jié)果是不可能為0的，所以是循環(huán)的
0.1 * 2 = 0.2 => 0
0.2 * 2 = 0.4 => 0
0.4 * 2 = 0.8 => 0
0.8 * 2 = 1.6 => 1
0.6 * 2 = 1.2 => 1
0.2 * 2 = 0.4 => 0
…

因此，0.1的二進(jìn)制是0.0001 1001 1001 1001…無限循環(huán)，0.2的二進(jìn)制是0.0011 0011 0011 0011…無限循環(huán)，所以0.3的二進(jìn)制就是0.0100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100，轉(zhuǎn)換為十進(jìn)制就是0.300000004，這就是精度丟失問題，所以0.1+0.2 !== 0.3?？梢杂胻oFixed(1)來解決，但也要注意，toFixed()返回的類型是String。

7.isNaN和Number.isNaN函數(shù)的區(qū)別

• isNaN接受參數(shù)后，會嘗試將這個參數(shù)轉(zhuǎn)換為數(shù)值，任何不能轉(zhuǎn)換的都會返回true，因此，非數(shù)字值傳入也會返回true，會影響NaN的判斷。
• Number.isNaN會首先判斷傳入?yún)?shù)是否是數(shù)字，如果是數(shù)字再繼續(xù)判斷是否為NaN，不會進(jìn)行數(shù)據(jù)類型的轉(zhuǎn)換，更加準(zhǔn)確。

console.log(isNaN(NaN)) //true
console.log(isNaN("123")); //false
console.log(isNaN("NaN")); //true
console.log(Number.isNaN(NaN)); //true
console.log(Number.isNaN("123")); //false
console.log(Number.isNaN("NaN")); //false

8.==操作符的強(qiáng)制類型轉(zhuǎn)換規(guī)則

（1）類型相同的話就直接比較；

（2）類型不同的話，會進(jìn)行類型轉(zhuǎn)換；

（3）先判斷是不是null 和 undefined，是的話就返回true；

（4）判斷是否是string 和 number，string --> number；

（5）如果有一方是boolean，那么boolean --> number；

（6）如果一方是object，另一方是string number symbol，把object–> 原始類型。

console.log(NaN == NaN);    //false
console.log(null instanceof Object);   //false 因?yàn)閚ull是原型鏈的頂端了，而instanceof是根據(jù)Object.getPrototypeof()實(shí)現(xiàn)的，找不到他的父類了
console.log(null == null);  //true
console.log(false == "");   //true
console.log(undefined == false);    //false

9.強(qiáng)制轉(zhuǎn)換的規(guī)則

（1）其他值–>字符串：Null、Undefined、Boolean、Number、Symbol都是直接轉(zhuǎn)換為字符串，加上雙引號，對于普通對象來說，一般會用toString()轉(zhuǎn)換為內(nèi)部屬性[[Class]]的值；

（2）其他值–>數(shù)字值：①Undefined類型的值轉(zhuǎn)換為NaN，Null類型轉(zhuǎn)換為0，true為1，false為0，String如果包含非數(shù)字就為NaN，否則為數(shù)字，空字符串為0，Symbol會報錯；

（3）其他值–>布爾值：false值包括（undefined,null,false,+0,-0,NaN,“”）,其他值都是真值。

10.Object.is()與比較操作符===和==的區(qū)別

答：==在進(jìn)行判斷時，如果兩邊類型不一致，會進(jìn)行轉(zhuǎn)換，轉(zhuǎn)換以后再比較；===如果兩邊類型不一致，就不會進(jìn)行強(qiáng)制類型轉(zhuǎn)換，直接返回false；Object.is()一般情況下和三等號相同，但是-0和+0不再相等，兩個NaN是相等的。

到此這篇關(guān)于JavaScript數(shù)據(jù)結(jié)構(gòu)常見面試問題整理的文章就介紹到這了,更多相關(guān)JavaScript數(shù)據(jù)結(jié)構(gòu)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論