摘要:但是,二進制浮點數(shù)表示法并不能精確的表示類似這樣的簡單的數(shù)字,會有舍入誤差。對于保證浮點數(shù)計算的正確性,有兩種常見方式。給你一個元素,創(chuàng)建一個能訪問該元素所有子元素的函數(shù),并且要將每個子元素傳遞給指定的回調(diào)函數(shù)。
1、使用 typeof bar === "object" 判斷 bar 是不是一個對象有神馬潛在的弊端?如何避免這種弊端?
let obj = {}; let arr = []; console.log(typeof obj === "object"); //true console.log(typeof arr === "object"); //true console.log(typeof null === "object"); //true
從上面的輸出結(jié)果可知,typeof bar === "object" 并不能準確判斷 bar 就是一個 Object。可以通過 Object.prototype.toString.call(bar) === "[object Object]" 來避免這種弊端:
let obj = {}; let arr = []; console.log(Object.prototype.toString.call(obj)); //[object Object] console.log(Object.prototype.toString.call(arr)); //[object Array] console.log(Object.prototype.toString.call(null)); //[object Null]
2、下面的代碼會在 console 輸出神馬?為什么?
(function(){ var a = b = 3; })(); console.log("a defined? " + (typeof a !== "undefined")); console.log("b defined? " + (typeof b !== "undefined"));
這跟變量作用域有關(guān),輸出換成下面的:
console.log(b); //3 console,log(typeof a); //undefined
拆解一下自執(zhí)行函數(shù)中的變量賦值:
b = 3; var a = b;
所以 b 成了全局變量,而 a 是自執(zhí)行函數(shù)的一個局部變量。
3、下面的代碼會在 console 輸出神馬?為什么?
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();
第一個和第二個的輸出不難判斷,在 ES6 之前,JavaScript 只有函數(shù)作用域,所以 func 中的 IIFE 有自己的獨立作用域,并且它能訪問到外部作用域中的 self,所以第三個輸出會報錯,因為 this 在可訪問到的作用域內(nèi)是 undefined,第四個輸出是 bar。如果你知道閉包,也很容易解決的:
(function(test) { console.log("inner func: this.foo = " + test.foo); //"bar" console.log("inner func: self.foo = " + self.foo); }(self));
如果對閉包不熟悉,可以戳此:從作用域鏈談閉包
4、將 JavaScript 代碼包含在一個函數(shù)塊中有神馬意思呢?為什么要這么做?
換句話說,為什么要用立即執(zhí)行函數(shù)表達式(Immediately-Invoked Function Expression)。
IIFE 有兩個比較經(jīng)典的使用場景,一是類似于在循環(huán)中定時輸出數(shù)據(jù)項,二是類似于 JQuery/Node 的插件和模塊開發(fā)。
for(var i = 0; i < 5; i++) { setTimeout(function() { console.log(i); }, 1000); }
上面的輸出并不是你以為的0,1,2,3,4,而輸出的全部是5,這時 IIFE 就能有用了:
for(var i = 0; i < 5; i++) { (function(i) { setTimeout(function() { console.log(i); }, 1000); })(i) }
而在 JQuery/Node 的插件和模塊開發(fā)中,為避免變量污染,也是一個大大的 IIFE:
(function($) { //代碼 } )(jQuery);
5、在嚴格模式("use strict")下進行 JavaScript 開發(fā)有神馬好處?
消除Javascript語法的一些不合理、不嚴謹之處,減少一些怪異行為;
消除代碼運行的一些不安全之處,保證代碼運行的安全;
提高編譯器效率,增加運行速度;
為未來新版本的Javascript做好鋪墊。
6、下面兩個函數(shù)的返回值是一樣的嗎?為什么?
function foo1() { return { bar: "hello" }; } function foo2() { return { bar: "hello" }; }
在編程語言中,基本都是使用分號(;)將語句分隔開,這可以增加代碼的可讀性和整潔性。而在JS中,如若語句各占獨立一行,通常可以省略語句間的分號(;),JS 解析器會根據(jù)能否正常編譯來決定是否自動填充分號:
var test = 1 + 2 console.log(test); //3
在上述情況下,為了正確解析代碼,就不會自動填充分號了,但是對于 return 、break、continue 等語句,如果后面緊跟換行,解析器一定會自動在后面填充分號( ; ),所以上面的第二個函數(shù)就變成了這樣:
function foo2() { return; { bar: "hello" }; }
所以第二個函數(shù)是返回 undefined。
7、神馬是 NaN,它的類型是神馬?怎么測試一個值是否等于 NaN?
NaN 是 Not a Number 的縮寫,JavaScript 的一種特殊數(shù)值,其類型是 Number,可以通過 isNaN(param) 來判斷一個值是否是 NaN:
console.log(isNaN(NaN)); //true console.log(isNaN(23)); //false console.log(isNaN("ds")); //true console.log(isNaN("32131sdasd")); //true console.log(NaN === NaN); //false console.log(NaN === undefined); //false console.log(undefined === undefined); //false console.log(typeof NaN); //number console.log(Object.prototype.toString.call(NaN)); //[object Number] ES6 中,isNaN() 成為了 Number 的靜態(tài)方法:Number.isNaN().
8、解釋一下下面代碼的輸出
console.log(0.1 + 0.2); //0.30000000000000004 console.log(0.1 + 0.2 == 0.3); //false
JavaScript 中的 number 類型就是浮點型,JavaScript 中的浮點數(shù)采用IEEE-754 格式的規(guī)定,這是一種二進制表示法,可以精確地表示分數(shù),比如1/2,1/8,1/1024,每個浮點數(shù)占64位。但是,二進制浮點數(shù)表示法并不能精確的表示類似0.1這樣 的簡單的數(shù)字,會有舍入誤差。
由于采用二進制,JavaScript 也不能有限表示 1/10、1/2 等這樣的分數(shù)。在二進制中,1/10(0.1)被表示為 0.00110011001100110011…… 注意 0011 是無限重復(fù)的,這是舍入誤差造成的,所以對于 0.1 + 0.2 這樣的運算,操作數(shù)會先被轉(zhuǎn)成二進制,然后再計算:
0.1 => 0.0001 1001 1001 1001…(無限循環(huán))
0.2 => 0.0011 0011 0011 0011…(無限循環(huán))
雙精度浮點數(shù)的小數(shù)部分最多支持 52 位,所以兩者相加之后得到這么一串 0.0100110011001100110011001100110011001100...因浮點數(shù)小數(shù)位的限制而截斷的二進制數(shù)字,這時候,再把它轉(zhuǎn)換為十進制,就成了 0.30000000000000004。
對于保證浮點數(shù)計算的正確性,有兩種常見方式。
一是先升冪再降冪:
function add(num1, num2){ let r1, r2, m; r1 = (""+num1).split(".")[1].length; r2 = (""+num2).split(".")[1].length; m = Math.pow(10,Math.max(r1,r2)); return (num1 * m + num2 * m) / m; } console.log(add(0.1,0.2)); //0.3 console.log(add(0.15,0.2256)); //0.3756
二是是使用內(nèi)置的 toPrecision() 和 toFixed() 方法,注意,方法的返回值字符串。
function add(x, y) { return x.toPrecision() + y.toPrecision() } console.log(add(0.1,0.2)); //"0.10.2"
9、實現(xiàn)函數(shù) isInteger(x) 來判斷 x 是否是整數(shù)
可以將 x 轉(zhuǎn)換成10進制,判斷和本身是不是相等即可:
function isInteger(x) { return parseInt(x, 10) === x; }
ES6 對數(shù)值進行了擴展,提供了靜態(tài)方法 isInteger() 來判斷參數(shù)是否是整數(shù):
Number.isInteger(25) // true Number.isInteger(25.0) // true Number.isInteger(25.1) // false Number.isInteger("15") // false Number.isInteger(true) // false
JavaScript能夠準確表示的整數(shù)范圍在 -2^53 到 2^53 之間(不含兩個端點),超過這個范圍,無法精確表示這個值。ES6 引入了Number.MAX_SAFE_INTEGER 和 Number.MIN_SAFE_INTEGER這兩個常量,用來表示這個范圍的上下限,并提供了 Number.isSafeInteger() 來判斷整數(shù)是否是安全型整數(shù)。
10、在下面的代碼中,數(shù)字 1-4 會以什么順序輸出?為什么會這樣輸出?
(function() { console.log(1); setTimeout(function(){console.log(2)}, 1000); setTimeout(function(){console.log(3)}, 0); console.log(4); })();
這個就不多解釋了,主要是 JavaScript 的定時機制和時間循環(huán),不要忘了,JavaScript 是單線程的。
11、寫一個少于 80 字符的函數(shù),判斷一個字符串是不是回文字符串
function isPalindrome(str) { str = str.replace(/W/g, "").toLowerCase(); return (str == str.split("").reverse().join("")); }
12、寫一個按照下面方式調(diào)用都能正常工作的 sum 方法
console.log(sum(2,3)); // Outputs 5 console.log(sum(2)(3)); // Outputs 5
針對這個題,可以判斷參數(shù)個數(shù)來實現(xiàn):
function sum() { var fir = arguments[0]; if(arguments.length === 2) { return arguments[0] + arguments[1] } else { return function(sec) { return fir + sec; } } } **13、下面的代碼會輸出什么?為什么?**
var arr1 = "john".split(""); j o h n
var arr2 = arr1.reverse(); n h o j
var arr3 = "jones".split(""); j o n e s
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));
>會輸出什么呢?你運行下就知道了,可能會在你的意料之外。 >MDN 上對于 reverse() 的描述是醬紫的:
Description
The reverse method transposes the elements of the calling array object in place, mutating the array, and returning a reference to the array.
reverse() 會改變數(shù)組本身,并返回原數(shù)組的引用。
slice 的用法請參考:slice
**14、下面的代碼會輸出什么?為什么?**
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);
>輸出什么,自己去運行吧,需要注意三個點: >多個數(shù)字和數(shù)字字符串混合運算時,跟操作數(shù)的位置有關(guān)
console.log(2 + 1 + "3"); / /‘33’
console.log("3" + 2 + 1); //"321"
>數(shù)字字符串之前存在數(shù)字中的正負號(+/-)時,會被轉(zhuǎn)換成數(shù)字
console.log(typeof "3"); // string
console.log(typeof +"3"); //number
>同樣,可以在數(shù)字前添加 "",將數(shù)字轉(zhuǎn)為字符串
console.log(typeof 3); // number
console.log(typeof (""+3)); //string
>對于運算結(jié)果不能轉(zhuǎn)換成數(shù)字的,將返回 NaN
console.log("a" * "sd"); //NaN
console.log("A" - "B"); // NaN
* 這張圖是運算轉(zhuǎn)換的規(guī)則 ![運算轉(zhuǎn)換的規(guī)則](http://upload-images.jianshu.io/upload_images/2791720-570777efcfd0e4e8.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) **15、如果 list 很大,下面的這段遞歸代碼會造成堆棧溢出。如果在不改變遞歸模式的前提下修善這段代碼?**
var list = readHugeList();
var nextListItem = function() {
var item = list.pop(); if (item) { // process the list item... nextListItem(); }
};
>原文上的解決方式是加個定時器:
var list = readHugeList();
var nextListItem = function() {
var item = list.pop(); if (item) { // process the list item... setTimeout( nextListItem, 0); }
};
>解決方式的原理請參考第10題。 **16、什么是閉包?舉例說明** 可以參考此篇:從作用域鏈談閉包([去看看](http://www.ido321.com/1641.html)) **17、下面的代碼會輸出什么?為啥?**
for (var i = 0; i < 5; i++) {
setTimeout(function() { console.log(i); }, i * 1000 );
}
>請往前面翻,參考第4題,解決方式已經(jīng)在上面了 **18、解釋下列代碼的輸出**
console.log("0 || 1 = "+(0 || 1));
console.log("1 || 2 = "+(1 || 2));
console.log("0 && 1 = "+(0 && 1));
console.log("1 && 2 = "+(1 && 2));
>邏輯與和邏輯或運算符會返回一個值,并且二者都是短路運算符:
邏輯與返回第一個是 false 的操作數(shù) 或者 最后一個是 true的操作數(shù)
console.log(1 && 2 && 0); //0
console.log(1 && 0 && 1); //0
console.log(1 && 2 && 3); //3
>如果某個操作數(shù)為 false,則該操作數(shù)之后的操作數(shù)都不會被計算
邏輯或返回第一個是 true 的操作數(shù) 或者 最后一個是 false的操作數(shù)
console.log(1 || 2 || 0); //1
console.log(0 || 2 || 1); //2
console.log(0 || 0 || false); //false
>如果某個操作數(shù)為 true,則該操作數(shù)之后的操作數(shù)都不會被計算
如果邏輯與和邏輯或作混合運算,則邏輯與的優(yōu)先級高:
console.log(1 && 2 || 0); //2 console.log(0 || 2 && 1); //1 console.log(0 && 2 || 1); //1
在 JavaScript,常見的 false 值:
0, "0", +0, -0, false, "",null,undefined,null,NaN
要注意空數(shù)組([])和空對象({}):
console.log([] == false) //true console.log({} == false) //false console.log(Boolean([])) //true console.log(Boolean({})) //true
所以在 if 中,[] 和 {} 都表現(xiàn)為 true:
19、解釋下面代碼的輸出
console.log(false == "0") console.log(false === "0") 請參考前面第14題運算符轉(zhuǎn)換規(guī)則的圖。
20、解釋下面代碼的輸出
var a={}, b={key:"b"}, c={key:"c"}; a[b]=123; a[c]=456; console.log(a[b]);
輸出是 456,參考原文的解釋:
The reason for this is as follows: When setting an object property, JavaScript will implicitly stringify the parameter value. In this case, since b and c are both objects, they will both be converted to "[object Object]". As a result, a[b] anda[c] are both equivalent to a["[object Object]"] and can be used interchangeably. Therefore, setting or referencing a[c] is precisely the same as setting or referencing a[b].
21、解釋下面代碼的輸出
console.log((function f(n){return ((n > 1) ? n * f(n-1) : n)})(10));
結(jié)果是10的階乘。這是一個遞歸調(diào)用,為了簡化,我初始化 n=5,則調(diào)用鏈和返回鏈如下:
22、解釋下面代碼的輸出
(function(x) { return (function(y) { console.log(x); })(2) })(1);
輸出1,閉包能夠訪問外部作用域的變量或參數(shù)。
23、解釋下面代碼的輸出,并修復(fù)存在的問題
var hero = { _name: "John Doe", getSecretIdentity: function (){ return this._name; } }; var stoleSecretIdentity = hero.getSecretIdentity; console.log(stoleSecretIdentity()); console.log(hero.getSecretIdentity());
將 getSecretIdentity 賦給 stoleSecretIdentity,等價于定義了 stoleSecretIdentity 函數(shù):
var stoleSecretIdentity = function (){ return this._name; }
stoleSecretIdentity 的上下文是全局環(huán)境,所以第一個輸出 undefined。若要輸出 John Doe,則要通過 call 、apply 和 bind 等方式改變 stoleSecretIdentity 的this 指向(hero)。
第二個是調(diào)用對象的方法,輸出 John Doe。
24、給你一個 DOM 元素,創(chuàng)建一個能訪問該元素所有子元素的函數(shù),并且要將每個子元素傳遞給指定的回調(diào)函數(shù)。
函數(shù)接受兩個參數(shù):
DOM
指定的回調(diào)函數(shù)
原文利用 深度優(yōu)先搜索(Depth-First-Search) 給了一個實現(xiàn):
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 } }
——————
文章版權(quán)歸作者所有,未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址:http://specialneedsforspecialkids.com/yun/87965.html
摘要:來自朋友去某信用卡管家的做的一道面試題,用原生模擬的方法,不準用和方法。他們的用途相同,都是在特定的作用域中調(diào)用函數(shù)。不同之處在于,方法傳遞給調(diào)用函數(shù)的參數(shù)是逐個列出的,而則是要寫在數(shù)組中。 本文首發(fā)我的個人博客:前端小密圈,評論交流送1024邀請碼,嘿嘿嘿?。 來自朋友去某信用卡管家的做的一道面試題,用原生JavaScript模擬ES5的bind方法,不準用call和bind方法。 ...
摘要:來自朋友去某信用卡管家的做的一道面試題,用原生模擬的方法,不準用和方法。他們的用途相同,都是在特定的作用域中調(diào)用函數(shù)。不同之處在于,方法傳遞給調(diào)用函數(shù)的參數(shù)是逐個列出的,而則是要寫在數(shù)組中。 本文首發(fā)我的個人博客:前端小密圈,評論交流送1024邀請碼,嘿嘿嘿?。 來自朋友去某信用卡管家的做的一道面試題,用原生JavaScript模擬ES5的bind方法,不準用call和bind方法。 ...
摘要:但是,二進制浮點數(shù)表示法并不能精確的表示類似這樣的簡單的數(shù)字,會有舍入誤差。對于保證浮點數(shù)計算的正確性,有兩種常見方式。 1、使用 typeof bar === object 判斷 bar 是不是一個對象有神馬潛在的弊端?如何避免這種弊端? 使用 typeof 的弊端是顯而易見的(這種弊端同使用 instanceof): let obj = {}; let arr = []; con...
摘要:特意對前端學(xué)習(xí)資源做一個匯總,方便自己學(xué)習(xí)查閱參考,和好友們共同進步。 特意對前端學(xué)習(xí)資源做一個匯總,方便自己學(xué)習(xí)查閱參考,和好友們共同進步。 本以為自己收藏的站點多,可以很快搞定,沒想到一入?yún)R總深似海。還有很多不足&遺漏的地方,歡迎補充。有錯誤的地方,還請斧正... 托管: welcome to git,歡迎交流,感謝star 有好友反應(yīng)和斧正,會及時更新,平時業(yè)務(wù)工作時也會不定期更...
閱讀 2703·2021-11-25 09:43
閱讀 2085·2021-11-24 09:39
閱讀 1954·2021-11-17 09:33
閱讀 2750·2021-09-27 14:11
閱讀 1840·2019-08-30 15:54
閱讀 3224·2019-08-26 18:27
閱讀 1264·2019-08-23 18:00
閱讀 1810·2019-08-23 17:53