人比較笨，以前只做項目，案例，然而一些javascript的很多理論不知道該怎么描述，所以最近開啟一波讀書之旅；

標識符

1、定義
標識符以字母開頭，可能后面跟上一個或多個字母、數字或者下劃線。

2、用處
標識符被用于語句、變量、參數、屬性名、運算符以及標記。

數值

1、數值在內部被表示為64位的浮點數；

2、NaN是一個數值，但是它不與任何值，包括它自己，即 NaN !== NaN 為 true；

3、isNaN可以檢查數值是否為NaN；

4、方法：

number.toExponential()

toExponential 方法把number轉換成一個指數形式的字符串。可選參數控制小數點的數字位數；

var num = Math.PI;
console.log(num.toExponential(0));//3e+0
console.log(num.toExponential(2));//3.14e+0
console.log(num.toExponential(7));//3.1415927e+0
console.log(num.toExponential(16));//3.1415926535897931e+0
console.log(num.toExponential());//3.141592653589793e+0

number.toFixed()

toFixed 方法把number轉換成一個十進制形式的字符串，可選參數控制小數點的數字位數，默認為0；

console.log(num.toFixed(0)); //3
console.log(num.toFixed(2)); //3.14
console.log(num.toFixed(7)); //3.1415927
console.log(num.toFixed(16)); //3.1415926535897931
console.log(num.toFixed());  // 3

number.toString

toString 方法把number轉換成一個字符串。可選參數控制基礎，2~36之間，默認為10，參數為多少，就轉換成幾進制的字符串

console.log(num.toString(2));//11.001001000011111101101010100010001000010110100011
console.log(num.toString(8));//3.1103755242102643
console.log(num.toString(10));//3.141592653589793
console.log(num.toString(16));//3.243f6a8885a3
console.log(num.toString()); //3.141592653589793

字符串

1、因為Unicode是一個16的字符集，所以Javascript中的所有字符串都是16位的；

2、Javascript中沒有字符類型，用一個引號就可以表示一個字符串；

3、字符串有長度：‘str’.length = 5;

4、字符串一旦創建時不可變得，但是可以用 += 運算符與其他字符連接，創建一個新的字符串；

5、方法

string.charAt(i)

charAt 方法返回在string中i位置處的字符，如果i小于0或大于等于字符串的長度，則返回空字符串；

var name = 'Tom';
var a = name.charAt(1);

console.log(a); //o

實現：

String.prototype.charAter = function(i){
    return this.slice(i,i+1);
}

string.concat()

concat 方法把其他字符串連接在一起來構成一個新的字符串，很少被用；

var str = 'Tom';
var name = str.concat('and','Jerry');
console.log(name); //Tom and Jerry

string.indexOf(searchStr,p) && string.lastIndexOf(searchStr,p)

indexOf 方法在string內查找另一個字符串searchStr，如果被找到，返回第一個匹配字符的位置，否則返回-1；可選參數p可以設置從string的某個指定位置開始查找；

var test = 'Mississippi';
var str1 = test.indexOf('ss');
var str2 = test.indexOf('ss',3);
var str3= test.indexOf('ss',6);

console.log(str1); //2
console.log(str2); //5
console.log(str3); //-1

lastIndexOf 與 indexOf 方法類似，只不過它是從字符串的末尾開始查找；

var str4 =test.lastIndexOf('ss');
var str5= test.lastIndexOf('ss',3);
var str6 = test.lastIndexOf('ss',6);

console.log(str4); //5
console.log(str5); //2
console.log(str6); //5

string.localeCompare(str1)

localeCompare方法比較兩個字符串，如果string 比字符串str1小，返回負數，如果相等，返回0；

var a = 'abc';
var b = 'ABC';
console.log(a.localeCompare(b));//-1

var arr = ['AAA','A','aa','Aa','aaa','a'];
arr.sort(function(a,b){
    return a.localeCompare(b);
});
console.log(arr);//["a", "A", "aa", "Aa", "aaa", "AAA"]

string.match(reg)

match 方法讓字符串和一個正則表達式精選匹配；

string.replace(searchStr,replaceStr)

replace 方法對string進行查找和替換操作，并返回一個新的字符串。參數searchStr可以是個字符串或正則表達式對象。如果是個字符串，那么searchStr只會在第一次出現的地方誒替換；

var str = 'monther_in_law';
var result = str.replace('_','-');
console.log(result);//monther-in_law

replaceStr 可以是一個字符串或函數，如果是個字符串，字符 $ 擁有特殊含義；

string.search(reg)

search方法與indexOf方法類似,它接受一個正則表達式，如果匹配到，返回第一個匹配的位置，否則，返回-1；

string.slice(start,end)

slice 方法復制string的一部分，來構造一個新的字符串；如果start參數是負數，他將與string.length相加，end參數可選，默認為string.length；

string.split(s,l)

splice方法把string分割成片段，來創建一個字符串數組，s是可以是一個字符串或者正則表達式，l是可選的，限制數量

string.subString(start,end)

subString方法與slice方法一樣,它不能處理負數;

string.toLocaleLowerCase()

toLocaleLowerCase 方法使用本地化規則，將string中的所有字母轉換為小寫格式；

string.toLocalUpperCase()

toLocaleUpperCase 方法使用本地化規則，將string中的所有字母轉換為大寫格式；

string.toLowerCase()

toLowerCase 方法將string中的所有字母轉換為小寫格式；

string.toUpperCase()

toUpperCase 方法將string中的所有字母轉換為大寫格式；

String.fromCharCode()

String.fromCharCode 函數根據一串數字編碼返回一個字符串；

布爾值

1、false值
false
null
undefined
空字符串
數字0
數字NaN

2、其他的都為true值，包括true和字符串‘false’,以及所有對象；

語句

1、通常按照從上到下的順序被執行；

2、代碼塊是包在一個對花括號中的一組語句；代碼塊不會創建新的作用域；

3、for in循環枚舉一個對象的所有屬性；通常先檢查這個屬性名是該對象本身的，還是來自原型鏈的；

for(var attr in object){
    if(object.hasOwnProperty(attr)){
        ...
    }
}

4、switch-case語句中case值可以為任何值；

表達式

1、運算符的優先級

2、typeof運算符的值

number、string、object、undefined、function、boolean

null或者數組為object

對象

1、定義

對象式屬性的容器，其中每個屬性都有對應的名字和值；

2、特點

屬性名可以是包括空字符串在內的任何字符串；（不能為保留字）

屬性值可以是除undefined之外的任何值，包括function；

3、對象字面量

一個對象字面量就是包圍在一對花括號中的零或多個‘名/值’對；

4、檢索

方式：[]和.

5、更新

對象里的值可以通過賦值語句來進行更新；

6、引用

對象只能通過引用快遞，永遠不會被復制；

7、枚舉

for in循環

8、刪除

通過delete運算符來進行對象屬性的刪除；

var obj = {
    a:1,
    b:2
};

console.log(obj);

delete obj.a;

console.log(obj);

9、方法

object.hasOwnProperty(name)

如果object包含一個名為name的屬性，那么hasOwnProperty方法返回true。原型鏈中的同名屬性是不會被檢查得。

var obj = {msg:true};
var a = Object.create(obj);
var t = obj.hasOwnProperty('msg');
var _msg = a.msg;
var _t = a.hasOwnProperty('msg');

console.log(t); //true
console.log(_msg);//true
console.log(_t);//false

數組

1、數組字面量

數組字面量提供了一種非常方便的創建數組的表示法；一個數組字面量是在一對方括號中包圍零個或多個用逗號分隔的值的表達式；

var arr = [0,1,2,3];

2、特性

JavaScript允許數組包涵任意混合類型的值；

3、長度

每個數組都有一個length屬性，javascript數組的length沒有上界；

4、刪除

delete刪除數組元素

var arr = [0,1,2,3,4];
console.log(arr);//[0,1,2,3,4]
delete arr[2];
console.log(arr); // [0,1,undefined,3,4]

splice 刪除元素

var arr = [0,1,2,3,4];
console.log(arr);//[0,1,2,3,4]
arr.splice(2,1);
console.log(arr); // [0,1,3,4]

5、判斷是否是數組

typeof arr 的類型是 object；

第一種方法：

var is_array = function(value){
    return value && typeof value === 'object'  && value.construcor === Array;
}

第二種方法：

var is_array = function(value){
    return Object.prototype.toString.apply(value) === '[Object,Array]';
}

6、構建矩陣

Array.matrix = function(m,n,initial){
    var a ;
    var b = [];
    for(var i = 0; i < m ;i++){
        a = [];
        for(var j = 0; j < n ; j++){
            a[j] = initial;
        }

        b[i] = a;
    }

    return b;
}

var myMatrix = Array.matrix(4,4,0);
document.writeln(myMatrix[0][0]);//0

7、方法

array.concat()

concat 方法產生一個新數組，先淺復制數組，然后把一個多個參數附加在其后；

var arr1 = [1,2,3,4];
var a = 'a';
var b = 'b';
var arr2 = [5,6,7,8];
var arr3 = [9,10];

var  arr = arr1.concat(a,b,arr2,arr3);
console.log(arr); //[1, 2, 3, 4, "a", "b", 5, 6, 7, 8, 9, 10]

array.join()

join 方法把一個數組構造成一個字符串。默認用“,”好分隔;當數據比較多時，join方法比+運算符要快；

var arr = ['a','b','c','d'];
var str = arr.join();
console.log(str);//a,b,c,d

var str1= arr.join('');
console.log(str1);//abcd

var str2= arr.join('-');
console.log(str2);//a-b-c-d

array.pop()

pop和push方法使得數組array想堆棧一樣工作。pop 方法移除array中的最后一個元素，并返回該元素；

var arr = [1,2,3,4,5];
var a = arr.pop();
console.log(arr); // [1,2,3,4]
console.log(a); // 5

實現：

Array.prototype.pop = function(){
    return this.splice(this.length-1,1)[0];
};

array.push()

push 方法把一個或者多個附加到一個數組的尾部。和concat不同，push方法會修改array,返回新數組的長度；

var arr = [1,2,3,4];
var arr2 =['a','b','c','d'];
var len = arr.push(arr2,true);
console.log(arr); // [1,2,3,4,['a','b','c','d'],true]
console.log(len); // 6

實現：

 Array.prototype.push = function(){
    var len  = arguments.length;

    for(var i= 0 ;i<len;i++){
        this.splice(this.length,0,arguments[i])
    }
    return this.length;
}

array.reverse()

reverse 方法反轉array里的元素順序，并返回array本身;

var arr = [1,2,3,4];
var a = arr.reverse();
console.log(a); // [4,3,2,1]

array.shift()

shift 方法移除數組array中的第一個元素并返回該元素；

var arr = [1,2,3,4];
var a = arr.shift();
console.log(arr);//[2,3,4]
console.log(a); //1

實現：

 Array.prototype.shifter = function(){
    return this.splice(0,1);
}

array.slice(start,end)

slice 方法對array中的一段做淺復制。首先復制array[start],一直復制到array[end]為止；end參數可選，默認值是該數組的長度length，如果兩個參數中的任何一個是負數，array.length會和她們相機，視圖讓他們為非負數。

var arr = [1,2,3,4,5];
var a = arr.slice(1,4);
console.log(arr);//[1,2,3,4,5]
console.log(a);//[2,3,4]

array.splice(start,delCount)

splice 方式從array中移除一個或多個元素，并用新的item替換。start是從數組中移除元素的開始位置，delCOunt是要移除的元素個數。如果有額外的參數，則插入到被移除的位置上。返回被移除的數組

var arr = [1,2,3,4,5];
var a = arr.splice(1,2,11,21,22);
console.log(arr);//[1,11,21,22,4,5]
console.log(a);//[2,3]

實現：

Array.prototype.splicer = function (start, count) {
    var argLen = Math.max(arguments.length - 2, 0); //是否有第三個參數
    var len = this.length; //數組長度
    var result = []; //刪除數組

    start = start || 0; //第一個參數，開始的位置

    //當start為負數時，加上數組長度length，變為非負數
    if (start < 0) {
        start += len;
    }

    start = Math.max(Math.min(start, len), 0);

    count = Math.max(Math.min(typeof count === 'number' ? count : 0, len-start), 0);

    for (var i = 0; i < count; i++) {
        var element = this[start + i]; //刪除的值;
        if (element !== undefined) {
            result[i] = element;
        }
    }

    var itemLen = argLen - count;
    var newLen = len + itemLen;
    var currentIndex = len - start - count;
    if (itemLen < 0) {
        var k = start + argLen;

        for (; currentIndex > 0; currentIndex--) {
            this[k] = this[k - itemLen];
            k++;
        }
    } else if (itemLen > 0) {
        var k = 1;
        for (; currentIndex > 0; currentIndex--) {
            this[newLen - k] = this[len - k];
            k++;
        }
    }
    this.length = newLen;

    for (var i = 0; i < argLen; i++) {
        this[start + i] = arguments[i + 2];
    }

    return result;

}

array.unshift()

unshift 方法用于吧元素插入到array的開始，返回array新的length；

var arr = [1,2,3,4,5];
var a = arr.unshift('a');
console.log(arr);//['a',1,2,3,4,5];
console.log(a);//6

實現:

Array.prototype.unshift = function () {
    var len = arguments.length;
    for (var i = len - 1; i >= 0; i--) {
        this.splice(0, 0, arguments[i]);
    }
    return this.length;
}

array.sort()

sort 方法是對數組array的元素進行排序，由于JavaScript的默認比較函數把要排序的元素都視為字符串，所以sort方法不能正確的排序；

var arr = [2,1,11,5,8,15];
arr.sort();
console.log(arr);//[1,11,15,2,5,8]

修改排序一：

arr.sort(function(a,b){
    return a-b;
});
console.log(arr);//[1,2,5,8,11,15]

雖然上面能正確的排序數字，但是不能排序字符串，所以

修改排序二：

var arr = ['a', 1, 13, 'c', 'd','b', '13', 'bb'];
arr.sort(function (a, b) {
    if (typeof a === typeof b) {
        return a < b ? -1 : 1;
    }

    return typeof a < typeof b ? -1 : 1;
});
console.log(arr);//[1, 13, "13", "a", "b", "bb", "c", "d"]

排序對象，修改排序三：

var arr = [
    {name:'Joe',age:12},
    {name:'Moe',age:22},
    {name:'Joe',age:21},
    {name:'Shemp',age:29},
    {name:'Larry',age:22},
    {name:'Curly',age:30}
]

var by = function(key){
    return function(o,p){
        if(o && p && typeof o === 'object' && typeof p === 'object'){
            var a = o[key];
            var b = p[key];

            if(a === b){
                return 0;
            }

            if(typeof a === typeof b){
                return a < b ? -1 : 1;
            }

            return typeof a < typeof b ? -1 : 1;
        }else{
            throw {
                name:'Error',
                massage:'Expected an object when sorting by'+name
            }
        }
    }
};

正則表達式

1、創建方式

第一種方式：直接創建

var reg = /^\w{3,8}$/g;

正則表達式標識

第二種方式：RegExp對象

 var reg = new RegExp("^\\w\{3,8\}$");

RegExp對象的屬性

2、正則表達式分支

var str = "into";
str.match(/in|int/); //匹配in，而不是int

3、正則表達式因子

定義：一個表達式因子可以是一個字符、一個有圓括號包圍的組、一個字符類、或者是一個轉義序列；

4、正則表達式轉義

\ / [ ] ( ) { } ? + * | . ^ $ 都需要用一個 \ 前綴來進行轉義

注意：\前綴不能使字母或數字字面化。

一個未被轉義的 . 會匹配除行結束符以外的任何字符；

一個未轉義 ^ 會匹配文本的開始，當指定了m 標識時，也能匹配行結束符；

一個未轉義的 $ 將匹配文本的結束，當指定了 m 標識時，也能匹配行結束符；

\f 換頁符
\n 換行符
\r 回車符
\t 制表符
\u Unicode字符的十六進制常量
\d 等于[0-9],匹配數字
\D 等于[^0-9],匹配非數字
\s 等于[\f\n\r\t\u00B\u0020\u00A0\u2028\u2029] 這是Unicode空白符的一個不完全子集
\S 等于[^\f\n\r\t\u00B\u0020\u00A0\u2028\u2029]
\w 等于 [0-9A-Z_a-z]
\W 等于[^0-9A-Z_a-z]
\b 被指定為一個字邊界標識，方便用于對文本的字邊界進行匹配
\1 指向分組1所捕獲到的文本的一個引用
\2 指向分組2的引用
\3 指向分組3的引用

5、正則表達式分組

捕獲型

一個捕獲型分組是一個被包圍在圓括號的正則表達式分支。任何匹配這個分組的字符都會被捕獲。

非捕獲型

非捕獲型分組有一個(?: 前綴，非捕獲型分組僅做簡單的匹配，并不會捕獲所匹配的文本。

向前正向匹配

向前正向匹配分組有一個(?= 前綴；類似于非捕獲型分組，但在這個組匹配后，文本會倒回到它開始的地方。

向前負向匹配

向前負向匹配分組有一個 (?! 前綴

6、正則表示式量詞

正則表達式因子可以用一個正則表達式量詞后綴來決定這個因子應該被匹配的次數。它包圍在一對花括號中的一個數組表示這個因子應該被匹配的次數；

/www/  ==  /w{3}/
{3,6}表示匹配3到6次
{3,}表示匹配至少3次
? 等同于{0,1} 匹配0到1次
* 等同于{0,} 匹配至少0次
+ 等同于{1,} 匹配至少1次

毒瘤

1、全局變量

定義全局變量的三種方法：

var foo = value;

window.foo = value;

foo = value;

弊端：全局變量使得在通一個程序中運行獨立的子程序變得更難。

2、作用域

弊端：除了函數，javascript沒有塊級作用域；

3、自動插入分號

4、保留字

弊端：不能用來命名變量火參數。

5、Unicode

弊端：JavaScript的字符是16位，覆蓋原有的65536個字符；剩下的百萬字符的每一個都可以用一對字符來表示，Unicode把一對字符視為一個單一的字符，而javascript認為一對字符是兩個不同的字符；

6、typeof

弊端：不能識別'null' 和數組 ，返回 'object';

7、parseInt

弊端：遇到非數字時會停止解析，所以parseInt('16')和parseInt('16 aaa')是相同結果；如果該字符串第一個字符是0，那么該字符會基于八進制，而不是十進制求值；

8、浮點數

弊端：二進制的浮點數不能正確地處理十進制的小數，因此0.1+0.2不等于0.3；因為javascript遵循的是二進制浮點數算術標準；

9、NaN

function isNumber(v){
    return typeof v === 'number' && isFinite(v);
 }

10、偽數組

javascript沒有真正的數組；

弊端：typeof運算符不能辨別數組和對象

11、對象

弊端：JavaScript的對象永遠不會是真的空對象，因為他們可以從原型鏈中取得成員屬性；

JSON

1、定義：JavsScript對象表示法的簡寫，是一種輕量級的數據交換格式；

2、值的類型：對象、數組、字符串、數字、布爾值、特殊值null；

3、JSONd對象：是一個容納“名/值”對的無序集合；名字可以是任何字符串，值可以使任何類型的JSON值。

4、JSON數組：是一個值的有序序列；值可以是任何類型的JSON值；

5、JSON字符串:被包圍在一對雙引號之間；

6、JSON數字：與JavaScript的數字類似，不循序首位為0；