摘要：本文記錄了我在學習前端上的筆記，方便以后的復習和鞏固。注意在算數計算時，所有的八進制和十六進制表示的數值最終都將被轉換成十進制。返回對象的字符串數值或布爾值表示。

本文記錄了我在學習前端上的筆記，方便以后的復習和鞏固。

嚴格模式是JavaScript定義了一種不同的解析和執行模型。在嚴格模式下ECMAScript3中的一些不確定行為將得到處理，而且對某些不安全的操作也會拋出錯誤。要在整個腳本中啟用嚴格模式，可以在頂部添加如下代碼：

"use strict";

這段代碼看起來像字符串，而且也沒賦值給任務變量，但其實它是一個編譯指示(pragma)，用于告訴支持的JavaScript引擎切換到嚴格模式。這是為不破壞ECMAScript3而特意選定的語法。
在函數內部的上方包含這條編譯提示，也可以指定函數在嚴格模式下執行:

function doSomething() {
    "use strict";
    //函數體
}

ECMAScript5關鍵字:
break、case、catch、continue、default、delete、do、else、finally、for、function、if、in、instanceof、new、return、switch、this、throw、try、typeof、var、void、while、with
ECMAScript5非嚴格模式保留字:
class、enum、extends、super、const、export、import
在嚴格模式下，第5版還對一下保留字施加了限制:
implements、package、public、interface、private、static、let、protected、yield

局部變量被函數調用后，當前函數退出后就會被銷毀，例如:

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

全局變量就不會:

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

這樣，只要調用過一次test()函數，這個變量就有了定義，就可以在函數外部任何地方被訪問到。但全局變量的做法不推薦。因為在局部作用域中定義的全局變量很難維護。
嚴格模式下不能定義名為eval或arguments的變量，否則會導致語法錯誤。

ECMAScript中有五種簡單數據類型:

Undefined

Null

Boolean

Number

String

還有一種復雜數據類型——Object

注意：ECMAScript6還新增了一種數據類型符號對象 - (Symbol) - 符號對象簡介

用于檢測給定變量的數據類型——typeof就是負責提供這方面信息的操作符。對一個值使用typeof操作符可能返回下列某個字符串:

"undefind"——如果這個值未定義;

"boolean"——如果這個值是布爾值;

"string"——如果這個值是字符串;

"number”——如果這個值是數值;

"object" ——如果這個值是對象或null;

"function"——如果這個值是函數
下面是幾個使用typeof操作符的例子:

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

注意：調用typeof null 會返回 "object",因為特殊值null被認為是一個空的對象引用。

Undefined類型只有一個值即undefind。在使用var聲明變量后但未對其加以初始化時，這個變量的值就是undefined，例如：

var message;
alert(message == undefined); //true
var message1 == undefined
alert(message1 == undefined); //true

typeof操作符對未初始化和未聲明的變量都返回undefined

Null類型是第二個只有一個值的數據類型,這個特殊的值是null。從邏輯角度看，null值表示一個空對象指針，而這也正是使用typeof操作符檢測null值會返回"object"的原因

var car = null;
console.log(typeof car); //"object"

如果定義的變量是為了以后要保存對象，那么最好該變量初始化為null值。

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

undefined值是派生自null的值得所以:

console.log(null == undefined); //true

該類型只有兩個字面值: true和false。
雖然Boolean類型只有兩個字面值，但是可以調用Boolean()函數把值轉換為對應的Boolean值:

var message = "Hello World!"；
var messageAsBoolean = Boolean(message);

轉換規程:

//十進制
var intNum = 55; //整數
//八進制
var octalNum1 = 070;//八進制56
var octalNum1 = 079;//無效的八進制數值——解析為79
var octalNum1 = 08;//無效的八進制數組——解析為8
//十六進制
var hexNum1 = 0xA; //十六進制的10
var hexNum2 = 0x1f;    //十六進制的31

八進制：第一位必須是零(0)，然后是八進制數字序列(0~7).如果字面值中的數值超出了范圍，那么前導零將被忽略，后面的數值當成十進制解析。
十六進制：前兩位必須是0x，后跟任何十六進制數字(0~9，A~F)。

注意：在算數計算時，所有的八進制和十六進制表示的數值最終都將被轉換成十進制。

浮點數值中必須包含個小數點

var floatNum1 = 1.1;
var floatNum2 = 0.1;
var floatNum3 = .1    //有效但不推薦

由于保存浮點數值需要的空間是整數數值的兩倍，因此ECMAScript會不失時機的將浮點數值轉換成整數值。

var floatNum1 = 1.;  //小數點后面沒有數字——解析為1
var floatNum2 = 10.0 //整數——解析為10

對于極大或極小的數值，可以用e表示法。

var floatNum  = 3.125e7; //31250000

浮點數值最高精度是17位小數，但在進行算數計算時它的精度遠遠不如整數。例如0.1加0.2不是0.3 ,而是0.30000000000000004。這個小小的舍入誤差會導致無法測試特定的浮點數值。例如:

if(a + b == 0.3){        //不要這樣做測試
    alert("You got 0.3");
}

在這個例子中如果兩個數是0.05和0.25或者是0.15和0.15都不會有問題。因此永遠不要測試某個特定的浮點數值。

NaN，既非數值，是這個特殊的數值，這個數值用于表示一個本來要返回的數值的操作數未返回數值的情況(這樣就不會拋出錯誤了)。
NaN本身有兩個非同尋常的特點。首先，任何涉及NaN的操作(例如NaN/10)都會返回NaN。其次NaN與任何值都不想等，包括NaN本身。例如:

console.log(NaN == NaN); //false

針對NaN這兩個特點，ECMAScript定義了isNaN()函數。這個函數接受一個參數，該參數可以是任何類型，2??函數會幫我們確定這個參數是否"不是數值"。
isNaN()接受到第一值后，會嘗試將這個值轉換為數值。任何不能被轉換的數值的值都會導致這個函數返回true。例如:

console.log(isNaN(NaN));  //true
console.log(isNaN(10));  //false（10是一個數值）
console.log(isNaN("10"));  //false（可以被轉換成數值10）
console.log(isNaN("blue"));  //true（不能轉換成數值）
console.log(isNaN(true));  //flase（可以被轉換成數值1）

isNaN也適用于對象，在基于對象調用isNaN()函數時，會首先調用valueOf()方法，然后確定該方法返回的值是否可以轉換為數值。如果不能，則基于這個返回值再調用toString()方法，再測試返回值

有3分函數可以把非數值轉換為數值:

Number()——可用于任何數據類型

parseInt()——專門用于把字符串轉換成整數數值

parseFloat()——專門用于把字符串轉換成浮點數值

Number()函數的轉換規則如下

如果是Boolean值，true和false將分別被轉換為1和0.

如果是數字值，只是簡單的傳入和返回

如果是null值，返回0

如果是undefined，返回NaN

var num1 = Number("Hello world!");  //NaN
var num2 = Number("");              //0
var num3 = Number("000011");        //11
var num4 = Number("true");          //1

parseInt()
由于Number()在轉換字符串時比較復雜而且不夠合理，因此在處理整數的時候更常用的事parseInt()函數。

    var num1 = parseInt("1234bule"); //1234
    var num2 = parseInt("");         //NaN
    var num3 = parseInt("0xA");      //10(十六進制數)
    var num4 = parseInt("22.5");     //22
    var num5 = parseInt("070");      //56(八進制數)
    var num6 = parseInt("70");       //70(十進制數)
    var num7 = parseInt("0xf");      //15(十六進制數)
    
    //在ES3和ES5存在分歧。例如:
    var num = parseInt("070");       //ES3認為是56(八進制)  ES5認為是70(十進制)
    
    //parseInt()函數有第二個參數:轉換時使用的基數(進制)
    var num = parseInt("0xAF", 16)   //175(按十六進制解析)
    //使用了16進制參數，字符串可以不帶0x
    var num1 = parseInt("AF", 16)    //175
    var num1 = parseInt("AF")        //NaN

不知道基數意味著讓parseInt()決定如何解析字符串，因此為了避免錯誤的解析，建議無論在什么情況都明確指定基數。

parseFloat()

var num1 = parseFloat("123bule");      //1234(整數)
var num2 = parseFloat("0xA");          //0
var num3 = parseFloat("22.5");         //22.5
var num4 = parseFloat("22.34.5");      //22.34
var num5 = parseFloat("0908.5");       //908.5
var num6 = parseFloat("3.125e7");      //31250000

String數據類型包含一些特殊的字符字面量，也叫轉義序列，用于表示非打印字符，或者具有其他用途的字符。

ECMAScript中的字符串是不可變的，也就是說，字符串一旦創建，它們的值就不能改變。要改變某個變量保存的字符串，首先要銷毀原來的字符串，然后在用另一個包含新值得字符串填充該變量例如:

var lang = "Java";
lang = lang + "Script"; //JavaScript

toString()方法

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

數值、布爾值、對象、字符串值都有toString()方法。但null和undefined值沒有這個方法。
toString()方法也跟上面的parseInt()方法類似一樣有一個參數:輸出數值的基數；

var num = 10;
console.log(num.toString());    //"10"
console.log(num.toString(2));    //"1010"
console.log(num.toString(8));    //"12"
console.log(num.toString(10));  //"10"
console.log(num.toString(16));  //"a"

在不知道要轉換的值是不是null或undefined的情況下，還可以使用轉型函數String()，這個函數能夠將任何類型的值轉換成字符串。String()函數遵循下列轉換規則:

如果值有toString()方法，則調用該方法(沒有參數)并返回相應的結果；

如果值是null，則返回"null"；

如果值是undefined，則返回"undefined"。

下面看幾個例子:

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

console.log(String(value1));  //"10"
console.log(String(value2));  //"true"
console.log(String(value3));  //"null"
console.log(String(value4));  //"undefined"

ECMAScript中的對象其實就是一組數據和功能的集合。對象可以通過執行new操作符后跟要創建的對象類型的名稱來創建。而創建Object類型的實例并為其添加屬性和方法，就可以創建自定義對象，如下所示:

var o = new Object();

如果不給構造函數傳遞參數，則可以省略后面的括號，但是這做法不推薦

var o = new Object;  //有效，但不推薦省略圓括號

僅僅創建Object的實例并沒有什么用處，但關鍵是要理解一個重要的思想:即在ECMAScript中，Object類型是所有它的實例的基礎。換句話說，Object類型所具有的任何屬性和方法也同樣存在于更具體的對象中。
Object的每個實例都具有下列屬性和方法：

constructor：保存著用于創建當前對象的函數。對于前面的例子而已，構造函數(constructor)就是Object()；返回一個指向創建了該對象原型的函數引用。該屬性的值就是那個函數本身。

hasOwnProperty(propertyName)：用于檢查給定的屬性在當前對象實例中(而不是在實例的原型中)是否存在，其中，作為參數的屬性名(propertyName)必須以字符串的形式指定例如:o.hasOwnProperty("name");

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

propertyIsEnumerable(propertyName)：用于檢查給定的屬性是否能夠使用for-in語句來枚舉。與hasOwnProperty()方法一樣，作為參數的屬性名必須以字符串形式指定。

toLocaleString()：返回對象的字符串表示，該字符串與執行環境的地區對應。

toString()：返回對象的字符串表示。

valueOf()：返回對象的字符串、數值、或布爾值表示。通常與toString()方法的返回值相同。
由于在ECMAScript中Object是所有對象的基礎，因此所有對象都具有這些基本的屬性和方法。

ECMA-262描述了一組用于操作數據值的操作符，包括算數操作符(如加號和減號)、位操作符、關系操作符和相等操作符。ECMAScript操作符的與眾不同之處在于，它們能夠使用于很多值，例如字符串、數字值、布爾值、甚至對象。不過在應用于對象時，相應的操作符通常都會調用對象的valueOf()和(或)toString()方法，以便取得可以操作的值。

1.遞增和遞減操作符
執行前置遞增和遞減操作時，變量的值都是在語句被求值以前改變的。

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

console.log(age); //28
console.log(anotherAge);  //30

由于前置遞增和遞減操作與執行語句的優先級相等，因此整個語句會從左至右被求值。

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

num4相應的加法操作使用了num減去1之后的值

后置遞增和遞減操作符語法不變，他們的區別就是前置遞增和遞減被操作時變量的值都是在語句被求值以前改變的。而后置是求值之后才執行的。

把遞增操作符放在后面并不會改變語句的結果。

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

遞增和遞減操作符對任何值都使用，字符串，布爾值，浮點數值，對象

1.邏輯非
邏輯非操作符由一個嘆號( ! )表示，可以應用于ECMAScript中的任何值。無論這個值是什么數據類型，這個操作符都會返回一個布爾值。邏輯非操作符首先會將她的操作數轉換為一個布爾值，然后再對其求反。

邏輯非操作符也可以用于將一個值轉換為與其對應的布爾值。而同時使用兩個邏輯非操作符。實際上就會模擬Boolean()轉型函數的行為。其中，第一個邏輯非操作會基于無論什么操作數返回一個布爾值，而第二邏輯非操作則對該布爾值求反，于是就得到了這個值正對應的布爾值。當然，最終的結果與對這個值使用Boolean()相同

2.邏輯與
邏輯與操作符由兩個和號(&&)表示，有兩個操作數，如下面的例子所示:

var result = true && false;

邏輯與操作可以應用于任何類型的操作數，而不僅僅是布爾值。在有一個操作數不是布爾值的情況下，邏輯與操作就不一定返回布爾值；此時它遵循下列規則:

如果第一個操作數是對象，則會返回第二個操作數；

如果第二個操作數是對象，則只有在第一個操作數的求值結果為true的情況下才會返回該對象；

如果兩個操作數都是對象，則返回第二個操作數；

如果有一個操作數是null，則返回null；

如果有一個操作數是NaN，則返回NaN；

如果有一個操作數是undefined，則返回undefined。

邏輯與操作屬于短路操作，即如果第一個操作數能夠決定結果，那么就不會再對第二個操作數求值。對于邏輯與而言，如果第一個操作數是false，則無論第二個操作數是什么值，結果都不再可能是true了。例子:

var found = true;
var result = (found && someUndefinedVariable) //這里會發生錯誤
alert(result)  這一行不會執行

上面例子發生錯誤，因為變量someUndefinedVariable沒有聲明。由于變量found的值是true，所以邏輯與操作符會繼續對變量someUndefinedVariable求值。所以邏輯與操作符會繼續對變量someUndefinedVariable求值。但someUndefinedVariable沒定義所以就導致錯誤。將found的值設置為false，就不會發生錯誤了。

3.邏輯或
邏輯或操作符由兩個和號(||)表示，有兩個操作數，如下面的例子所示:

var result = true || false;

與邏輯與操作相似，如果有一個操作數不是布爾值，邏輯或也不一定返回布爾值;此時它遵循下列規則:

如果第一個操作數是對象，則會返回第一個操作數；

如果第一個操作數的求值結果為false，則返回第二個操作數。

如果兩個操作數都是對象，則返回第一個操作數；

如果有兩個操作數是null，則返回null；

如果有兩個操作數是NaN，則返回NaN；

如果有兩個操作數是undefined，則返回undefined。
與邏輯與操作符相似，邏輯或操作符也是短路操作符。如果第一個操作數的求值結果為true，就不會對第二個操作值求值了，跟邏輯與是相反的。

小于(<)、大于(>)、小于等于(<=)和大于等于(>=)

與ECMAScript中的其他操作符一樣，當關系操作符的操作數使用了非數值時，也要進行數據轉換或完成某些奇怪的操作。一下就是相應的規則。

如果兩個操作符都是數值，則執行數值比較；

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

如果一個操作數是數值，則另一個操作數轉換為一個數值，然后執行數值比較；

如果一個操作數是對象，則調用這個對象的valueOf()方法，并用得到的結果根據前面的規則執行比較。如果對象沒有valueOf()方法，則調用toString()方法，并用得到的結果根據前面的規則執行比較；

如果一個操作數是布爾值，則將他轉換為數值，然后執行比較。

任何數與NaN比較都返回false

1.相等和不相等

== 兩個數相等 返回true
!= 兩個數不相等 返回ture
要比較相等性之前，不能將null和undefined轉換成其他任何值。
如果兩個操作數都是對象，則比較它們是不是同一個對象，如果兩個操作數都指向同一個對象則true，不是則false；

注意：null和undefined是相等的，NaN不等于NaN

2.全等和不全等
全等和相等類似，兩者最大區別是全等比較時不轉換成數值。
全等和不全等的比較都是在操作數未經轉換的情況下比較。

注意：null == undefined返回true，因為他們類似的值；但null === undefined返回false，因為他們是不同類型的值

variable = boolean_expression ? true_value : false_value;
var max = (num1 > num2) ? num1 : num2;

if(condition) statement1 else statement2
if(i > 25) {
    alert("Greater than 25.");    
}else{
    alert("Less than of equal to 25.");
}

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

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

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

由于ECMAScript中不存在塊級作用于，因此在循環內部定義的變量也可以在外部訪問到。

注意：for語句中的初始化表達式、控制表達式和循環后表達式都是可選的。將這三個表達式全部省略，就會創建一個無限循環。

var data = [1,3,2,4,5];
for(var propName in data){
    console.log(data[propName]); //1,3,2,4,5
    console.log(propName); //0,1,2,3,4
}
for(var propName in window){
    console.log(propName); //window對象屬性名
}

注意：ECMAScript對象屬性沒有順序。因此通過for-in循環輸出的屬性名的順序是不可預測的。
注意：建議在使用for-in之前，先檢測確認該對象的值不是null或undefined。

使用label語句可以再代碼中添加標簽，以便將來使用。

start: for (var i = 0; i < count; i++){
    alert(i);
}

這個例子中定義的start標簽可以在將來有break或continue語句引用。加標簽的語句一般都要與for語句等循環語句配合使用

break：

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

continue:

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

label可以和break和continue:

var num = 0;

outermost:  //循環外標簽
for(var i = 1; i < 10; i++){
    for(var j= 0; j < 10; j++){
        if(i == 5 && j == 5){ 
//正常來說break只能跳出一層循環，但外面使用了label語句的標簽outrmost可以直接跳出全部循環到outermost的位置；
            break outermost;
        }
        num++;
    }
}
console.log(num);  //55

with語句的作用是將代碼的作用域設置到一個特定的對象中。with語句的語法如下:

with (expression) statement;

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

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

上面幾行代碼都包括location對象。如果使用with語句如下：

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

注意：嚴格模式不允許使用with語句，會視為語法錯誤。with語句大量使用會導致性能下降，同時也會給調試代碼造成困難，因此在開發大型項目時，不建議使用with語句

var num = 25;
switch (true){
    case num < 0:
        console.log("0");
        break;
    case num >= 0 && num <= 10:
        console.log("0");
        break;
    default:
        console.log("0");
}

注意：switch語句在比較值時使用的是全等操作符。

return語句也可以不帶任何返回值。在這種情況下，函數在停止執行后將返回undefined值。

推薦做法：是要么讓函數使用都返回一個值，要么永遠都不要返回值。否則，如果函數有時候返回值，有時候不反回，會給調試代碼帶來不便

在函數體內可以使通過arguments對象來訪問這個參數的數組，從而獲取傳遞給函數的每一個參數。
通過訪問argments對象的length屬性可以獲知有多少個參數傳遞給了函數

function doAdd(num1,num2){
    arguments[1] = 10;
    console.log(arguments[1]);        //10
    console.log(num2);                //10
    console.log(arguments[0] + num2); //20
    console.log(arguments.length);    //2  也可以訪問arguments對象的length屬性可以獲取有多少個參數傳遞給函數
}
doAdd(10,20);

每次執行這個doAdd()函數都會重寫第二參數，將第二個參數的值修改為10。因為arguments對象中的值會自動反映到對應的命名函數，所以修改arguments[1]，也就修改了num2，結果它們的值都會變成10，不過，這并不是說讀取這個兩個值會訪問相同的內存空間；它們的內存空間是獨立的，但它們的值會同步。你也可以反過來修改num2的值效果也是一樣的。

function doAdd(num1,num2){
    num2 = 10;
    console.log(arguments[1]);        //10
}
doAdd(10,20);

arguments對象可以與命名參數一起使用，如:

function doAdd(num1, num2){
    if(arguments.length == 1){
        console.log(num1 + 10)
    }else{
        console.log(argments[0] + num2);
    }
}

arguments對象只是與數組類似(它并不是Array的實例).

arguments的值永遠與對應命名參數的值保持同步

沒有傳遞值得命名參數將自動被賦予undefined值。

嚴格模式下不允許重寫命名參數或者arguments的值，雖然可以執行，但是命名參數與arguments對應的值將不再同步

ECMAScript函數沒有簽名，因為其參數是由包括零或多個值的數組來表示的。而沒有函數簽名，真正的重載是不可能做到的。

最后，如有錯誤和疑惑請指出，多謝各位大哥

如果在ECMAScript中定義了兩個名字相同的函數，則該名字只屬于后定義的函數。