語(yǔ)法

Javascript語(yǔ)法中的基本規(guī)范

區(qū)分大小寫

ECMAScript中的一切（變量、函數(shù)名和操作符）都區(qū)分大小寫。
所以，test和Test分別表示兩個(gè)不同的變量；

標(biāo)識(shí)符

標(biāo)識(shí)符：指變量、函數(shù)、屬性的名字，或者函數(shù)的參數(shù)；規(guī)則如下：

• 第一個(gè)字符必須是一個(gè)字母、下劃線（_）或一個(gè)美元符號(hào)（$）；
• 其他字符可以是字母、下劃線、美元符號(hào)和數(shù)字；

命名慣例：ECMAScript標(biāo)識(shí)符采用駝峰大小寫格式，如：myCar , doSomethingImportant 等；
駝峰格式不是強(qiáng)制要求的，但和官方命名規(guī)范保持一致是個(gè)好習(xí)慣；
不能把關(guān)鍵字、保留字、true、false和null用作標(biāo)識(shí)符；

注釋

單行注釋
// 單行注釋

塊級(jí)注釋
/*
第一行注釋
第二行注釋
*/

語(yǔ)句

• 語(yǔ)句結(jié)尾加上分號(hào)，有些時(shí)候不是必須的，加上是個(gè)好習(xí)慣；
• 遇到控制語(yǔ)句時(shí)，代碼塊使用｛｝，哪怕只有一行代碼；

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

關(guān)鍵字
break do instanceof typeof 等一堆；
保留字
long int public static 等一堆；

變量

ECMAScript 的變量是松散類型的，就是可以用來保存任何類型的數(shù)據(jù)。
定義變量時(shí)使用var操作符，如下：

var message;

這行代碼定義了一個(gè)名為 message的變量，該變量可以用來保存任何值，像這樣未經(jīng)過初始化的變量，會(huì)保存一個(gè)特殊的值 undefined 。也可以直接初始化變量，即設(shè)置變量的值，如下：

var message = 'hi'; 
message = 100;    //有效，但不推薦

上面例子，開始保存了一個(gè)字符串值，又被一個(gè)數(shù)字值取代。雖然不建議這樣做，但這樣做也沒錯(cuò)；

如果在函數(shù)中使用var定義一個(gè)變量，這個(gè)變量在函數(shù)退出后會(huì)被銷毀，如下：

function test(){
  var message = "hi";   //局部變量
}
test();
alert(message);  // 錯(cuò)誤

上面例子，變量message是在函數(shù)中使用var定義的，當(dāng)函數(shù)被調(diào)用時(shí)，就會(huì)創(chuàng)建該變量并為其賦值。之后，這個(gè)變量又會(huì)立即被銷毀，因此代碼就會(huì)導(dǎo)致錯(cuò)誤。

如果省略var操作符，就會(huì)創(chuàng)建一個(gè)全局變量。

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

上面例子，省略了var 操作符，因而message就成了全局變量。這樣，只要調(diào)用過一次test()函數(shù)，這個(gè)變量就有了定義，就可以在函數(shù)上部的任何地方被訪問到。
省略var操作符可以定義全局變量，但不推薦這樣做。因?yàn)樵诰植孔饔糜蛑卸x的全局變量很難維護(hù)，也可能導(dǎo)致混亂。

可以使用一條語(yǔ)句定義多個(gè)變量，用逗號(hào)分開即可，如下：

var message = "hi",
    found = false,
    age = 30;

上面例子，定義并初始化了3個(gè)變量。

數(shù)據(jù)類型

ECMAScript中有5種基本數(shù)據(jù)類型：Undefined Null Boolean Number String
還有一種復(fù)雜數(shù)據(jù)類型： Object。
Object 本質(zhì)上是由一組無序的名值對(duì)組成的。

typeof操作符 負(fù)責(zé)檢測(cè)給定變量的數(shù)據(jù)類型；對(duì)一個(gè)值使用typeof操作符可能返回下列某個(gè)字符串：

• “undefined” --- 如果這個(gè)值未定義；
• “boolean” ---如果這個(gè)值是布爾值；
• “string” --- 如果這個(gè)值是字符串；
• “number” --- 如果這個(gè)值是數(shù)值；
• “boject” --- 如果這個(gè)值是對(duì)象或null；
• “function” --- 如果這個(gè)值是函數(shù)；

var msg = "some string"; 
alert(typeof msg); // "string"
alert(typeof(msg)); // "string"
alert(typeof 95); // "number"

上面例子，typeof 操作符的操作數(shù)，可以是變量，也可以是數(shù)值字面量。
typeof 是一個(gè)操作符而不是函數(shù)，因此例子中的圓括號(hào)盡管可以使用，但不是必需的；

Undefined 類型

Undefined 類型只有一個(gè)值，即特殊的undefined。 在使用var聲明變量但未對(duì)其加以初始化時(shí)，這個(gè)變更的值就是 undefined，例如：

var msg;
alert(msg == undefined);  // true

Null 類型

Null 類型是第二個(gè)只有一值的數(shù)據(jù)類型，這個(gè)特殊的值就是 null。 從邏輯角度來看，null 值表示一個(gè)空對(duì)象指針，而這也正是使用typeof操作符檢測(cè)null值時(shí)會(huì)返回"object"的原因，如下：

var car = null ; 
alert(typeof(car)); // "object"

上面例子，如果定義的變量準(zhǔn)備在將來用于保存對(duì)象，那么最好將該變量初始化為null。這樣一來，只要直接檢查null值就可以知道相應(yīng)的變量是否已經(jīng)保存了一個(gè)對(duì)象的引用，如下：

if(car != null){
  // 對(duì)car對(duì)象執(zhí)行某些操作
}

實(shí)際上，undefined值是派生自null值的，因此ECMA-262規(guī)定對(duì)他們的相等性測(cè)試要返回true;

alert(null == undefined);  //true

Boolean類型

Boolean 類型是ECMAScript 中使用最多的一種類型，該類型只有兩個(gè)字面值：true 和 false。

var found = true; 
var lost = false;

上面例子，Boolean 類型的字面值 true 和 false 是區(qū)分大小寫的，也就是說，True 和 False 都不是Boolean值，只是標(biāo)識(shí)符；

要將一個(gè)值轉(zhuǎn)換為其對(duì)應(yīng)的 Boolean 值，可以調(diào)用轉(zhuǎn)型函數(shù) Boolean()，如下：

var msg = "Hello Javascript"; 
var msgAsBoolean = Boolean(msg);
console.log(msgAsBoolean);  // true

可以對(duì)任何數(shù)據(jù)類型的值調(diào)用 Boolean() 函數(shù)，而且總會(huì)返回一個(gè) Boolean 值。至于返回的這個(gè)值是 true 還是 false，取決于要轉(zhuǎn)換值的數(shù)據(jù)類型及其實(shí)際值，如下：

轉(zhuǎn)換為true的值

• 任何非空字符串（String）
• 任何非零數(shù)字值（Number）
• 任何對(duì)象（Object）

轉(zhuǎn)換為false的值

• “”空字符串（String）
• 0和NaN（Number）
• null （Object）
• undefined

這些轉(zhuǎn)換規(guī)則對(duì)理解流控制語(yǔ)句（如if語(yǔ)句）自動(dòng)執(zhí)行相應(yīng)的 Boolean 轉(zhuǎn)換非常重要，如下：

var msg = "Hello Javascript";
if (msg){
  alert("value is true");
}

上面例子能彈出框，因?yàn)樽址甿sg被自動(dòng)轉(zhuǎn)換成對(duì)應(yīng)的 Boolean 值（ture）。由于存在這種自動(dòng)執(zhí)行的 Boolean 轉(zhuǎn)換，因此確切地知道在流控制語(yǔ)句中使用的是什么變量至關(guān)重要。

Number類型

這種類型使用IEEE754格式來表示整數(shù)和浮點(diǎn)數(shù)值，最基本的字面量格式是十進(jìn)制整數(shù)，如下：

var iteNum = 55;  // 整數(shù)

除了十進(jìn)制，還可以通過八進(jìn)制和十六進(jìn)制的字面值來表示。
其中，八進(jìn)制字面值的第一位必須是零（0），然后是八進(jìn)制數(shù)字序列（0-7），如果字面值中的數(shù)值超出范圍，那么前導(dǎo)零將被忽略，后面的數(shù)值半被當(dāng)作十進(jìn)制數(shù)值解析。如下：

var octalNum1 = 070;  // 八進(jìn)制的56 
var octalNum2 = 079;  // 無效的八進(jìn)制數(shù)值， 被解析為79 
var octalNum3 = 08;    // 無效的八進(jìn)制數(shù)值，被解析為8

十六進(jìn)制字面值的前兩位必須是0x，后跟任何十六進(jìn)制數(shù)字（0-9及A-F）。其中，字母A-F可以大寫，也可以小寫，如下：

var hexNum1= 0xA;  // 十六進(jìn)制10
var hexNum2= 0x1f;  // 十六進(jìn)制31

在進(jìn)行算術(shù)計(jì)算時(shí)，所有以八進(jìn)制和十六進(jìn)制的表示的數(shù)值都將被轉(zhuǎn)換成十進(jìn)制數(shù)值。

浮點(diǎn)數(shù)值
所謂浮點(diǎn)數(shù)值，就是該數(shù)值中必須包含一個(gè)小數(shù)點(diǎn)，并且小數(shù)點(diǎn)后面必須至少有一位數(shù)字。

var floatNum1 = 1.1; 
var floatNum2 = 0.1;
var floatNum3 = .1;   //  有效，但不推薦；
var floatNum4 = 1.;   //  小數(shù)點(diǎn)后面沒有數(shù)字，解析為1
var floatNum5 = 10.0  //  整數(shù)，解析為10
var floatNum6 = 3.125e7;  //  科學(xué)計(jì)數(shù)法，等于31250000

浮點(diǎn)數(shù)值計(jì)算會(huì)產(chǎn)生舍入誤差的問題，例如：0.1加0.2不等于0.3，而是0.30000000000000004。 浮點(diǎn)數(shù)的最高精度是17位小數(shù)。

NaN
Nan，即非數(shù)值（Not a Number）是一個(gè)特殊的數(shù)值，這個(gè)數(shù)值用于表示一個(gè)本來要返回?cái)?shù)值的操作數(shù)未返回?cái)?shù)值的情況，這樣就不會(huì)拋出錯(cuò)誤了。
Nan本身有兩個(gè)非同尋常的特點(diǎn)：

• 任何涉及NaN的操作（Nan/10）都會(huì)返回NaN；
• NaN與任何值都不相等，包括NaN本身； 即 console.log(NaN == NaN) 會(huì)返回 false；

isNaN()函數(shù)
這個(gè)函數(shù)接受一個(gè)參數(shù)，該參數(shù)可以是任何類型，函數(shù)會(huì)確定這個(gè)參數(shù)是否“不是數(shù)值”。
isNaN() 在接收到一個(gè)值之后，會(huì)嘗試將這個(gè)值轉(zhuǎn)換成數(shù)值，某些不是數(shù)值的值會(huì)直接轉(zhuǎn)換為數(shù)值，如：字符串‘10’或Boolean值。任何不能被轉(zhuǎn)換為數(shù)值的值都會(huì)返回 true，如下：

console.log(isNaN(NaN));     // true
console.log(isNaN(10));      // false (10是一個(gè)數(shù)值)
console.log(isNaN(‘10’));    // false (可以被轉(zhuǎn)換成數(shù)值10)
console.log(isNaN(true));    // fasle (可以被轉(zhuǎn)換成數(shù)值1)
console.log(isNaN(‘blue’));  // true (不能轉(zhuǎn)換成數(shù)值)

isNaN 也適用于對(duì)象，在基于對(duì)象調(diào)用 isNaN()函數(shù)時(shí)，會(huì)首先調(diào)用對(duì)象的 valueOf() 方法，確定該方法返回的值是否可以轉(zhuǎn)換為數(shù)值，如果不能，則基于這個(gè)返回值再調(diào)用 toString() 方法，再測(cè)試返回值。

數(shù)值轉(zhuǎn)換
有3個(gè)函數(shù)可以把非數(shù)值轉(zhuǎn)換為數(shù)值：Number() 、parseInt()、parseFloat()
Number() 可以用于任何數(shù)據(jù)類型，另兩個(gè)函數(shù)則專門用于把字符串轉(zhuǎn)換成數(shù)值。

Number() 函數(shù)的轉(zhuǎn)換規(guī)則如下：

• 如果是 Boolean 值，true 和 false 將分別被轉(zhuǎn)換成 1 和0；
• 如果是數(shù)字值，即為數(shù)值；
• 如果是 null 值，返回 0;
• 如果是 undefined ，返回 NaN ;
• 如果是字符串，那么按如下規(guī)則：
  ++ 如果字符串中只包含數(shù)字，則將其轉(zhuǎn)換為十進(jìn)制數(shù)值，即 “1” 會(huì)變成1，“123”會(huì)變成123，而“011”會(huì)變成11（注意：前導(dǎo)的零被忽略了）
  ++ 如果字符串中包含有效的浮點(diǎn)格式，如“1.1”，則將其轉(zhuǎn)換為對(duì)應(yīng)的浮點(diǎn)值。
  ++ 如果字符串中包含有效的十六進(jìn)制格式，例如：“0xF”，則將其轉(zhuǎn)換為相同大小的十進(jìn)制整數(shù)值；
  ++ 如果字符串是空的，則將其轉(zhuǎn)換為 0；
  ++ 如果字符串中包含除上述格式之外的字符，則將其轉(zhuǎn)換為NaN；
• 如果是對(duì)象，則調(diào)用對(duì)象的valueOf()方法，然后按照前面的規(guī)則轉(zhuǎn)換返回的值。如果轉(zhuǎn)換的結(jié)果是NaN，則調(diào)用對(duì)象的toString()方法，然后再次按照前面的規(guī)則轉(zhuǎn)換返回的字符串值。

規(guī)則講完，看實(shí)例：

var num1 = Number("hello");   // NaN
var num2 = Number("");        // 0
var num2 = Number("000011");  // 11
var num2 = Number("true");    // 1

hello 因?yàn)椴话瑪?shù)字值，所以被轉(zhuǎn)換成NaN，空字符串會(huì)被轉(zhuǎn)換成0，字符串“000011”會(huì)被轉(zhuǎn)換為11，true 值被轉(zhuǎn)成1。

處理整數(shù)時(shí)，更常用 parseInt() 函數(shù)。parseInt() 函數(shù)在轉(zhuǎn)換字符串時(shí)，更多的是看其是否符合數(shù)值模式。它會(huì)忽略字符串前面的空格，直到找到第一個(gè)非空格字符。如果第一個(gè)字符不是數(shù)字字符或者負(fù)號(hào)，parseInt() 就會(huì)返回NaN；也就是說，用parseInt() 會(huì)轉(zhuǎn)換空字符串返回NaN（Number()對(duì)空字符串返回0），如果第一個(gè)字符是數(shù)字字符，parseInt() 會(huì)繼續(xù)解析第二個(gè)字符，直到解析完所有或者遇到 了一個(gè)非數(shù)字字符。例如：“1234blue” 會(huì)被轉(zhuǎn)換成1234，因?yàn)?blue"被忽略。類似地，“22.5”會(huì)被轉(zhuǎn)換為22，因?yàn)樾?shù)點(diǎn)并不是有效的數(shù)字字符。也能識(shí)別八進(jìn)制和十六進(jìn)制，用的不多，不說了。

var num1 = parseInt("1234blue"); // 1234
var num2 = parseInt("123abc456"); // 123
var num3 = parseInt("");  // NaN
var num4 = parseInt("22.5");  // 22

與parseInt()類似，parseFloat() 也是從第一個(gè)字符開始解析每個(gè)字符，直到字符串結(jié)尾，或者解析到遇見一個(gè)無效的浮點(diǎn)數(shù)字字符為止。也就是說，字符串中的第一個(gè)小數(shù)點(diǎn)是有效的，而第二個(gè)小數(shù)點(diǎn)就無效了，因此后面的字符串會(huì)被忽略。

var num1 = parseFloat("123abc");  // 123
var num2 = parseFloat("22.5");  // 22.5
var num3 = parseFloat("22.34.5");  //22.34
var num4 = parseFloat("098.5"); // 98.5
var num5 = parseFloat("3.125e7");  // 31250000

字符串

字符串可以由雙引號(hào)（"）或單引號(hào)（‘）表示，兩種方式表示的字符串完全相同，如下：

var str1 = "hello javascript";
var str2 = 'hello javascript';

開頭和結(jié)尾要么都用雙引號(hào)，要么都用單引號(hào)，不能一邊是單引號(hào)，一邊是雙引號(hào)；

字符字面量
String 數(shù)據(jù)類型包含一些特殊的字符字面量，也叫轉(zhuǎn)義序列，用于表示非打印字符，或者其他用途的字符。
\n 換行；\t 制表；\b 退格；\r 回車； \f 進(jìn)紙； \\ 斜杠；\' 單引號(hào)；\" 雙引號(hào)；
任何字符串的長(zhǎng)度都可以通過訪問其length 屬性取得，如下：

console.log("hello javascript");  // 16

字符串拼接
字符串可以通過“+”來拼接，如下：

var lang = "Java"; 
lang = lang + "script"; 
console.log(lang);  //  Javascript

轉(zhuǎn)化為字符串
要把一個(gè)值轉(zhuǎn)換為字符串，有兩個(gè)方法： toString()方法和 String()函數(shù)。
數(shù)值、布爾值、對(duì)象和字符串值都有 toString() 方法，但null 和 undefined 值沒有這個(gè)方法。

var age = 11; 
var ageAsString = age.toString(); // 字符串 "11"
var found = true; 
var foundAsString = found.toString(); // 字符串“true”

在不知道要轉(zhuǎn)換的值是不是null 或 undefined 的情況下，還可以使用轉(zhuǎn)型函數(shù) String()，這個(gè)函數(shù)能將任何類型的值轉(zhuǎn)換為字符串。

• 如果值有 toString() 方法，則調(diào)用該 方法并返回相應(yīng)的結(jié)果；
• 如果值是 null，則返回“null”;
• 如果值是 undefined， 則返回"undefined";

var v1 = 10; 
var v2 = true; 
var v3 = null ; 
var v4;
console.log(String(v1)); // "10"
console.log(String(v2)); // "true"
console.log(String(v3)); // "null"
console.log(String(v4)); // "undefined"

要把某個(gè)值轉(zhuǎn)換為字符串，可以使用加號(hào)操作符把它與一個(gè)字符串（“”）加在一起,如下。

var v1 = 10; 
var v2 = v1+"";
console.log(typeof(v2)); // “10” --> string

Object類型

ECMAScript中的對(duì)象其實(shí)就是一組數(shù)據(jù)和功能的集合。對(duì)象可以通過執(zhí)行 new 操作符后跟要?jiǎng)?chuàng)建的對(duì)象類型的名稱來創(chuàng)建。而創(chuàng)建Object類型的實(shí)例并為其添加屬性或方法，就可以創(chuàng)建自定義對(duì)象，如：

var o = new Object();

僅創(chuàng)建Object的實(shí)例并沒有什么用處，在EMCAScript中，Object類型是所有它的實(shí)例的基礎(chǔ)。換句話說，Object 類型所具有的任何屬性和方法也同樣存在于他的實(shí)例中。
Object的每個(gè)實(shí)例都具有下列屬性方法：

• constructor：保存著用于創(chuàng)建當(dāng)前對(duì)象的函數(shù)；
• hasOwnProperty()：用于檢查給定的屬性在當(dāng)前對(duì)象實(shí)例中；
• isPrototypeof()：用于檢查傳入的對(duì)象是否是當(dāng)前對(duì)象的原型；
• propertyIsEnumerable()： 用于檢查給定的屬性是否能夠使用 for-in 語(yǔ)句來枚舉；
• toLocaleString()：返回對(duì)象的字符串表示，該字符串與執(zhí)行環(huán)境的地區(qū)對(duì)應(yīng)；
• toString()：返回對(duì)象的字符串表示；
• valueOf()：返回對(duì)象的字符串、數(shù)值或布爾值表示；
  在ECMAScript中Object是所有對(duì)象的基礎(chǔ)，所有對(duì)象都具有這些基本的屬性和方法。

操作符

ECMAScript 描述了一組用于操作數(shù)據(jù)值的操作符，包括算術(shù)操作符、位操作符、關(guān)系操作符和相等操作符。

一元操作符

只能操作一個(gè)值的操作符叫做一元操作符。 使用前置遞增操作符給一個(gè)數(shù)值加1時(shí)，把兩個(gè)加號(hào)(++)放在這個(gè)數(shù)值的前面，如下：

var age = 29;
++age;  // 30

前置遞增操作符把a(bǔ)ge的值變成 了30，實(shí)際上，執(zhí)行這個(gè)前置遞增操作與執(zhí)行以下操作的效果相同：

var age =29;
age = age +1;

執(zhí)行遞減操作的方法也類似，變量的值都是在語(yǔ)句被求值以前改變的。這種情況被稱作：副效應(yīng)。

var age = 29; 
var anotherAge = --age +2;

console.log(age);  // 輸出28；
console.log(anotherAge);  // 輸出30

上面例子，變量anotherAge的初始值等于變量age的值前置遞減之后加2。由于先執(zhí)行了減法操作，age的值變成了28，所以再加上2的結(jié)果就是30。

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

上面例子，num3之所以等于21是因?yàn)閚um1先減去了1才與num2相加，而變量num4也等于21是因?yàn)橄鄳?yīng)的加法操作使用了num1減去1之后的值。

后置型遞增和遞減操作符的語(yǔ)法不變，只不過要放在變量的后面而不是前面。
與前置遞增遞減的重要區(qū)別是：后置的操作是在包含它們的語(yǔ)句被求值之后才執(zhí)行的。

var num1 = 2; 
var num2 = 20;
var num3 = num1-- + num2;  // 22  與前置 -- 的重要區(qū)別，先求值后遞減
var num4 = num1 + num2;   // 21

與前置不同，差別在計(jì)算 num3時(shí)使用num1 的原始值（2）完成了加法計(jì)算，而num4則使用了遞減后的值（1）。

布爾操作符

布爾操作符一共有3個(gè)： 非(NOT)、與(AND)和或(OR)

邏輯非 ： 由一個(gè)嘆號(hào)（！）表示，無論這個(gè)值是什么數(shù)據(jù)類型，都會(huì)返回一個(gè)布爾值。
邏輯非操作符首先會(huì)將它的操作類轉(zhuǎn)換為一個(gè)布爾值，然后再對(duì)其求反。

• 如果操作數(shù)是一個(gè)對(duì)象，返回false;
• 如果操作數(shù)是一個(gè)空字符串，返回true;
• 如果操作數(shù)是一個(gè)非空字符串，返回 false;
• 如果操作數(shù)是數(shù)值0，返回true;
• 如果操作數(shù)是任意非0數(shù)值（包括：Infinity），返回 false;
• 如果操作數(shù)是null ，返回 true;
• 如果操作數(shù)是NaN，返回 true;
• 如果操作數(shù)是undefined，返回true;

console.log(!flase); // true
console.log(!"blue"); //false
console.log(!0); // true
console.log(!NaN); // true
console.log(!""); // true
console.log(!12345); // false

同時(shí)使用兩個(gè)邏輯非，實(shí)際上會(huì)模擬 Boolean() 轉(zhuǎn)型函數(shù)，最終結(jié)果與對(duì)這個(gè)值使用 Boolean() 函數(shù)相同，如：

console.log(!!"blue"); //true
console.log(!!0); // false
console.log(!!NaN); // false
console.log(!!""); // false
console.log(!!12345); // true

邏輯與 由兩個(gè)和號(hào)（&&）表示，有兩個(gè)操作數(shù)，如下：

var res = true && false;

邏輯與的真值表
第一個(gè)操作數(shù) 第二個(gè)操作數(shù) 結(jié)果
true true --> true
true false --> false
false true --> false
false false --> false

邏輯與 操作可以應(yīng)用于任何類型的操作數(shù)，而不僅僅是布爾值，在有一個(gè)操作數(shù)不是布爾值的情況下，邏輯與 操作就不一定返回爾值。

• 如果第一個(gè)操作是對(duì)象，則返回第二個(gè)操作數(shù)；
• 如果第二個(gè)操作數(shù)是對(duì)象，則只有在第一個(gè)操作數(shù)據(jù)求值結(jié)果為true的情況下，才會(huì)返回該對(duì)象；
• 如果兩個(gè)操作數(shù)都是對(duì)象，則返回第二個(gè)操作數(shù)；
• 如果有一個(gè)操作數(shù)是null (NaN或undefined)，則返回null (NaN或undefined)；

邏輯與 操作屬于短路操作，即如果第一個(gè)操作數(shù)能夠決定結(jié)果，那么就不會(huì)再對(duì)第二個(gè)操作數(shù)求值。對(duì)于 邏輯與 操作而言，如果第一個(gè)操作數(shù)是 false，則無論第二個(gè)操作數(shù)是什么值，結(jié)果都不再可能是 true 了，如：

var found = true; 
var res = (found && someUndefinedVariable);  // 這里發(fā)生錯(cuò)誤
alert(res);  // 這一行不會(huì)執(zhí)行

上面例子，當(dāng)執(zhí)行 邏輯與 操作時(shí)會(huì)發(fā)生錯(cuò)誤，因?yàn)樽兞?someUndefinedVariable 沒有聲明。
由于變量 found 的值是 true，所以邏輯與操作符會(huì)繼續(xù)對(duì)變量 someUndefinedVariable 求值，但他尚未定義，因此報(bào)錯(cuò)，這說明不能在邏輯與操作中使用未定義的值。如果將 found 的值設(shè)置為 false，就不會(huì)報(bào)錯(cuò)。

var found = false; 
var res = (found && someUndefinedVariable);  // 不會(huì)報(bào)錯(cuò)
alert(res);   //  會(huì)執(zhí)行，結(jié)果是 false

無論變量someUndefinedVariable 有沒有定義，永遠(yuǎn)不會(huì)對(duì)它求值，因?yàn)榈谝粋€(gè)操作數(shù)的值是 false。 意味著邏輯與的結(jié)果必定是false，根本用不著再對(duì) && 右側(cè)的操作數(shù)求值了。

在使用邏輯與操作符時(shí)要始終銘記，它是一個(gè)短路操作符。

邏輯或
邏輯或操作符由兩個(gè)豎線符號(hào)（||）表示，如下：

var res = true || false; 

邏輯或的真值表
第一個(gè)操作數(shù) 第二個(gè)操作數(shù) 結(jié)果
true true --> true
true false --> true
false true --> true
false false --> false

與邏輯與相似，如果有一個(gè)操作數(shù)不是布爾值，邏輯或也不一定返回布爾值；

• 如果第一個(gè)操作數(shù)是對(duì)象，則返回這個(gè)對(duì)象；
• 如果第一個(gè)操作數(shù)的求值結(jié)果為 false，則返回第二個(gè)操作數(shù)；
• 如果兩個(gè)操作數(shù)都是對(duì)象，則返回第一個(gè)操作數(shù)；
• 如果兩個(gè)操作數(shù)都是null(NaN或undefined)，則返回null(NaN或undefined);

與邏輯與操作符相似，邏輯或操作符也是短路操作符。也就是說，如果第一個(gè)操作數(shù)的求值結(jié)果為 true， 就不會(huì)對(duì)第二個(gè)操作數(shù)求值了，看實(shí)例：

var found = true; 
var res = (found || someUndefinedVariable) ;     // 不會(huì)發(fā)生錯(cuò)誤
console.log(res);  // 會(huì)執(zhí)行 true

上面例子，變量someUndefinedVariable 也沒有定義，但是，由于變量 found 的值是true，而變量 someUndefinedVariable永遠(yuǎn)不會(huì)被求值，因此結(jié)果就會(huì)輸出 true，

我們可以邏輯或的這一行為來避免為變量賦null或undefined值，如：

var myObject = preferredObject || backupObject;

上面例子，變量myObject將被賦予等號(hào)后面兩個(gè)值中的一個(gè)，變量preferredObject中包含優(yōu)先賦給變量 myObject 的值，變量 backupObject負(fù)責(zé)在preferredObject中不包含有效值的情況下提供后備值。如果preferredObject的值不是null，那么它的值將被賦給myObject；如果是null，則將backupObject的值賦給 myObject。ECMAScript程序的賦值語(yǔ)句經(jīng)常會(huì)使用這種模式。

乘性操作符

ECMAScript 定義了3個(gè)乘性操作符：乘法、除法和求模。在操作數(shù)為非數(shù)值的情況下會(huì)執(zhí)行自動(dòng)的類型轉(zhuǎn)換。如果參與乘性計(jì)算的某個(gè)操作數(shù)不是數(shù)值，后臺(tái)先使用Number()轉(zhuǎn)型函數(shù)將其轉(zhuǎn)換為數(shù)值。也就是說，空字符串將被當(dāng)作0，布爾值將被當(dāng)作1。

乘法
乘法操作符由一個(gè)星號(hào)（*）表示，用于計(jì)算兩個(gè)數(shù)值的乘積。

var res = 34*56

在處理特殊值的情況下，乘法操作符遵循下列特殊的規(guī)則：

• 如果操作數(shù)都是數(shù)值，執(zhí)行常規(guī)的乘法計(jì)算；
• 如果有一個(gè)操作數(shù)是NaN，則結(jié)果是NaN；
• 如果是Infinity與0相乘，則結(jié)果是NaN;
• 如果是Infinity與非0數(shù)相乘，則結(jié)果是Infinity 或-Infinity，取決于有符號(hào)操作數(shù)的符號(hào)；
• 如果是Infinity 與Infinity 相乘，則結(jié)果是 Infinity；
• 如果有一個(gè)操作數(shù)不是數(shù)值，則在后臺(tái)調(diào)用 Number() 將其轉(zhuǎn)換為數(shù)值，然后再應(yīng)用上面的規(guī)則。

除法
除法操作符由一個(gè)斜線符號(hào)（/）表示；

var res = 66/11;

與乘法操作符類似，除法操作符對(duì)特殊值也有特殊的處理規(guī)則，如下：

• 如果操作數(shù)都是數(shù)值，執(zhí)行常規(guī)的除法計(jì)算；
• 如果有一個(gè)操作數(shù)是NaN，則結(jié)果是NaN；
• 如果是Infinity被Infinity除，則結(jié)果是NaN;
• 如果是零被零除，則結(jié)果是NaN;
• 如果是非零的有限數(shù)被零除，則結(jié)果是 Infinity 或 -Infinity；
• 如果是Infinity被任何非零數(shù)值除，結(jié)果是Infinity或-Infinity；
• 如果有一個(gè)操作數(shù)不是數(shù)值，則在后臺(tái)調(diào)用 Number() 將其轉(zhuǎn)換為數(shù)值，然后再應(yīng)用上面的規(guī)則。

求模
求模（求余）操作符由一個(gè)百分號(hào)（%）表示；

var res = 26%5;  // 1

特殊規(guī)則

• 如果操作數(shù)都是數(shù)值，執(zhí)行常規(guī)的除法計(jì)算，返回除得的余數(shù)；
• 如果被除數(shù)是無窮大值而除數(shù)是有限大的數(shù)值，則返回NaN；
• 如果被除數(shù)是有限大的數(shù)值而除數(shù)是零，則結(jié)果是NaN；
• 如果是Infinity被Infinity除，則結(jié)果是NaN；
• 如果被除數(shù)是有限大的數(shù)值而除數(shù)是無窮大的數(shù)值，則結(jié)果是被除數(shù)；
• 如果被除數(shù)是零，則結(jié)果是零；
• 如果有一個(gè)操作數(shù)不是數(shù)值，則在后臺(tái)調(diào)用 Number() 將其轉(zhuǎn)換為數(shù)值，然后再應(yīng)用上面的規(guī)則。

加性操作符

加法和減法也會(huì)在后臺(tái)轉(zhuǎn)換不同的數(shù)據(jù)類型，撿點(diǎn)重要的說一說；
加法
加法操作符（+） 的用法：

var res = 1+2;

如果兩個(gè)操作符都是數(shù)值，執(zhí)行常規(guī)的加法計(jì)算

• 如果有一個(gè)操作數(shù)是NaN，則結(jié)果是NaN;
• 如果有一個(gè)操作數(shù)是字符串，那么
  ++ 如果兩個(gè)操作數(shù)都是字符串，則將第二個(gè)操作數(shù)與第一個(gè)操作數(shù)拼接起來；
  ++ 如果只有一個(gè)是字符串，則將另一個(gè)操作數(shù)轉(zhuǎn)換成字符串再將兩個(gè)字符串拼接；
• 如果有一個(gè)操作數(shù)是對(duì)象、數(shù)值或布爾值，則調(diào)用他們的toString()方法取得相應(yīng)的字符串值，然后拼接。對(duì)于undefined 和 null ，則分別調(diào)用String()函數(shù)并取得字符串“undefined”和“null”。

var res1 = 5+5;  // 兩數(shù)相加
alert(res1);  // 10

var res2 = 5+"5";  // 一個(gè)數(shù)值和一個(gè)字符串相加
alert(res2);  // "55"

第一行代碼演示了正常的情況，即5+5等于10（數(shù)值）。但是，如果將一個(gè)操作數(shù)改為字符串“5”，結(jié)果就變成了"55"（字符串值），因?yàn)榈谝粋€(gè)操作數(shù)也被轉(zhuǎn)成了"5"。
減法
減法操作符（-）的用法：

var res = 2-1;

與加法類似，也有一些特殊用法：

• 如果兩個(gè)操作符都是數(shù)值，執(zhí)行常規(guī)的算術(shù)減法操作；
• 如果有一個(gè)操作數(shù)是NaN，則結(jié)果是NaN；
• 如果是 -0 減 -0 ，則結(jié)果是+0；
• 如果有一個(gè)操作數(shù)是字符串、布爾值、null 或 undefined，則先在后臺(tái)調(diào)用 Number() 函數(shù)將其轉(zhuǎn)換為數(shù)值，然后再根據(jù)前面的規(guī)則執(zhí)行減法計(jì)算 ，如果轉(zhuǎn)換的結(jié)果是 NaN ，則減法的結(jié)果是NaN；
• 如果有一個(gè)操作數(shù)是對(duì)象，則調(diào)用對(duì)象的valueOf()方法 以取得表示該 對(duì)的數(shù)值，如果得到的是NaN，則減法的結(jié)果就是NaN，如果對(duì)象沒有 valueOf() 方法 ，則調(diào)用其toString()方法并將得到字符串轉(zhuǎn)換為數(shù)值。

var res1 = 5- true;  // 4 因?yàn)?true 被轉(zhuǎn)換成了1
var res2 = Nan -1; // NaN
var res3 = 5-"";  // 5 因?yàn)椤啊?被轉(zhuǎn)換成了0
var res4 = 5-"2"; // 3 , 因?yàn)椤?”被轉(zhuǎn)換成了2
var res5 = 5-null; // 5, 因?yàn)閚ull被轉(zhuǎn)換成了0

關(guān)系操作符

小于（<）、大于（>）、小于等于（<=）和大于等于（>=）這幾個(gè)關(guān)系操作符用于對(duì)兩個(gè)值進(jìn)行比較。
這幾個(gè)操作符，都返回布爾值：

var res1 = 5> 3; // true
var res2 = 5< 3; // false

當(dāng)關(guān)系操作符使用了非數(shù)值時(shí)，也要進(jìn)行數(shù)據(jù)轉(zhuǎn)換或完成某些奇怪的操作：

• 如果兩個(gè)操作數(shù)都是數(shù)值，則執(zhí)行數(shù)值比較；
• 如果兩個(gè)操作數(shù)都是字符串，則比較兩個(gè)字符串的字符編碼值；
• 如果一個(gè)操作數(shù)是數(shù)值，則將另一個(gè)操作數(shù)轉(zhuǎn)換為一個(gè)數(shù)值，然后執(zhí)行數(shù)值比較；
• 如果一個(gè)操作數(shù)是對(duì)象，則調(diào)用這個(gè)對(duì)象的valueOf()方法，用得到的結(jié)果執(zhí)行比較，如果對(duì)象沒有valueOf()方法，則調(diào)用toString()方法，并用得到的結(jié)果執(zhí)行比較；
• 如果一個(gè)操作數(shù)是布爾值，則先將其轉(zhuǎn)換為數(shù)值，再執(zhí)行比較；
  一些可能讓人困惑又合理的比較結(jié)果，如下：

var res = "Brick" < "alphabet";  // true 

字符串"Brick"被認(rèn)為小于字符串"alphabet"，因?yàn)樽帜窧的字符編碼是66，而字母a的字符編碼是97。
全部轉(zhuǎn)換成小寫，再執(zhí)行比較，如下：

var res = "Brick".toLowerCase() < "alphabet".toLowerCase();  // false

上面例子，"alphabet"按字母表順序排在"Brick"之前；
再看一個(gè)，兩個(gè)數(shù)字字符串比較，如：

var res = "23" < "3";  // true

兩個(gè)字符串比較，比較的是字符編碼，字符串“23”中“2”的字符編碼是50，而“3”的編碼是51。
如果把其中一個(gè)操作數(shù)改為數(shù)值，那么：

var res = "23" < 3;  // false

此時(shí)，字符串"23"會(huì)被轉(zhuǎn)換成數(shù)值23，再與3比較，就會(huì)得出合理的結(jié)果。
如果字符串不能被轉(zhuǎn)換成數(shù)值的話，如：

var res = "a" < 3; // false,因?yàn)?a"被轉(zhuǎn)換成了NaN

由于字母"a"不能被轉(zhuǎn)換成數(shù)值，就轉(zhuǎn)換成了NaN。任何操作數(shù)與NaN進(jìn)行關(guān)系比較，都是false，于是：

var res1 = NaN > 3; // false
var res2 = NaN <= 3:  // false

與NaN比較時(shí)，結(jié)果都返回NaN；

相等操作符

相等和不相等：先轉(zhuǎn)換再比較；
全等和不全等：僅比較而不轉(zhuǎn)換；

相等和不相等

相等操作符由兩個(gè)等于號(hào)（==）表示， 如果兩個(gè)操作數(shù)相等，則返回 true。
不相等操作由（!=）表示，如果兩個(gè)操作數(shù)不相等，則返回 true。
這兩個(gè)操作符都會(huì)先轉(zhuǎn)換操作數(shù)（通常稱為強(qiáng)制轉(zhuǎn)型），然后再比較相等性。

在轉(zhuǎn)換不同的數(shù)據(jù)類型時(shí)，相等和不相等的基本規(guī)則：

• 如果有一個(gè)操作數(shù)是布爾值，則在比較相等性之前先將其轉(zhuǎn)換為數(shù)值：false 轉(zhuǎn)換為0，true轉(zhuǎn)換為1；
• 如果一個(gè)操作數(shù)是字符串，另一個(gè)是數(shù)值，那先將字符串轉(zhuǎn)換成數(shù)值；
• 如果一個(gè)操作數(shù)是對(duì)象，另一個(gè)不是，則調(diào)用對(duì)象valueOf()方法，用得到的類型值進(jìn)行比較；

這兩個(gè)操作符在進(jìn)行比較時(shí)：

• null 和 undefined 是相等的；
• 要比較相等性之前，不能將null 和undefined轉(zhuǎn)換成其他任何值；
• 如果有一個(gè)操作數(shù)是 NaN ，則相等操作符返回 false，不相等操作符返回 true；NaN不等于自身；
• 如果兩個(gè)操作數(shù)都是對(duì)象，則比較他們是不是同一對(duì)象，如果都指向同一個(gè)對(duì)象，則相等返回 true，否則，返回 false

null == undefined; // true
"NaN" == NaN; // false  NaN 跟誰(shuí)比都不相等，也不等于自身
NaN == NaN;  // false
false == 0; // true
true == 1; // true
null == 0; // false
undefined == 0; // false
"5" == 5; // true

全等和不全等

全等用三個(gè)等于號(hào)（===）表示，它只在兩個(gè)操作數(shù)未經(jīng)轉(zhuǎn)換就相等的情況下返回 true；

var res1 = ("55" == 55) ; // true 因?yàn)檗D(zhuǎn)換成相等
var res2 = ("55" === 55); // false 因?yàn)椴煌臄?shù)據(jù)類型不相等

上面例子，相等操作符比較時(shí)，會(huì)轉(zhuǎn)換數(shù)據(jù)類型，字符串“55”被轉(zhuǎn)換成數(shù)值55，所以相等，返回true；
全等操作符比較時(shí)，不轉(zhuǎn)換數(shù)據(jù)類型，字符串不等于數(shù)值，所以不相等，返回 false；

不全等操作符用（!==）表示，在兩個(gè)操作數(shù)未經(jīng)轉(zhuǎn)換就不相等的情況下返回 true

var res1 = ("55" !== 55);  // false,因?yàn)檗D(zhuǎn)換后是相等的
var res2 = ("55" !=== 55); // true, 因?yàn)椴煌臄?shù)據(jù)類型不相等

null == undefined 會(huì)返回 true，因?yàn)樗麄兪穷愃频闹担?br> null === undefined 會(huì)返回 false， 因?yàn)樗麄兪遣煌愋偷闹担?/p>

為了保持代碼中數(shù)據(jù)類型的完整性，推薦使用全等和不全等操作符進(jìn)行比較。

條件操作符

條件 ? 真時(shí)的值 : 假時(shí)的值

variable = boolean_expression ? true_value : false_value;

基于對(duì) boolean_expression 求值的結(jié)果，決定給變量 variable 賦什么值。
如果求值結(jié)果為 true ， 賦 true_value值；如果求值結(jié)果為 false， 賦 false_value值

var max_num = (num1>num2) ? num1 : num2; 

max_num 將會(huì)保存一個(gè)最大的值。

賦值操作符

賦值操作符用（=）表示，其作用是把右側(cè)的值賦給左側(cè)的變量，如下：

var num = 10; 

復(fù)合賦值操作

var num = 10;
num = num +10; // 20

等同于

var num = 10; 
num += 10; // 20

其他復(fù)合賦值操作符：*= 、/=、 %=、 +=、 -= 、<<=、 >>=；

逗號(hào)操作符

用逗號(hào)操作符，可在一條語(yǔ)句中執(zhí)行多個(gè)操作

var num1 = 1, num2 = 2, num3 =3;

逗號(hào)操作符多用于聲明多個(gè)變量。

流控制語(yǔ)句

if語(yǔ)句

if (condition) statments1 else statments2

其中 condition(條件)可以是任意表達(dá)式，這個(gè)表達(dá)式的求值結(jié)果不一定是布爾值。ECMAScript會(huì)自動(dòng)調(diào)用 Boolean() 轉(zhuǎn)換函數(shù)將這個(gè)表達(dá)式的結(jié)果轉(zhuǎn)換為一個(gè)布爾值。如果是true，則執(zhí)行語(yǔ)句1，如果是 false，則執(zhí)行語(yǔ)句2.

var i;
if (i>25){
  alert("Greater than 25.");
} else if (i<0){
  alert("Less than 0.");
} else{
  alert("Between 0 and 25, inclusive.");
}

while語(yǔ)句

while 語(yǔ)句屬于前測(cè)試循環(huán)語(yǔ)句，就是說，在循環(huán)體內(nèi)的代碼被執(zhí)行之前，不會(huì)對(duì)出口條件求值。
因此，循環(huán)體內(nèi)的代碼可能永遠(yuǎn)不會(huì)被執(zhí)行
語(yǔ)法：while(expression) statement

var i= 0;
while(i<10){
    i+=2;
}

上面例子，變量i開始時(shí)的值是0，每次循環(huán)遞增2.只要i的值小于10，循環(huán)就會(huì)繼續(xù)下去。

for語(yǔ)句

for語(yǔ)句也是一種前測(cè)循環(huán)語(yǔ)句，但它具有在執(zhí)行循環(huán)之前初始化變量和定義循環(huán)后要執(zhí)行的代碼的能力。

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

上面例子，定義了變量i的初始值為0，只有當(dāng)條件表達(dá)式（i<count）返回 true 的情況下才會(huì)進(jìn)入 for 循環(huán)，因此也有可能不會(huì)執(zhí)行循環(huán)體中的代碼。如果執(zhí)行循環(huán)體中的代碼，則一定會(huì)對(duì)循環(huán)后的表達(dá)式 （i++）求值，即遞增 i 的值。這個(gè) for 循環(huán)與下面 while 語(yǔ)句的功能相同；

var count =10;
var i;
while(i<count){
    console.log(i);
    i++;
}

for 語(yǔ)句中的初始化表達(dá)式、控制表達(dá)式和循環(huán)后表達(dá)式都是可選的。將這三個(gè)表達(dá)式全部省略，就會(huì)創(chuàng)建一個(gè)無限循環(huán)，如下：

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

只給出控制表達(dá)式實(shí)際上就是把 for 循環(huán)轉(zhuǎn)換成了 while 循環(huán)，如下：

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

for 語(yǔ)句比較靈活，用的比較多；

for-in 語(yǔ)句

for-in 語(yǔ)句是一種精準(zhǔn)的迭代語(yǔ)句，可以用來枚舉對(duì)象的屬性。

for (var propName in window){
    console.log(propName);
}

上面例子，使用for-in循環(huán)顯示了 BOM 中 window 對(duì)象的所有屬性，每次執(zhí)行循環(huán)時(shí)，都會(huì)將 window 對(duì)象中存在 的一個(gè)屬性名賦值給變量 propName。這個(gè)過程會(huì)一直持續(xù)到對(duì)象中的所有屬性被枚舉一遍為止。

ECMAScript 對(duì)象的屬性沒有順序。因此，通過 for-in 循環(huán)輸出的屬性名的順序是不可預(yù)測(cè)的，具體來講，所有屬性都會(huì)被返回一次，但返回的先后次序可能會(huì)因?yàn)g覽器而異。

break 和 continue 語(yǔ)句

break 和 continue 語(yǔ)句用于在循環(huán)中精確地控制代碼的執(zhí)行。

break 語(yǔ)句會(huì)立即退出循環(huán)，強(qiáng)制繼續(xù)執(zhí)行循環(huán)后面的語(yǔ)句。
continue 語(yǔ)句也是立即退出循環(huán)，但退出循環(huán)后從循環(huán)的頂部繼續(xù)執(zhí)行。即退出當(dāng)次的循環(huán)。

var num = 0; 
for (var i=0; i<10; i++){
    if (i%5 == 0){
        break;
    }  
    num ++;
}
console.log(num);  // 4

上面例子，當(dāng)if 語(yǔ)句檢查 i 的值是否可以被5整除。如果是，則執(zhí)行 break 語(yǔ)句退出循環(huán)。在變量i 等于5時(shí)，循環(huán)總共執(zhí)行了4次。而break 語(yǔ)句的執(zhí)行，導(dǎo)致循環(huán)在 num 再次遞增前就退出了。
如果把 break 換成 continue 的話，會(huì)是另一個(gè)結(jié)果：

var num = 0; 
for (var i=0; i<10; i++){
    if (i%5 == 0){
        continue;
    }  
    num ++;
}
console.log(num);  // 8

上面例子，循環(huán)共執(zhí)行8次，當(dāng)變量i 等于5時(shí)，循環(huán)會(huì)在num再次遞增前退出，但接下來執(zhí)行的是下一次循環(huán)，即的值等于 6的循環(huán)。于是，循環(huán)又繼續(xù)執(zhí)行，直到 i 等于10時(shí)自然結(jié)束。

switch 語(yǔ)句

switch 語(yǔ)句與 if 語(yǔ)句的關(guān)系最為密切，所有switch 語(yǔ)句都可以用 if - else if - else 代替。

var i;
swith(i){
  case 25:
      console.log('25');
      break;
  case 35:
      console.log('35');
      break;
  case 40:
      console.log('40');
      break;
  default:
      console.log('other');
}

switch 語(yǔ)句中的每一種情形（case）的含義是：如果表達(dá)式等于這個(gè)值（value），則執(zhí)行后面的語(yǔ)句。而break 關(guān)鍵字會(huì)導(dǎo)致代碼執(zhí)行流跳出 switch 語(yǔ)句。 如果省略 break 關(guān)鍵字，就會(huì)導(dǎo)致執(zhí)行完當(dāng)前case 后，繼續(xù)執(zhí)行下一個(gè) case ，所以要特別注意。最后的 default 關(guān)鍵字則用于在表達(dá)式不匹配前面所有情形的時(shí)候，執(zhí)行機(jī)動(dòng)代碼。

case 也可以是布爾值， 即 case i<25:

switch 語(yǔ)句在比較值時(shí)使用的是全等操作符，因此不會(huì)發(fā)生類型轉(zhuǎn)換，例如 字符串 ‘10’ 不等于數(shù)值 10.

函數(shù)

函數(shù)對(duì)任何語(yǔ)言來說都是一個(gè)核心的概念，通過函數(shù)可以封裝任意多條語(yǔ)句，而且可以在任何地方、任何時(shí)候調(diào)用 執(zhí)行。ECMAScript 中的函數(shù)使用 function 關(guān)鍵字來聲明，如：

function sayHi(name,mes){
    console.log('Hello '+name+','+mes);
}
sayHi('Jack','nice to meet you!');  // Hello Jack,nice to meet you!

ECMAScript 中的函數(shù)在定義時(shí)不必指定是否返回值，實(shí)際上，任何函數(shù)在任何時(shí)候都可以通過 return 語(yǔ)句后跟要返回的值來實(shí)現(xiàn)返回值，如：

function sum(n1,n2){
  return n1+n2;
}
var rs = sum(2,3);
console.log(rs);  // 5

這個(gè) sum() 函數(shù)的作用是把兩個(gè)值加起來返回一個(gè)結(jié)果。這個(gè)函數(shù)會(huì)在執(zhí)行完 return 語(yǔ)句之后停止并立即退出，因此，位于 return 語(yǔ)句之后的任何代碼都永遠(yuǎn)不會(huì)執(zhí)行。

function sum(n1,n2){
  return n1+n2;
  alert('hello');  // 不會(huì)執(zhí)行
}

上面例子，alert() 函數(shù)位于retrun 語(yǔ)句后面，因此不會(huì)執(zhí)行。
另外，return 語(yǔ)句也可以不帶有任何返回值，在這種情況下，函數(shù)在停止執(zhí)行后將返回 undefiend 值，這種用法一般用在需要提前停止函數(shù)執(zhí)行而又不需要返回值的情況下。

function sayHi(name,mes){
    return;
    console.log('Hello '+name+','+mes);   // 此句不會(huì)執(zhí)行
}

本章總結(jié)：
ECMAScript是 Javascript 語(yǔ)言的國(guó)際標(biāo)準(zhǔn)，Javascript 是ECMAScript 的實(shí)現(xiàn)。
Javascript 中的基本數(shù)據(jù)類型包括： Undefined Null Boolean Number String.
ECMAScript 沒有為整數(shù)和浮點(diǎn)數(shù)分別定不同的數(shù)據(jù)類型，Number類型可以用于表示所有數(shù)值。
ECMAScript 也有一種復(fù)雜的數(shù)據(jù)類型，即Object類型，該類型是這門語(yǔ)言中所有對(duì)象的基礎(chǔ)類型。