( 2 ) JavaScript. The Definitive Guide ( 第 3~4 章 )

JavaScript. The Definitive  -- GuideJavaScript 權威指南(第6版)

9/19
第 3 章 類型、值和變量
1.JavaScript 的數據類型分為兩類:
 a.原始類型：數字、字符串和布爾值與特殊的原始值(null 和 undefined)
 b.對象類型：屬性 (property) 的集合
     每個屬性都由"名/值對"構成
     全局對象(g1obalobject)
     數組 (array) ，表示帶編號的值的有序集合。
     函數：具有與它相關聯的可執行代碼的對象。
     函數用初始化一個新建的對象：構造函數(定義一類 class)對象
             類：對象類型的子函數(分有 數組類、函數類、日期類、錯誤類、正則類(RegExp))
3.1 數字
1.JavaScript 使用浮點數值表示法。表示適用64位，操作運算使用32位整數。
2.(-)：表示反運算符號。

3.1.1 整型直接量
JavaScript 使用10進制；但也支持16與8進制

3.1.2 浮點型直接量
A.傳統的實數寫法。一個實數由整數部分、小數點和小數部分組成。
B.還可以使用指數記數法表示浮點型直接量，即在實數後跟字母 E. 後面再跟正
負號，其後再加一個整型的指數。例：123.789E-36

3.1.3 JavaScript 中的算術運算
1.基本的運算符：加法運算符(+)、減法運算符(一)、乘法運算符(*)、除法運算符 (/) 和求餘(求整除後的餘數)運算符(%)
2.複雜的算術運算：不常用的複雜運算符 a.Math.ceil(0.6)=1.1(向上求整)。b.Math.floor(0.6)=0.0(向下求整)。

9/20 P36實P48(PDF)

溢出 (overflow)
3.當數字運算結果超過了 JavaScript 所能表示的數字上限(溢出)，結果為一個特殊的無窮大 (infinity) 值，在 JavaScript 中以 Infinity 表示。
4.當負數的值超過了JavaScript 所能表示的負數範圍，結果為負無窮大，在 JavaScript 中以 -Infinity 表示。
下溢 (underflow)
5.是當運算結果無限接近於零併比 JavaScript 能表示的最小值還小的時候發生的一種情形。這種情況下， JavaScript 將會返回 0 。當一個負數發生下溢時，JavaScript 返回一個特殊的值"負零"。這個值(負零)幾乎和正常的零完全一樣，JavaScript 程序員很少用到負零。
6.被零整除在 JavaScript 井不報錯 它只是簡單的返回無窮大 (Infinity) 或負無窮大( -Infinity) 。
7.零除以零是沒有意義的，這種整除運算結果也是一個非數字 (not-a-number) 值，用 NaN 表示。
8.無窮大除以無窮大、給任意負數作開方運算或者算術運算符與不是數字或無撞轉換為數字的操作數一起使用時都將返回 NaN。
9.全局變量 Infinity 和NaN ，用來表示正無窮大和非數字值。ECMAScript 將它們定義為只讀的。

3.1.4 二進制浮點數和四捨五入錯誤
1.JavaScript 中使用實數的時候，常常只是真實值的一個近似表示。
2.JavaScript 採用了 IEEE-754 浮點數表示陸(幾乎所有現代編程語言所採用) ，這是一種二
進制表示法。
3.二進制浮點數表示法並不能精確表示類似 0.1 這樣簡單的數字。
4.使用大整數進行重要的金融計算，例如，要使用整數"分"而不要使用小數"元"進行基於貨幣單位的運算。

3.1.5 日期和時間
1. JavaScript 語言核心包括 Date() 構造函數
(例)
1. var then = new Date(2011,0,1); // 2011年1月1日
2. later.getFullYear() // => 2011

3.2 文本    字符串 (string) 是一組由 16 位值組成的不可變的有序序列

字符集，內碼和 JavaScript 字符串
JavaScript 採用 UTF-16 編碼的 Unicode 字符集， JavaScript 字符串是由一組元符號的 16位值組成的序列。

3.2.1 字符串直接量
1. 是由單引號或雙引號括起來的字符序列。由單引號定界的字符串中可以包含雙引號，由雙引號定界的字符串中也可以包含單引號。
2. 字符串直接量可以拆分成數行，每行必須以反斜線(\)結束，
3. 如果希望在字符串直接量中另起一行，可以使用轉義字符 \n，
4. 當使用單引號來定界字符串時，需要格外小心英文中的縮寫和所有格寫法，比如 can't 和O'Reilly's 。因為撇號和單引號是同一個字符，所以必須使用反斜線(\)來轉義，
註：在 JavaScript 表達式中使用單引號表示字符串 "Thank you" ，而在 HTML 事件處理程序屬性中則使用雙引號表示字符串:<button onclick= "alert('Thank you')">Click e</button>。

3.2.2 轉義字符
1.反斜線(\)有著特殊的用途，反斜線符號後加一個字符，就不再表示它們的字面含義了，比如，\n就是一個轉義字符 (escape sequence)，它表示的是一個換行符。
2.反斜線可以使我們避免使用常規方式解釋單引號，當單引號不是用來標記字符串結尾時，它只是一個撇號: 'You're right, it can't be a quote'

JavaScript 轉義字符

\o	NUL 字符(飛 uOOOO)				\b	退格符(飛 u0008)
\t	水平制表符(飛 U0009)				\n	換行符 (\uOOOA)
\v	垂直制表符 (\uOOOB)				\f	換頁符 (\uOOOC)
\r	迴車符 (\uOOOD)				\"	雙引號 (\u0022)
\'	撇號或單引號。 u002 7)				\\	反斜線 (\u005C)
\xXX	由兩位十六進制數 XX 指定的 Latin-l 字符				\uXXXX	位十六進制數 XXXX 指定的 Unicode 字符

3.2.3 字符串的使用
1. 如果將加號(+)運算符用於數字，表示兩數相加。
2. 用於字符串，則表示字符串連接，將第二個字符串拼接在第一個之後。
3. 要得到字符串的長度：s.length
4. 字串屬性很多可 觀看第三部分 javascript核心参考
5. 常用

var S = "hello， world"
S.charAt(0)	//==> "h"：第一个字符
S.charAt(S.length-1)	//==> "d"：最后一个字符
S.substring(1 , 4)	//==> "ell"： 2-4 个字符

6. 除了使用 charAt()方法，也可以使用方括號來訪問字符串中的單個字符：

S.[0]	//==> "h"：第一个字符
S.[S.length-1]	//==> "d"：最后一个字符

3.2.4模式匹配   "正則表達式" (regular expression)
1. 在兩條斜線之間的文本構成了一個正則表達式直接量。
2. 第二條斜線之後也可以跟隨一個或多個字母，用來修飾匹配模式的含義。

3.3 布爾值 布林值 (Boolean)
1. 真或假、開或關、是或否。這個類型只有兩個值，保留字 true 或 false；JavaScript 程序中的比較語句的結果通常都是布爾值，
(例 1 )
if (a == 4)
b = b + 1；
else
a = a + 1；
(例 2 )
undefined
null
-0
NaN
"" //空字符串
上面這些值會被轉換成false。
2. (a) "&&"運算符執行了邏輯與(AND)操作。當兩個操作數都是真值時它才返回truel 否則返回 false。
(b). "||" 運算符是布爾或 (OR) 操作，如果兩個操作數其中之一為真值它就返回 true ，如果兩個操作數都是假值則返回 false 。

3.4 null和undefined
 null (關鍵字)
1. null 是它自有類型的唯一的一個成員，它可以表示數字、字符串和對象是"無值"的。
2. 對 null執行 typeof 預算，結果返回字符串 "object"。
undefined
1. 如果要查詢對象屬性或數組元素的值時返回 undefined 則說明這個屬性或元素不存在。

3.5 全局對象

1. 全局對象的屬性是全局定義的符號， JavaScript 程序可以直接使用。
2. 當 JavaScript 解釋器啟動時(或者任何 Web 瀏覽器加載新頁面的時候) ，它將創建一個新的全局對象，井給它一組定義的初始屬性：
全局屬性，比如 undefined、Infinity、NaN
全局函數，比如 isNaN()、parselnt() 和 eval()
構造函數，比如 Date()、RegExp()、String()、Object()和Array()
全局對象，比如 Math和JSON
3. 在代碼的最頂級-不在任何函數內的JavaScript 代碼-可以使用 JavaScript 關鍵字this 來引用全局對象:
var global = this； //定義一個引用全局對象的全局變量

3.6 包裝對象
1. JavaScript 對象是一種複合值:它是屬性或已命名值的集合。
2. 通過"."符號來引用屬性值。
3. 當屬性值是一個函數的時候，稱其為方法。
4. 通過 o.m() 來調用對象O中的方法。

3.7 不可變的原始值和可變的對象引用
< 看不懂 >

3.8 類型轉換

須補資料其他單位須用此資料

3.9 變量聲明

for(var i = 0; i < 10; i++) console.log(i);

重複的聲明和遺漏的聲明

3.10 變量作用域
一個變量的作用域 (scope) 是程式源代碼中定義這個變量的區域。

3.10.1 函數作用域和聲明提前
3.10.2 作為屬性的變量
3.10.3 作用域鏈

3.7不可變的原始值和可變的對象引用 開始至 3.10.3 作用域鏈
有點複雜 暫不看 !! 待有問題時再回來看

第四章 表達式和運算符


4.1 原始表達式
1. 原始表達式是表達式的最小單位 - 它們不再包含其他表達式。 (包含常量或直接量、關鍵字和變量。)
2. 直接量是直接在程序中出現的常數值。
(例)
1.23 / /數字直接量
"hello" / /字符串直接量
/pattern/ / /正則表達式直接量

3. JavaScript 中的一些保留字構成了原始表達式:
(例)
true / /返回一個布爾值：真
false / /返回一個布爾值：假
null / /返回一個值：空
this / /返回"當前"對象
4. 變量：
i / /返回變量i的值
sum //返回 sum 的值
undefined // undefined 是全局變量，和 null 不同，它不是一個關鍵字

4.2 對象和數組的初始化表達式
數組
1. 數組初始化表達式是通過一對方括號和其內由逗號隔開的列表構成的。
(例) [1+2，3+4]
對象
2.對象初始化表達式是通過一對花括號和其內由逗號隔開的列表構成的，並且每個子表達式都包含一個屬性名和一個冒號作為前綴。
(例) var p = {x：2.3，y：-1.2}；//一個擁有兩個屬性成員的對象

4.3 函數定義表達式
一個典型的函數定義表達式包含關鍵字 function ，跟隨其後的是一對圓括號，括號內是一個以逗號分割的列表，列表含有 個或多個標識符(參數名) ，然後再跟隨一個由花括號包裹的 JavaScript 代碼段(函數體)。
(例) var square = function(x) { return  X* X； }//這個函數返回傳入參數值的平方

4.4 屬性訪問表達式
1. 一個表達式(變數名稱)後跟隨一個句點和標識符。
2. 使用方括號，方括號內是另外一個表達式(這種方法適用於對象和數組)。

(例)
var 0 = {X：1 ， Y：{Z：3}}；//一個示例對象
var a = [0，4，[5，6]]；//一個包含這個對象的示例數組
o.x    // => 1：表達式o的x屬性
o.y.Z  // => 3： 表達式o.y的z屬性

4.5 調用表達式
是一種調用(或者執行)函數或方法的語法表示。
(例)
f(o)   //f是一個函數表達式o是一個參數表達式
ath.max(x z)   // Math.max 是一個函數; x, 是參數
a.sort()   // a.sort 是一個函數，它沒有參數

4.6 對象創建表達式
對象創建表達式和函數調用表達式非常類似，只是對象創建表達式之前多了一個關鍵字 new:

(例)
new Object()
new Point(2,3)
如果一個對象創建表達式不需要傳入任何參數給構造函數的話，那麼這對空圓括號是可以省略掉的:

(例)
new Object
new Date

4.7 运算符概述
JavaScript 中的運算特用於算術表達式、比較表達式、邏輯表達式、賦值表達式等。
大多數運算符都是由標點符號表示的，而另外一些運算符則是由關鍵字表示的。

JavaScript 運算子
No	運算符	操作	A	N	類型	備註
1	++	前/後增量	R	1	lavl->num
2	--	前/後減量	R	1	lavl->num
3	-	求反 (負數)	R	1	num->num
4	+	轉換為數位 (轉換為數字)	R	1	num->num
5	~	按位求反	R	1	int->int
6	!	邏輯非	R	1	bool->bool
7	delete	刪除屬性	R	1	lval->bool
8	tyoeof	檢測運算元類型	R	1	any->str
9	void	返回 undefined值	R	1	any->str
10	*、/、%	乘，除，求餘	L	2	Num、num->num
11	+、-	加，減	L	2	Num、num->num
12	+	字元串連接	L	2	Str、str->str
13	<<	左移位	L	2	Int、int->int
14	>>	有符號右移	L	2	Int、int->int
15	>>>	無符號右移	L	2	Int、int->int
16	<、<=、>、>=	比較 數位順序	L	2	Num、num->bool
17	<、<=、>、>=	比較 在字母表中的順序	L	2	Str、str->bool
18	instanceof	測試 對象類	L	2	Obj、func->bool
19	in	測試 屬性是否存在	L	2	Str、obj->bool
20	==	判斷 相等	L	2	Any、any->bool
21	!=	判斷 不等	L	2	Any、any->bool
22	===	判斷 恒等	L	2	Any、any->bool
23	!==	判斷 非恒等	L	2	Any、any->bool
24	&	按位 與	L	2	int、int->int
25	^	按位 異或	L	2	int、int->int
26	|	按位 或	L	2	int、int->int
27	&&	邏輯 與	L	2	any、any->any
28	||	邏輯 或	L	2	any、any->any
29	?：	條件運算子	R	3	bool、any、any->any
30	=	變數賦值或物件屬性賦值	R	2	lval、any->any
31	*=, /=, %=, +=, -=, &=, ^=, |=, <<=, >>=, >>>=	運算且賦值	R	2	lval、any->any
32	，	忽略第一個運算元， 返回第二個運算元	L	2	Any、any->any
附註		lval 是left-value 的簡寫，意思是"左值"。
		L(從左至右)或 R(從右至左)，標題為N的列表示操作數的個數。

4.7.1 操作數的個數
運算符可以根據其操作數的個數進行分類。

4.7.2 操作數類型和結果類型
一些運算符可以作用於任何數據類型，但仍然希望它們的操作數是指定類型的數據，井且大多數運算符返回(或計算出)一個特定類型的值。

4.7.3 左值

左值(lvalue) 是一個古老的術語，它是指"表達式只能出現在賦值運算符的左側"

4.7.4 運算符的副作用
計算一個簡單的表達式(比如 2*3) 不會對程序的運行狀態造成任何影響，程序後續執行的計算也不會受到該計算的影響。而有一些表達式則具有很多副作用。

4.7.5 運算符優先級

乘法和除法的優先級高於加法和減法，賦值運算的優先級非常低，通常總是最後執行的。

4.7.6 運算符的結合性

4.7.7 運算順序

4.8 算術表達式

9/21 P69 / P81-PDF

1. 基本的算術運算符是* (乘法)、/ (除法)、% (求餘)、+ (加法)和-(喊法)。
2. 所有那些無法轉換為數字的操作數都轉換為NaN值。如果操作數(或者轉換結果)是NaN值，算術運算的結果也NaN

4.8.1 "+"運算符
二元加在主運算符"+"可以對兩個數字做加法，也可以做字符串連接操作

1. 如果其中一個操作數是對象，則對象會遵循對象到原始值的轉換規則轉換為原始類值 日期對象通過 toString() 方住執行轉換，其他對象則通過valueOf() 方怯執行轉換(如果valueOf() 方住返回一個原始值的話)。由於多數對象都不具備可用的 valueOf() 方法，因此它們會通過 toString() 方陸來執行轉換。
2. 在進行了對象到原始值的轉換後，如果其中一個操作數是字符串的話，另一個操作數也會轉換為字符串，然後進行字符串連接。
3. 否則，兩個操作數都將轉換為數字(或者 NaN) ，然後進行加撞操作。

4.8.2 一元算術運算符
一元運算符作用於一個單獨的操作數，井產生一個新值。

一元加法(+)：一元加法運算符把操作數轉換為數字(或者 NaN) ，井返回這個轉換後的數字。如果操作數本身就是數字，則直接返回這個數字。

一元減法(一)：當"-"用做一元運算符時，它會根據需要把操作數轉換為數字，然後改變運算結果的符號。

递增(++)：遞增"++"運算符對其操作數進行增量(加一)操作，操作數是一個左值(lvalue) (變量、數組元素或對象屬性)。運算符將操作數轉換為數字，然後給數字加 1，並將加 1後的數值重新賦值給變量、數組元素或者對象屬性。

遞減(--)：它把操作數轉換為數字，然後減 1，井將計算後的值重新賊值給操作數。

4.8.3 位運算符
位運算符可以對由數字表示的二進制數據進行更低層級的按位運算。

按位與(&)：位運算符"&"對它的整型操作數逐位執行布爾與 (AND) 操作。

按位或 ( | )：位運算特 "|" 對它的整型操作數逐位執行布爾或 (OR) 操作。

按位異或 (^)：位運算符 "|" 對它的整型操作數逐位執行布爾異或 (XOR) 操作。

按位非(~)：運算符"~"是一元運算符，位於一個整型參數之前，它將操作數的所有位取反。

左移(<<)：將第一個操作數的所有二進制位進行左移操作，移動的位數由第二個操作數指定，移動的位數是 0~31之間的一個整數。

帶符號右移(>>)：運算符">>"將第一個操作數的所有位進行右移操作，移動的位數由第二個操作數指定，移動的位數是 ~31之間的一個整數。

無符號右移(>>>)：運算符">>>"和運算符">>"一樣，只是左邊的高位總是填補0，與原來的操作數符號無關。

4.9 關係表達式 
關係運算符用於測試兩個值之間的關係(比如"相等"，"小於"，或"是...的屬性")，根據關係是否存在而返回 true false

4.9.1 相等和不等運算符
"=="和"==="運算符用於比較兩個值是否相等，當然它們對相等的定義不盡相同。
兩個運算符允許任意類型的操作數，如果操作數相等則返回 true ，否則返回 false。

4.9.2 比較運算符
比較運算特用來檢測兩個操作數的大小關係(數值大小或者字母表的順序)。

小於(<)：比較運算特用來檢測兩個操作數的大小關係(數值大小或者字母表的順序)。

大於(>)：如果第一個操作數大於第二個操作數，則">"運算符的計算結果為 true ，否則為false。

小於等於 (<=)：如果第一個操作數小於或者等於第二個操作數，則"<="運算特的計算結果為true; 否則為 false。

大於等於(>=)：如果第一個操作數大於或者等於第二個操作數，則">="運算符的計算結果為true ，否則為 false。

比較操作符的操作數可能是任意類型。然而，只有數字和字符串才能真正執行比較操作，因此那些不是數字和字符串的操作數都將進行類型轉換，類型轉換規則如下:


1. 如果操作數為對象，那麼這個對象將依照 3.8.3 節結尾處所描述的轉換規則轉換為原始值:如果 valueOf() 返回一個原始值，那麼直接使用這個原始值。否則，使用toString() 的轉換結果進行比較操作。

2. 在對象轉換為原始值之後，如果兩個操作數都是字符串，那麼將依照字母表的順序對兩個字符串進行比較，這裡提到的"字母表順序"是指組成這個字符串的16位Unicode 字符的索引順序。

3. 在對象轉換為原始值之後，如果至少有一個操作數不是字符串，那麼兩個操作數都將轉換為數字進行數值比較。0和-0是相等的。Infinity 比其他任何數字都大(除Infinity 本身) ，-Infinity 比其他任何數字都小(除了它自身)。如果其中一個操作數是(或轉換後是) NaN，那麼比較操作符總是返回 false。

4.9.3 in運算符
in 運算符希望它的左操作數是一個字符串或可以轉換為字符串，希望它的右操作數是一個對象。如果右側的對象擁有一個名為左操作數值的屬性名，那麼表達式返回 true ，

var point = {x：1，y：1}； //定義一個對象
"x" in point  //==> true；對象有一個名為"X"的屬性
"z" in point  // => false: 對象中不存在名為"z"的屬性
"toString" in point     // => true：對象繼承了 toString()方法
var data = [7，8，9]；     //擁有三個元素的數組
"0" in data             // => true：數組包含元素"0"
1 in data               // => true：數字轉換為字符串
3 in data               // => false：沒有索引為3的元素

4.9.4 instanceof 運算符
instanceof 運算符希望左操作數是一個對象，右操作數標識對象的類。如果左側的對象是右側類的實例，則表達式返回 truel 否則返回 false。JavaScript 中對象的類是通過初始化它們的構造函數來定義的。

var d = new Date()；       //通過Date()構造函數來創建一個新對象
d instanceof Date；         //計算結果為 true ，d是由 Date() 創建的
d instanceof Object；      //計算結果為 true ，所有的對象都是 Object 的實例
d. instanceof Number；  //計算結果為 false，不是一個 Number 對象
var a = [1，2，3]；        //通過數組直接量的寫法創建一個數組
a instanceof Array；       //計算結果為 true a是一個數組
a instanceof Object；      //計算結果為 true ，所有的數組都是對象
a instanceof RegExp；    //計算結果為 false，數組不是正則表達式

4.10 邏輯表達式
邏輯運算符"&&"、"||"和"!"是對操作數進行布爾算術運算，經常和關係運算符一起配合使用，邏輯運算符將多個關係表達式組合起來組成一個更複雜的表達式。

4.10.1 邏輯 與(&&)

第一層：當操作數都是布爾值的時候， "&&"對兩個值執行布爾與 (AND) 操作，只有在第一個操作數和第二個操作數都是 true 的時候，它才返回 true 。如果其中一個操作數是 false ，它返回 false。

第二層："&&"可以對真值和假值進行布爾與 (AND) 操作。如果兩個操作數都是真值，那麼返回一個真值 否則，至少一個操作數是假值的話，則返回一個假值。

第三層：運算符首先計算左操作數的值，即首先計算"腦"左側的表達式。如果計算結果是假值，那麼整個表達式的結果一定也是假值，因此"腦"這時簡單地返回左操作數的值，而並不會對右操作數進行計算。

儘管"&&"可以按照第二層和第三層的理解進行一些複雜表達式運算，但大多數情況下，"&&"僅用來對真值和假值做布爾計算。

4.10.2 邏輯 或( | | )
如果其中一個或者兩個操作數是真值，它返回一個真值。如果兩個操作數都是假值，它返回一個假值。

4.10.3 邏輯 非(!)
它的目的是將操作數的布爾值進行求反。例如，如果x是真值，則 !x 返回 false，如果x是假值，則 !x 返回 true。
(例)
!(p && q) === ! p | | ! q
!(p | | q) === !p && !q

4.11 賦值表達式

使用"="運算符來給變量或者屬性賦值。

帶操作的賦值運算
total += sales-tax
和接下來的表達式是等價的:
total = total + sales-tax

4.12 表達式計算 
JavaScript 可以解釋運行由 JavaScript 源代碼組成的字符串，井產生一個值。 JavaScript 通過全局函數 eval( ) 來完成這個工作：
(例)
eval("3+2")   //=> 5

4.12.1 eval( )
eval( ) 只有一個參數。如果傳入的參數不是字符串，它直接返回這個參數。如果參數是字符串，它會把字符串當成 JavaScript 代碼進行編譯 (parse)，如果編譯失敗則拋出一個語法錯誤 (SyntaxError) 異常。如果編譯成功，則開始執行這段代碼，井返回字符串中的最後一個表達式或語句的值，如果最後一個表達式或語句沒有值，則最終返回undefined 。

4.12.2 全局 eval ( )
eval() 具有更改局部變量的能力，這對於 JavaScript 優化器來說是一個很大的問題。然而作為一種權宜之計，JavaScript 解釋器針對那些調用了eval()的函數所做的優化並不多。但當腳本定義了 eval() 的一個別名，且用另一個名稱調用它， JavaScript 解釋器又會如何工作呢?為了讓 JavaScript 解釋器的實現更加簡化， ECMAScript 標準規定了任何解釋器都不允許對eval()賦予別名。如果 eval() 函數通過別名調用的話，則會拋出一個 EvalError 異常。

4.12.3 嚴格 eval( )

4.13 其他運算符

4.13.1 條件運算符(?:)

三元運算符(三個操作數)

(例)
x > 0 ? x ：-x // 求x的絕對值
第一個操作數當成布爾值，如果它是真值，那麼將計算第二個操作數，井返回其計算結果。否則，如果第一個操作數是假值，那麼將計算第三個操作數，井返回其計算結果。第二個和第三個操作數總是會計算其中之一，不可能兩者同時執行。
if x>0 then
x=x
else
x=-x

4.13.2 typeof 運算符
typeof 是一元運算符，放在其單個操作數的前面，操作數可以是任意類型。返回值為表示操作數類型的一個字符串。

4.13.3 delete 運算符
delete 是一元操作符，它用來刪除對象屬性或者數組元素。

4.13.4 void運算符
；操作數會照常計算，但忽略計算結果井返回 undefined。由於 void 會忽略操作數的值，因此在操作數具有副作用的時候使用 void 來讓程序更具語義。

4.13.5 逗號運算符(，)















































































































12345