摘要：在嚴(yán)格模式下，嘗試這樣做會(huì)引發(fā)錯(cuò)誤。問(wèn)題是在解析數(shù)字之前將其第一個(gè)參數(shù)強(qiáng)制轉(zhuǎn)換為字符串。當(dāng)處理程序完成時(shí)，將檢查隊(duì)列并處理該事件例如，執(zhí)行腳本。當(dāng)值為零作為的第二個(gè)參數(shù)傳遞時(shí)，它將嘗試盡快執(zhí)行指定的函數(shù)。

盡管typeof bar ===“object”是檢查bar是否是對(duì)象的可靠方法，但JavaScript中令人驚訝的問(wèn)題是_null_也被認(rèn)為是一個(gè)對(duì)象！

因此，下面的代碼打印到控制臺(tái)的是true而不是false：

var bar = null;
console.log(typeof bar === "object");  // logs true!

只要知道這一點(diǎn)，就可以通過(guò)檢查bar是否為空來(lái)輕松避免該問(wèn)題：

console.log((bar !== null) && (typeof bar === "object"));  // logs false

為了在我們的答案更加的完整，還有兩件事值得注意：

首先，如果bar是一個(gè)函數(shù)，上面的解決方案將返回false。在大多數(shù)情況下，這是所期望的行為，但是在您希望函數(shù)返回true的情況下，您可以將上述解決方案修改為：

console.log((bar !== null) && ((typeof bar === "object") || (typeof bar === "function")));

其次，如果bar是數(shù)組，則上述解決方案將返回true（例如，如果var bar = [];）。在大多數(shù)情況下，這是所希望的行為，因?yàn)閿?shù)組確實(shí)是對(duì)象，但是在您想要對(duì)數(shù)組也是false的情況下，可以將上述解決方案修改為：

console.log((bar !== null) && (typeof bar === "object") && (toString.call(bar) !== "[object Array]"));

但是，還有一個(gè)替代方法對(duì)空值，數(shù)組和函數(shù)返回false，但對(duì)于對(duì)象則為true：

console.log((bar !== null) && (bar.constructor === Object));

或者，如果您使用jQuery：

console.log((bar !== null) && (typeof bar === "object") && (! $.isArray(bar)));

ES5使得數(shù)組的情況非常簡(jiǎn)單，包括它自己的空檢查：

console.log(Array.isArray(bar));

(function(){
  var a = b = 3;
})();

console.log("a defined? " + (typeof a !== "undefined"));
console.log("b defined? " + (typeof b !== "undefined"));

由于a和b都在函數(shù)的封閉范圍內(nèi)定義，并且由于它們所在的行以var關(guān)鍵字開(kāi)頭，因此大多數(shù)JavaScript開(kāi)發(fā)人員會(huì)希望typeof a和typeof b在上面的示例中都未定義。

但是，情況并非如此。這里的問(wèn)題是大多數(shù)開(kāi)發(fā)人員錯(cuò)誤地理解語(yǔ)句var a = b = 3;以下簡(jiǎn)寫(xiě)為：

var b = 3;
var a = b;

但實(shí)際上，var a = b = 3;其實(shí)是速記：

b = 3;
var a = b;

因此（如果您不使用嚴(yán)格模式），代碼片段的輸出將為：

a defined? false
b defined? true

但是如何在封閉函數(shù)的范圍之外定義b？那么，因?yàn)槁暶鱲ar a = b = 3;是語(yǔ)句b = 3的簡(jiǎn)寫(xiě);并且var a = b; b最終成為一個(gè)全局變量（因?yàn)樗辉趘ar關(guān)鍵字后面），因此它仍然在作用域內(nèi)，即使在封閉函數(shù)之外。

注意，在嚴(yán)格模式下（即，使用strict），語(yǔ)句var a = b = 3;會(huì)產(chǎn)生一個(gè)ReferenceError的運(yùn)行時(shí)錯(cuò)誤：b沒(méi)有定義，從而避免了可能導(dǎo)致的任何頭headfakes/bugs。 （這就是為什么你應(yīng)該在你的代碼中使用strict，一個(gè)重要的例子！）

var myObject = {
    foo: "bar",
    func: function() {
        var self = this;
        console.log("outer func:  this.foo = " + this.foo);
        console.log("outer func:  self.foo = " + self.foo);
        (function() {
            console.log("inner func:  this.foo = " + this.foo);
            console.log("inner func:  self.foo = " + self.foo);
        }());
    }
};
myObject.func();

以上代碼將輸出到控制臺(tái)：

outer func:  this.foo = bar
outer func:  self.foo = bar
inner func:  this.foo = undefined
inner func:  self.foo = bar

在外部函數(shù)中，this和self都引用myObject，因此都可以正確地引用和訪問(wèn)foo。

但在內(nèi)部函數(shù)中，這不再指向myObject。因此，this.foo在內(nèi)部函數(shù)中是未定義的，而對(duì)局部變量self的引用仍然在范圍內(nèi)并且可以在那里訪問(wèn)。

這是一種日益普遍的做法，被許多流行的JavaScript庫(kù)（jQuery，Node.js等）所采用。這種技術(shù)在文件的全部?jī)?nèi)容周圍創(chuàng)建一個(gè)閉包，這可能最重要的是創(chuàng)建一個(gè)私有名稱空間，從而有助于避免不同JavaScript模塊和庫(kù)之間的潛在名稱沖突。

這種技術(shù)的另一個(gè)特點(diǎn)是為全局變量提供一個(gè)容易引用（可能更短）的別名。例如，這通常用于jQuery插件。 jQuery允許您使用jQuery.noConflict（）來(lái)禁用對(duì)jQuery名稱空間的$引用。如果這樣做了，你的代碼仍然可以使用$使用閉包技術(shù)，如下所示：

(function($) { /* jQuery plugin code referencing $ */ } )(jQuery);

這里最簡(jiǎn)單也是最重要的答案是use strict是_一種在運(yùn)行時(shí)自動(dòng)執(zhí)行更嚴(yán)格的JavaScript代碼解析和錯(cuò)誤處理的方法_。如果代碼錯(cuò)誤被忽略或失敗，將會(huì)產(chǎn)生錯(cuò)誤或拋出異常。總的來(lái)說(shuō)，這是一個(gè)很好的做法。

嚴(yán)格模式的一些主要優(yōu)點(diǎn)包括：

使調(diào)試更容易。 如果代碼錯(cuò)誤本來(lái)會(huì)被忽略或失敗，那么現(xiàn)在將會(huì)產(chǎn)生錯(cuò)誤或拋出異常，從而更快地發(fā)現(xiàn)代碼中的問(wèn)題，并更快地指引它們的源代碼。

防止意外全局。 如果沒(méi)有嚴(yán)格模式，將值賦給未聲明的變量會(huì)自動(dòng)創(chuàng)建一個(gè)具有該名稱的全局變量。這是JavaScript中最常見(jiàn)的錯(cuò)誤之一。在嚴(yán)格模式下，嘗試這樣做會(huì)引發(fā)錯(cuò)誤。

消除隱藏威脅。在沒(méi)有嚴(yán)格模式的情況下，對(duì)null或undefined的這個(gè)值的引用會(huì)自動(dòng)強(qiáng)制到全局。這可能會(huì)導(dǎo)致許多_headfakes_和_pull-out-your-hair_類型的錯(cuò)誤。在嚴(yán)格模式下，引用null或undefined的這個(gè)值會(huì)引發(fā)錯(cuò)誤。

不允許重復(fù)的參數(shù)值。 嚴(yán)格模式在檢測(cè)到函數(shù)的重復(fù)命名參數(shù)（例如，函數(shù)foo（val1，val2，val1）{}）時(shí)會(huì)引發(fā)錯(cuò)誤，從而捕獲代碼中幾乎可以肯定存在的錯(cuò)誤，否則您可能會(huì)浪費(fèi)大量的時(shí)間追蹤。

注意：它曾經(jīng)是（在ECMAScript 5中）strict模式將禁止重復(fù)的屬性名稱（例如var object = {foo：“bar”，foo：“baz”};）但是從ECMAScript 2015 開(kāi)始，就不再有這種情況了。

使eval（）更安全。 eval（）在嚴(yán)格模式和非嚴(yán)格模式下的行為方式有些不同。最重要的是，在嚴(yán)格模式下，在eval（）語(yǔ)句內(nèi)部聲明的變量和函數(shù)不會(huì)在包含范圍中創(chuàng)建（它們是以非嚴(yán)格模式在包含范圍中創(chuàng)建的，這也可能是問(wèn)題的常見(jiàn)來(lái)源）。

拋出無(wú)效的使用錯(cuò)誤的刪除符。 刪除操作符（用于從對(duì)象中刪除屬性）不能用于對(duì)象的不可配置屬性。當(dāng)試圖刪除一個(gè)不可配置的屬性時(shí)，非嚴(yán)格代碼將自動(dòng)失敗，而在這種情況下，嚴(yán)格模式會(huì)引發(fā)錯(cuò)誤。

function foo1()
{
  return {
      bar: "hello"
  };
}

function foo2()
{
  return
  {
      bar: "hello"
  };
}

令人驚訝的是，這兩個(gè)函數(shù)不會(huì)返回相同的結(jié)果。而是：

console.log("foo1 returns:");
console.log(foo1());
console.log("foo2 returns:");
console.log(foo2());

會(huì)產(chǎn)生：

foo1 returns:
Object {bar: "hello"}
foo2 returns:
undefined 

這不僅令人驚訝，而且特別令人煩惱的是，foo2（）返回未定義而沒(méi)有引發(fā)任何錯(cuò)誤。

原因與JavaScript中分號(hào)在技術(shù)上是可選的事實(shí)有關(guān)（盡管忽略它們通常是非常糟糕的形式）。因此，在foo2（）中遇到包含return語(yǔ)句的行（沒(méi)有其他內(nèi)容）時(shí)，_會(huì)在return語(yǔ)句之后立即自動(dòng)插入分號(hào)。_

由于代碼的其余部分是完全有效的，即使它沒(méi)有被調(diào)用或做任何事情（它只是一個(gè)未使用的代碼塊，它定義了一個(gè)屬性欄，它等于字符串“hello”），所以不會(huì)拋出任何錯(cuò)誤。

這種行為也被認(rèn)為是遵循了在JavaScript中將一行開(kāi)頭大括號(hào)放在行尾的約定，而不是在新行的開(kāi)頭。如此處所示，這不僅僅是JavaScript中的一種風(fēng)格偏好。

NaN屬性表示“不是數(shù)字”的值。這個(gè)特殊值是由于一個(gè)操作數(shù)是非數(shù)字的（例如“abc”/ 4）或者因?yàn)椴僮鞯慕Y(jié)果是非數(shù)字而無(wú)法執(zhí)行的。

雖然這看起來(lái)很簡(jiǎn)單，但NaN有一些令人驚訝的特征，如果人們沒(méi)有意識(shí)到這些特征，就會(huì)導(dǎo)致bug。

一方面，雖然NaN的意思是“不是數(shù)字”，但它的類型是，數(shù)字：

console.log(typeof NaN === "number");  // logs "true"

此外，NaN相比任何事情 - 甚至本身！ - 是false：

console.log(NaN === NaN);  // logs "false"

測(cè)試數(shù)字是否等于NaN的半可靠方法是使用內(nèi)置函數(shù)isNaN（），但即使使用isNaN（）也不是一個(gè)好的解決方案。.

一個(gè)更好的解決方案要么是使用value！==值，如果該值等于NaN，那么只會(huì)生成true。另外，ES6提供了一個(gè)新的Number.isNaN（）函數(shù) ，它與舊的全局isNaN（）函數(shù)不同，也更加可靠。

console.log(0.1 + 0.2);
console.log(0.1 + 0.2 == 0.3);

對(duì)這個(gè)問(wèn)題的一個(gè)有教養(yǎng)的回答是：“你不能確定。它可能打印出0.3和true，或者可能不打印。 JavaScript中的數(shù)字全部用浮點(diǎn)精度處理，因此可能不會(huì)總是產(chǎn)生預(yù)期的結(jié)果。“

上面提供的示例是演示此問(wèn)題的經(jīng)典案例。令人驚訝的是，它會(huì)打印出來(lái)：

0.30000000000000004
false

一個(gè)典型的解決方案是比較兩個(gè)數(shù)字與特殊常數(shù)Number.EPSILON之間的絕對(duì)差值：

function areTheNumbersAlmostEqual(num1, num2) {
    return Math.abs( num1 - num2 ) < Number.EPSILON;
}
console.log(areTheNumbersAlmostEqual(0.1 + 0.2, 0.3));

討論寫(xiě)函數(shù)的可能方法isInteger（x），它確定x是否是一個(gè)整數(shù)。

這聽(tīng)起來(lái)很平凡，事實(shí)上，ECMAscript 6為此正好引入了一個(gè)新的Number.isInteger（）函數(shù)，這是微不足道的。但是，在ECMAScript 6之前，這有點(diǎn)復(fù)雜，因?yàn)闆](méi)有提供與Number.isInteger（）方法等價(jià)的方法。

問(wèn)題在于，在ECMAScript規(guī)范中，整數(shù)只在概念上存在;即數(shù)值始終作為浮點(diǎn)值存儲(chǔ)。

考慮到這一點(diǎn)，最簡(jiǎn)單，最清潔的ECMAScript-6之前的解決方案（即使將非數(shù)字值（例如字符串或空值）傳遞給該函數(shù)，該解決方案也具有足夠的可靠性以返回false）將成為以下用法按位異或運(yùn)算符：

function isInteger(x) { return (x ^ 0) === x; } 

下面的解決方案也可以工作，盡管不如上面那樣高雅

function isInteger(x) { return Math.round(x) === x; }

請(qǐng)注意，在上面的實(shí)現(xiàn)中Math.ceil（）或Math.floor（）可以同樣使用（而不是Math.round（））。

或者：

function isInteger(x) { return (typeof x === "number") && (x % 1 === 0); }

一個(gè)相當(dāng)常見(jiàn)的不正確的解決方案如下：

function isInteger(x) { return parseInt(x, 10) === x; }

雖然這個(gè)基于parseInt的方法對(duì)許多x值很有效，但一旦x變得相當(dāng)大，它將無(wú)法正常工作。問(wèn)題是parseInt（）在解析數(shù)字之前將其第一個(gè)參數(shù)強(qiáng)制轉(zhuǎn)換為字符串。因此，一旦數(shù)字變得足夠大，其字符串表示將以指數(shù)形式呈現(xiàn)（例如1e + 21）。因此，parseInt（）將嘗試解析1e + 21，但是當(dāng)它到達(dá)e字符時(shí)將停止解析，因此將返回值1.觀察：

> String(1000000000000000000000)
"1e+21"

> parseInt(1000000000000000000000, 10)
1

> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false

(function() {
    console.log(1); 
    setTimeout(function(){console.log(2)}, 1000); 
    setTimeout(function(){console.log(3)}, 0); 
    console.log(4);
})();

這些值將按以下順序記錄：

1
4
3
2

我們先來(lái)解釋一下這些可能更為明顯的部分：

首先顯示1和4，因?yàn)樗鼈兪峭ㄟ^(guò)簡(jiǎn)單調(diào)用console.log（）而沒(méi)有任何延遲記錄的

在3之后顯示，因?yàn)樵谘舆t1000毫秒（即1秒）之后記錄2，而在0毫秒的延遲之后記錄3。

好的。但是，如果在延遲0毫秒后記錄3，這是否意味著它正在被立即記錄？而且，如果是這樣，不應(yīng)該在4之前記錄它，因?yàn)?是由后面的代碼行記錄的嗎？

答案與正確理解JavaScript事件和時(shí)間有關(guān)。 .

瀏覽器有一個(gè)事件循環(huán)，它檢查事件隊(duì)列并處理未決事件。例如，如果在瀏覽器繁忙時(shí)（例如，處理onclick）在后臺(tái)發(fā)生事件（例如腳本onload事件），則該事件被附加到隊(duì)列中。當(dāng)onclick處理程序完成時(shí)，將檢查隊(duì)列并處理該事件（例如，執(zhí)行onload腳本）。

同樣，如果瀏覽器繁忙，setTimeout（）也會(huì)將其引用函數(shù)的執(zhí)行放入事件隊(duì)列中。

當(dāng)值為零作為setTimeout（）的第二個(gè)參數(shù)傳遞時(shí)，它將嘗試“盡快”執(zhí)行指定的函數(shù)。具體來(lái)說(shuō)，函數(shù)的執(zhí)行放置在事件隊(duì)列中，以在下一個(gè)計(jì)時(shí)器滴答時(shí)發(fā)生。但請(qǐng)注意，這不是直接的;該功能不會(huì)執(zhí)行，直到下一個(gè)滴答聲。這就是為什么在上面的例子中，調(diào)用console.log（4）發(fā)生在調(diào)用console.log（3）之前（因?yàn)檎{(diào)用console.log（3）是通過(guò)setTimeout調(diào)用的，所以稍微延遲了一點(diǎn)）。

如果str是回文，以下一行函數(shù)將返回true;否則，它返回false。

function isPalindrome(str) {
  str = str.replace(/W/g, "").toLowerCase();
  return (str == str.split("").reverse().join(""));
}

例如：

console.log(isPalindrome("level"));                   // logs "true"
console.log(isPalindrome("levels"));                  // logs "false"
console.log(isPalindrome("A car, a man, a maraca"));  // logs "true"

console.log(sum(2,3));   // Outputs 5
console.log(sum(2)(3));  // Outputs 5

有（至少）兩種方法可以做到這一點(diǎn)：

METHOD 1

function sum(x) {
  if (arguments.length == 2) {
    return arguments[0] + arguments[1];
  } else {
    return function(y) { return x + y; };
  }
}

在JavaScript中，函數(shù)提供對(duì)參數(shù)對(duì)象的訪問(wèn)，該對(duì)象提供對(duì)傳遞給函數(shù)的實(shí)際參數(shù)的訪問(wèn)。這使我們能夠使用length屬性在運(yùn)行時(shí)確定傳遞給函數(shù)的參數(shù)的數(shù)量

如果傳遞兩個(gè)參數(shù)，我們只需將它們相加并返回。

否則，我們假設(shè)它是以sum（2）（3）的形式被調(diào)用的，所以我們返回一個(gè)匿名函數(shù)，它將傳遞給sum（）（在本例中為2）的參數(shù)和傳遞給匿名函數(shù)的參數(shù)這種情況3）。

METHOD 2

function sum(x, y) {
  if (y !== undefined) {
    return x + y;
  } else {
    return function(y) { return x + y; };
  }
}

當(dāng)函數(shù)被調(diào)用時(shí)，JavaScript不需要參數(shù)的數(shù)量來(lái)匹配函數(shù)定義中參數(shù)的數(shù)量。如果傳遞的參數(shù)數(shù)量超過(guò)了函數(shù)定義中參數(shù)的數(shù)量，則超出的參數(shù)將被忽略。另一方面，如果傳遞的參數(shù)數(shù)量少于函數(shù)定義中的參數(shù)數(shù)量，則在函數(shù)內(nèi)引用時(shí)，缺少的參數(shù)將具有未定義的值。因此，在上面的例子中，通過(guò)簡(jiǎn)單地檢查第二個(gè)參數(shù)是否未定義，我們可以確定函數(shù)被調(diào)用的方式并相應(yīng)地繼續(xù)。

for (var i = 0; i < 5; i++) {
  var btn = document.createElement("button");
  btn.appendChild(document.createTextNode("Button " + i));
  btn.addEventListener("click", function(){ console.log(i); });
  document.body.appendChild(btn);
}

(a) 當(dāng)用戶點(diǎn)擊“按鈕4”時(shí)，什么被記錄到控制臺(tái)？為什么？

(b) 提供一個(gè)或多個(gè)可按預(yù)期工作的替代實(shí)現(xiàn)。

答：

(a) 無(wú)論用戶點(diǎn)擊哪個(gè)按鈕，數(shù)字5將始終記錄到控制臺(tái)。這是因?yàn)椋谡{(diào)用onclick方法（對(duì)于任何按鈕）時(shí)，for循環(huán)已經(jīng)完成，并且變量i已經(jīng)具有值5.（如果受訪者知道足夠的話就可以獲得獎(jiǎng)勵(lì)點(diǎn)數(shù)關(guān)于執(zhí)行上下文，變量對(duì)象，激活對(duì)象和內(nèi)部“范圍”屬性如何影響閉包行為。）

(b) 使這項(xiàng)工作的關(guān)鍵是通過(guò)將它傳遞給新創(chuàng)建的函數(shù)對(duì)象來(lái)捕獲每次通過(guò)for循環(huán)的i的值。以下是四種可能的方法來(lái)實(shí)現(xiàn)這一點(diǎn)：

for (var i = 0; i < 5; i++) {
  var btn = document.createElement("button");
  btn.appendChild(document.createTextNode("Button " + i));
  btn.addEventListener("click", (function(i) {
    return function() { console.log(i); };
  })(i));
  document.body.appendChild(btn);
}

或者，您可以將新的匿名函數(shù)中的整個(gè)調(diào)用包裝為btn.addEventListener：

for (var i = 0; i < 5; i++) {
  var btn = document.createElement("button");
  btn.appendChild(document.createTextNode("Button " + i));
  (function (i) {
    btn.addEventListener("click", function() { console.log(i); });
  })(i);
  document.body.appendChild(btn);
}

或者，我們可以通過(guò)調(diào)用數(shù)組對(duì)象的原生forEach方法來(lái)替換for循環(huán)：

["a", "b", "c", "d", "e"].forEach(function (value, i) {
  var btn = document.createElement("button");
  btn.appendChild(document.createTextNode("Button " + i));
  btn.addEventListener("click", function() { console.log(i); });
  document.body.appendChild(btn);
});

最后，最簡(jiǎn)單的解決方案，如果你在ES6 / ES2015上下文中，就是使用let i而不是var i：

for (let i = 0; i < 5; i++) {
  var btn = document.createElement("button");
  btn.appendChild(document.createTextNode("Button " + i));
  btn.addEventListener("click", function(){ console.log(i); });
  document.body.appendChild(btn);
}

var d = {};

...使用下面的代碼完成了什么？

[ "zebra", "horse" ].forEach(function(k) {
    d[k] = undefined;
});

上面顯示的代碼片段在對(duì)象d上設(shè)置了兩個(gè)屬性。理想情況下，對(duì)具有未設(shè)置鍵的JavaScript對(duì)象執(zhí)行的查找評(píng)估為未定義。但是運(yùn)行這段代碼會(huì)將這些屬性標(biāo)記為對(duì)象的“自己的屬性”。

這是確保對(duì)象具有一組給定屬性的有用策略。將該對(duì)象傳遞給Object.keys將返回一個(gè)包含這些設(shè)置鍵的數(shù)組（即使它們的值未定義）。

var arr1 = "john".split("");
var arr2 = arr1.reverse();
var arr3 = "jones".split("");
arr2.push(arr3);
console.log("array 1: length=" + arr1.length + " last=" + arr1.slice(-1));
console.log("array 2: length=" + arr2.length + " last=" + arr2.slice(-1));

記錄的輸出將是：

"array 1: length=5 last=j,o,n,e,s"
"array 2: length=5 last=j,o,n,e,s"

arr1和arr2是相同的（即["n"，"h"，"o"，"j"，["j"，"o"，"n"，"e"，"s"]]）上述代碼由于以下原因而被執(zhí)行：

調(diào)用數(shù)組對(duì)象的reverse（）方法不僅以相反的順序返回?cái)?shù)組，它還顛倒了數(shù)組本身的順序（即在這種情況下，arr1）。

reverse（）方法返回對(duì)數(shù)組本身的引用（即，在這種情況下為arr1）。因此，arr2僅僅是對(duì)arr1的引用（而不是副本）。因此，當(dāng)對(duì)arr2做任何事情時(shí)（即，當(dāng)我們調(diào)用arr2.push（arr3）;）時(shí)，arr1也會(huì)受到影響，因?yàn)閍rr1和arr2只是對(duì)同一個(gè)對(duì)象的引用。

這里有幾個(gè)觀點(diǎn)可以讓人們回答這個(gè)問(wèn)題：

將數(shù)組傳遞給另一個(gè)數(shù)組的push（）方法會(huì)將整個(gè)數(shù)組作為單個(gè)元素推入數(shù)組的末尾。結(jié)果，聲明arr2.push（arr3）;將arr3作為一個(gè)整體添加到arr2的末尾（即，它不連接兩個(gè)數(shù)組，這就是concat（）方法的用途）。

像Python一樣，JavaScript在調(diào)用像slice（）這樣的數(shù)組方法時(shí)，會(huì)承認(rèn)負(fù)面下標(biāo)，以此作為在數(shù)組末尾引用元素的方式;例如，下標(biāo)-1表示數(shù)組中的最后一個(gè)元素，依此類推。

console.log(1 +  "2" + "2");
console.log(1 +  +"2" + "2");
console.log(1 +  -"1" + "2");
console.log(+"1" +  "1" + "2");
console.log( "A" - "B" + "2");
console.log( "A" - "B" + 2);

以上代碼將輸出到控制臺(tái)：

"122"
"32"
"02"
"112"
"NaN2"
NaN

這是為什么...

這里的基本問(wèn)題是JavaScript（ECMAScript）是一種松散類型的語(yǔ)言，它對(duì)值執(zhí)行自動(dòng)類型轉(zhuǎn)換以適應(yīng)正在執(zhí)行的操作。讓我們來(lái)看看這是如何與上面的每個(gè)例子進(jìn)行比較。

示例1：1 +“2”+“2”輸出：“122”說(shuō)明：第一個(gè)操作在1 +“2”中執(zhí)行。由于其中一個(gè)操作數(shù)（“2”）是一個(gè)字符串，所以JavaScript假定需要執(zhí)行字符串連接，因此將1的類型轉(zhuǎn)換為“1”，1 +“2”轉(zhuǎn)換為“12”。然后，“12”+“2”產(chǎn)生“122”。

示例2：1 + +“2”+“2”輸出：“32”說(shuō)明：根據(jù)操作順序，要執(zhí)行的第一個(gè)操作是+“2”（第一個(gè)“2”之前的額外+被視為一個(gè)一元運(yùn)算符）。因此，JavaScript將“2”的類型轉(zhuǎn)換為數(shù)字，然后將一元+符號(hào)應(yīng)用于它（即將其視為正數(shù)）。結(jié)果，下一個(gè)操作現(xiàn)在是1 + 2，當(dāng)然這會(huì)產(chǎn)生3.但是，我們有一個(gè)數(shù)字和一個(gè)字符串之間的操作（即3和“2”），所以JavaScript再次轉(zhuǎn)換數(shù)值賦給一個(gè)字符串并執(zhí)行字符串連接，產(chǎn)生“32”。

示例3：1 + - “1”+“2”輸出：“02”說(shuō)明：這里的解釋與前面的示例相同，只是一元運(yùn)算符是 - 而不是+。因此，“1”變?yōu)?，然后在應(yīng)用 - 時(shí)將其變?yōu)?1，然后將其加1到產(chǎn)生0，然后轉(zhuǎn)換為字符串并與最終的“2”操作數(shù)連接，產(chǎn)生“02”。

示例4：+“1”+“1”+“2”輸出：“112”說(shuō)明：盡管第一個(gè)“1”操作數(shù)是基于其前面的一元+運(yùn)算符的數(shù)值類型轉(zhuǎn)換的，當(dāng)它與第二個(gè)“1”操作數(shù)連接在一起時(shí)返回一個(gè)字符串，然后與最終的“2”操作數(shù)連接，產(chǎn)生字符串“112”。

示例5：“A” - “B”+“2”輸出：“NaN2”說(shuō)明：由于 - 運(yùn)算符不能應(yīng)用于字符串，并且既不能將“A”也不能將“B”轉(zhuǎn)換為數(shù)值， “ - ”B“產(chǎn)生NaN，然后??與字符串”2“串聯(lián)產(chǎn)生”NaN2“。

例6：“A” - “B”+2輸出：NaN說(shuō)明：在前面的例子中，“A” - “B”產(chǎn)生NaN。但是任何運(yùn)算符應(yīng)用于NaN和其他數(shù)字操作數(shù)仍然會(huì)產(chǎn)生NaN。

var list = readHugeList();

var nextListItem = function() {
    var item = list.pop();

    if (item) {
        // process the list item...
        nextListItem();
    }
};

通過(guò)修改nextListItem函數(shù)可以避免潛在的堆棧溢出，如下所示：

var list = readHugeList();

var nextListItem = function() {
    var item = list.pop();

    if (item) {
        // process the list item...
        setTimeout( nextListItem, 0);
    }
};

堆棧溢出被消除，因?yàn)槭录h(huán)處理遞歸，而不是調(diào)用堆棧。當(dāng)nextListItem運(yùn)行時(shí)，如果item不為null，則將超時(shí)函數(shù)（nextListItem）推送到事件隊(duì)列，并且函數(shù)退出，從而使調(diào)用堆棧清零。當(dāng)事件隊(duì)列運(yùn)行超時(shí)事件時(shí)，將處理下一個(gè)項(xiàng)目，并設(shè)置一個(gè)計(jì)時(shí)器以再次調(diào)用nextListItem。因此，該方法從頭到尾不經(jīng)過(guò)直接遞歸調(diào)用即可處理，因此調(diào)用堆棧保持清晰，無(wú)論迭代次數(shù)如何。

閉包是一個(gè)內(nèi)部函數(shù)，它可以訪問(wèn)外部（封閉）函數(shù)的作用域鏈中的變量。閉包可以訪問(wèn)三個(gè)范圍內(nèi)的變量;具體來(lái)說(shuō)：（1）變量在其自己的范圍內(nèi)，（2）封閉函數(shù)范圍內(nèi)的變量，以及（3）全局變量。

這里是一個(gè)例子：

var globalVar = "xyz";

(function outerFunc(outerArg) {
    var outerVar = "a";
    
    (function innerFunc(innerArg) {
    var innerVar = "b";
    
    console.log(
        "outerArg = " + outerArg + "
" +
        "innerArg = " + innerArg + "
" +
        "outerVar = " + outerVar + "
" +
        "innerVar = " + innerVar + "
" +
        "globalVar = " + globalVar);
    
    })(456);
})(123);

在上面的例子中，innerFunc，outerFunc和全局名稱空間的變量都在innerFunc的范圍內(nèi)。上面的代碼將產(chǎn)生以下輸出：

outerArg = 123
innerArg = 456
outerVar = a
innerVar = b
globalVar = xyz

for (var i = 0; i < 5; i++) {
    setTimeout(function() { console.log(i); }, i * 1000 );
}

解釋你的答案。如何在這里使用閉包？

顯示的代碼示例不會(huì)顯示值0,1,2,3和4，這可能是預(yù)期的;而是顯示5,5,5,5。

這是因?yàn)檠h(huán)內(nèi)執(zhí)行的每個(gè)函數(shù)將在整個(gè)循環(huán)完成后執(zhí)行，因此所有函數(shù)都會(huì)引用存儲(chǔ)在i中的最后一個(gè)值，即5。

通過(guò)為每次迭代創(chuàng)建一個(gè)唯一的作用域 ，可以使用閉包來(lái)防止這個(gè)問(wèn)題，并將該變量的每個(gè)唯一值存儲(chǔ)在其作用域中，如下所示：

for (var i = 0; i < 5; i++) {
    (function(x) {
        setTimeout(function() { console.log(x); }, x * 1000 );
    })(i);
}

這會(huì)產(chǎn)生將0,1,2,3和4記錄到控制臺(tái)的可能結(jié)果。

在ES2015上下文中，您可以在原始代碼中簡(jiǎn)單地使用let而不是var：

for (let i = 0; i < 5; i++) {
    setTimeout(function() { console.log(i); }, i * 1000 );
}

console.log("0 || 1 = "+(0 || 1));
console.log("1 || 2 = "+(1 || 2));
console.log("0 && 1 = "+(0 && 1));
console.log("1 && 2 = "+(1 && 2));

解釋你的答案。

該代碼將輸出以下四行：

0 || 1 = 1
1 || 2 = 1
0 && 1 = 0
1 && 2 = 2

在JavaScript中，都是||和&&是邏輯運(yùn)算符，當(dāng)從左向右計(jì)算時(shí)返回第一個(gè)完全確定的“邏輯值”。

或（||）運(yùn)算符。在形式為X || Y的表達(dá)式中，首先計(jì)算X并將其解釋為布爾值。如果此布爾值為真，則返回true（1），并且不計(jì)算Y，因?yàn)椤盎颉睏l件已經(jīng)滿足。但是，如果此布爾值為“假”，我們?nèi)匀徊恢繶 || Y是真還是假，直到我們?cè)u(píng)估Y，并將其解釋為布爾值。

因此，0 || 1評(píng)估為真（1），正如1 || 2。

和（&&）運(yùn)算符。在X && Y形式的表達(dá)式中，首先評(píng)估X并將其解釋為布爾值。如果此布爾值為false，則返回false（0）并且不評(píng)估Y，因?yàn)椤癮nd”條件已失敗。但是，如果這個(gè)布爾值為“真”，我們?nèi)匀徊恢繶 && Y是真還是假，直到我們?cè)u(píng)估Y，并將其解釋為布爾值。

然而，&&運(yùn)算符的有趣之處在于，當(dāng)表達(dá)式評(píng)估為“真”時(shí)，則返回表達(dá)式本身。這很好，因?yàn)樗谶壿嫳磉_(dá)式中被視為“真”，但也可以用于在您關(guān)心時(shí)返回該值。這解釋了為什么，有點(diǎn)令人驚訝的是，1 && 2返回2（而你可能會(huì)期望它返回true或1）。

console.log(false == "0")
console.log(false === "0")

該代碼將輸出：

true
false

在JavaScript中，有兩套相等運(yùn)算符。三重相等運(yùn)算符===的行為與任何傳統(tǒng)的相等運(yùn)算符相同：如果兩側(cè)的兩個(gè)表達(dá)式具有相同的類型和相同的值，則計(jì)算結(jié)果為true。然而，雙等號(hào)運(yùn)算符在比較它們之前試圖強(qiáng)制這些值。因此，通常使用===而不是==。對(duì)于！== vs！=也是如此。

var a={},
    b={key:"b"},
    c={key:"c"};

a[b]=123;
a[c]=456;

console.log(a[b]);

此代碼的輸出將是456（不是123）。

原因如下：設(shè)置對(duì)象屬性時(shí)，JavaScript會(huì)隱式地將參數(shù)值串聯(lián)起來(lái)。在這種情況下，由于b和c都是對(duì)象，它們都將被轉(zhuǎn)換為“[object Object]”。因此，a [b]和a [c]都等價(jià)于[“[object Object]”]，并且可以互換使用。因此，設(shè)置或引用[c]與設(shè)置或引用[b]完全相同。

console.log((function f(n){return ((n > 1) ? n * f(n-1) : n)})(10));

該代碼將輸出10階乘的值（即10！或3,628,800）。

原因如下：

命名函數(shù)f（）以遞歸方式調(diào)用自身，直到它調(diào)用f（1），它簡(jiǎn)單地返回1.因此，這就是它的作用：

f(1): returns n, which is 1
f(2): returns 2 * f(1), which is 2
f(3): returns 3 * f(2), which is 6
f(4): returns 4 * f(3), which is 24
f(5): returns 5 * f(4), which is 120
f(6): returns 6 * f(5), which is 720
f(7): returns 7 * f(6), which is 5040
f(8): returns 8 * f(7), which is 40320
f(9): returns 9 * f(8), which is 362880
f(10): returns 10 * f(9), which is 3628800

(function(x) {
    return (function(y) {
        console.log(x);
    })(2)
})(1);

輸出將為1，即使x的值從未在內(nèi)部函數(shù)中設(shè)置。原因如下：

正如我們的JavaScript招聘指南中所解釋的，閉包是一個(gè)函數(shù)，以及創(chuàng)建閉包時(shí)在范圍內(nèi)的所有變量或函數(shù)。在JavaScript中，閉包被實(shí)現(xiàn)為“內(nèi)部函數(shù)”;即在另一功能的主體內(nèi)定義的功能。閉包的一個(gè)重要特征是內(nèi)部函數(shù)仍然可以訪問(wèn)外部函數(shù)的變量。

因此，在這個(gè)例子中，因?yàn)閤沒(méi)有在內(nèi)部函數(shù)中定義，所以在外部函數(shù)的作用域中搜索一個(gè)定義的變量x，該變量的值為1。

var hero = {
    _name: "John Doe",
    getSecretIdentity: function (){
        return this._name;
    }
};

var stoleSecretIdentity = hero.getSecretIdentity;

console.log(stoleSecretIdentity());
console.log(hero.getSecretIdentity());

這段代碼有什么問(wèn)題，以及如何解決這個(gè)問(wèn)題。

該代碼將輸出：

undefined
John Doe

第一個(gè)console.log打印未定義，因?yàn)槲覀儚膆ero對(duì)象中提取方法，所以stoleSecretIdentity（）在_name屬性不存在的全局上下文（即窗口對(duì)象）中被調(diào)用。

修復(fù)stoleSecretIdentity（）函數(shù)的一種方法如下：

var stoleSecretIdentity = hero.getSecretIdentity.bind(hero);

該函數(shù)的參數(shù)應(yīng)該是：

一個(gè) DOM 元素

一個(gè)回調(diào)函數(shù)（以DOM元素作為參數(shù)）

訪問(wèn)樹(shù)中的所有元素（DOM）是[經(jīng)典的深度優(yōu)先搜索算法]Depth-First-Search algorithm應(yīng)用程序。以下是一個(gè)示例解決方案：

function Traverse(p_element,p_callback) {
   p_callback(p_element);
   var list = p_element.children;
   for (var i = 0; i < list.length; i++) {
       Traverse(list[i],p_callback);  // recursive call
   }
}

var length = 10;
function fn() {
    console.log(this.length);
}

var obj = {
  length: 5,
  method: function(fn) {
    fn();
    arguments[0]();
  }
};

obj.method(fn, 1);

輸出：

10
2

為什么不是10和5？

首先，由于fn作為函數(shù)方法的參數(shù)傳遞，函數(shù)fn的作用域（this）是窗口。 var length = 10;在窗口級(jí)別聲明。它也可以作為window.length或length或this.length來(lái)訪問(wèn)（當(dāng)這個(gè)===窗口時(shí)）。

方法綁定到Object obj，obj.method用參數(shù)fn和1調(diào)用。雖然方法只接受一個(gè)參數(shù)，但調(diào)用它時(shí)已經(jīng)傳遞了兩個(gè)參數(shù);第一個(gè)是函數(shù)回調(diào)，其他只是一個(gè)數(shù)字。

當(dāng)在內(nèi)部方法中調(diào)用fn（）時(shí)，該函數(shù)在全局級(jí)別作為參數(shù)傳遞，this.length將有權(quán)訪問(wèn)在Object obj中定義的var length = 10（全局聲明）而不是length = 5。

現(xiàn)在，我們知道我們可以使用arguments []數(shù)組訪問(wèn)JavaScript函數(shù)中的任意數(shù)量的參數(shù)。

因此arguments0只不過(guò)是調(diào)用fn（）。在fn里面，這個(gè)函數(shù)的作用域成為參數(shù)數(shù)組，并且記錄參數(shù)[]的長(zhǎng)度將返回2。

因此輸出將如上所述。

(function () {
    try {
        throw new Error();
    } catch (x) {
        var x = 1, y = 2;
        console.log(x);
    }
    console.log(x);
    console.log(y);
})();

1
undefined
2

var語(yǔ)句被掛起（沒(méi)有它們的值初始化）到它所屬的全局或函數(shù)作用域的頂部，即使它位于with或catch塊內(nèi)。但是，錯(cuò)誤的標(biāo)識(shí)符只在catch塊內(nèi)部可見(jiàn)。它相當(dāng)于：

(function () {
    var x, y; // outer and hoisted
    try {
        throw new Error();
    } catch (x /* inner */) {
        x = 1; // inner x, not the outer one
        y = 2; // there is only one y, which is in the outer scope
        console.log(x /* inner */);
    }
    console.log(x);
    console.log(y);
})();

var x = 21;
var girl = function () {
    console.log(x);
    var x = 20;
};
girl ();

21，也不是20，結(jié)果是‘undefined’的

這是因?yàn)镴avaScript初始化沒(méi)有被掛起。

（為什么它不顯示21的全局值？原因是當(dāng)函數(shù)執(zhí)行時(shí)，它檢查是否存在本地x變量但尚未聲明它，因此它不會(huì)查找全局變量。 ）

var obj = {a: 1 ,b: 2}
var objclone = Object.assign({},obj);

現(xiàn)在objclone的值是{a：1，b：2}，但指向與obj不同的對(duì)象。

但請(qǐng)注意潛在的缺陷：Object.clone（）只會(huì)執(zhí)行淺拷貝，而不是深拷貝。這意味著嵌套的對(duì)象不會(huì)被復(fù)制。他們?nèi)匀灰门c原始相同的嵌套對(duì)象：

let obj = {
    a: 1,
    b: 2,
    c: {
        age: 30
    }
};

var objclone = Object.assign({},obj);
console.log("objclone: ", objclone);

obj.c.age = 45;
console.log("After Change - obj: ", obj);           // 45 - This also changes
console.log("After Change - objclone: ", objclone); // 45

for (let i = 0; i < 5; i++) {
  setTimeout(function() { console.log(i); }, i * 1000 );
}

for (let i = 0; i < 5; i++) {
    setTimeout(function() { console.log(i); }, i * 1000 );
}

它會(huì)打印0 1 2 3 4，因?yàn)槲覀冊(cè)谶@里使用let而不是var。變量i只能在for循環(huán)的塊范圍中看到。

console.log(1 < 2 < 3);
console.log(3 > 2 > 1);

第一條語(yǔ)句返回true，如預(yù)期的那樣。

第二個(gè)返回false是因?yàn)橐嫒绾吾槍?duì)<和>的操作符關(guān)聯(lián)性工作。它比較從左到右，所以3> 2> 1 JavaScript翻譯為true> 1. true具有值1，因此它比較1> 1，這是錯(cuò)誤的。

var myArray = ["a", "b", "c", "d"];
myArray.push("end");
myArray.unshift("start");
console.log(myArray); // ["start", "a", "b", "c", "d", "end"]

使用ES6，可以使用擴(kuò)展運(yùn)算符：

myArray = ["start", ...myArray];
myArray = [...myArray, "end"];

或者，簡(jiǎn)而言之：

myArray = ["start", ...myArray, "end"];

var a = [1, 2, 3];

a）這會(huì)導(dǎo)致崩潰嗎？

a[10] = 99;

b）這個(gè)輸出是什么？

console.log(a[6]);

a）它不會(huì)崩潰。 JavaScript引擎將使陣列插槽3至9成為“空插槽”。

b）在這里，a [6]將輸出未定義的值，但時(shí)隙仍為空，而不是未定義的。在某些情況下，這可能是一個(gè)重要的細(xì)微差別。例如，使用map（）時(shí)，map（）的輸出中的空插槽將保持為空，但未定義的插槽將使用傳遞給它的函數(shù)重映射：

var b = [undefined];
b[2] = 1;
console.log(b);             // (3) [undefined, empty × 1, 1]
console.log(b.map(e => 7)); // (3) [7,         empty × 1, 7]

該表達(dá)式將被評(píng)估為true，因?yàn)镹ULL將被視為任何其他未定義的變量。

注意：JavaScript區(qū)分大小寫(xiě)，我們?cè)谶@里使用NULL而不是null。

console.log(typeof typeof 1);

string

typeof 1將返回“number”，typeof“number”將返回字符串。

var b = 1;
function outer(){
       var b = 2
    function inner(){
        b++;
        var b = 3;
        console.log(b)
    }
    inner();
}
outer();

輸出到控制臺(tái)將是“3”。

在這個(gè)例子中有三個(gè)閉包，每個(gè)都有它自己的var b聲明。當(dāng)調(diào)用變量時(shí)，將按照從本地到全局的順序檢查閉包，直到找到實(shí)例。由于內(nèi)部閉包有自己的b變量，這就是輸出。

此外，由于提升內(nèi)部的代碼將被解釋如下：

function inner () {
    var b; // b is undefined
    b++; // b is NaN
    b = 3; // b is 3
    console.log(b); // output "3"
}

面試比棘手的技術(shù)問(wèn)題要多，所以這些僅僅是作為指導(dǎo)。并不是每個(gè)值得聘用的“A”候選人都能夠回答所有問(wèn)題，也不會(huì)回答他們都保證有“A”候選人。在這一天結(jié)束時(shí)，招聘仍然是一門(mén)藝術(shù)，一門(mén)科學(xué) - 還有很多工作。.

英文原文地址：https://www.toptal.com/javasc...