摘要：本質(zhì)上是由一組無序名值對組成的。浮點數(shù)值的最高精度是位小數(shù)，但在進行計算時其精度遠遠不如證書。例如這是使用基于數(shù)值的浮點計算的通病，并非獨此一家數(shù)值范圍。

函數(shù)名不能使用關(guān)鍵字（typeof不行但typeOf可以，區(qū)分大小寫）

標識符就是指變量、函數(shù)、屬性的名字，或者函數(shù)的參數(shù)。

第一個字符必須是一個字母、下劃線（_）或者一個美元符號（$）

其他字符可以是字母、下劃線、美元符號或者數(shù)字

嚴格模式 在嚴格模式下ECMAScript3中的一些不確定的行為將得到處理，而且某些不安全的操作也會拋出錯誤。

// 在整個腳本頂部添加
"use strict";

// 在函數(shù)內(nèi)部上方使用
function deSmoething() {
    "use strict";
    // 函數(shù)體
}

關(guān)鍵字和保留字

break,do,instanceof,typeof,case,else,new,var,catch,finally,return,viod,continue,for,switch,while,debugger*,function,this,with,default,if,throw,delete,in,try

在函數(shù)中不用var聲明變量會變成全局變量，有效但不推薦

function test() {
    message = "hi"; //全局變量
}
test()
alert(message);     // "hi"

數(shù)據(jù)類型 ECMAScript中有5種簡單數(shù)據(jù)類型（也稱為基本數(shù)據(jù)類型）：Undefined,Null,Boolean,Number,String 還有1種復雜數(shù)據(jù)類型Object。本質(zhì)上Object是由一組無序名值對組成的。

typeof返回值"undefined","boolean","string","number","object","function" (typeof null 返回結(jié)果是"object") (typeof 是操作符不是函數(shù)因此最好不要用括號）

// 在使用bar聲明變量但未對其加以初始化，這個變量的值就是undefined
var message;
alert(message == undefined); // true
alert(message === undefined); // true

// 下面這個變量并沒有聲明
// var age
alert(age); // 報錯

// 對于尚未聲明過的變量，只能執(zhí)行一項操作，即使用typeof操作符檢測其數(shù)據(jù)類型
// 對未經(jīng)聲明的變量使用delete不會導致錯誤，但這樣沒什么意義，而且在嚴格模式下確實會導致錯誤
var message;
// var age
alert(typeof message);     // "undefined"
alert(typeof age);        // "undefined"

// 兩者都返回了undefined這個結(jié)果有其邏輯上的合理性。
// 因為雖然這兩種變量從技術(shù)角度看有本質(zhì)區(qū)別，但實際上無論對那種變量也不可能執(zhí)行真正的操作

// 從邏輯角度來看，null值表示一個空對象指針，而這也正是使用typeof 操作符檢測null值時會返回"object"的原因
var car = null;
alert(typeof car);         //    "object"

//  如果定義變量準備在將來用于保存對象，那么最好將該變量初始化為null而不是其他值
if (car != null) {
   ...
}

// 實際上 undefined值時派生自null值得，因此ECMA-262規(guī)定他們的相等性測試要返回true
alert(null == undefined)     // true

Boolean 類型

// 雖然Boolean類型的字面值只有2個，但ECMAScript中所有類型的值都有與這兩個Boolean值等價的值。
// 任何非零的數(shù)字值（包括無窮大）返回true   0 和 NaN 返回false
var message = "Hello world!";
Boolean(message);  // true
Boolean(0);        // false
Boolean(NaN);      // false
Boolean(Infinity)  // true
Boolean({})        // true
Boolean(null)      // false

// 八進制如果字面值中的數(shù)值超出了范圍，那么前導零將被忽略，后面的數(shù)值將被當做十進制數(shù)值解析
var num1 = 070;         // 八進制的56
var num2 = 079;         // 無效的八進制數(shù)值 解析為79
var num3 = 08;          // 無效的八進制數(shù)值 解析為8

// 八進制字面量在嚴格模式下是無效的，會導致支持該模式的JavaScript引擎拋出錯誤

// 十六進制字面值的前兩位必須是0x 后跟任何十六進制數(shù)字 （0~9 和 A~F）其中字母不區(qū)分大小寫
// 在進行算術(shù)計算時，所有八進制和十六進制表示的數(shù)值最終都將被轉(zhuǎn)換成十進制數(shù)值

// 鑒于JavaScript中數(shù)值的保存方式，可以保存正零和負零，兩者被認為相等
0 === -0  // true

由于保存浮點數(shù)值需要的內(nèi)存空間是保存證書值得兩倍，因此ECMAScript會不失時機的將浮點數(shù)值轉(zhuǎn)換為整數(shù)值。

浮點數(shù)值的最高精度是17位小數(shù)，但在進行計算時其精度遠遠不如證書。例如 0.1 + 0.2 = 0.30000000000000004

這是使用基于IEEE754數(shù)值的浮點計算的通病，ECMASscript并非獨此一家

由于內(nèi)存限制，ECMAScript能夠表示的最小值保存在Number.MIN_VALUE 在大多數(shù)瀏覽器中這個值時 5e-324

最大值在Number.MAX_VALUE中在大多數(shù)瀏覽器中，這個值是1.7976931348623157e+308;

如果計算中超過了范圍將會自動轉(zhuǎn)換成Infinity或-Infinity

Infinity無法參加計算

想要確定某個值是不是有窮的（在范圍內(nèi)）使用isFinite()函數(shù)

訪問Number.NEGATIVE_INFINITY 和 Number.POSITIVE_INFINITY 也可以得到負和正Infinity的值

Infinity + -Infinity // NaN

var res = Number.MAX_VALUE + Number.MAX_VALUE;
alert(isFinite(res));     //    false

是一個特殊的數(shù)值，這個數(shù)值用于表示一個本來要返回數(shù)值的操作數(shù)值未返回數(shù)值的情況

任何涉及NaN的操作都會返回NaN

NaN與任何值都不相等，包括NaN本身

isNaN() 在接受到一個值之后，會嘗試將其轉(zhuǎn)換為數(shù)值，而任何不能轉(zhuǎn)換為數(shù)值的值都會導致整個函數(shù)返回true

isNaN(NaN);     // true
isNaN(10);     // false
isNaN("10");     // false
isNaN("blue"); // ture
isNaN(true);     // false 可以被轉(zhuǎn)換成數(shù)值1

// isNaN()也適用于對象，在基于對象調(diào)用isNaN()函數(shù)時，會首先調(diào)用對象的valueOf()方法，然后確定該方法返回的值是否可以轉(zhuǎn)換為數(shù)值
// 如果不能，則基于整個返回值再調(diào)用toString()方法，再測試返回值
// 整個過程也是ECMAScript中內(nèi)置函數(shù)和操作符的一般執(zhí)行流程
var o = {
    valueOf: function() {
        return "10";
    }
}
isNaN(o)    // false 先返回"10" 再轉(zhuǎn)換成數(shù)值10

var o2 = {
    valueOf: function() {
        return "blue";
    }
}
isNaN(o2)    // ture 先返回"blue" 不能轉(zhuǎn)換成數(shù)值

數(shù)值轉(zhuǎn)換。Number() parseInt() parseFloat()

Number(true) // 1
Number(false) // 0
Number(null) // 0
Number(undefined) // NaN
Number("") // 0

// 如果字符串中包含有效的十六進制格式，例如"0xf" 則將其轉(zhuǎn)換為相同大小的十進制數(shù)值
// Number()也適用于對象，在基于對象調(diào)用isNaN()函數(shù)時，會首先調(diào)用對象的valueOf()方法，然后確定該方法返回的值是否可以轉(zhuǎn)換為數(shù)值
// 如果不能，則基于整個返回值再調(diào)用toString()方法，再測試返回值

// 由于Number()函數(shù)在轉(zhuǎn)換字符串時比較復雜而且不夠合理，因此在處理整數(shù)和浮點數(shù)的時候更通常的做法是用parseInt() 和 parseFloat()函數(shù)
Number("    0.2") // 0.2
Number("   02blue") // NaN
parseInt("   02blue") // 2
Number("    0.2blue;") // NaN
parseFloat("    0.2blue;") // 0.2

// 在使用parseInt() 解析八進制字面量的字符串時 ECMAScript 3 和 5 存在分歧
// ECMAScript 3 認為56（八進制）， ECMAScript 5 認為是70（十進制）
var num = parseInt("070")
// ECMAScript 5 中 parseInt()已經(jīng)不具有解析八進制值得能力 即使在非嚴格模式下也是如此
// 可以為這個函數(shù)提供第二個參數(shù)避免歧義
var num = parseInt("0xAF", 16);  // 175
// 實際上，如果有第二個參數(shù)，字符串可以不帶“0x”
var num1 = parseInt("AF", 16);   // 175
var num2 = parseInt("AF");   // NaN

// parseFloat() 從第一個字符開始解析，直到末尾，除非解析到遇見一個無效的浮點數(shù)為止
// 第一個小數(shù)點有效之后就無效
// parseFloat() 只能解析十進制值，因此它沒有用的哥參數(shù)指定基數(shù)的用法,非十進制數(shù)值都返回0
// 如果字符串包含的是一個可解析為整數(shù)的數(shù)，會返回一個整數(shù)
parseFloat("1234blue"); // 1234
parseFloat("0xA"); // 0
parseFloat("22.24.5")  // 22.24
parseFloat("0980.5"); // 980.5
parseFloat("3.125e"); // 31250000

單引號和雙引號都可以用，單首尾必須匹配

換行

制表

 退格

回車

f 進紙

斜杠

" 單引號

" 雙引號

xnn 以十六進制代碼nn表示的一個字符（其中n為0~F） 例如 x41表示"A"

unnnn 以十六進制代碼nnnn表示一個Unicode字符 （其中n為0~F） 例如 u03a3 表示希臘字符 sigma 字符串length為1

ECMAScript 中的字符串時不可變的，字符串一旦創(chuàng)建，它們的值就不能改變

要改變某個變量保存的字符串，首先要銷毀原來的字符串，然后再用另一個包含新值得字符串填充該變量

var lang = "Java";
lang = lang + "Script";
/*
 * 實現(xiàn)這個操作的過程
 * 首先創(chuàng)建一個能容納10個字符的新字符串，然后再這個字符串中填充"Java" 和 "Script"
 * 最后銷毀原來的字符串"Java"和字符串"Script"，因為這個兩個字符串都沒用了
 * 這個過程是在后臺發(fā)生的，而這也是某些舊版本的瀏覽器 （1.0以下的Firefox IE6等）拼接字符串速度很慢的原因所在
 */

使用幾乎每個值都有的toString()方法 數(shù)值、布爾值、對象和字符串值（沒錯，字符串也有）

在不知道要轉(zhuǎn)換的值是不是null或undefined的情況下，還可以使用轉(zhuǎn)型函數(shù)String()

// toSring()可以傳一個參數(shù)：輸出數(shù)值的基數(shù) 默認十進制
var num = 10;
num.toString();   // "10"
num.toString(2);  // "1010"
num.toString(8);  // "12"
num.toString(10); // "10"
num.toSring(16);  // "a" 

null.toString();  // 報錯
undefined.toString() // 報錯 

String(null); // "null"
String(undefined); // "undefined"

// 三種寫法等價 但不建議省略小括號
var o = {};
var o = new Object();
var o = new Object;
o.constructor // ? Object() { [native code] }  就是Object() 

從技術(shù)角度講，ECMA-262中對象的行為不一定適用于JavaScript中的其他對象。瀏覽器環(huán)境中的對象，比如BOM DOM中的對象都屬于宿主中的對象

Object 的每個實例都具有下列屬性和方法

constructor: 保存著用于創(chuàng)建當前對象的函數(shù)

hasOwnProperty(propertyName): 用于檢查給定的屬性在當前對象實例中（而不是在實例的原型中）是否存在。其中propertyName必須為字符串

isPrototypeOf(object): 用于檢查傳入的對象是否是當前對象的原型

propertyIsEnumerable(propertyName): 用于檢查給定的屬性是否能使用for-in語句來枚舉

toLocaleString(): 返回對象的字符串表示，該字符串與執(zhí)行環(huán)境的地區(qū)對應

toString(): 返回對象的字符串

valueOf(): 返回對象的字符串、數(shù)值或布爾值表示。通常與toString()方法的返回值相同

// Baz.prototype, Bar.prototype, Foo.prototype 和 Object.prototype 在 baz 對象的原型鏈上：
function Foo() {}
function Bar() {}
function Baz() {}

Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);

var baz = new Baz();

console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true

包括算數(shù)操作符、位操作符、關(guān)系操作符和相等操作符

前置型 在賦值前改變

后置型 在賦值后改變

var num1 = 2;
var num2 = 20;
var num3 = --num1 + num2;         // 21
var num4 = num1 + num2;           // 21

var num1 = 2;
var num2 = 20;
var num3 = num1-- + num2;         // 22
var num4 = num1 + num2;           // 21

在應用于一個包含有效數(shù)字字符串時，先將其轉(zhuǎn)換為數(shù)值

在應用于一個包含有效數(shù)字的字符串時，將變量的值設(shè)置為NaN，字符串變量變成數(shù)值變量

false，先將其轉(zhuǎn)換為0

true，先將其轉(zhuǎn)換為1

浮點數(shù)，正常加減1

對象，先調(diào)用vlueOf()方法，如果結(jié)果是NaN則調(diào)用toString()方法后再應用前述規(guī)則

var s1 = "2";
var s2 = "z";
var b = false;
bar f = 1.1;
var o = {
    varluOf: function() {
        return -1;
    }
};

s1++;        // 3
s2++;         // NaN
b++;        // 1
f--;         // 0.10000000000000009 浮點運算舍入錯誤導致
o--;        // -2

+號會對值自動轉(zhuǎn)換成數(shù)值

-號會變成負數(shù)

ECMAscript中的所有數(shù)值都以IEEE-754 64位格式存儲，但位操作符并不直接操作64位值。而是先將64位的值轉(zhuǎn)成32位的整數(shù)，然后執(zhí)行操作 ，最后再將結(jié)果轉(zhuǎn)回64位。

32位中的前31位表示整數(shù)的值，第32位表示數(shù)值的符號，0為正數(shù) 1為負數(shù)，即為符號位

正數(shù)以純二進制格式存儲，沒有用到的位用0填充

負數(shù)同樣二進制，但使用的格式是二進制補碼

求數(shù)值絕對值的二進制碼

求二進制反碼 將0換成1 1換成0

得到的二進制反碼加1

NaN 和 Infinity 應用位操作符時，會被當做0處理，由于64位轉(zhuǎn)存32位導致

按位非（NOT） ~

按位與（AND） &

按位或（OR） |

按位異或（XOR） ^ 兩個數(shù)值對應位上只有一個1時才返回1，其他情況返回0

左移 << 右側(cè)以0填充

有符號的右移 >> 數(shù)值向右移動，保留符號位，左側(cè)以符號位數(shù)值填充

無符號的右移 >>> 數(shù)值向右移動，不保留符號位 ，左側(cè)以0來填充

var oldvalue = 64;
var newvalue = oldvalue >> 5;        // 二進制10

var oldvalue = 64;
var newvalue = oldvalue >>> 5;      // 二進制 10

var oldvalue = -64;
var newvalue = oldvalue >>> 5;         // 等于十進制的134217726

邏輯非 !

!"blue"       // false
!0            // true
!NaN          // true
!null         // true
!undefined    // true
!""           // true
!12345        // false

邏輯與 && 邏輯與是短路操作，如果第一個操作數(shù)能夠決定結(jié)果，就不會對第二個操作數(shù)求值

var found = true;
var result = (found && someUndefinedVariable);     // 拋出錯誤
alert(result);         //    這里不會執(zhí)行

var found = false;
var result = (found && someUndefindedVariable);     // 不會發(fā)生錯誤
alert(result);         // false

如果第一個操作數(shù)是對象，則返回第二個操作數(shù)

如果第二個操作數(shù)是對象，則只有在第一個求值結(jié)果為true的時候才會返回該對象

如果兩個都是對象，則返回第二個操作數(shù)

如果有一個操作數(shù)是null 則返回null

如果有一個操作數(shù)是NaN 則返回NaN

如果有一個操作數(shù)是undefined 則返回undefined

如果求值的操作數(shù)沒有聲明會拋出錯誤

邏輯或 || 短路操作

var found = true;
var result = (found || someUndefinedVariable);     // 不會拋出錯誤
alert(result);         // true   

var found = false;
var result = (found || someUndefindedVariable);     // 發(fā)生錯誤
alert(result);         // 這里不會執(zhí)行

如果第一個操作數(shù)是對象，則返回第一個操作數(shù)

如果第一個操作數(shù)求值為false，則返回第二個

如果兩個都是對象，則返回第一個操作數(shù)

如果兩個操作數(shù)都是null 則返回null

如果兩個操作數(shù)都是NaN 則返回NaN

如果兩個操作數(shù)都是undefined 則返回undefined

如果求值的操作數(shù)沒有聲明會拋出錯誤

如果參與計算的某個操作數(shù)不是數(shù)值，后臺會先試用Number()轉(zhuǎn)型函數(shù)

如果有一個操作數(shù)是NaN 則結(jié)果是NaN

如果Infinity 與 0 相乘 則結(jié)果是NaN

如果Infinity 與 非0相乘 則結(jié)果是Infinity 或 -Infinity

Infinity * Infinity = Infinity

-Infinity * Infinity = -Infinity

Infinity / Infinity = NaN

0 / 0 = NaN

非0的有限數(shù) / 0 = Infinity 或 - Infinity

0 / 非0的有限數(shù) = Infinity 或 - Infinity

有限數(shù)值 % 0 = NaN

Infinity % Infinity = NaN

Infinity % 有限數(shù)值 = NaN

Infinity + -Infinity = NaN

+0 + -0 = +0

兩個操作數(shù)都是字符串 結(jié)果是拼接字符串

如果只有一個操作數(shù)是字符串，則將另一個操作數(shù)轉(zhuǎn)換為字符串

+0 - -0 = +0

var num1 = 5;
var num2 = 10;
var message = "the sum of 5 and 10 is " + num1 + num2;
alert(message);    // "the sum of 5 and 10 is 510"
var message = "the sum of 5 and 10 is " + (num1 + num2);
alert(message);    // "the sum of 5 and 10 is 15"

var res6 = 5 - null;  // 5 null轉(zhuǎn)為0

如果兩個操作數(shù)都是字符串，則比較兩個字符串對應的字符編碼值

如果一個操作數(shù)是數(shù)值，則將另一個操作數(shù)轉(zhuǎn)換為一個數(shù)值進行比較

如果一個操作數(shù)是對象，調(diào)用valueOf()方法，如果沒有則調(diào)用toString()

如果一個操作數(shù)是布爾值，則先將其轉(zhuǎn)換為數(shù)值

任何操作數(shù)與NaN進行關(guān)系比較，結(jié)果都是false

// 字母B的字符編碼為66 而字母a的字符編碼是97
// 如果要真正按照字母順序比較字符串，就要相同大小
var result = "Brick" < "alphabet";         // true
var result = "Brick".toLowerCase() < "alphabet".toLowerCase();     // false

// "2" 字符編碼是50，而"3"的字符編碼是51
var result = "23" < "3";    // true
var result = "23" > 3;    // false

var result = "a" < 3;     // false 因為"a"被轉(zhuǎn)換成了NaN

var result = NaN < 3;    // false
var result = NaN >= 3;    // false

相等和不相等 == , !=

這兩個操作符都會先轉(zhuǎn)換操作數(shù)（通常稱為強制轉(zhuǎn)型），然后再比較他們的相等性

如果有一個操作數(shù)是布爾值，先轉(zhuǎn)為1或0再比較

如果一個是字符串另一個是數(shù)值，則轉(zhuǎn)換為數(shù)值比較

對象先調(diào)用valueOf()，用得到的基本類型值按照前面規(guī)則進行比較

null 和 undefined 相等

比較之前不能講null和undefined轉(zhuǎn)換成其他任何值

如果有一個操作數(shù)是NaN，則相等操作符返回false， NaN也不等于NaN

如果兩個操作數(shù)都是對象，則比較他們是不是同一個對象，如果都指向同一個對象，則相等操作符返回true

全等和不全等 ===, !==

除了比較之前不轉(zhuǎn)換操作數(shù)類型，全等和不全等與相等和不相等操作符沒有掃碼區(qū)別。

null == undefined     // true
null === undefined    // false null 和 undefined是兩個基本類型

variable = boolean_expression ? true_value : false_value;

= 把右側(cè)的值賦給左側(cè)的變量

*= /= %= += -=

<<= 左移賦值

">>=" 有符號右移賦值

">>>=" 無符號右移賦值

主要目的就是簡化賦值操作，使用它們不能帶來任何性能的提升

使用逗號操作符可以在一條語句中執(zhí)行多個操作

逗號操作符總會返回表達式中的最后一項

var num1=1, num2=2, num3=3;
var num = (5,3,2,4,0);     // num的值為0

推薦代碼塊寫法

后測試循環(huán)語句，只有在循環(huán)體中的代碼執(zhí)行之后，才會測試出口條件

var i = 2;
do {
    i += 2;
    console.log(i);
} while (i < 2);

// 打印 4

前測試循環(huán)語句，在循環(huán)體內(nèi)的代碼被執(zhí)行之前，就會對出口條件求值

var i = 2;
while (i < 2 ) {
    i += 2;
    console.log(i);
}
// 沒有打印

前測試循環(huán)語句，在循環(huán)體內(nèi)的代碼被執(zhí)行之前，就會對出口條件求值

使用while循環(huán)做不到的，使用for循環(huán)同樣做不到，也就是說for循環(huán)只是把循環(huán)有關(guān)的代碼集中在了一個位置

由于ECMAScript中不存在塊級作用域，因此在循環(huán)內(nèi)部定義的變量也可以在外部訪問到

// 無限循環(huán)
for (;;) {
    ...
}

for-in語句是一種精準迭代語句，可以用來枚舉對象的屬性

循環(huán)輸出的屬性名的順序是不可預測的，根據(jù)瀏覽器而異

迭代對象為null或undefined會拋出錯誤， ECMAScript 5 更正了這一行為，不再拋出錯誤，而是不執(zhí)行語句

加標簽的語句一般都要與for語句等循環(huán)語句配合使用

var i, j;

loop1:
for (i = 0; i < 3; i++) {      //The first for statement is labeled "loop1"
   loop2:
   for (j = 0; j < 3; j++) {   //The second for statement is labeled "loop2"
      if (i == 1 && j == 1) {
         continue loop1;
      }
      console.log("i = " + i + ", j = " + j);
   }
}

// Output is:
//   "i = 0, j = 0"
//   "i = 0, j = 1"
//   "i = 0, j = 2"
//   "i = 1, j = 0"
//   "i = 2, j = 0"
//   "i = 2, j = 1"
//   "i = 2, j = 2"
// Notice how it skips both "i = 1, j = 1" and "i = 1, j = 2"

var itemsPassed = 0;
var i, j;

top:
for (i = 0; i < items.length; i++){
  for (j = 0; j < tests.length; j++){
    if (!tests[j].pass(items[i])){
      continue top;
    }
  }

  itemsPassed++;
}

var i, j;

loop1:
for (i = 0; i < 3; i++) {      //The first for statement is labeled "loop1"
   loop2:
   for (j = 0; j < 3; j++) {   //The second for statement is labeled "loop2"
      if (i == 1 && j == 1) {
         break loop1;
      }
      console.log("i = " + i + ", j = " + j);
   }
}

// Output is:
//   "i = 0, j = 0"
//   "i = 0, j = 1"
//   "i = 0, j = 2"
//   "i = 1, j = 0"
// Notice the difference with the previous continue example

break會立即退出循環(huán)

continue雖然也會立即退出循環(huán)，但會從循環(huán)頂部繼續(xù)執(zhí)行

嚴格模式下不能使用

定義with語句的目的主要是為了簡化多次編寫同一個對象的工作

大量使用with語句會導致性能下降，同時也會給調(diào)式代碼造成困難

var qs = location.search.substring(1);
var hostName = location.hostname;
var url = location.href;

with(location) {
    var qs = search.substring(1);
    var hostName = hostname;
    var url = href;
}

通過為每個case后面都添加一個break語句，就可以避免同時執(zhí)行多個case

假如確實需要混合集中情形，不要忘了添加注釋，說明有意省略了break關(guān)鍵字

switch語句在比較值時使用的是全等操作，因此"10"不等于10

switch (i) {
    case 25:
        // 合并兩種情況
    case 35:
        alert("25 or 35");
        break;
    case 45:
        alert("45");
        break;
    default:
        alert("Other");
}

return語句可以不帶任何返回值，函數(shù)在停止執(zhí)行后返回undefined

推薦的做法是要么讓函數(shù)始終都返回一個值要么永遠都不要返回值，否則會給調(diào)試帶來麻煩

嚴格模式對函數(shù)有一些限制，否則會拋出錯誤

不能把函數(shù)命名為eval或arguments

不能把參數(shù)命名為eval或arguments

不能出現(xiàn)兩個命名參數(shù)同名的情況

ECMAScript函數(shù)不介意傳遞進來多少個參數(shù)，也不在乎數(shù)據(jù)類型，即便定義接受兩個參數(shù)，調(diào)用時也未必要傳兩個

原因是ECMAScript中的參數(shù)在內(nèi)部是用一個數(shù)組來表示的，在函數(shù)體內(nèi)可以通過arguments對象來訪問這個參數(shù)數(shù)組

arguments對象只是與數(shù)組類似，它并不是Array的實例，可以用方括號語法訪問每個元素，也有l(wèi)ength屬性

函數(shù)體內(nèi)部可以arguments[0],arguments[1]...不顯式地使用參數(shù)，說明ECMAScript函數(shù)的一個重要特點：命名的參數(shù)只提供便利性，但不是必需的，解析器不會驗證參數(shù)名

函數(shù)體內(nèi)可以直接使用arguments[1] = 10 來給參數(shù)賦值，但嚴格模式下會報錯不能使用

ECMAScript函數(shù)不能像傳統(tǒng)意義上那樣實現(xiàn)重載，而在其他語言中可以為一個函數(shù)編寫兩個定義，只要這兩個定義的簽名（接受的參數(shù)的類型和數(shù)量）不同即可

如果在ECMAscript中定義了兩個名字相同的函數(shù)，則該名字只屬于后定義的函數(shù)