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

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

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

獲取數組長度直接arr.length

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

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

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

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

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

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

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

sort()——數組排序

reverse()——數組反向

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

join()——數組轉換為字符串

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

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])
}

函數定義
（1）函數聲明

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

（2）函數表達式

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

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

變量

如果一個變量在函數體內部申明，則該變量的作用域為整個函數體，在函數體外不可引用該變量

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

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

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

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

由于JavaScript的變量作用域實際上是函數內部，我們在for循環等語句塊中是無法定義具有局部作用域的變量的,也就是說for循環中的i或者j在函數內部都可以訪問到。

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

"use strict";

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

xiaoming.age();
//在一個方法內部，this是一個特殊變量，它始終指向當前對象，也就是xiaoming這個變量。所以，this.birth可以拿到xiaoming的birth屬性。
//針對函數內再套函數的問題，因為this指向發生了變化，可以使用that首先捕獲this，在進行傳值

高階函數
高階函數就是函數的參數是一個函數

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

高階函數——map()

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

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

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

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

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

由map方法引發的一個js題目：

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

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

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

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

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

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

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

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

所以：["1", "2", "3"].map(parseInt)相當于
[parseInt("1", 0), parseInt("2", 1), parseInt("3", 2)]
parseInt("3", 2) 的第二個參數是界于 2-36 之間的，之所以返回 NaN 是因為 字符串 "3" 里面沒有合法的二進制數，所以 NaN

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

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

比方說對一個Array求和，就可以用reduce實現：

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

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

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

filter回調函數可以帶三個參數

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;
});

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

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

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

sort()方法會對當前array進行修改，返回時當前的arry；

閉包

箭頭函數

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

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

在js中一切都是對象。

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

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

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

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

再例如：

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

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

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

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

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

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

通常不必把任意類型轉換為boolean再判斷，因為可以直接寫if (myVar) {...}；

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

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

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

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

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

number調用toString()時應該這樣：

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

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

兩個轉換小技巧：

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, 毫秒數
now.getTime(); // 1435146562875, 以number形式表示的時間戳
new Date(1487644350463)//獲取一個時間戳之后使用Date()轉換成時間格式

RegExp

基礎規則

用d可以匹配一個數字

w可以匹配一個字母或數字

.可以匹配任意字符

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

用+表示至少一個字符

用?表示0個或1個字符

用{n}表示n個字符

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

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

面向對象編程
js沒有類的概念，可是通過__prototype__來實現繼承，但是這個方法不要使用，有兼容問題，可以通過創建函數的形式來實現類似java類繼承。

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

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

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