JS 面試題總結

2023年1月14日 127次阅读来源: 我們不動

請詮釋事宜代辦 (event delegation)

事宜託付手藝能讓你防備對特定的每一個節點增添事宜監聽器；相反，事宜監聽器是被增添到它們的父元素上。事宜監聽器會剖析從子元素冒泡上來的事宜，找到是哪個子元素的事宜。

長處：

機能獲得了優化（須要建立的以及駐留在內存中的事宜處置懲罰器少了）
動態增添的元素也能綁定事宜了

請詮釋 JavaScript 中 this 是如何事情的

this 永久指向函數運轉時地點的對象，而不是函數被建立時地點的對象。

函數挪用es3和非嚴厲es5為全局對象，嚴厲es5為undefined
要領挪用this指向挪用該要領的對象（挪用高低文）
構造函數時，this指向新建立的對象
call() apply() 挪用要領時，this指向挪用要領的對象，而不是該要領具有者對象

請詮釋原型繼承 (prototypal inheritance) 的道理？

原型繼承的基本是原型鏈查找。

原型鏈查找基本觀點：
每一個函數 F 都有一個原型對象（prototype）F.prototype
每一個函數都可以經由歷程 new 癥結字化身成為一個類構造函數，new F 會發作一個對象 O
在挪用對象的某個屬性或許要領，比方 http://O.xxx 的時刻，會起首查找對象自身是不是有這個要領或許屬性，如果沒找到就會去對象的構造函數的原型對象中查找（注重有兩個定語），也就是查找 O 的構造函數 F 的原型對象 http://F.prototype.xxx
F.prototype 也是一個對象，查找 http://F.prototype.xxx 的時刻會反覆第 3 步的歷程

請詮釋為什麼接下來這段代碼不是 IIFE (馬上挪用的函數表達式)：function foo(){ }();要做哪些修正使它變成 IIFE?

　這裏只是聲明一個叫foo的function，直接用()執行如許是不成功的，想要變成IIFE就要把聲明變成表達式，就可以馬上執行了，可以如許(function foo(){})()或許(function foo(){}())，這就是用括號把定義強轉成表達式，固然另有其他要領，癥結就是聲明不可以執行，表達式才可以執行。

形貌以下變量的區分：null，undefined 或 undeclared？該如何檢測它們？

undefined:未定義，在變量沒有賦值的時刻的值即為undefined。“缺乏值”，就是此處應當有一個值，然則還沒有定義。
underclared:即為被污染的定名，接見沒有被聲明的變量，會拋出異常，住手執行。嘗試接見一個undeclared的變量，瀏覽器會報錯，JS執行會中綴。
null:是一個空的對象援用。“沒有對象”，即該處不該該有值

區分:
undefined和null在if語句中，都邑被自動轉為false，相稱運算符以至直接報告二者相稱。typeof undefined會返回undefined ，而typeof null 總返回 object(typeof有六種可以：“number”、“string”、“boolean”、“object”、“function”、“undefined”)

false == undefined;//false
false == null;//false
null == undefined;//true

該如何檢測它們？

var obj;
obj ===undefined; //檢測undfined 要領一
typeof obj === ‘undefined’;//檢測undefined要領2
obj = null;
obj === null;//來檢測null
typeof null;//‘object’

什麼是閉包 (closure)，如何運用它，為什麼要運用它？

定義：閉包就是可以讀取到其他函數內部變量的函數。
閉包的用處：

可以讀取函數內部的變量。(外界沒法接見函數的內部的私有要領和變量，只能經由歷程供應的接口接見)
讓變量的值一直堅持在內存中。
可以防備污染全局變量，完成私有要領或許變量等

注重：

由於閉包會使得函數中的變量都被保存在內存中，內存斲喪很大，所以不能濫用閉包，不然會形成網頁的機能題目，在IE中可以致使內存泄漏。處理要領是，在退出函數之前，將不運用的部份變量悉數刪除。
閉包會在父函數外部，轉變父函數內部變量的值。所以，如果你把父函數看成對象（object）運用，把閉包看成它的公用要領（Public Method），把內部變量看成它的私有屬性（private value），這時候肯定要警惕，不要隨意轉變父函數內部變量的值。

請舉出一個匿名函數的典範用例？

匿名函數可以用作回調函數執行，可以防備全局變量污染。
在 JS 框架中常運用匿名函數來防備全局變量的污染。
$.(“input”).each(function(e){this.val(‘OK’)});
(function(){})();
$(document).ready(function(){ });
$(function() {})

你是如何構造自身的代碼？是運用模塊情勢，照樣運用典範繼承的要領？

請指出 JavaScript 宿主對象 (host objects) 和原生對象 (native objects) 的區分？

原生對象:獨立於宿主環境的 ECMAScript 完成供應的對象。為array obj regexp date function等可以new實例化的對象。

內置對象:為gload Math 等，開闢者沒必要明白實例化內置對象，它已被實例化了。相似於isNaN()、parseInt()和parseFloat()要領等，看起來都是函數，而實際上，它們都是Global對象的要領。詳細可以參考 JavaScript 全局對象

宿主對象:即由 ECMAScript 完成的宿主環境（支配系統和瀏覽器）供應的對象。一切的BOM和DOM對象都是宿主對象。由於其關於差別的“宿主”環境所展現的內容差別（這就是兼容性和特性檢測的啟事）。ECMAScript官方未定義的對象都屬於宿主對象。

請指出以下代碼的區分：function Person(){}、var person = Person()、var person = new Person()？

第一個為函數聲明，第二個將函數person()返回值賦值給person,第三個經由歷程Person()的構造器建立了一個對象讓person變量援用該對象；

.call 和 .apply 的區分是什麼？

call和apply都是挪用一個對象的一個要領，以另一個對象替換當前對象。它們都屬於Function.prototype的一個要領，所以每一個function實例都有call和apply屬性。這兩個要領可以用來替換另一個對象挪用一個要領，可將一個函數的對象高低文從初始的高低文轉變成由 thisObj 指定的新對象。

區分:
二者通報的參數差別，雖然函數第一個參數都是要傳入給當前對象的對象，然則，apply的第二個參數是一個參數數組，將多個參數組合成為一個數組傳入；而call第二個參數則是直接的參數列表。

請詮釋 Function.prototype.bind？

Function.prototype.bind()實在就是函數綁定。函數的接收者取決於他是如何被挪用，可以經由歷程挪用.bind()給函數綁定作用域高低文（this的值），即函數的接收者。

var foo = { x: 3} 
var bar = function(){console.log(    this.x);}

bar(); // undefinedvar
boundFunc = bar.bind(foo);//隱式看做是在foo作用域里挪用bar要領
boundFunc(); // 3

.bind()建立了一個函數，當這個函數在被挪用的時刻，它的 this 癥結詞會被設置成被傳入的值（這裏指挪用bind()時傳入的參數）也就是我們傳入想要的高低文。簡樸的用法：關於 Function.prototype.bind() 內部，這裡有個異常簡樸的例子：

Function.prototype.bind = function (scope) {
    var fn = this;
    return function () {
        return fn.apply(scope);//運用call效果一樣
    };
}

在什麼時刻你會運用 document.write()？

document.write()要領可以用在兩個方面：

頁面載入歷程頂用及時劇本建立頁面內容，該要領須要一個字符串參數，它是寫到窗口或框架中的HTML內容。
以及用延時劇本建立本窗口或新窗口的內容。該要領須要一個字符串參數，它是寫到窗口或框架中的HTML內容。

記着，在載入頁面后，瀏覽器輸出流自動關閉。在此以後，任何一個對當前頁面舉行支配的document.write()要領將翻開—個新的輸出流，它將消滅當前頁面內容(包括源文檔的任何變量或值)。因而，如果願望用劇本天生的HTML替換當前頁面，就必需把HTML內容銜接起來賦給一個變量，運用一個document.write()要領完成寫支配。沒必要消滅文檔並翻開一個新數據流，一個document.write()挪用便可完成一切的支配。

關於document.write()要領另有一點要申明的是它的相干要領document.close()。劇本向窗口(不論是本窗口或其他窗口)寫完內容后，必需關閉輸出流。在延時劇本的末了一個document.write()要領背面，必需確保含有document.close()要領，不如許做就不能顯現圖象和表單。而且，任何背面挪用的document.write()要領只會把內容追加到頁面后，而不會消滅現有內容來寫入新值。為了演示document.write()要領，我們供應了同一個運用遞次的兩個版本。

大多數天生的廣告代碼照舊運用 document.write()，雖然這類用法會讓人很不爽。

請指出瀏覽器特性檢測，特性揣摸和瀏覽器 UA 字符串嗅探的區分？

檢測瀏覽器的特別稱號和版本（用戶代辦檢測）即瀏覽器UA字符串嗅探。瀏覽器嗅探手藝可以快速的將代碼舉行分支，以便針對差別的瀏覽器運用差別的指令；針對特定瀏覽器的特定版本，超出局限以外都是不牢靠的

請只管詳實的詮釋 Ajax 的事情道理？

運用 Ajax 都有哪些好壞？

上風：可以革新部份頁面，而不必團體頁面都革新
瑕玷：用戶禁用javascript的狀況

請詮釋 JSONP 的事情道理，以及它為什麼不是真正的 Ajax。

事情道理:JSONP動態建立script標籤，回調函數。Ajax是頁面無革新請求數據支配，動態增添一個&ltscript>標籤，而script標籤的src屬性是沒有跨域的限定的。如許說來，這類跨域體式格局實在與ajax XmlHttpRequest協定無關了。
當GET請求從被挪用頁面返回時，可以返回一段JavaScript代碼，這段代碼會自動挪用主頁面中的一個callback函數。

長處:不受同源戰略的影響，它的兼容性更好，在越發陳舊的瀏覽器中都可以運轉，不須要XMLHttpRequest或ActiveX的支撐；而且在請求終了后可以經由歷程挪用callback的體式格局回傳效果　　
瑕玷:只支撐GET請求而不支撐POST等別的範例的HTTP請求；它只支撐跨域HTTP請求這類狀況，不能處理差別域的兩個頁面之間如何舉行JavaScript挪用的題目。

請詮釋變量聲明提拔 (hoisting)

在JavaScript代碼運轉之前實際上是有一個編譯階段的。編譯以後才是從上到下，一行一行詮釋執行。變量提拔就發作在編譯階段，它把變量和函數的聲明提拔至作用域的頂端。（編譯階段的事情之一就是將變量與其作用域舉行關聯）。

變量提拔鬚要注重兩點：

提拔的部份只是變量聲明，賦值語句和可執行的代碼邏輯還堅持在原地不動
提拔只是將變量聲明提拔到變量地點的變量局限的頂端，並不是提拔到全局局限

函數聲明：

變量聲明和函數聲明都邑獲得變量提拔，但函數聲明會最早獲得提拔，然後是變量聲明（函數是一等國民）
關於函數聲明來講，如果定義了雷同的函數變量聲明，后定義的聲明會掩蓋掉先前的聲明

請形貌事宜冒泡機制 (event bubbling)

從目標元素最先，往頂層元素流傳。途中如果有節點綁定了相應的事宜處置懲罰函數，這些函數都邑被順次觸發。如果想阻撓事宜起泡，可以運用e.stopPropagation()（Firefox）或許e.cancelBubble=true（IE）來構造事宜的冒泡流傳

“attribute” 和 “property” 的區分是什麼？

DOM元素的attribute和property二者是差別的東西。attribute翻譯為“特性”，property翻譯為“屬性”。

attribute是一個特性節點，每一個DOM元素都有一個對應的attributes屬性來寄存一切的attribute節點，attributes是一個類數組的容器，說得正確點就是NameNodeMap，不繼承於Array.prototype，不能直接挪用Array的要領。attributes的每一個数字索引以名值對(name=”value”)的情勢寄存了一個attribute節點。

property就是一個屬性，如果把DOM元素看成是一個一般的Object對象，那末property就是一個以名值對(name=”value”)的情勢寄存在Object中的屬性。要增添和刪除property和一般的對象相似。

很多attribute節點另有一個相對應的property屬性，比方上面的div元素的id和class既是attribute，也有對應的property，不論運用哪一種要領都可以接見和修正。

總之，attribute節點都是在HTML代碼中可見的，而property只是一個一般的名值對屬性

為什麼擴大 JavaScript 內置對象不是好的做法？

由於你不曉得哪一天瀏覽器或javascript自身就會完成這個要領，而且和你擴大的完成有不一致的表現。到時刻你的javascript代碼可以已在無數個頁面中執行了數年，而瀏覽器的完成致使一切運用擴大原型的代碼都崩潰了。

須要給Array原型增添一個distinct的要領，最好搜檢是不是存在同名的要領，防備自定義要領掩蓋原生要領：

Arrray.prototype.distinct = Arrray.prototype.distinct || function(){/…../}

請指出 document load 和 document DOMContentLoaded 兩個事宜的區分。

ready 示意文檔的 DOM 已加載完成（不包括圖片、視頻等資本）；load 示意全部網頁加載完成。可以看出，ready 事宜發作在 load 事宜之前。

== 和 === 有什麼差別？

如果雙方的支配數具有一致的範例且具有雷同的值時，=== 返回 true，!== 返回 false。

請詮釋 JavaScript 的同源戰略 (same-origin policy)。

同源戰略限定了一個源（origin）中加載文本或劇本與來自別的源（origin）中資本的交互體式格局。

同源戰略出於平安，不許可源 A 的劇本讀取（read）源 B 的資本的內容，但卻許可執行（execute）源 B 的資本。這個觀點也有些拗口。簡樸說，有一個頁面挪用了 Google CDN 供應的 jQuery，以及別的 CDN 上的 Bootstrap JS、CSS 代碼，雖然它們與我的博客差別源，但我可以用它們來支配這個頁面，並運用款式，這是執行的觀點。

如何完成以下代碼：[1,2,3,4,5].duplicator(); // [1,2,3,4,5,1,2,3,4,5]

將此要領增添至 Array.prototype 完成，代碼以下：

Array.prototype.duplicator = function(){
　　var l = this.length,i;
    　　for(i=0;i<l;i++){
    　　　this.push(this[i])　
       }
}

什麼是三元表達式 (Ternary expression)？“三元 (Ternary)” 示意什麼意義？

一個運算符如果有一個支配數，為一元運算符，兩個為二元，三個為三元運算符，三元表達式則為一個三元運算表達式！

什麼是 “use strict”; ? 運用它的優點和害處離別是什麼？

ECMAScript5中引入的嚴厲情勢,經由歷程讓JavaScript運轉環境對一些開闢歷程中最罕見和不輕易發明的毛病做出和當前差別的處置懲罰,來讓開闢者具有一個”更好”的JavaScript言語。

優點：

消弭Javascript語法的一些不合理、不嚴謹的處所，削減一些奇異行動;
消弭代碼運轉的一些不平安的處所，保證代碼運轉的平安；
進步編譯器效力，增添運轉速率；
為將來新版本的Javascript做好鋪墊。

優點詳細表現：

去除WITH癥結詞
防備不測為全局變量賦值
函數中的THIS不再默許指向全局
防備重名
平安的 EVAL()
對只讀屬性修正時拋出異常

害處：一樣的代碼，在“嚴厲情勢”中，可以會有不一樣的運轉效果；一些在“一般情勢”下可以運轉的語句，在“嚴厲情勢”下將不能運轉

總結：啟用JavaScript嚴厲情勢,它能幫你發明代碼中不曾注重到的毛病。不要在全局環境中啟用,但你能只管多的運用IIFE(馬上執行函數表達式)來把嚴厲情勢作用到多個函數局限內。一最先,你會遇到之前不曾遇到過的毛病提示,這是一般的。當啟用嚴厲情勢后,請確保在支撐的瀏覽器中做了測試,以發明新的潛伏題目。肯定不要僅僅在代碼中增添一行”use strict”就假定餘下的代碼能一般事情。

請完成一個遍歷至 100 的 for loop 輪迴，在能被 3 整除時輸出 “fizz”，在能被 5 整除時輸出 “buzz”，在能同時被 3 和 5 整除時輸出 “fizzbuzz”。

for (var i = 1; i <= 30; i++) {

    if (i % 3 === 0) {
        if (i % 5 === 0) {
            alert('fizzbuzz' + i);
            continue;
        }
        alert('fizz' + i);
        continue;
    } else if (i % 5 === 0) {
        if (i % 3 === 0) {
            alert('fizzbuzz' + i);
            continue;
        }
        alert('buzz' + i);
        continue;
    }
}

為什麼一般會認為保存網站現有的全局作用域 (global scope) 不去轉變它，是較好的挑選？

它的意義是: 只管少在全局作用域定義變量。

目標:削減稱號爭執利於模塊化

為什麼你會運用 load 之類的事宜 (event)？此事宜有瑕玷嗎？你是不是曉得其他替換品，以及為什麼運用它們？

要比及等頁面完整加載后(一切圖象、javascript文件、CSS等外部文件)。替換：把script標籤放到末了面。

請詮釋什麼是單頁運用 (single page app), 以及如何使其對搜刮引擎友愛 (SEO-friendly)。

單頁運用是一種特別的web運用，它將一切的運動局限於一個web頁面中，僅在該Web頁面初始化時加載相應的HTML、JavaScript 和 CSS。

長處：

用戶體驗：關於內容的修正不須要加載全部頁面
高效：效勞器壓力很小，斲喪更少的帶寬，可以與面向效勞的架構更好地連繫。
典範MVC開闢情勢，前後端各負其責。
一套Server API，多端運用（web、挪動APP等）
重前端，營業邏輯悉數在當地支配，數據都須要經由歷程AJAX同步、提交

瑕玷：

不利於SEO：處理計劃也有一些：H5pushState,經由歷程瀏覽器歷史記錄讓搜刮引擎抓取；url中#！
龐雜的單頁架構頁面，對Google來講抓取比較難題，因而給開闢者制訂一個範例：
1）、網站提交sitemap給Google；
2）、Google發明URL里有#!標記，比方example.com/#!/detail/1，因而Google最先抓取example.com/?_escaped_fragment_=/detail/1；_escaped_fragment_這個參數是Google指定的定名，如果開闢者願望把網站內容提交給Google，就必需經由歷程這個參數天生靜態頁面。
首屏襯着速率慢

運用 Promises 而非回調 (callbacks) 優瑕玷是什麼？

長處：易讀性改良

運用一種可以編譯成 JavaScript 的言語來寫 JavaScript 代碼有哪些優瑕玷？

以Typescript為例子：
typescript是javascript的強範例版本，在編譯期去掉範例和特有語法，天生地道的javascript代碼。TypeScript 是 JavaScript 的超集，這意味着他支撐一切的 JavaScript 語法。並在此之上對 JavaScript 增添了一些擴大，如 class / interface / module 等。如許會大大提拔代碼的可瀏覽性。

長處：

靜態範例搜檢
IDE 智能提示（編譯階段即可發明範例不婚配的毛病）
代碼重構
可讀性

瑕玷：

不指定範例就寫不了遞次，範例只是輔佐信息，並不是遞次的本以後
天真性題目

你運用哪些東西和手藝來調試 JavaScript 代碼？

alert
console.log
斷點調試（這三種調試體式格局都是打斷點）
js斷點調試
source斷點調試
Debugger斷點（詳細的說就是經由歷程在代碼中增添”debugger;”語句，當代碼執行到該語句的時刻就會自動斷點。）
DOM斷點調試
當節點內部子節點變化時斷點
當節點屬性發作變化時斷點
當節點被移除時斷點

請詮釋可變 (mutable) 和穩定 (immutable) 對象的區分？

javascript中的原始值（undefined、null、布爾值、数字和字符串）與對象（包括數組和函數）有着基礎區分。原始值是不可變動的：任何要領都沒法變動（或“突變”）一個原始值。對数字和布爾值來講顯著云云—-轉變数字的值自身就說不通，而對字符串來講就不那末顯著了，由於字符串看起來像由字符構成的數組，我們希冀可以經由歷程指定索引來假改字符串中的字符。實際上，javascript是制止如許做的。字符串中一切的要領看上去返回了一個修正後的字符串，實際上返回的是一個新的字符串值。

區分:

可變性：對象和原始值差別，起首，它們是可變的–它們的值是可修正的
值的比較：對象的比較並不是值的比較：縱然兩個對象包括一樣的屬性及雷同的值，它們也是不相稱的。各個索引元素相稱的兩個數組也不相稱。

穩定性 (immutability) 有哪些優瑕玷？

長處：
*由於不能修正一個穩定對象的狀況，所以可以防備由此引發的沒必要要的遞次毛病；一個穩定的對象要比一個可變的對象越發輕易保護。

由於沒有任何一個線程可以修正穩定對象的內部狀況，一個穩定對象自動就是線程平安的，如許可以免卻處置懲罰同步化的開支。一個穩定對象可以自由地被差別的客戶端同享。

瑕玷：

一旦須要修正一個穩定對象的狀況，就只好建立一個新的同類對象。在須要頻仍修正穩定對象的環境里，會有大批的穩定對象作為中心效果被建立出來，這是一種資本上的糟蹋。

如何用你自身的代碼來完成穩定性 (immutability)？

可以運用const 潤飾變量不可變

你會運用如何的言語構造來遍歷對象屬性 (object properties) 和數組內容？

請詮釋同步 (synchronous) 和異步 (asynchronous) 函數的區分。

同步式：當盤算機調理線程舉行I/O支配敕令后，由於文件的讀寫或許網絡通信須要較長的支配時候，支配系統為了充分應用cpu，此時會停息到當前的I/O線程對CPU的掌握（故又稱同步式為壅塞式I/O），把cup資本然給其他的線程資本，當I/O線程完成了支配時，此時支配系統會恢復此時的I/O線程，從而當前I/O線程從新獲得了cup的的掌握權，繼承完成其他支配。

異步式：異步式IO又稱非壅塞式I/O，異步式與同步式差別的是，當線程舉行IO支配時，支配系統並不是停息當前的線程支配，而是執行完I/O指令后，支配系統繼承讓當前線程執行下一條指令，當I/O支配完成后，會經由歷程事宜（event)關照I/O線程，而線程在接收到關照后，會處置懲罰相應事宜。

什麼是事宜輪迴 (event loop)？

主線程從“使命行列”中讀取事宜，這個歷程是輪迴不斷的，所以全部的這類運轉機制又稱為Event Loop（事宜輪迴）。

叨教挪用棧 (call stack) 和使命行列 (task queue) 的區分是什麼？

所謂“回調函數”（callback），就是那些會被主線程掛起來的代碼。異步使命必需指定回調函數，當異步使命從“使命行列”回到執行棧，回調函數就會執行。

“使命行列”是一個先進先出的數據構造，排在前面的事宜，優先返回主線程。主線程的讀取歷程基本上是自動的，只需執行棧一清空，“使命行列”上第一名的事宜就自動返回主線程。然則，由於存在後文提到的“定時器”功用，主線程要搜檢一下執行時候，某些事宜必需要在劃定的時候返回主線程。

詮釋 function foo() {} 與 var foo = function() {} 用法的區分？

第一個未函數聲明，第二個為函數定義表達式（函數定義表達式foo，變量聲明提早單賦值並未提早）

下面的代碼將輸出什麼到掌握台，為什麼?

(function(){ 
    var a = b = 3;
})(); 
console.log("a defined? " + (typeof a !== 'undefined'));
console.log("b defined? " + (typeof b !== 'undefined'));

輸出： a defined? false b defined? true

封裝JavaScript源文件的悉數內容到一個函數塊有什麼意義及來由?

這是一個愈來愈廣泛的做法，被很多盛行的JavaScript庫(jQuery，Node.js等)採納。這類手藝建立了一個繚繞文件悉數內容的閉包，也許是最重要的是，建立了一個私有的定名空間，從而有助於防備差別JavaScript模塊和庫之間潛伏的稱號爭執。
這類手藝的另一個特性是，許可一個易於援用的(假定更短的)別號用於全局變量。這一般用於，比方，jQuery插件中。jQuery許可你運用jQuery.noConflict()，來禁用 $ 援用到jQuery定名空間。在完成這項事情以後，你的代碼依然可以運用$ 應用這類閉包手藝，以下所示：
(function($) { /* jQuery plugin code referencing $ */ } )(jQuery);

在JavaScript源文件的開首包括 use strict 有什麼意義和優點?

use strict 是一種在JavaScript代碼運轉時自動執行更嚴厲剖析和毛病處置懲罰的要領。那些被疏忽或默默失利了的代碼毛病，會發作毛病或拋出異常。一般而言，這是一個很好的做法。

嚴厲情勢的一些重要長處包括：

使調試越發輕易。那些被疏忽或默默失利了的代碼毛病，會發作毛病或拋出異常，因而儘早提示你代碼中的題目，你才更快地指引到它們的源代碼。
防備不測的全局變量。如果沒有嚴厲情勢，將值分配給一個未聲明的變量會自動建立該稱號的全局變量。這是JavaScript中最罕見的毛病之一。在嚴厲情勢下，如許做的話會拋出毛病。
消弭 this 強迫。如果沒有嚴厲情勢，援用null或未定義的值到 this 值會自動強迫到全局變量。這可以會致使很多使人頭痛的題目和讓人巴不得拔自身頭髮的bug。在嚴厲情勢下，援用 null或未定義的 this 值會拋出毛病。
不許可反覆的屬性稱號或參數值。當檢測到對象(比方，var object = {foo: “bar”, foo: “baz”};)中反覆定名的屬性，或檢測到函數中(比方，function foo(val1, val2, val1){})反覆定名的參數時，嚴厲情勢會拋出毛病，因而捕獲險些可以肯定是代碼中的bug可以防備糟蹋大批的跟蹤時候。
使eval() 更平安。在嚴厲情勢和非嚴厲情勢下，eval() 的行動體式格局有所差別。最不言而喻的是，在嚴厲情勢下，變量和聲明在 eval() 語句內部的函數不會在包括局限內建立(它們會在非嚴厲情勢下的包括局限中被建立，這也是一個罕見的題目源)。
在 delete運用無效時拋出毛病。delete支配符(用於從對象中刪除屬性)不能用在對象不可設置的屬性上。當試圖刪除一個不可設置的屬性時，非嚴厲代碼將默默地失利，而嚴厲情勢將在如許的狀況下拋出異常。

斟酌以下兩個函數。它們會返回雷同的東西嗎? 為什麼雷同或為什麼不雷同?

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

返回不雷同： foo1 returns:Object {bar: “hello”}foo2 returns:undefined

分號在JavaScript中是一個可選項(只管省略它們一般是異常蹩腳的情勢)。其效果就是，當遇到 foo2()中包括 return語句的代碼行(代碼行上沒有其他任何代碼)，分號會馬上自動插進去到返回語句以後。也不會拋出毛病，由於代碼的其餘部份是完整有用的，縱然它沒有獲得挪用或做任何事情(相當於它就是是一個未運用的代碼塊，定義了等同於字符串 “hello”的屬性 bar)。

這類行動也支撐安排左括號於JavaScript代碼行的末尾，而不是新代碼行開首的商定。正如這裏所示，這不僅僅只是JavaScript中的一個作風偏好。

NaN 是什麼?它的範例是什麼?你如何牢靠地測試一個值是不是即是 NaN ?

NaN 屬性代表一個“不是数字”的值。這個特別的值是由於運算不能執行而致使的，不能執行的緣由要麼是由於个中的運算對象之一非数字(比方， “abc” / 4)，要麼是由於運算的效果非数字(比方，除數為零)。

NaN的特性：

NaN的範例為Number: console.log(typeof NaN === “Number”); // logs “true”
NaN 和任何東西比較——以至是它自身自身!——效果是false：console.log(NaN === NaN); // logs “false”

測試数字為NaN的要領：

運用內置函數iSNaN(半牢靠)
value !== value，如果值即是NaN，只會發作true
ES6供應： Number.isNaN() 比老的isNaN更牢靠

以下代碼將輸出什麼?並詮釋緣由

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

JavaScript中的数字和浮點精度的處置懲罰雷同，因而，可以不會老是發作預期的效果。
以上所供應的例子就是一個演示了這個題目標典範例子。但出人意表的是，它會輸出：
0.30000000000000004false

議論寫函數 isInteger(x) 的可以要領，用於肯定x是不是是整數

ECMAScript 6 之前沒有供應相似 Number.isInteger 的要領。在ECMAScript規格申明中，整數只觀點上存在：即，数字值老是存儲為浮點值。
要領：

最簡樸又最清潔的ECMAScript6之前的處理要領(同時也異常妥當地返回 false ，縱然一個非数字的值，如字符串或 null ，被通報給函數)如:function isInteger(x) { return (x^0) === x; }
function isInteger(x) { return Math.round(x) === x; } （不如第一個文雅）
function isInteger(x) { return (typeof x === ‘number’) && (x % 1 === 0);
function isInteger(x) { return parseInt(x, 10) === x; }

雖然這個以 parseInt函數為基本的要領在 x 取很多值時都能事情優越，但一旦 x 取值相當大的時刻，就會沒法一般事情。題目在於 parseInt() 在剖析数字之前強迫其第一個參數到字符串。因而，一旦數量變得足夠大，它的字符串就會表達為指數情勢(比方， 1e+21)。因而，parseInt() 函數就會去剖析 1e+21，但當抵達 e字符串的時刻，就會住手剖析，因而只會返回值 1。注重：

String(1000000000000000000000)’1e+21′> parseInt(1000000000000000000000, 10)1> parseInt(1000000000000000000000, 10) === 1000000000000000000000false

以下代碼行1-4如何排序，使之可以在執行代碼時輸出到掌握台? 為什麼?

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

序號以下：
1 4 3 2

比較明不言而喻的那部份：
1 和 4之所以放在前面，是由於它們是經由歷程簡樸挪用 console.log() 而沒有任何耽誤輸出的
2 之所以放在 3的背面，是由於 2 是耽誤了1000毫秒(即，1秒)以後輸出的，而 3 是耽誤了0毫秒以後輸出的。
好的。然則，既然 3 是0毫秒耽誤以後輸出的，那末是不是意味着它是馬上輸出的呢?如果是的話，那末它是不是應當在 4 之前輸出，既然 4 是在第二行輸出的?
要回答這個題目，你須要正確理解JavaScript的事宜和時候設置。
瀏覽器有一個事宜輪迴，會搜檢事宜行列和處置懲罰未完成的事宜。比方，如果時候發作在背景(比方，劇本的 onload 事宜)時，瀏覽器正忙(比方，處置懲罰一個 onclick)，那末事宜會增添到行列中。當onclick處置懲罰遞次完成后，搜檢行列，然後處置懲罰該事宜(比方，執行 onload 劇本)。
一樣的， setTimeout() 也會把其援用的函數的執行放到事宜行列中，如果瀏覽器正忙的話。
當setTimeout()的第二個參數為0的時刻，它的意義是“儘快”執行指定的函數。詳細而言，函數的執行會安排在事宜行列的下一個計時器最先。然則請注重，這不是馬上執行：函數不會被執行除非下一個計時器最先。這就是為什麼在上述的例子中，挪用 console.log(4) 發作在挪用 console.log(3) 之前(由於挪用 console.log(3) 是經由歷程setTimeout被挪用的，因而會輕微耽誤)。

寫一個簡樸的函數(少於80個字符)，請求返回一個布爾值指明字符串是不是為迴文構造。

下面這個函數在 str 是迴文構造的時刻返回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'

寫一個 sum要領，在運用下面任一語法挪用時，都可以一般事情

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

(最少)有兩種要領可以做到：

要領1：


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

要領2：

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

請看下面的代碼片斷

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)當用戶點擊“Button 4”的時刻會輸出什麼到掌握台，為什麼?
不管用戶點擊什麼按鈕，数字5將總會輸出到掌握台。這是由於，當 onclick 要領被挪用(關於任何按鈕)的時刻， for 輪迴已完畢，變量 i 已獲得了5的值。

(b)供應一個或多個備用的可按預期事情的完成計劃？
要讓代碼事情的癥結是，經由歷程通報到一個新建立的函數對象，在每次通報經由歷程 for 輪迴時，捕獲到 i 值。下面是三種可以完成的要領：

要領一

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);

}

要領二: 封裝悉數挪用到在新匿名函數中的 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);

}

要領三: 挪用數組對象的當地 forEach 要領來替換 for 輪迴

[‘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);

});

下面的代碼將輸出什麼到掌握台，為什麼?

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"

挪用數組對象的 reverse() 要領並不只返回反遞次的陣列，它也反轉了數組自身的遞次(即，在這類狀況下，指的是 arr1)。
reverse() 要領返回一個到數組自身的援用(在這類狀況下即，arr1)。其效果為，arr2 僅僅是一個到 arr1的援用(而不是副本)。因而，當對 arr2做了任何事情(即當我們挪用 arr2.push(arr3);)時，arr1 也會受到影響，由於 arr1 和 arr2 援用的是同一個對象。

注重：
通報數組到另一個數組的 push() 要領會讓全部數組作為單個元素映射到數組的末尾。其效果是，語句 arr2.push(arr3); 在其團體中增添 arr3 作為一個單一的元素到 arr2 的末尾(也就是說，它並沒有銜接兩個數組，銜接數組是 concat() 要領的目標)。
和Python一樣，JavaScript標榜數組要領挪用中的負數下標，比方 slice() 可作為援用數組末尾元素的要領：比方，-1下標示意數組中的末了一個元素，等等。

下面的代碼將輸出什麼到掌握台，為什麼?

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);

上面的代碼將輸出以下內容到掌握台：

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

基礎緣由是，JavaScript(ECMAScript)是一種弱範例言語，它可對值舉行自動範例轉換，以順應正在執行的支配。讓我們經由歷程上面的例子來申明這是如何做到的。
例1：1 + “2” + “2” 輸出：”122″ 申明： 1 + “2” 是執行的第一個支配。由於个中一個運算對象(“2”)是字符串，JavaScript會假定它須要執行字符串銜接，因而，會將 1 的範例轉換為 “1”， 1 + “2”效果就是 “12”。然後， “12” + “2” 就是 “122”。
例2： 1 + +”2″ + “2” 輸出： “32” 申明：依據運算的遞次，要執行的第一個運算是 +”2″(第一個 “2” 前面的分外 + 被視為一元運算符)。因而，JavaScript將 “2” 的範例轉換為数字，然後運用一元 + 號(即，將其視為一個正數)。其效果是，接下來的運算就是 1 + 2 ，這固然是 3。然後我們須要在一個数字和一個字符串之間舉行運算(即， 3 和 “2”)，一樣的，JavaScript會將數值範例轉換為字符串，並執行字符串的銜接，發作 “32”。
例3： 1 + -“1” + “2” 輸出： “02” 申明：這裏的詮釋和前一個例子雷同，除了此處的一元運算符是 – 而不是 +。先是 “1” 變成 1，然後當運用 – 時又變成了 -1 ，然後將其與 1相加，效果為 0，再將其轉換為字符串，銜接末了的 “2” 運算對象，獲得 “02”。
例4： +”1″ + “1” + “2” 輸出： “112” 申明：雖然第一個運算對象 “1”由於前綴的一元 + 運算符範例轉換為數值，但又馬上轉換回字符串，當銜接到第二個運算對象 “1” 的時刻，然後又和末了的運算對象”2″ 銜接，發作了字符串 “112”。
例5： “A” – “B” + “2” 輸出： “NaN2” 申明：由於運算符 – 不能被運用於字符串，而且 “A” 和 “B” 都不能轉換成數值，因而，”A” – “B”的效果是 NaN，然後再和字符串 “2” 銜接，獲得 “NaN2” 。
例6： “A” – “B” + 2 輸出： NaN 申明：拜見前一個例子， “A” – “B” 效果為 NaN。然則，運用任何運算符到NaN與其他任何的数字運算對象，效果依然是 NaN。

下面的遞歸代碼在數組列表偏大的狀況下會致使客棧溢出。在保存遞歸情勢的基本上，你怎樣處理這個題目?

var list = readHugeList();
var nextListItem = function() { var item = list.pop(); 
    if (item) { 
        // process the list item...
        nextListItem();
    }
};

潛伏的客棧溢出可以經由歷程修正nextListItem 函數防備：

var list = readHugeList();
var nextListItem = function() { 
    var item = list.pop(); 
    if (item) { // process the list item...
        setTimeout( nextListItem, 0);
    }
};

客棧溢出之所以會被消弭，是由於事宜輪迴支配了遞歸，而不是挪用客棧。當 nextListItem 運轉時，如果 item不為空，timeout函數(nextListItem)就會被推到事宜行列，該函數退出，因而就清空挪用客棧。當事宜行列運轉其timeout事宜，且舉行到下一個 item 時，定時器被設置為再次挪用 extListItem。因而，該要領從頭至尾都沒有直接的遞歸挪用，所以不管迭代次數的若干，挪用客棧堅持清空的狀況。

JavaScript中的“閉包”是什麼?請舉一個例子

閉包是一個可以接見外部(關閉)函數作用域鏈中的變量的內部函數。
閉包可以接見三種局限中的變量：這三個局限詳細為：

自身局限內的變量
關閉函數局限內的變量
全局變量。

下面是一個簡樸的例子：

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

在上面的例子中，來自於 innerFunc， outerFunc和全局定名空間的變量都在 innerFunc的局限內。因而，上面的代碼將輸出以下：

outerArg = 123innerArg = 456outerVar = ainnerVar = bglobalVar = xyz

下面的代碼將輸出什麼

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

詮釋你的答案。閉包在這裡能起什麼作用?
上面的代碼不會按預期顯現值0，1，2，3，和4，而是會顯現5，5，5，5，和5。
緣由是在輪迴中執行的每一個函數將全部輪迴完成以後被執行，因而，將會援用存儲在 i中的末了一個值，那就是5。
閉包可以經由歷程為每次迭代建立一個唯一的局限，存儲局限內變量的每一個唯一的值，來防備這個題目，以下：

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

這就會按預期輸出0，1，2，3，和4到掌握台。

以下代碼即將輸出什麼到掌握台?

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 = 11 || 2 = 10 && 1 = 01 && 2 = 2

在JavaScript中， || 和 &&都是邏輯運算符，用於在從左至右盤算時，返回第一個可完整肯定的“邏輯值”。
或( || )運算符。在形如 X||Y的表達式中，起首盤算X 並將其詮釋執行動一個布爾值。如果這個布爾值true，那末返回true(1)，不再盤算 Y，由於“或”的前提已滿足。如果這個布爾值為false，那末我們依然不能曉得 X||Y是真是假，直到我們盤算 Y，而且也把它詮釋執行動一個布爾值。

因而， 0 || 1 的盤算效果為true(1)，同理盤算1 || 2。
與( &&)運算符。在形如 X&&Y的表達式中，起首盤算 X並將其詮釋執行動一個布爾值。如果這個布爾值為 false，那末返回 false(0)，不再盤算 Y，由於“與”的前提已失利。如果這個布爾值為true，然則，我們依然不曉得 X&&Y 是真是假，直到我們去盤算 Y，而且也把它詮釋執行動一個布爾值。

不過，關於 &&運算符風趣的處所在於，當一個表達式盤算為“true”的時刻，那末就返回表達式自身。這很好，雖然它在邏輯表達式方面盤算為“真”，但如果你願望的話也可用於返回該值。這就詮釋了為什麼，有些使人奇怪的是， 1 && 2返回 2(而不是你認為的可以返回 true 或 1)。

執行下面的代碼時將輸出什麼?請詮釋。

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

代碼將輸出：

true false

在JavaScript中，有兩種等式運算符。三個即是運算符 === 的作用相似傳統的即是運算符：如果兩側的表達式有着雷同的範例和雷同的值，那末盤算效果為true。而雙即是運算符，會只強迫比較它們的值。因而，總體上而言，運用 ===而不是 ==的做法更好。 !==vs !=亦是同理。

以下代碼將輸出什麼?並詮釋你的答案。

var a={},
b={key:'b'}, c={key:'c'};
a[b]=123;
a[c]=456;
console.log(a[b]);

這段代碼將輸出 456(而不是 123)

原由於：當設置對象屬性時，JavaScript會暗中字符串化參數值。在這類狀況下，由於 b 和 c都是對象，因而它們都將被轉換為”[object Object]”。效果就是， a[b]和a[c]均相當於a[“[object Object]”] ，並可以交換運用。因而，設置或援用 a[c]和設置或援用 a[b]完整雷同。

以下代碼即將輸出什麼到掌握台?

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

代碼將輸出10!的值(即10!或3628800)。
緣由是：
定名函數 f()遞歸地挪用自身，當挪用 f(1)的時刻，只簡樸地返回1。下面就是它的挪用歷程：
f(1): returns n, which is 1f(2): returns 2 f(1), which is 2f(3): returns 3 f(2), which is 6f(4): returns 4 f(3), which is 24f(5): returns 5 f(4), which is 120f(6): returns 6 f(5), which is 720f(7): returns 7 f(6), which is 5040f(8): returns 8 f(7), which is 40320f(9): returns 9 f(8), which is 362880f(10): returns 10 * f(9), which is 3628800

請看下面的代碼段。掌握台將輸出什麼，為什麼?

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

掌握台將輸出 1，縱然從來沒有在函數內部設置過x的值。緣由是：
閉包是一個函數，連同在閉包建立的時刻，其局限內的一切變量或函數一同。在JavaScript中，閉包是作為一個“內部函數”實行的：即，另一個函數主體內定義的函數。閉包的一個重要特性是，內部函數依然有權接見外部函數的變量。
因而，在本例中，由於 x未在函數內部中定義，因而在外部函數局限中搜刮定義的變量 x，且被發明具有1的值。

下面的代碼將輸出什麼到掌握台，為什麼

var hero = {
    _name: 'John Doe',
    getSecretIdentity: function (){ 
        return this._name;
    }
}; 
var stoleSecretIdentity = hero.getSecretIdentity;
console.log(stoleSecretIdentity());
console.log(hero.getSecretIdentity());

代碼將輸出：

undefinedJohn Doe

第一個 console.log之所以輸出 undefined，是由於我們正在從 hero對象提取要領，所以挪用了全局高低文中(即窗口對象)的 stoleSecretIdentity()，而在此全局高低文中， _name屬性不存在。
个中一種修復stoleSecretIdentity() 函數的要領以下：
var stoleSecretIdentity = hero.getSecretIdentity.bind(hero);

建立一個給定頁面上的一個DOM元素，就會去接見元素自身及其一切子元素(不只是它的直接子元素)的函數。關於每一個被接見的元素，函數應當通報元素到供應的回調函數

此函數的參數為：
DOM元素
回調函數(將DOM元素作為其參數)
接見樹(DOM)的一切元素是典範的深度優先搜刮算法運用。下面是一個樹模的處理計劃：

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
    }
}

面試題網絡

面試題一
 面試題二

    原文作者：我們不動
    原文地址: https://segmentfault.com/a/1190000014478360
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。

請詮釋事宜代辦 (event delegation)

請詮釋 JavaScript 中 this 是如何事情的

請詮釋原型繼承 (prototypal inheritance) 的道理？

請詮釋為什麼接下來這段代碼不是 IIFE (馬上挪用的函數表達式)：function foo(){ }();要做哪些修正使它變成 IIFE?

形貌以下變量的區分：null，undefined 或 undeclared？ 該如何檢測它們？

什麼是閉包 (closure)，如何運用它，為什麼要運用它？

請舉出一個匿名函數的典範用例？

你是如何構造自身的代碼？是運用模塊情勢，照樣運用典範繼承的要領？

請指出 JavaScript 宿主對象 (host objects) 和原生對象 (native objects) 的區分？

請指出以下代碼的區分：function Person(){}、var person = Person()、var person = new Person()？

.call 和 .apply 的區分是什麼？

請詮釋 Function.prototype.bind？

在什麼時刻你會運用 document.write()？

請指出瀏覽器特性檢測，特性揣摸和瀏覽器 UA 字符串嗅探的區分？

請只管詳實的詮釋 Ajax 的事情道理？

運用 Ajax 都有哪些好壞？

請詮釋 JSONP 的事情道理，以及它為什麼不是真正的 Ajax。

請詮釋變量聲明提拔 (hoisting)

請形貌事宜冒泡機制 (event bubbling)

“attribute” 和 “property” 的區分是什麼？

為什麼擴大 JavaScript 內置對象不是好的做法？

請指出 document load 和 document DOMContentLoaded 兩個事宜的區分。

== 和 === 有什麼差別？

請詮釋 JavaScript 的同源戰略 (same-origin policy)。

如何完成以下代碼：[1,2,3,4,5].duplicator(); // [1,2,3,4,5,1,2,3,4,5]

什麼是三元表達式 (Ternary expression)？“三元 (Ternary)” 示意什麼意義？

什麼是 “use strict”; ? 運用它的優點和害處離別是什麼？

請完成一個遍歷至 100 的 for loop 輪迴，在能被 3 整除時輸出 “fizz”，在能被 5 整除時輸出 “buzz”，在能同時被 3 和 5 整除時輸出 “fizzbuzz”。

為什麼一般會認為保存網站現有的全局作用域 (global scope) 不去轉變它，是較好的挑選？

為什麼你會運用 load 之類的事宜 (event)？此事宜有瑕玷嗎？你是不是曉得其他替換品，以及為什麼運用它們？

請詮釋什麼是單頁運用 (single page app), 以及如何使其對搜刮引擎友愛 (SEO-friendly)。

運用 Promises 而非回調 (callbacks) 優瑕玷是什麼？

運用一種可以編譯成 JavaScript 的言語來寫 JavaScript 代碼有哪些優瑕玷？

你運用哪些東西和手藝來調試 JavaScript 代碼？

請詮釋可變 (mutable) 和穩定 (immutable) 對象的區分？

穩定性 (immutability) 有哪些優瑕玷？

如何用你自身的代碼來完成穩定性 (immutability)？

你會運用如何的言語構造來遍歷對象屬性 (object properties) 和數組內容？

請詮釋同步 (synchronous) 和異步 (asynchronous) 函數的區分。

什麼是事宜輪迴 (event loop)？

叨教挪用棧 (call stack) 和使命行列 (task queue) 的區分是什麼？

詮釋 function foo() {} 與 var foo = function() {} 用法的區分？

下面的代碼將輸出什麼到掌握台，為什麼?

封裝JavaScript源文件的悉數內容到一個函數塊有什麼意義及來由?

在JavaScript源文件的開首包括 use strict 有什麼意義和優點?

斟酌以下兩個函數。它們會返回雷同的東西嗎? 為什麼雷同或為什麼不雷同?

NaN 是什麼?它的範例是什麼?你如何牢靠地測試一個值是不是即是 NaN ?

以下代碼將輸出什麼?並詮釋緣由

議論寫函數 isInteger(x) 的可以要領，用於肯定x是不是是整數

以下代碼行1-4如何排序，使之可以在執行代碼時輸出到掌握台? 為什麼?

寫一個簡樸的函數(少於80個字符)，請求返回一個布爾值指明字符串是不是為迴文構造。

寫一個 sum要領，在運用下面任一語法挪用時，都可以一般事情

請看下面的代碼片斷

下面的代碼將輸出什麼到掌握台，為什麼?

下面的代碼將輸出什麼到掌握台，為什麼?

下面的遞歸代碼在數組列表偏大的狀況下會致使客棧溢出。在保存遞歸情勢的基本上，你怎樣處理這個題目?

JavaScript中的“閉包”是什麼?請舉一個例子

下面的代碼將輸出什麼

以下代碼即將輸出什麼到掌握台?

執行下面的代碼時將輸出什麼?請詮釋。

以下代碼將輸出什麼?並詮釋你的答案。

以下代碼即將輸出什麼到掌握台?

請看下面的代碼段。掌握台將輸出什麼，為什麼?

下面的代碼將輸出什麼到掌握台，為什麼

建立一個給定頁面上的一個DOM元素，就會去接見元素自身及其一切子元素(不只是它的直接子元素)的函數。關於每一個被接見的元素，函數應當通報元素到供應的回調函數

面試題網絡

形貌以下變量的區分：null，undefined 或 undeclared？該如何檢測它們？