JavaScript比較冷門的知識點

這個屬性無法直接

Object.prototype.toString(..)

　　　　　　例如:

　　　　　　　　Object.prototype.#　　　　　　　　Object.prototype.#　　　　　　　　Object.　　/ "[ object Array]"　　　　基本型別值　　　　　　　　Object.prototype.

 　　　　封裝物件包裝

　　　　　　　　由於基本類型值沒有.length 和.

　　　　　　想要自行封裝基本型別值，可以使用Object(..)(

Object(..)帶new

關鍵字)

　　　　　　　　#　　　　　　　　#　　　　　　　　　#H　　　　　]

valueOf()

　　　　　　　　var a = new String("abc");

　　　　　　　　var b = new N　　　　　　] new Boolean(true);

　　　　　　　　a.valueOf(); // "abc"

　　　　　　#　b##　　　　　　　c.valueOf(); // true

　　　　　　　　Array(..)##　　　　　Array(..)##　　　　　Array(..)##　　3) 　　　　　　　　　　a; // [1,2,3]　　　　　　　　　; // [1,2,3] 　　　　　　建構子

不要求必須帶關鍵字

new,

#他會自動補上

建構子只帶一個參數時候，該參數會被陣列的預設長度而不是當陣列中的一個元素。

　　　　　　　　var a = new Array(3);　　　　　　　　　　a.le　　　　　　　　　a;

　　　　　　　　總之永遠不要建立和使用空白單元數組

和

RegExp(..)#　　　　　　　　除非萬不得已，否則不要使用

　　　　　　建立時間必須使用 new Date(),主要是用來取得目前的Unix 時間戳Date .new()然後透過日期物件中的getTime() 來取得。

　　　　 建立錯誤物件(error objec) 主要是為了獲得目前運作的上下文。

　　　　Symbol(..)

#　　　　　　基本資料型別—符號。符號具有唯一性的特殊值，用它來命名屬性不容易導致重名。

　　　　　　Symbol 的靜態屬性形式，Symbol.create, Symbol.iterator

　　　　　　　　使用 Symbol(..) 原生建構子來自訂符號，不能帶new 關鍵字，否則報錯。

#　　　　　　　　　　　　　　　　　　　{ };

　　　　　　　　　　　　a[mysym ] = "foobar";

　　　　　　　　　　　　Object.getOwnPropertySymbols(a);

own symbol)]

　　　　　　原生建構子有自己的 .prototype

Array.prototype,　　　　　　　　　　　　　#　　　　　　　　String#indexOf(..)

　　　　　　　在字串中尋找指定字串的位置。

　　　　　　 　　#substring(..)

# String#toUpperCase() 和

#　　　　　　　#trim()　　　　　　去掉字符串前後的空格，返回新的字符串

　　　　強制類型轉換

　　　　　　值的型別轉換

##　　　　　　　　　　##　　　　　　　　　　」將值從一種類型轉換為另一種類型轉換，這就是顯示#隱式的情況通常為強制型別轉換。

　　　　　　　　　　JavaScript 中的型別轉換總是傳回標量基本型別。

　　　　　　抽象值操作　　　　　　　　ToString

　　　　　　　　　　抽像操作ToString

陣列的預設toString()

　　　　　　　　　　　　var a = [1,2,3];　　　　　　、　　　　　　　　　JSON #字串換，

　　　　　　　　　　JSON.stringify(..) 在對像中遇到undefined,function 和symbol 時會自動將其忽略，在陣列中則會傳回null。

　　　　　　　　　　　　例如：

傳回的應該是一個適當的值，可以是任何類型，然後再由JSON.stringify(. .) 對齊進行字串化。

　　　　　　　　有時需要將非數字值當做數字來使用，例如數學運算。

轉為1#，false ## 0 ,undefined 轉換為

　　　　　　　　　　null 轉換為

　　　　　　　　為了將值轉換為對應的基本型別，抽像運算ToPrimitive ,先檢查該值是否有valueOf() 值進行強制類型轉換。沒有就用

　　　　　　　　的傳回值來進行強制型別轉換。如果valueOf() 和toString() 都不會回傳值就會產生TypeError

　　　　ToBoolean

:##　　　　　

　　　　　　　　　　1.可以被強制型別轉換為##false的值

#　　　　　　　　　　　　　　　　　　　　(被輕質型別轉換為true#的值)

#　　　　　　　　以下這些是假值

#null NaN

""

　　　　　　　　假值物件：瀏覽器在某些特定情況下，在常規JavaScript語法基礎上#創建了一些外來值，這些就是 “假值物件”

　　　　　　真值

#　　　　　　　　真值就是假值列表以外的值

　　　　　　顯式強制類型轉換

　　　　　　　　字符串和數字之間的顯示轉換

　　　　　　　　字符串和數字之間顯示強制類型轉換是通過String(..) 和Number(..).

　　　　　　　　兩者之間的明確強制類型轉換

var a = 42;

var b = String(a);

var c = "3.14";

var d = Number(c);

b; // "42"

d: // 3.14

　　　　　　   #也它方式實作字串與數字之間的顯示轉換

var a = 42 ;

var b = a.toString();

var c = "3.14";

var d = +c;

b; / / "42"

d: // 3.14

　　　　日期顯示轉換為數字

#一元運算子#+ 的另一個常見的用途是將日期物件(Date)物件強制轉換為數字。

　　　　　　　　var timestamp = +new Date();

　　　　顯式解析數字　字串中解析##　　　　　字串中解析##　數字和將字串強制類型轉換為數字的回傳結果都是數字。

　　　　　　　　例如：

var a = "42";

parseInt(b); // 42　　　　　　　　解析允許字串中含有非數字字符，解析按從左到右的順序，如果

遇到非數字字符就停止。 　　　　　　　　parseInt(..) 針對的是字串，像parseInt(..)

傳遞數字和其他類型的參數是沒用的

　　　　顯示轉換為布爾值　　　　　　ToBoolean 是顯式的ToBoolean

強制型別轉換：

Boolea(g);  / / false

　　　　　　一元運算子！顯示地將值強制類型轉換為布林值。

　　　　隱式強制類型轉換

　　　　　　　　字串和數字之間的隱式強制類型轉換

　　　　　　　　+#運算子既能用於數字加法，也能用於數字加法字串。

var a = "42";

var b = "0";

var  c= 42;

var d = 0 ;

a + b; // "42"

c + d; // 42

　　　　　　　　我們物件的 - 操作與+ 類似；

var  a =  [3];

var b = [1];

a - b ; // 2

　　　　　　布林值到數字的隱式強制型別轉換

#　　　　　　隱式類型轉換為強制類型值

　　　　　　下面的情況會發生隱式強制型別轉換

語句中的條件判斷表達式。 2.for(..;...;..)語句中的條件判斷表達式(#第二個

)3.while(..) 與do..while(..)

迴圈中的條件判斷表達式。

？ ： 中的條件表達式5.邏輯運算子|| (邏輯或) 與(邏輯與)

#左邊的運算元（作為條件判斷表達式）#　　　　　　|| 和

#&&##|| 和&& &&

##||

var a = 42;

var b = "abc";

var c = null;

a || b;  // 42a && b; // "abc" #c || b; // "abc"c&& b; // null 對於 ||

true

如果為false 就傳回第二個運算元。 && 則相反。

||

function foo(a,b){

a = a || "hello";

b = b || "world";

console.log(a + " " + b );}

 foo(); // "hello world"

　　　　　　　　　　“== 允許在相等比較中進行強制類型轉換， 而=== 不允許”

　　　　　　　　抽象相等

##　　　　　　　　　##　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

+0 等於-0

#  寬鬆不相等 != 就是 ==的相反， !== 同理

# 

　　　　　　　　　　字符串與數字之間的相等比較

1.如果Type(x) 是數字，Type( y)是字串，則傳回x== ToNumber(y)

的結果。

2.如果Type(x) 是字串，#Type(y) #是數字，則傳回ToNumber(x)== y 的結果。

　　　　　　其他類型和布林類型之間的相等比較

       　　　　　　 == n的地方。 ##和false

與其他型別之間的相等比較

##var b = true;

a == b; // false1.如果Type(x) 是布林類型，則傳回ToNumber(x) == y

#2.如果Type(y) 是布林類型，則回傳x == ToNumber(y)

var x = true;

var y = "42";

x == y;  // false##反過來

　　　　　　　　　　null ##undefined 之間的相等比較

　　　　　　　　　　null 和undefinded #」和##==  

1.如果x 為null ,y 為undefined ,則結果為

2.如果x 為undefined, y 為#null, 則結果為true

 var  a == null;

var b;

a == b;  // true

a == null; // true

b == null; // true

a == false; // false

b == false; // false

a == "" ; // false

#b == ""; // false

a == 0; // false

b == 0; // false

#  　　　　物件與非物件之間的相等比較

#　　　　　　　　關於對象和(對象/函數

/ 數組) 與標量基本型別(字串/數字

/#布爾值)之間的比較。      1.若

#Type(x) 是字串或數字，

x == ToPrimitive(y)

      2.

# Type(x)

##Type(y)

是字串或數字，則傳回

　　　　　　ToPromitive(x) == y 的結果。 var a = 42;var  b = [42];a == b; // true #var a = "abc";var b = Object(a);  // new String(a) 一樣a === b; // falsea == b; // true

結果為true,

應為b

透過

ToPromitive

進行強制型別轉換，並傳回基本型別值

，與

a

相等。

　　　　　　假值相等的比較

　　　　　　　　一下是常規和非常規的比較

"0" == undefined;  // false

false == ""  //  true   -- 暈！

false == []  //   true   -- 暈！

false == {}  // false

"" == null;  // false

#"" == undefined; // false

"" == NaN; // false

"" == 0;  // true  -- 暈！

"" == []; // true  -- 暈！

"" == {}; // false

0 == null;  // false

0 == undefined; // false

0 == NaN;  // false

0 == []; true   -- 暈！

0 == {}; false

　　　　　　　　　　因為他們屬於假陽。

    　　　　　　極端情況

　　　　　　〠　H　　[　

[] == ![] 變成[] == false,　　　　　　　　　　 2 == [2]

##　　　　　　　　　　　　　　　　　　= [null]; //true

42 == "43"      // false

"foo" == 42;     // false

H #"true" = '""        // false# 42 == "42"      // true

"foo" == ["foo"]  / true　　　　　　安全運用隱式強制型別轉換1.如果兩邊的值中有##true #1.如果兩邊的值中有##true 或

==.

2.如果兩邊的之中有

##這時候最好使用 === 來避免強制類型的轉換。  　　　　　　抽象關係比較

　　　　　　　　雙方都是比# 比較= ["42"];var b = ["043"];

 a < b; // false

 a

a 被轉換為「4,2」，b 轉為「 0,4,3” 同樣式按字母順序進行比較的。

var a = {b: 42};

var b = {b:43};

a < b ; // false

     a 是 [object  Object], b也是 [object  Object] #所以按字母順序

a < b 不成立。

　　　　下面的範例