JavaScript比較冷門的知識點

原生函數

　　常用的原生函數

##　　　　String()

#　　　　Number()

#　　　　Number()

#　　　　Number()

#　　　　Number()

# #　　　　Boolean()

　　　　Array()

　　　　Object()

　　　　　Date()

　　　　Error()

　　　　Symbol()

　　內部屬性 [Class]##　　內部屬性 [Class]##" ##" '#'例如##例如類型##例如類型#例如多#例如超##

#例如#例如#'都有## object

的物件都包含一個內部屬性

#[Class],

這個屬性無法直接

訪問，一般透過

Object.prototype.toString(..)

來看。

　　　　　　例如:

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

#　ect Null]"

 　　　　封裝物件包裝

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

#這樣的屬性和方法。

　　　　封裝物件釋疑

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

Object(..)(

Object(..)帶new

關鍵字)

　　　　　　　　var a = "abc";

　　　　var a = "abc";

　　　　　　　　　　　　　　　　　(a);

　　　　　　　　var c = Object(a);

　　　　　　　　#　　　　　　　　#　　　　　　　　　#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] 　　　　　　建構子

Array(..),

不要求必須帶關鍵字

new,

#他會自動補上

Array

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

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

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

　　　　Object(..) , Function(..) ,

和

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

Object(..) / Function(..)/ RegExp(..)###### ######　　　　　　　　#和######Error(..)######

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

 

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

　　　　Symbol(..)

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

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

##　　　　　　　〷、] {/*..*/}

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

　　　　　　　　　　var mysym = Symbol("my own symbol");

　　　　　比　　　　　　　　　尾　　　〵　　]　　　　　　　　　　　　mysym.toString(); / / "Symbol(my own symbol)"

　　　　　　　　　　　　typeof mysym; // "symbol"

　

#　　　　　　　　　　　　　　　　　　　{ };

　　　　　　　　　　　　a[mysym ] = "foobar";

　　　　　　　　　　　　Object.getOwnPropertySymbols(a);

own symbol)]

     　　

原型類型

　　　　　　原生建構子有自己的 .prototype

物件如：

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

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

　　　　　　　　String#charAt(..)

　　　　　　 　　#substring(..)

和

String# slice(..)

　　　　　　取得字串的指定部分

# String#toUpperCase() 和

String#toLowerCase()

　　　　　　將字串轉換為大寫和小寫

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

 

　　　　強制類型轉換

　　　　　　值的型別轉換

##　　　　　　　　　　

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

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

　　　　　　抽象值操作　　　　　　　　ToString

　　　　　　　　　　抽像操作ToString

，它負責處理非字符串到字串的強制類型轉換

陣列的預設toString()

方法經過重新定義，將所有的單元字串化以後

在連接在一起。

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

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

　　　　　　　　　　　　例如：

　　　　　　　　　

　　　　　　　　　　　　　　JSON.stringify(function(){}); // undefined

　　　　　　　　　　　　　　JSON.stringify(

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　[1,undefined,function(){},4]

　　　　　　　　　　　　　　　　); // "[1,null,null　　　　　); // "[1,null,null. 4]"

　　　　　　　　　　　　　　JSON.stringify(

　　　　　　　　　　　　　　tion(){}}

　　　　　　　　　　　　　　); // "{"a":2} "

 

　　　　　　　　　toJSON()

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

　　　　　　ToNumber

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

　　　　　　　　　　true

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

NaN

　　　　　　　　　　null 轉換為

0

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

toString()

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

錯誤。

　　　　ToBoolean

#　　　　　　　假值

:##　　　　　

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

#　

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

#　　　　　　　　以下這些是假值

undefined

null

false

+0,-0

#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";

var b = "42px";

#Number

#var b = "42px";

#Number

# (a); // 42

parseInt(a); // 42

Number(b); // NaN

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

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

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

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

強制型別轉換：

var  a = "0";

var b = [];

var c = {};

 

var d = "";

var e = 0;

var f = null;

var g;

 

Boolean(a); // true

Boolean(b); // true

Boolean(c); // true

 

#Boolea(d);  // false

Boolea(e);  // false

Boolea(f);  // false

Boolea(g);  / / false

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

var  a = "0";

var b = [];

var c = {};

 

var d = "";

var e = 0;

var f = null;

var g;

 

!!a;  // true

!!b;  // true

!!c;  // true

 

#!!d; // false

!!e; // false

!!f; // false

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

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

　　　　　　

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

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

1.if(..)

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

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

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

4.

？ ： 中的條件表達式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"

#### foo("yeah","yeah"); // "yeah yeah"#########符號的強制型別轉換############　　　　　　　　寬鬆相等且嚴格相等### ####

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

　　　　　　　　抽象相等

　　　　　　　　　

##　　　　　　　　　

##　　　　　　　　　##　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

+0 等於-0

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

# 

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

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

的結果。

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

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

       　　　　　　 == n的地方。 ##和false

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

var  a = "42";

##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##反過來

#var x = "42";

var y = false;

x == y; // false

　　　　　　　　　　null ##undefined 之間的相等比較

　　　　　　　　　　null 和undefinded #」和##==  

也涉及隱士強制型別轉換。

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

true######

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) 是字串或數字，

##type(y)

是對象，

則回傳

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

　　　　　　　　　　　　a == b

結果為true,

應為b

透過

ToPromitive

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

“abc”

，與

a

相等。

　　　　　　假值相等的比較

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

= null;     // false

"0" == undefined;  // false

"0" == false; // true  -- ###暈！ #########「0」 == NaN;  // false######"0" == 0; // true######"0" == "";   / / false###### ######false == null; // false######false == undefined; // false#######false == NaN; // false ######false == 0; // true   -- ###暈！ ######

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]

##　　　　 2 == [2]

##　　　　　　　　　　　　　　　　　　= [null]; //true

 

42 == "43"      // false

"foo" == 42;     // false

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

"foo" == ["foo"]   // true

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

false,

千萬不要使用

==.

2.如果兩邊的之中有

[],""

或

0

，盡量千萬不要使用

==.

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

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

 a < b; // false

 a

和

b

並沒有被準換到數字，因為######ToPrimitive #######回傳的是字串，###### ######比較的是### "42 " ###和######"043" ######兩個字串， 因為######"0"# #####在字母順序上小於#########「4」###，所以最後結果為######false.###########同理#########var a = [4,2];######var b = [0,4,3];######a < b; // false  ###

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 不成立。

　　　　下面的範例

var a = {b: 42};

var b = {b:43};

a < b; // false

a == b; // false

a > b; // false

a <= b; // true

a >= b; // true####

以上是JavaScript比較冷門的知識點的詳細內容。更多資訊請關注PHP中文網其他相關文章！