Javascript中的陷阱有哪些

本篇內容介紹了“Javascript中的陷阱有哪些”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

函數和操作符

雙等號(嚴格使用===替代==)

==操作符比較時會進行類型的強制轉換，這意味著它可以比較兩個不同類型的對象，在執行比較之前它將會嘗試把這兩個對象轉換成同一個類型，舉一個例子：
"1" == 1 //true
然而，這樣往往會誤導我們，而且我們也不需要這樣子來比較。在上面的例子中，我們完全可以先將字符串轉換成數字型，然后利用對類型敏感的三重等號（===）來進行比較，如：
Number("1") === 1; //true
或者，更好的是，確保你放在首位的操作數的類型是正確的。
由于雙等號具有強制類型轉換的行為，所以它會打破一般的傳遞性規則，這點有點嚇人，請看下面的列子：
"" == 0 //true
- 空字符串會被強制轉換為數字0.
0 == "0" //true
- 數字0會被強制轉換成字符串"0"
"" == "0" //false
- 兩操作數都是字符串所以不執行強制轉換復制代碼

如果使用三重等號，上面的三個比較都將返回false。

parseInt不把10作為數字基數(使用parseInt明確指明第二個參數)

如果你忽略parseInt的第二個參數，那么數字的基數將由下面的規則所決定：

• 默認基數為10，即按10進制解析

• 如果數字以0x開頭，那么基數為16，即按16進制解析

• 如果數字以0開頭，那么基數為8，即按8進制解析
  

一個常見的錯誤是我們讓用戶輸入以0開頭的數字，這時候它就按8進制的方式去解析了，于是我們就看到了如下的效果：
parseInt("8"); //8
parseInt("08"); //0復制代碼

因此，我們很多時候都會指定parseInt的第二個參數，如下所示：
parseInt("8", 10); //8
parseInt("08", 10); //8復制代碼

ECMAScript5方面的說明：ECMAScript已不再支持8進制的解析假設，另外，如果忽略parseInt的第二個參數將會引起JSLint的警告。

字符串替換(replace函數的第一參數支持字符串和正則，第二個參數支持字符串和函數，具體用法請見http://www.w3school.com.cn/js/jsref_replace.asp)

字符串替換函數僅僅會替換第一個匹配項，并不能替換你所期望的全部匹配項。如下代碼：
"bob".replace("b", "x"); // "xob"
"bob".replace(/b/, "x"); // "xob"
(使用了正則表達式)復制代碼

如果要替換所有的匹配項，我們可以使用正則表達式，并為他它添加全局修飾符，如下代碼：
"bob".replace(/b/g, "x"); // "xox"
"bob".replace(new RegExp("b",
"g"), "x"); // "xox"
(alternate explicit RegExp)復制代碼

全局修飾符確保了替換函數找到第一個匹配項后不會停止對下一個匹配項的替換。

“+"操作符會執行相加操作和字符串連接操作

php作為另一種弱類型語言，可以使用”.“操作符對字符串進行連接。Javascript卻不是這樣的 - 所以當操作數是字符串的時候”a+b“通常是執行連接操作。如果你想執行數字相加那你就要引起注意了，因為輸入的內容可能是字符串類型的，所以你在執行相 加操作前需要先將其轉換成數字類型，代碼如下：
1 + document.getElementById("inputElem").value; // 連接操作
1 + Number(document.getElementById("inputElem").value); // 相加操作復制代碼

需要注意的是，相減操作會嘗試將操作數轉換成數字類型，代碼如下：
"3" - "1"; // 2
盡管有時候你想用減法將字符串從另一個字符串中減掉，但這時候往往會產生一些邏輯錯誤。
很多時候我們用數字和空串相加來實現數字轉換成字符串的操作，代碼如下：
3 + ""; // "3"
但是這樣做并不好，所以我們可以用String(3)來取代上面的方法。

typeof

typeof這會返回一個javascript基本類型的實例的類型。Array實際上不是基本類型，所以typeof
Array對象將返回Object，代碼如下：
typeof {}
=== "object" //true
typeof ""
=== "string" //true
typeof []
=== "array"; //false復制代碼

當你對自己的對象的實例使用這個操作符時將會得到相同的結果（typeof = "object"）。
另外說明一點，”typeof null“將返回”object“，這個有點詭異。

instanceof

instanceof返回指定對象是否是由某個類構造的實例，這個對我們檢查指定對象是否是自定義類型之一很有幫助，但是，如果你是用文本語法創建的內置類型那可能會得出錯誤的結果，代碼如下：
"hello" instanceof String; //false
new String("hello") instanceof String; //true復制代碼

由于Array實際上不是內置類型（只是偽裝成內置類型 - 因此對它使用typeof不能得到預期的結果），但是使用instanceof就能得到預期效果了，代碼如下所示：
["item1", "item2"] instanceof Array;  //true
new Array("item1",
"item2") instanceof Array;  //true復制代碼

唉，不爽！總的來說，如果你想測試Boolean, String, Number, 或者Function的類型，你可以使用typeof，對于其他的任何類型，你可以使用instanceof測試。
哦，還有一點，在一個function中，有一個預定義變量叫“arguments”，它以一個array的形式傳遞給function。然而，它并不是真正的array，它只是一個類似array的對象，帶有長度屬性并且屬性值從0-length。非常奇怪...你可以用下面的小伎倆將它轉換成真正的數組：
var args
= Array.prototype.slice.call(arguments, 0);
這個對由getElementsByTagName返回的NodeList對象也是一樣的 - 它們都可以用以上的代碼轉換成合適的數組。

eval

eval 可以將字符串以javascript代碼的形式來解析執行，但是一般來說我們不建議這么做。因為eval非常慢 - 當javascript被加載到瀏覽器中時，它會被編譯成本地代碼；然而執行的過程中每次遇到eval表達式，編譯引擎都將重新啟動執行編譯，這樣做的代價太大了。而且這樣做也丑陋無比，有很多eval被濫用的例子。另外，在eval中的代碼會在當前范圍內執行，因此它可以修改局部變量，以及在你的范圍內添加一些讓你意想不到的東西。
JSON 轉換是我們經常要做的；通常我們使用“var obj = eval(jsonText);”來進行轉換。然而現在幾乎所有的瀏覽器都支持本地JSON對象，你可以使用“var obj = JSON.parse(jsonText);”來替代前面的代碼。相反你也可以用“JSON.stringify”將JSON對象轉換成字符串。更妙的是，你可以使用“jQuery.parseJSON”來完成上述的工作。
setTimeout和setInterval函數的第一個參數可以用字符串作為函數體來解析執行，當然，我們也不建議這樣做，我們可以用實際的函數來替代。
最后，Function的構造函數和eval非常像，唯一不同的是，Function構造函數是在全局范圍內執行的。

with

with表達式將為你提供訪問對象屬性的速記方式，但我們是否應該使用它，仍然存在矛盾的觀點。Douglas Crockford不太喜歡它。John Resig在他的書中有找了很多with的巧妙用法，但是他也承認這將會影響性能并且會產生一點混亂。來看看我們分離出來的with代碼塊，他不能準確地告訴我們現在正在執行什么，代碼如下所示：
with (obj)
{
    bob = "mmm";
    eric = 123;
}復制代碼

我是否剛剛修改了一個叫bob的局部變量？或者我是否設置了obj.bob？如果obj.bob已經被定義，那么它將會被重置為“mmm”。否則，如果有 另一個bob在這個范圍中，那么他將會被改變。否則，全局變量bob會被設置。最后，下面的寫法可以非常明確地表達你的意思：
obj.bob = "mmm";
obj.eric = 123;復制代碼

ECMAScript5說明：ES5嚴格的來說已經不支持with表達式。

類型和構造函數

使用“new”關鍵字構造內置類型

Javascript中有Object, Array, Boolean, Number, String, 和Function這些類型，他們各自都有各自的文字語法，所以就不需要顯式構造函數了。
顯式構造(不建議)文字語法(推薦)
var a = new Object();
a.greet = "hello";var a = { greet: "hello" };
var b = new Boolean(true);var b = true;
var c = new Array("one", "two");var c = ["one", "two"];
var d = new String("hello");var d = "hello"
var e = new Function("greeting", "alert(greeting);");var e = function(greeting) { alert(greeting); };然而，如果你使用new關鍵字來構造上面其中的一種類型，你實際上將會得到一個類型為Object并且繼承自你要構造的類型的原型的對象（Function類型除外）。所以盡管你用new關鍵字構造了一個Number類型，它也將是一個Object類型，如下代碼：
typeof new Number(123); // "object"
typeof Number(123); // "number"
typeof 123; // "number"復制代碼

上面的第三項是文本語法，為了避免沖突，我們應該使用這種方法來構造上面的這些類型。

使用“new”關鍵字來構造任何東西

如果你自寫構造函數并且忘記了new關鍵字，那么悲劇就發生了：
var Car
= function(colour)
{
    this.colour
= colour;
};

var aCar
= new Car("blue");
console.log(aCar.colour); // "blue"

var bCar
= Car("blue");
console.log(bCar.colour); // error
console.log(window.colour); //"blue"復制代碼

使用new關鍵字調用函數會創建一個新的對象，然后調用新對象上下文中的函數，最后再返回該對象。相反的，如果不使用new關鍵在調用函數，那它將會變成一個全局對象。

沒有Integer類型

數值計算是相對緩慢的，因為沒有Integer類型。只有Number類型 - Number是IEEE標準中雙精度浮點運算（64位）類型。這就意味著Number會引起下面的精度舍入錯誤：
0.1 + 0.2 === 0.3 //false
因為integers和floats沒有區別，不像C#和JAVA下面代碼是true： 
0.0 === 0; //true
最后是一個關于Number的疑問，我們該如何實現下面的問題：
a === b; //true
1/a === 1/b; //false復制代碼

答案是按照Number的規范是允許出現+0和-0的，+0等于-0，但是正無窮大不等于負無窮大，代碼如下：
var a
= 0 * 1; // 這個結果為0
var b
= 0 * -1; // 這個結果為-0
(你也可以直接"b=-0",但是你為何要這樣做?)
a === b; //true:
0等于-0
1/a === 1/b; //false:
正無窮大不等于負無窮大復制代碼

作用域

沒有塊作用域

因為你可能已經注意到上一個觀點，javascript中沒有塊作用域的概念，只有函數作用域。可以試試下面的代碼：
for(var i=0;
i<10; i++) {
    console.log(i);
}
var i;
console.log(i); // 10

當i被定義在for循環中，退出循環后它人被保留在這個作用域內，所以最后調用console.log輸出了10。這里有一個JSLint警告來讓你避免這個問題：強制將所有的變量定義在函數的開頭。 我們有可能通過寫一個立即執行的function來創建一個作用域：
(function (){
    for(var i=0;
i<10; i++) {
        console.log(i);
    }
}());
var i;
console.log(i); // undefined

當你在內部函數之前聲明一個變量，然后在函數里重聲明這個變量，那將會出現一個奇怪的問題，示例代碼如下：
var x
= 3;
(function (){
    console.log(x + 2); // 5
    x = 0; //No
var declaration
}());

但是，如果你在內部函數中重新聲明x變量，會出現一個奇怪的問題：
var x
= 3;
(function (){
    console.log(x + 2); //NaN
- x is not defined
    var x
= 0; //var
declaration
}());

這是因為在函數中x變量被重新定義了，這說明了翻譯程序將var表達式移動到了函數頂部了，最終就變成這樣執行了：
var x
= 3;
(function (){
    var x;
    console.log(x + 2); //NaN
- x is not defined
    x = 0;
}());

這個實在是太有意義了！

全局變量

Javascript 有一個全局作用域，在為你的代碼創建命名空間時一定要小心謹慎。全局變量會給你的應用增加一些性能問題，因為當你訪問它們時，運行時不得不通過每一個作用域來建立知道找到它們為止。他們會因你的有意或者無意而被訪問或者修改，這將導致另外一個更加嚴重的問題
- 跨站點腳本攻擊。如果一個不懷好意的家伙在你的頁面上找出了如何執行那些代碼的方法，那么他們就可以通過修改全局變量非常容易地擾亂你的應用。缺乏經驗的開發者在無意中會不斷的將變量添加到全局作用域中，通過本文，將會告訴大家這樣會發生什么意外的事情。
我曾經看到過下面的代碼，它將嘗試聲明兩個值相等的局部變量：
var a
= b = 3;
這樣非常正確的得到了a=3和b=3，但是a在局部作用域中而b在全局作用域中，”b=3“將會被先執行，全局操作的結果，3，再被分配給局部變量a。
下面的代碼聲明了兩個值為3的變量，這樣能達到預期的效果：
var a
= 3,
b = a;

”this“和內部函數

”this“關鍵字通常指當前正在執行的函數所在的對象，然而，如果函數并沒有在對象上被調用，比如在內部函數中，”this“就被設置為全局對象（window），如下代碼：
var obj
= {
    doSomething: function ()
{
        var a
= "bob";
        console.log(this); // 當前執行的對象
        (function ()
{
            console.log(this); // window
- "this" is reset
            console.log(a); // "bob"
- still in scope
        }());
    }
};
obj.doSomething();

雜項

數據不存在：”null“和”undefined“

有兩種對象狀態來表明數據不存在：null和undefined。這會讓那些從其他編程語言比如C#轉過來的程序員變得相當混亂。也許你會期望下面的代碼返回true：
var a;
a === null; //false
a === undefined; //true

”a“實際上是undefined的（盡管你用雙等號==來與null比較會得出true的結果，但這只是表面上看起來正確的另一個錯誤）。
如果你想檢查一個變量是否真的存在值，那你不能用雙等號==去判斷，要用下面的方法：
if(a
!== null &&
a !== undefined) {
    ...
}復制代碼

”哈“，你也許會說，既然null和undefined都是false，那么你可以這樣去做：
if(a)
{
    ...
}

當然，0是false，空字符串也是。那么如果這其中一個是a的正確的值的話，你就要用前者了。那種比較短小的比較方式，適合于比較objects, arrays, 和booleans類型。

重定義undefined

非常正確，你可以重定義undefined，因為它不是一個保留字：
undefined = "surprise!";
但是，你要通過給undefined變量分配一個值或者使用”void“操作符來取回值（否則這是相當沒用的）。
undefined = void 0;
這就是為什么jquery腳本庫的第一行要這樣寫了：
(function (
window, undefined ) {
    ... // jQuery
library!
}(window));

這個函數被調用時是傳入一個參數的，同時確保了第二個參數”undefined“實際上是undefined的。
順便說一下，你不能重定義null - 但是你可以重定義NaN，Infinity和帶構造函數的內置類型。可以這樣嘗試一下：
Array = function (){
alert("hello!"); }
var a
= new Array();

當然，你可以在任何地方用文字語法聲明Array。

可選的分號

Javascript代碼中分號是可選的，所以初學者寫代碼就簡單多了。但是很不幸的是如果忽略了分號并不會給任何人帶來方便。結果是當解釋器遇到錯誤時，必須追溯并嘗試去猜測因為哪些分號漏寫導致的問題。
這里有一個經典的例子：
return
{
    a: "hello"
};

上面的代碼并不會返回一個對象，而是返回了undefined - 但是也沒有錯誤拋出。其實是因為分號自動加到了return語句后面，其他的代碼都是非常正確的，但是就是什么都不執行，這就證明了在 javascript中，左花括號應該緊跟這一行而不該換行，這不只是一個編程風格的問題。下面的代碼才會正確返回一個屬性為a的對象：
return {
    a: "hello"
};


NaN
NaN的類型是...Number
typeof NaN
=== "number" //true
另外NaN和任何東西比較都是false：
NaN === NaN; // false
因為NaN之間是不能比較的，唯一判斷一個數字是否為NaN的方法是調用isNaN方法。
從另一個方面可以說明，我們也可以用函數isFinite，當其中一個操作數為NaN或者InFinity時返回false。

arguments對象
在一個函數中，我們可以引用arguments對象來遍歷傳入的參數列表，第一個比較怪異的地方是這個對象并不是Array，而是一個類似 Array的對象（有一個length屬性，其值在0-length-1之間）。為了將其轉換成array，我們可以array的splice函數來創建
其對應的array數組：
(function(){
console.log(arguments instanceof Array); // false
var argsArray
= Array.prototype.slice.call(arguments);
console.log(argsArray instanceof Array); // true
}());

第二個比較怪異的地方是當一個函數的簽名中有顯式arguments參數時，它們是可以被重新分配的并且arguments對象也會被改變。這就表明了arguments對象指向了變量本身。你不能利用arguments對象來給出它們的初始值：
(function(a){
    alert(arguments[0]); //1
    a = 2;
    alert(arguments[0]); //2
}(1));

“Javascript中的陷阱有哪些”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！