摘要：是時(shí)候把的知識點(diǎn)總結(jié)下，并且會持續(xù)施工，每個(gè)知識點(diǎn)如果有更深入的技術(shù)探討和知識會陸續(xù)添加進(jìn)去。返回對象的字符串?dāng)?shù)值或布爾值表示。通常與方法的返回值相同。

是時(shí)候把JS的知識點(diǎn)總結(jié)下，并且會持續(xù)施工，每個(gè)知識點(diǎn)如果有更深入的技術(shù)探討和知識會陸續(xù)添加進(jìn)去。

ECMAScirpt中的變量，函數(shù)名，操作符都區(qū)分大小寫。

標(biāo)識符指的可能是：

變量名

函數(shù)名

屬性名

函數(shù)的參數(shù)

標(biāo)識符的名稱：

第一個(gè)字符只能是字母，下劃線_，或者美元符號$；

其他的可以是字母，數(shù)字，下劃線_，或者美元符號$。

按照慣例，標(biāo)識符名稱應(yīng)使用駝峰法，即首字母小寫，剩下的每個(gè)單詞首字母大寫。

不能把關(guān)鍵字、保留字、TRUE、FALSE、NULL作為標(biāo)識符名稱。

//單行注釋

/*
多行注釋
多行注釋
*/

ES5引入了嚴(yán)格模式，嚴(yán)格模式下，某些舊版本（ES3）的一些不確定行為將得到處理，而對某些不安全的操作也會拋出錯(cuò)誤。支持嚴(yán)格模式的瀏覽器：IE10+ Firefox 4+ Safari 5.1+ Opera 12+ Chrome

//在整個(gè)腳本中引入嚴(yán)格模式，則在script標(biāo)簽頂部或者*.js文件頂部添加如下代碼即可。
"use strict";

//在指定函數(shù)中引入嚴(yán)格模式：
function f1(){
     "use strict";
     //TODO...
};

TODO : 引入了嚴(yán)格模式與沒引入嚴(yán)格模式的js文件如何解決沖突以及共存？

ES中的語句以一個(gè)分號結(jié)尾，省略分號雖然有效但不推薦。

    var sum = 1 + 2;

// 關(guān)鍵字
break case catch continue debugger default delete do instanceof else new finally return for switch function this if throw in try typeof var void while with

// ES3定義的保留字
abstract boolean byte char class const debugger double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile

//ES5中非嚴(yán)格模式下的保留字縮減為這些：
class enum extends super const export import

//ES5中嚴(yán)格模式下的相對非嚴(yán)格模式增加的保留字，其中l(wèi)et與yield是新增的。
implements interface let package private protected public static yield
//實(shí)際開發(fā)中，建議將ES3定義的保留字外加新增的let與yield作為參考。

需要注意的是，ES5的嚴(yán)格模式下，eval與arguments也不能作為標(biāo)識符與屬性名，否則會拋出錯(cuò)誤。

ES中的變量是松散類型的，即變量可以保存任何類型的數(shù)據(jù)。
定義變量使用var操作符，后跟變量名（即一個(gè)標(biāo)識符），
使用var操作符定義的變量會成為該作用域下的局部變量，該變量在函數(shù)退出之后就會被銷毀：

var a; //定義一個(gè)名為a的變量，值是undefined
var b = null; //定義一個(gè)名為b的變量，值為null（空）
var c = "percy"; //定義一個(gè)名為c的變量，值為字符串“percy”

function f1(){
  var name = "jon"; //函數(shù)f1()下的局部變量
  alert(name); 
}
f1(); //jon
alert(name); //外部不能直接訪問函數(shù)的內(nèi)部變量

//使用一條語句定義多個(gè)變量，用逗號分隔即可。
var name="jon", age=25, isMarried=false;

ES中有
5種簡單數(shù)據(jù)類型（基本數(shù)據(jù)類型）：Undefined、Null、Boolean、Number、String
1種復(fù)雜數(shù)據(jù)類型：Object

返回值：

undefined——給定的值未定義；

boolean——給定的值是布爾值；

string——給定的值是字符串；

number——給定的值是數(shù)值；

object——給定的值是對象或者null；

function——給定的是函數(shù)；

function f2(){
    console.log("Hi!");
}
var name = "jon";
var age = 25;

alert(typeof f2); //function
alert(typeof name); //string
alert(typeof age); //number

只有一個(gè)值：undefined

var name; 
/*var name = undefined;*/ //無需把變量顯式設(shè)置undefined值
alert(name == undefined); //true 

變量的值為undefined與未聲明的變量并不一樣，但使用typeof操作符均會返回undefined，但輸出值時(shí)未聲明的變量會產(chǎn)生錯(cuò)誤：

var job; //該變量已聲明但未賦值，默認(rèn)值為undefined
// var name2; 該變量并未聲明

alert(typeof job); //測試變量類型，輸出undefined
alert(typeof name2); //測試變量類型，即使變量未聲明也會輸出undefined

//輸出值時(shí)
alert(job); //undefined
alert(name2); //產(chǎn)生錯(cuò)誤：Uncaught ReferenceError: name2 is not defined

只有一個(gè)值：null；
undefined值派生自null值，所以用==測試兩者時(shí)會返回true ；
null值表示一個(gè)空對象指針，所以使用typeof操作符時(shí)會返回object；
如果創(chuàng)建的變量將來用于保存對象，那么初始聲明該變量時(shí)應(yīng)把值設(shè)置為null；

var name = null;
alert(typeof name); //object

有兩個(gè)值：true、false；

//注意Boolean類型字面值是區(qū)分大小寫的，True、False以及其他大小寫混合的形式均不屬于Boolean類型值；
var isBoy = true;
var isGirl = false;

使用Boolean()函數(shù)把其他值轉(zhuǎn)為Boolean值

var name = "jon";
var nameBool = Boolean(name); //true

轉(zhuǎn)換規(guī)則如下表：

轉(zhuǎn)換規(guī)則對于流程控制語句自動(dòng)執(zhí)行相應(yīng)的Boolean轉(zhuǎn)換非常重要：

var name = "jon";
if(name){ //name轉(zhuǎn)換為true，執(zhí)行下面的語句
    alert("name is defined!");
}

包含整數(shù)和浮點(diǎn)數(shù)（雙精度數(shù)值），NaN。

整數(shù)

var intN1 = 123; //十進(jìn)制整數(shù)
var intN2 = 013; //十進(jìn)制的11
var intN3 = 018; //無效的八進(jìn)制，會被轉(zhuǎn)成十進(jìn)制的18，并且在嚴(yán)格模式下回拋出錯(cuò)誤
var intN4 = 0xB; //十六進(jìn)制，會被轉(zhuǎn)為十進(jìn)制的11
alert(-0 == +0); //true,ES中正零相等于負(fù)零;

浮點(diǎn)數(shù)

var fN1 = 0.1;
var fN2 = 1.1;
var fN3 = .1; //不推薦
var fN4 = 1. //被解析為整數(shù)1
var fN5 = 1.0; //被解析為整數(shù)1
var fN6 = 1.05e5; //e表示法，即科學(xué)記數(shù)法，會被解析成105000，即1.05乘以10的7次方
var fN7 = 3e-6; //會被解析成0.000003

浮點(diǎn)數(shù)的精確度遠(yuǎn)遠(yuǎn)不如整數(shù)，所以永遠(yuǎn)不要用計(jì)算浮點(diǎn)數(shù)來進(jìn)行條件測試：

if(a + b = 0.3){ //不要做這樣的測試！
    //DO STH...
}

數(shù)值范圍

console.log(Number.MIN_VALUE); //ES能表示的最小數(shù)，結(jié)果是5e-324
console.log(Number.MAX_VALUE); //ES能表示的最大數(shù)，結(jié)果是1.7976931348623157e+308
/*
若一次運(yùn)算中，計(jì)算結(jié)果超過了ES的最大或最小數(shù)，那么這個(gè)結(jié)果會被轉(zhuǎn)換成特殊的Infinity或-Infinity，該值無法參與運(yùn)算；以下兩個(gè)屬性也保存著上述兩個(gè)值；
*/
alert(Number.NEGATIVE_INFINITY); //-Infinity
alert(Number.POSITIVE_INFINITY); //Infinity

確定某個(gè)結(jié)果是否為有窮的（是否位于ES能表示的最大與最小數(shù)之間的有效數(shù)值），使用isFinite()函數(shù)；

var a = 10.4e-8;
alert(isFinite(a)); //true，該數(shù)值在有效范圍之內(nèi)

NaN (Not a Number，非數(shù)值（中文名字）是一個(gè)特殊的數(shù)值)

用于表示一個(gè)本來要返回?cái)?shù)值的操作數(shù)沒有返回?cái)?shù)值的情況，這樣就不會拋出錯(cuò)誤；

ES中0除以0都會返回NaN；(其他數(shù)值除以0會返回Infinity或者-Infinity)

任何涉及NaN的運(yùn)算操作也會返回NaN；

NaN不等于任何值，包括它自己；

alert(NaN == NaN); //false

isNaN()函數(shù)，接受一個(gè)參數(shù)，確定該參數(shù)是否“不是數(shù)值”，如果該參數(shù)是數(shù)值或者能轉(zhuǎn)換成數(shù)值，則會返回false，否則返回true；

alert(isNaN(1)); //false
alert(isNaN("2")); //false，可以把字符串2轉(zhuǎn)換成數(shù)值2
alert(isNaN(true)); //false，可以把布爾值true轉(zhuǎn)換成數(shù)值1，如果false則轉(zhuǎn)換成0
alert(isNaN("1024cl")); //true，數(shù)值與字符串不能轉(zhuǎn)換成數(shù)值
alert(isNaN("true")); //true，字符串*均*不能轉(zhuǎn)換成數(shù)值
alert(isNaN(NaN)); //true，NaN本身不是有效的數(shù)值

數(shù)值轉(zhuǎn)換，有三個(gè)方法，Number()，parseInt()，parseFloat()

Number()的轉(zhuǎn)換例子：

alert(Number(1)); //1
alert(Number(true)); //轉(zhuǎn)換成1
alert(Number(false)); //轉(zhuǎn)換成0
alert(Number(null)); //轉(zhuǎn)換成0
alert(Number(undefined)); //NaN
alert(Number("")); //空字符串轉(zhuǎn)換成0
alert(Number("12")); //轉(zhuǎn)換成12
alert(Number("034")); //忽略前導(dǎo)0，轉(zhuǎn)換成34
alert(Number("12ab")); //NaN
alert(Number("0x11")); //有效的十六進(jìn)制會轉(zhuǎn)換成十進(jìn)制的17

更常用的parseInt()與parseFloat()例子：

alert(parseInt(1)); //1
alert(parseInt(11.91)); //11
alert(parseInt(true)); //NaN
alert(parseInt(false)); //NaN
alert(parseInt(null)); //NaN
alert(parseInt(undefined)); //NaN
alert(parseInt("")); //NaN
alert(parseInt("12")); //12
alert(parseInt("034")); //34
alert(parseInt("12ab")); //忽略數(shù)值后的無效字符，轉(zhuǎn)換為12
alert(parseInt("ab12")); //NaN
alert(parseInt("0x11")); //17

//在轉(zhuǎn)換八進(jìn)制的字符串包含的數(shù)值中，ES3與ES5有時(shí)會存在分歧：
alert(parseInt("067")); //ES3中會輸出55
alert(parseInt("067")); //ES5中會忽略前導(dǎo)0，并轉(zhuǎn)換成10進(jìn)制的67

基于上面的問題，作為最佳實(shí)踐，使用parseInt()始終應(yīng)該加入第二個(gè)參數(shù)，即需要轉(zhuǎn)換時(shí)需要使用的進(jìn)制數(shù)：

alert(parseInt("076",8)); //62
alert(parseInt("076",10)); //76
alert(parseInt("0xAA",16)); //170
alert(parseInt("AA",16)); //170
alert(parseInt("AA")); //NaN

//parseFloat()只會解析十進(jìn)制數(shù)值，所以沒有第二個(gè)參數(shù)
alert(parseFloat("1.2.3")); //只會解析左起第一個(gè)小數(shù)點(diǎn)，所以該數(shù)值會被轉(zhuǎn)換成1.2
alert(parseFloat("0xAA")); //十六進(jìn)制數(shù)值始終會被轉(zhuǎn)換成0
alert(parseFloat(11.1)); //11.1
alert(parseFloat("443abc")); //443，忽略后面的無效字符
alert(parseFloat("443.3aa")); //443.3，忽略后面的無效字符
alert(parseFloat("3.33e7")); //33300000
alert(parseFloat("0757.2768")); //忽略前導(dǎo)0，757.2768

即字符串，由0或多個(gè)16位Unicode字符組成的字符序列；

//可以由單引號或雙引號包裹，且左右引號必須匹配
var s1 = "name1"; 
var s2 = "name2";

字符字面量

String數(shù)據(jù)類型包含一些特殊的字符字面量，也叫轉(zhuǎn)義序列，用于表示非打印字符，或者有其他用途的字符：

上述的字符字面量可以出現(xiàn)在字符串的任意位置，并且也會被作為字符來解析：

var sign = "sign is : u011f";
console.log(sign);  /*sign is : ?*/
console.log(sign.length); //11，說明六個(gè)字符長的轉(zhuǎn)義序列只會表示一個(gè)字符，占一個(gè)索引位置；

轉(zhuǎn)換為字符串的方法toString():

var name = "Jon";
alert(name.toString()); //"Jon"
var age = 25;
alert(age.toString()); //字符串"25"
var isMarried = false;
alert(isMarried.toString()); //字符串"false"

//null與undefined沒有toString()方法
alert(null.toString()); //NaN
alert(undefined.toString()); //NaN

//轉(zhuǎn)換數(shù)值的情況下，可以傳入一個(gè)參數(shù)，即輸出數(shù)值的基數(shù)
var num = 10;
alert(num.toString()); //默認(rèn)十進(jìn)制輸出，10
alert(num.toString(2)); //二進(jìn)制輸出，1010
alert(num.toString(8)); //八進(jìn)制輸出，12
alert(num.toString(10)); //十進(jìn)制輸出，10
alert(num.toString(16)); //十六進(jìn)制輸出，A

在不知道轉(zhuǎn)換的值是否為null或undefined的情況下，可以使用轉(zhuǎn)型函數(shù)String()，該函數(shù)能把任何類型的值轉(zhuǎn)為字符串：

如果傳入的值有toString()方法，則調(diào)用該方法并返回相應(yīng)的結(jié)果；

如果傳入的值是null，則返回"null"；

如果傳入的值是undefined，則返回"undefined"；

var value1 = 10;
var value2 = true;
var value3 = null;
var value4;

alert(String(value1)); // "10"
alert(String(value2)); // "true"
alert(String(value3)); // "null"
alert(String(value4)); // "undefined"

ES中的Object（對象）就是一組數(shù)據(jù)和功能的集合。
Object類型是所有其他類型的基礎(chǔ)，所以O(shè)bject類型的所以屬性和方法也會存在于其他具體的對象中。

var o1 = new Object(); //創(chuàng)建一個(gè)自定義對象

Object實(shí)例擁有的屬性和方法

包括 一元操作符，位操作符，布爾操作符，乘性操作符，加性操作符，關(guān)系操作符，相等操作符，條件操作符，賦值操作符，逗號操作符。

遞增與遞減操作符（包括前置型與后置型）

//前置型操作符
var n1 = 25;
++n1;
 
var n2 = 25;
--n2;

//前置型操作符會在求值前被執(zhí)行
var age = 25;
var anotherAge = --age + 2;

console.log(age); //24 (在下一句執(zhí)行之前已經(jīng)執(zhí)行了自減)
console.log(anotherAge); //26 （24+2）

//后置型操作符
var n1 = 25;
n1++;

//后置型操作符會在被求值之后才執(zhí)行，注意以下問題
var n1 = 2;
var n2 = 20;
var n3 = n1-- + n2; 
console.log(n3); //計(jì)算n3時(shí)使用了原始值計(jì)算，所以輸出22
var n4 = n1 + n2; 
console.log(n4); //計(jì)算n4時(shí)，n1已經(jīng)被遞減，所以輸出21

上述的4個(gè)操作符可以用于整數(shù)，浮點(diǎn)數(shù)，字符串，布爾值，對象運(yùn)算；

var s1 = "2"; 
console.log(++s1);//轉(zhuǎn)換為數(shù)值2再參與運(yùn)算，輸出3
var s2 = "a"; 
console.log(++s2);//值為NaN，無法參與運(yùn)算
var s3 = false; 
console.log(++s3);//轉(zhuǎn)換為數(shù)值0再參與運(yùn)算，輸出1， **true則轉(zhuǎn)換為1**
var s4 = 2.1; 
console.log(--s4); //參與減一運(yùn)算，注意浮點(diǎn)數(shù)舍入錯(cuò)誤問題，輸出1.1
console.log(++s4); //參與加一運(yùn)算，注意浮點(diǎn)數(shù)舍入錯(cuò)誤問題，輸出2.1
var s5 = {
  valueOf: function(){
    return -1;
  }
};
console.log(++s5); //先調(diào)用對象的valueOf()方法，取得一個(gè)可供操作的值，然后把該值應(yīng)用于前述規(guī)則；如果結(jié)果是NaN，則調(diào)用toString()方法后再應(yīng)用前述規(guī)則。對象變量變成數(shù)值變量，這里輸出0
console.log(++s5); //輸出1

即+和-；
對非數(shù)值應(yīng)用一元加和減操作符時(shí)，會像Number()轉(zhuǎn)型函數(shù)一樣對這個(gè)值執(zhí)行轉(zhuǎn)換

/*一元加操作符*/
var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var o = {
    valueOf: function() {
        return -1;
    } 
};
s1 = +s1; //1
s2 = +s2; //1.1
s3 = +s3; //NaN
b= +b; //0
f= +f; //1.1
o= +o; //-1

/*一元減操作符*/
//一元減操作符主要用來表示負(fù)數(shù)
var n1 = 1;
n2 = -n1; //-1

非（NOT）,與（AND）,或（OR）

邏輯非!

返回一個(gè)布爾值, 然后再對其求反

alert(!false); //true
alert(!"blue"); //false
alert(!0); //true
alert(!NaN); //true
alert(!""); //true
alert(!12345); //false
alert(!undefined); //true
alert(!null); //true
var i = function(){};
alert(!i); //false

邏輯與&&

有兩個(gè)操作數(shù), 只有兩個(gè)操作數(shù)都返回true時(shí), 才返回true; 否則返回false

var i = function(){};
var j = function(){console.log("funciton j")};
alert(i && true); //true
alert(i && false); //false

alert(true && i); //function(){}
alert(false && i); //false
alert(i && j); //function(){console.log("funciton j")};
//如果有一個(gè)操作數(shù)是null, NaN或undefined, 則返回該三者之一
alert(null && false); //null
alert(null && true); //null
alert(null && i); //null

/*邏輯與屬于短路操作, 即如果第一個(gè)操作數(shù)能決定結(jié)果,就不會再對第二個(gè)操作數(shù)求值*/
var f = true;
var r = (f && cc); //cc未聲明 
alert(r); //這一句不會執(zhí)行,因?yàn)樯厦娴腸c未聲明. Uncaught ReferenceError: cc is not defined(…)

//如果f為false,則會執(zhí)行并返回false, 因?yàn)榈谝粋€(gè)操作數(shù)已經(jīng)是false, 所以就不會再對后面的操作數(shù)求值了
var f = false;
var r = (f && cc); //cc未聲明
alert(r); //false

邏輯或||

有兩個(gè)操作數(shù), 只要有一個(gè)操作數(shù)都返回true, 就會返回true;

var i = function(){};
var j = function(){console.log("funciton j")};
alert(i || true); //function(){};
alert(i || false); //function(){};
alert(i || j); //function(){};
alert(true || i); //true
alert(false || i); //function(){};
alert(null || false); //false
alert(null || true); //true
alert(null || i); //function(){};
//如果兩個(gè)操作數(shù)都是null, NaN, undefined, 則會返回同樣的結(jié)果.

//邏輯或也屬于短路操作
var f = true;
var r = (f || cc); //cc未聲明 
alert(r); //會執(zhí)行true

var f = false;
var r = (f || cc); //cc未聲明
alert(r); //這一句不會執(zhí)行,因?yàn)樯厦娴腸c未聲明. Uncaught ReferenceError: cc is not defined(…)

/*正常開發(fā)中, 可以使用邏輯與來避免為變量賦null或undefined值*/
var o = preferredObject || backupObject;
//backupObject提供一個(gè)后備值, 如果preferredObject不包含期望的有效值的情況下, backupObject會被賦值給o, 否則在經(jīng)常情況下, preferredObject賦值給o.

*, 乘法,用于計(jì)算兩個(gè)值的乘積

alert(2 * 2); //4
alert(2 * -2); //-4
alert(NaN * 2); //NaN
alert(Infinity * 0); //NaN
alert(Infinity * 1); //Infinity
alert(Infinity * -1); //-Infinity
alert(Infinity * Infinity); //Infinity
//在操作數(shù)不是數(shù)值的情況下, 后臺會調(diào)用Number()將其轉(zhuǎn)換為數(shù)值,然后在進(jìn)行運(yùn)算

/, 除法,第二個(gè)操作數(shù)除第一個(gè)操作數(shù)

alert(2 / 2); //1
alert(2 / -2); //-1
alert(2 / NaN); //NaN
alert(Infinity / Infinity); //NaN
alert(0 / Infinity); //0
alert(Infinity / 0); //Infinity
alert(0 / 0); //NaN
alert(0 / 2); //0
alert(2 / 0); //Infinity
alert(-2 / 0); //-Infinity
//在操作數(shù)不是數(shù)值的情況下, 后臺會調(diào)用Number()將其轉(zhuǎn)換為數(shù)值,然后在進(jìn)行運(yùn)算

+, 加法

alert(1 + 2); //3
alert(NaN + 1);//NaN
alert(Infinity + Infinity); //Infinity
alert(-Infinity + (-Infinity)); //-Infinity
alert(Infinity + (-Infinity)); //NaN
alert(0 + 0); //0
alert(-0 + (-0)); //0
alert(0 + (-0)); //0
alert(1+"2"); //12, 字符串拼接

//注意加法操作中的數(shù)據(jù)類型錯(cuò)誤
var num1 = 5;
var num2 = 10;
var message = "The sum of 5 and 10 is " + num1 + num2;
alert(message);    // 得到的結(jié)果是 : "The sum of 5 and 10 is 510"

//應(yīng)該像下面這樣使用括號
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 15"

-, 減法

alert(2 - 1);
alert(NaN - 1); //NaN
alert(Infinity - Infinity); //NaN
alert(-Infinity -(-Infinity)); //NaN
alert(Infinity -(-Infinity)); //Infinity
alert(-Infinity - Infinity); //-Infinity
alert(0 - 0); //0
alert(0 - (-0)); //-0
alert(-0 -(-0)); //0
alert(5 - true); //4, ture to 1
alert(5 - ""); //5, "" to 0
alert(5 - "2"); //3, "2" to 2
alert(5 - null); //5, null to 0

小于<, 大于>, 小于等于<=, 大于等于>=, 均返回一個(gè)布爾值

var r = 5 > 4; //true
var r = 5 < 4; //false

//在字符串的比較中, 決定結(jié)果的是字符串字母(大小寫)的字符編碼, 而不是字母的順序 : 
alert("app" > "back"); //false
alert("app" > "Back"); //true
alert("App" > "Back"); //false
//因字符編碼的順序不同, 所以在進(jìn)行比較時(shí)應(yīng)該把字符串統(tǒng)一轉(zhuǎn)換成大寫或者小寫再進(jìn)行比較;
alert("App".toLowerCase() > "Back".toLowerCase()); //false

//同樣的, 數(shù)字字符串也會比較的是字符編碼 : 
alert("15" > "4"); //false
//把其中一個(gè)變成數(shù)值類型, 或者使用有效的轉(zhuǎn)型函數(shù)轉(zhuǎn)型成數(shù)值, 結(jié)果就正常了 :
alert("15" > 4); //true
alert(Number("15") > Number("4")); //true

//NaN跟任何數(shù)值比較均返回false
alert(NaN > 4); //false
alert(NaN < 4); //false

相等==和不相等!=, 全等===和不全等!==
相等和不相等在比較前都會先轉(zhuǎn)換操作數(shù), 然后再進(jìn)行比較

相等和不相等

//布爾值會被先轉(zhuǎn)換成0和1
alert(1 == true); //true
alert(2 == true); //false
alert(0 == false); //true
alert("a" == 1); //false
var a = "jon";
var b = "percy";
var c = a;
alert(a == c); //true, 比較兩個(gè)對象時(shí), 如果兩個(gè)對象指向的是同一個(gè)對象,則返回true, 否則返回false
alert(a == b); //false
alert(a == 1); //false
alert(null == undefined); //true
alert(undefined == 0); //false
alert(null == 0); //false
alert(5 == "5"); //true
alert("NaN" == NaN); //false
alert(5 == NaN); //false
alert(NaN == NaN); //false, NaN不等于自身

全等和不全等

全等和不全等不會像上面的相等和不相等一樣進(jìn)行數(shù)據(jù)類型轉(zhuǎn)換, 而是直接進(jìn)行比較 :

alert(55 == "55"); //相等比較下, 會進(jìn)行數(shù)據(jù)轉(zhuǎn)換, 所以返回true
alert(55 === "55"); //全等比較下, 不會進(jìn)行數(shù)據(jù)轉(zhuǎn)換, 所以這里返回false
/*注意null和undefined進(jìn)行全等比較會返回false, 因?yàn)樗麄兪穷愃频闹?所以相等比較會返回true)但是屬于不同類型的值*/
alert(null == undefined); //false

//對boolean_expression求值, 如果結(jié)果為true則返回true_value(給variable), 否則返回false_value(給variable)
variable = boolean_expression ? true_value : false_value;

var num1 = 4;
var num2 = 6;
var max = (num1 > num2) ? num1 : num2;
console.log(max); //6

簡單的賦值操作符=

乘/賦值*=

除/賦值/=

模/賦值%=

加/賦值+=

減/賦值-=

左移/賦值<<=

有符號右移/賦值>>=

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

var n = 2;
n = n + 2; //4 

//可以簡化成
n += 2;

//其他原理相同

//可用于同時(shí)聲明多個(gè)變量
var a, b, c;

ES指流程控制語句

if(condition){
    statement1
}else{
      statement2
}

var i = 20;
if(i > 25){
  console.log("i is greater than 25");
}else{
  console.log("i is less than or equal to 25");
}
//i is less than or equal to 25

if(condition1){
  statement1
}else if(condition2){
  statement2
}else{
  statement3
}

var i = 25;
if(i > 25){
  console.log("i is greater than 25");
}else if(i == 25){
  console.log("i is equal to 25");
}else{
  console.log("i is less than 25");
}
//i is equal to 25

do-while語句在對表達(dá)式求值之前, 循環(huán)體內(nèi)的代碼會被最少執(zhí)行一次

do{
  statement
}while(expression)

var i = 2;
do{
  i += 2;
  console.log(i);
}while(i < 7);
//之所以出現(xiàn)8的原因是, 當(dāng)i遞增到6的時(shí)候依然少于7, 所以在判斷while里面的條件之前依然會被遞增一次
//4, 6, 8

var i = 10;
do{
  i ++;
  console.log(i);
}while(i < 10);
//雖然while里面的條件已經(jīng)不滿足,但do里面的語句還是會被執(zhí)行一次, 輸出11

與do-while語句相反, while語句會在循環(huán)體(expression)內(nèi)的代碼被執(zhí)行之前, 先對條件求值

while(expression){
  statement
}

var i = 10;
while(i < 20){
  i+=2;
  console.log(i);
  //12, 14, 16, 18, 20
}
console.log("the last i is : " + i); //20

for與while一樣, 也是前測試循環(huán)語句, 但它可以在執(zhí)行循環(huán)之前初始化變量和定義循環(huán)后要執(zhí)行的代碼

for(initialization; expression; post-loop-expression){
  statement;
}

var c = 10;
for(var i = 1; i <= c; i+=2){
  console.log(i);
}
//1, 3, 5, 7, 9

//提前定義好變量, 就可以在for語句里面省略var關(guān)鍵字
var i, c = 10;
for(i = 1; i <= 10; i+=3){
  console.log(i);
  //1, 4, 7, 10
}
//注意ES里面沒有塊級作用域, 所以下面的語句可以正常輸出
console.log("the last i is : " : i); //10

for-in是精準(zhǔn)的迭代語句, 可以用來枚舉對象的屬性

for(property in expression){
  statement
}

var arr = ["Jon","Martin","Percy"];
for(var i in arr){
  console.log(arr[i]);
  //Jon, Martin, Percy
}
//注意for-in語句輸出的結(jié)果順序是不可預(yù)測的
//作為最佳實(shí)踐, 使用for-in語句時(shí), 應(yīng)該確認(rèn)該對象的值不是null或undefined

label語句可以在代碼中添加標(biāo)簽, 以便在將來被break或continue引用

label : statement

first : for(var i = 0; i < 10; i+=2){
  console.log(i);
}
//first作為for循環(huán)的標(biāo)簽

break與continue語句用于在循環(huán)中精確的控制代碼的執(zhí)行;

break會立即退出循環(huán), 強(qiáng)制執(zhí)行后面的語句

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

//break
var n = 0; //初始化計(jì)算累積次數(shù)的變量
for(var i = 1; i < 10; i++){ //i從1遞增到10
  if(i % 5 == 0){ //遞增過程中判斷i是否能被0整除
      break; //是的話立即退出循環(huán),這里在i=5的時(shí)候退出了循環(huán)
  }
  n++; //每循環(huán)一次累積計(jì)算次數(shù)
}
console.log(n); //退出循環(huán)之前,循環(huán)體執(zhí)行了4次,所以輸出4

//continue
var n = 0; //初始化計(jì)算累積次數(shù)的變量
for(var i = 1; i < 10; i++){ //i從1遞增到10
  if(i % 5 == 0){ //遞增過程中判斷i是否能被0整除
      continue; //是的話立即退出循環(huán),這里在i=5的時(shí)候退出了循環(huán), 并且回到循環(huán)頂部繼續(xù)執(zhí)行(在for循環(huán)條件未滿足之前繼續(xù)執(zhí)行)
  }
  n++; //每循環(huán)一次累積計(jì)算次數(shù)
}
console.log(n); //退出循環(huán)之前(for循環(huán)結(jié)束之前),循環(huán)體執(zhí)行了8次(因?yàn)樵?被整除的時(shí)候退出了循環(huán),導(dǎo)致循環(huán)體少執(zhí)行了一次),所以最終輸出8

與label標(biāo)簽配合使用

//break
var i, j, n = 0;
outerloop:
for(i = 0; i < 10; i++){
  for(j = 0; j < 10; j++){
    if(i == 5 && j ==5){
        break outerloop;
    }
    n++;
  }
}
//正常來說, i每遞增1次, j就會遞增10次, 所以n最終值在不受干擾的情況下回等于100
//這里判斷如果i和j都等于5的情況下回立即退出循環(huán), 所以循環(huán)體最終會退出內(nèi)部和外部的for循環(huán)(退回標(biāo)簽outerloop的位置), 所以最終n會輸出55
console.log(n); //55

//continue
var i, j, n = 0;
outerloop:
for(i = 0; i < 10; i++){
  for(j = 0; j < 10; j++){
    if(i == 5 && j ==5){
        continue outerloop;
    }
    n++;
  }
}
//這里判斷如果i和j都等于5的情況下回立即退出循環(huán), 但退回外部的for循環(huán)(outerloop標(biāo)簽)的循環(huán)之后會繼續(xù)強(qiáng)制執(zhí)行外部循環(huán), 所以最終會得到95
console.log(n); //95

with語句作用是將代碼的作用域設(shè)置到一個(gè)特定的對象中

with(expression){
  statement;
}

//定義with語句的目的主要是簡化多次編寫同一個(gè)對象的工作
var qs = location.search.substring(1);
var hostName = location.hostname;
var url = location.href;

//使用with語句上面的代碼可以改成
with(location){
  var qs = search.substring(1);
  var hostName = hostname;
  var url = href;
}
//嚴(yán)格模式下不允許使用with, 否則會報(bào)錯(cuò)
//with會導(dǎo)致性能下降, 在大型項(xiàng)目中不建議使用

switch語句

switch(expression){
  //如果expression等于value, 則執(zhí)行后面的statement, 并跳出當(dāng)前循環(huán)
  case value : statement
  break;
  case value : statement
  break;
  case value : statement
  break;
  case value : statement
  break;
  //如果expression不等于前面任何一個(gè)value, 則使用default內(nèi)的statement代碼
  default : statement
}

var i = 2;
switch(i){
    case 1 : 
    console.log("result is 1");
    break;
    
    case 2;
    console.log("result is 2");
    break;
    
    default : 
    console.log("what is the result?");
}

//可以合并兩種情形(cast)
switch(i){
  case 1 :
  case 2 :
  console.log("1 or 2");
  break;
  
  case N...
}

函數(shù)可以封裝任意多條語句, 且可以在不同地方, 不同時(shí)間調(diào)用執(zhí)行.

使用關(guān)鍵字function聲明,后面跟一組參數(shù)以及函數(shù)體

function functionName(arg0, arg1, arg2, ...argN){
  statements;
}

//實(shí)例
function sayHi(name, age){
  console.log("my name is " + name +", age is" + age + ".");
}
//調(diào)用
sayHi("Jon",25);
//輸出my name is Jon, age is 25.

//使用return語句后面跟要返回的值來實(shí)現(xiàn)返回值
function sum(n1, n2){
  return n1 + n2;
}
var r = sum(1 + 2);
alert(r); //3

//注意在return后面的語句永遠(yuǎn)不會執(zhí)行
function sum(n1, n2){
  return n1 + n2;
  console.log("Hi!"); //永遠(yuǎn)不會執(zhí)行
}

//一個(gè)函數(shù)中可以包含多個(gè)return語句
function diff(n1 ,n2){
  if(n1 < n2){
      return n2 - n1;
  }else{
    return n1 - n2;
  }
}

//return可以不帶有任何返回值,一般用在需要提前執(zhí)行函數(shù)執(zhí)行有不需要返回值的情況下.
function sayHi(name, message){
  return;
  console.log("Hi! " + name + "," + message); //永遠(yuǎn)不會調(diào)用
}
//推薦的做法是要么讓函數(shù)始終返回一個(gè)值, 要么永遠(yuǎn)不會返回值

ES中的參數(shù)不限定數(shù)量和數(shù)據(jù)類型

假設(shè)被調(diào)用的函數(shù)的參數(shù)定義了兩個(gè), 在調(diào)用這個(gè)函數(shù)時(shí)也不強(qiáng)制需要傳入兩個(gè), 可以少傳或多穿而不會報(bào)錯(cuò), 命名的參數(shù)只是為了便利, 并不是必須的

ES函數(shù)的參數(shù)內(nèi)部是一組類數(shù)組, 在函數(shù)體內(nèi)可以通過arguments對象來訪問這組數(shù)組的內(nèi)容, 訪問的時(shí)候像訪問數(shù)組一樣, 使用方括號語法arguments[0], arguments[1], arguments[2], arguments[n] ...

//上面的sum函數(shù)例子可以寫成
function sum(n1, n2){
  //return n1 + n2;
  return arguments[0] + arguments[1];
}
sum(1 , 2); //3

//訪問arguments的length屬性可以知道多少個(gè)參數(shù)傳遞給了函數(shù)
function howManyArgs(){
  console.log(arguments.length);
}
howManyArgs(); //0
howManyArgs(1); //1
howManyArgs(1,2); //2

//可以利用這一點(diǎn)讓函數(shù)在接收不同參數(shù)時(shí)執(zhí)行不同的功能
function doAdd(n1, n2){
  if(arguments.length == 1){
    console.log(arguments[0] + 2);
  }else if(arguments.length == 2){
      console.log(arguments[0] + arguments[1]);
    //argument對象可以和命名參數(shù)混合使用
    //console.log(arguments[0] + n2); //沒有問題!
  }
}
doAdd(1); //3
doAdd(2,3); //5

arguments的值和對應(yīng)的命名參數(shù)的值會保持同步

function doAdd(n1, n2){
  arguments[1] = 10;//注意嚴(yán)格模式下會無效,n2仍然等于undefined
  console.log(arguments[0] + n2); 
}
doAdd(12,1); //22, 而不是13
//嚴(yán)格模式下重寫arguments的值會導(dǎo)致語法錯(cuò)誤, 代碼不能執(zhí)行

ES中所有參數(shù)傳遞都是值, 不可能通過引用傳遞參數(shù)

?

其他語言中可以為一個(gè)函數(shù)編寫兩個(gè)定義, 只要這兩個(gè)定義的簽名(接受的參數(shù)類型和數(shù)量)不同即可

ES中的參數(shù)是由包含零個(gè)或多個(gè)值的數(shù)組來表示的, 而沒有函數(shù)簽名, 真正的重載是不可能的

如果定義了兩個(gè)名字相同的函數(shù), 那么改名字只屬于后定義的函數(shù)

function add(n){
  return n + 10;
}
function add(n){
  return n + 20;
}
add(1); //21

通過檢查傳入函數(shù)中參數(shù)的類型和數(shù)量并作出不同的反應(yīng), 可以模擬方法的重載.