摘要：小明在一個方法內(nèi)部，是一個特殊變量，它始終指向當(dāng)前對象，也就是這個變量。原型對象基于原型創(chuàng)建一個新對象初始化新對象小明小明

數(shù)字
字符串
布爾：false和true
數(shù)組
對象
null——空值
undefined——未定義。僅僅在判斷函數(shù)參數(shù)是否傳遞的情況下使用

用""或者""包括的叫字符串。
轉(zhuǎn)義字符：""
toUpperCase()——轉(zhuǎn)換為大寫
toLowerCase()——轉(zhuǎn)換為小寫
indexOf()——搜索指定字符串出現(xiàn)的位置，如果沒有找到返回-1
subString(start,end)——字符串截取，索引值不包含end

獲取數(shù)組長度直接arr.length

通過索引修改值arr[2]=0;

indexOf()——搜索指定元素所在位置

slice(起始索引,結(jié)束索引)——截取元素，返回新的數(shù)組，包含起始索引，但是不包含結(jié)束索引，類似數(shù)學(xué)中[start，end)

push()——向數(shù)組末尾添加新元素

unshift()——想數(shù)組頭部添加新元素

pop()——刪除數(shù)組末尾的元素

shift()——刪除數(shù)組頭部的元素

sort()——數(shù)組排序

reverse()——數(shù)組反向

concat()——數(shù)組合并，返回新數(shù)組

join()——數(shù)組轉(zhuǎn)換為字符串

splice(start,num,newElement)——數(shù)組修改萬能方法。

var arr = ["Microsoft", "Apple", "Yahoo", "AOL", "Excite", "Oracle"];

//從索引2開始刪除3個元素,然后再添加兩個元素:
arr.splice(2, 3, "Google", "Facebook");

//刪除的元素 ["Yahoo", "AOL", "Excite"]

arr; 
//["Microsoft", "Apple", "Google", "Facebook", "Oracle"]

對象我粗暴的理解就是鍵值對。

var person={
    name:"小明",
    age:18,
    sex:"男",
    "middle-school":"NO.1 middle school"
}

訪問屬性使用.，例如person.name或者person["name"],屬性命名含有特殊字符的必須使用后一種方式，即person["middle-school"]

判斷對象中某一個屬性是否存在使用in或者hasOwnProperty(),前者判斷的屬性不一定是對象私有也可能是繼承的，后者可以判斷對象是否擁有該屬性。

//in
"name" in person //true
"height" in person //false

//hasOwnProperty()
person.hasOwnProperty("name") //true
person.hasOwnProperty("height") //false

對象的屬性都是字符串，屬性值什么類型都有。
遍歷對象屬性和屬性值

var per={
  name:"zch",
  age:18,
  "height-h":178
}
var x=per.hasOwnProperty("name");
for(item in per){
  console.log(per[item])
}

函數(shù)定義
（1）函數(shù)聲明

function abc(x){
    if(x>0){
        return x;
    }else{
        return -x;
    }
}
//*函數(shù)內(nèi)部執(zhí)行到return時語句會停止

（2）函數(shù)表達(dá)式

var abs=function(x){
    return x > 0 ? x : -x;
};

(1)和(2)在定義上完全等價，但是使用上要注意，函數(shù)聲明方式可以先調(diào)用后定義，也就是函數(shù)提升，表達(dá)式定義則不行，另外方式(2)本質(zhì)上是一個賦值語句，因此在末尾要加;

變量

如果一個變量在函數(shù)體內(nèi)部申明，則該變量的作用域?yàn)檎麄€函數(shù)體，在函數(shù)體外不可引用該變量

如果兩個不同的函數(shù)各自申明了同一個變量，那么該變量只在各自的函數(shù)體內(nèi)起作用。換句話說，不同函數(shù)內(nèi)部的同名變量互相獨(dú)立，互不影響

由于JavaScript的函數(shù)可以嵌套，此時，內(nèi)部函數(shù)可以訪問外部函數(shù)定義的變量，反過來則不行

JavaScript的函數(shù)在查找變量時從自身函數(shù)定義開始，從“內(nèi)”向“外”查找。如果內(nèi)部函數(shù)定義了與外部函數(shù)重名的變量，則內(nèi)部函數(shù)的變量將“屏蔽”外部函數(shù)的變量

變量也可以提升，不過不能提升值

由于JavaScript的變量作用域?qū)嶋H上是函數(shù)內(nèi)部，我們在for循環(huán)等語句塊中是無法定義具有局部作用域的變量的,也就是說for循環(huán)中的i或者j在函數(shù)內(nèi)部都可以訪問到。

方法
在一個對象中綁定函數(shù)，稱為這個對象的方法。

"use strict";

var xiaoming = {
    name: "小明",
    birth: 1990,
    age: function () {
        function getAgeFromBirth() {
            var y = new Date().getFullYear();
            return y - this.birth;
        }
        return getAgeFromBirth();
    }
};

xiaoming.age();
//在一個方法內(nèi)部，this是一個特殊變量，它始終指向當(dāng)前對象，也就是xiaoming這個變量。所以，this.birth可以拿到xiaoming的birth屬性。
//針對函數(shù)內(nèi)再套函數(shù)的問題，因?yàn)閠his指向發(fā)生了變化，可以使用that首先捕獲this，在進(jìn)行傳值

高階函數(shù)
高階函數(shù)就是函數(shù)的參數(shù)是一個函數(shù)

function add(x, y, f) {
    return f(x) + f(y);
}
add(-5,9,Math.abs)// Math.abs(-5) + Math.abs(6)==>5+6=11

高階函數(shù)——map()

//jquery map() 返回一個jquery對象
//js原生map()返回一個數(shù)組

var x=$("input").map(function(){
      return $(this).val();
    })
//返回{ 0: "氣球", 1: "是否", 2: "水電費(fèi)剎車發(fā)生"}
console.log(x)//返回objct

//get()是jq DOM操作方法，目標(biāo)對象是獲取的DOM元素，返回數(shù)組。
//結(jié)果[ "氣球", "是否", "水電費(fèi)剎車發(fā)生" ]
console.log(x.get())

在實(shí)際使用的時候，我們可以利用map方法方便獲得對象數(shù)組中的特定屬性值們，如下：

var users = [
  {name: "張含韻", "email": "[email protected]"},
  {name: "江一燕",   "email": "[email protected]"},
  {name: "李小璐",  "email": "[email protected]"}
];
var emails = users.map(function (user) { return user.email; });
console.log(emails.join(", ")); // [email protected], [email protected], [email protected]

由map方法引發(fā)的一個js題目：

["1", "2", "3"].map(parseInt);
// 你可能覺的會是[1, 2, 3]
// 但實(shí)際的結(jié)果是 [1, NaN, NaN]

// 通常使用parseInt時,只需要傳遞一個參數(shù).但實(shí)際上,parseInt可以有兩個參數(shù).第二個參數(shù)是進(jìn)制數(shù).可以通過語句"alert(parseInt.length)===2"來驗(yàn)證.
// map方法在調(diào)用callback函數(shù)時,會給它傳遞三個參數(shù):當(dāng)前正在遍歷的元素, 元素索引, 原數(shù)組本身.
// 第三個參數(shù)parseInt會忽視, 但第二個參數(shù)不會,也就是說,parseInt把傳過來的索引值當(dāng)成進(jìn)制數(shù)來使用.從而返回了NaN.

//應(yīng)該使用如下的用戶函數(shù)returnInt
function returnInt(element){
  return parseInt(element,10);
}

["1", "2", "3"].map(returnInt);// 返回[1,2,3]

parseInt()方法
語法：parseInt(string, radix)
string 必需。要被解析的字符串。
radix 可選。

表示要解析的數(shù)字的基數(shù)。該值介于 2 ~ 36 之間。

如果省略該參數(shù)或其值為 0，則數(shù)字將以 10 為基礎(chǔ)來解析。如果它以 "0x" 或 "0X" 開頭，將以 16 為基數(shù)。

如果該參數(shù)小于 2 或者大于 36，則 parseInt() 將返回 NaN。

所以：["1", "2", "3"].map(parseInt)相當(dāng)于
[parseInt("1", 0), parseInt("2", 1), parseInt("3", 2)]
parseInt("3", 2) 的第二個參數(shù)是界于 2-36 之間的，之所以返回 NaN 是因?yàn)?字符串 "3" 里面沒有合法的二進(jìn)制數(shù)，所以 NaN

高階函數(shù)——reduce
Array的reduce()把一個函數(shù)作用在這個Array的[x1, x2, x3...]上，這個函數(shù)必須接收兩個參數(shù)，reduce()把結(jié)果繼續(xù)和序列的下一個元素做累積計算，其效果就是：

[x1, x2, x3, x4].reduce(f) = f(f(f(x1, x2), x3), x4)

比方說對一個Array求和，就可以用reduce實(shí)現(xiàn)：

var arr = [1, 3, 5, 7, 9];
arr.reduce(function (x, y) {
    return x + y;
}); // 25

高階函數(shù)——filter()
過濾器，返回true保留，false丟棄，類似map()，接收一個函數(shù)。

//篩選出字符串
var arr=[1,2,4,"dfdf",343,"asdfsad"];
var x=arr.filter(function(x){
  return typeof(x)=="string"
})
console.log(x)

filter回調(diào)函數(shù)可以帶三個參數(shù)

var arr = ["A", "B", "C"];
var r = arr.filter(function (element, index, self) {
    console.log(element); // 依次打印"A", "B", "C"
    console.log(index); // 依次打印0, 1, 2
    console.log(self); // self就是變量arr
    return true;
});

高階函數(shù)——sort()
sort()排序時先把元素轉(zhuǎn)換為字符串再進(jìn)行判斷，因此數(shù)字排序有時候不正確，因此需要我們自己傳入一個比較函數(shù)。

arr.sort(function(x,y){
    if(xy){
        rerturn 1;
    }
    return 0;
})

//當(dāng)然最簡潔是這樣寫
arr.sort(function(x,y){
    return x-y;//正序
    return y-x;//倒序
})

sort()方法會對當(dāng)前array進(jìn)行修改，返回時當(dāng)前的arry；

閉包

箭頭函數(shù)

(x,y)=> x*y
等同于
function(x,y){
    return x*y;
}

generator
ES6標(biāo)準(zhǔn)，generator由function定義（注意多出的號），并且，除了return語句，還可以用yield返回多次

在js中一切都是對象。

包裝對象
在js中只有對象才可以使用.加屬性進(jìn)行訪問，js的三個基本類型number，string和boolean看著人家有對象心里不平衡，自己也想有對象，于是就借助包裝對象來讓自己變成對象，有兩個方式，一個是隱式轉(zhuǎn)換一個是顯式轉(zhuǎn)換。
什么是隱式轉(zhuǎn)換呢？看下面例子：

var str="asfkjas";
console.log(str.length);

變量str是一個字符串，但是卻可以使用.加屬性的形式獲取到字符長度，這大大超出了我們的預(yù)知，完全是反人類啊，其實(shí)瀏覽器默默的給他包裝成了一個對象，本質(zhì)上是這樣的：

var str="asfkjas";
console.log(new String(str).length);

再例如：

var str="hello";
str.a="haha";
console.log(str.a)

結(jié)果是undefined，第二行聲明的時候默認(rèn)是new String(str).a="haha",用完就立即舍棄了，所以打印的時候并沒有賦值，結(jié)果是undefined；
具體解釋點(diǎn)擊這里

建議包裝對象不要隨意使用，涉及到類型轉(zhuǎn)換的時候建議使用以下方式：

不要使用new Number()、new Boolean()、new String()創(chuàng)建包裝對象；

用parseInt()或parseFloat()來轉(zhuǎn)換任意類型到number；

用String()來轉(zhuǎn)換任意類型到string，或者直接調(diào)用某個對象的toString()方法；

通常不必把任意類型轉(zhuǎn)換為boolean再判斷，因?yàn)榭梢灾苯訉慽f (myVar) {...}；

typeof操作符可以判斷出number、boolean、string、function和undefined；

判斷Array要使用Array.isArray(arr)；

判斷null請使用myVar === null；

判斷某個全局變量是否存在用typeof window.myVar === "undefined"；

函數(shù)內(nèi)部判斷某個變量是否存在用typeof myVar === "undefined"。
null和undefined沒有toString()方法。

number調(diào)用toString()時應(yīng)該這樣：

123..toString(); // "123", 注意是兩個點(diǎn)！
(123).toString(); // "123"

為什么？不要問為什么？這就是js的樂趣！
String()和toString()方法的區(qū)別

兩個轉(zhuǎn)換小技巧：

var x1=x+"";
console.log(typeof(x1));//string
var y="123";
var y1=y-0;
console.log(typeof(y1));//number

date

var now = new Date();
now; // Wed Jun 24 2015 19:49:22 GMT+0800 (CST)
now.getFullYear(); // 2015, 年份
now.getMonth(); // 5, 月份，注意月份范圍是0~11，5表示六月
now.getDate(); // 24, 表示24號
now.getDay(); // 3, 表示星期三
now.getHours(); // 19, 24小時制
now.getMinutes(); // 49, 分鐘
now.getSeconds(); // 22, 秒
now.getMilliseconds(); // 875, 毫秒數(shù)
now.getTime(); // 1435146562875, 以number形式表示的時間戳
new Date(1487644350463)//獲取一個時間戳之后使用Date()轉(zhuǎn)換成時間格式

RegExp

基礎(chǔ)規(guī)則

用d可以匹配一個數(shù)字

w可以匹配一個字母或數(shù)字

.可以匹配任意字符

用*表示任意個字符（包括0個）

用+表示至少一個字符

用?表示0個或1個字符

用{n}表示n個字符

用{n,m}表示n-m個字符

JSON
JSON還定死了字符集必須是UTF-8，表示多語言就沒有問題了。為了統(tǒng)一解析，JSON的字符串規(guī)定必須用雙引號""，Object的鍵也必須用雙引號""。

面向?qū)ο缶幊?/strong>
js沒有類的概念，可是通過__prototype__來實(shí)現(xiàn)繼承，但是這個方法不要使用，有兼容問題，可以通過創(chuàng)建函數(shù)的形式來實(shí)現(xiàn)類似java類繼承。

// 原型對象:
var Student = {
    name: "Robot",
    height: 1.2,
    run: function () {
        console.log(this.name + " is running...");
    }
};

function createStudent(name) {
    // 基于Student原型創(chuàng)建一個新對象:
    var s = Object.create(Student);
    // 初始化新對象:
    s.name = name;
    return s;
}

var xiaoming = createStudent("小明");
xiaoming.run(); // 小明 is running...
xiaoming.__proto__ === Student; // true