1 數(shù)據(jù)類型
1-2 六種數(shù)據(jù)類型
1-3 隱式轉(zhuǎn)換
1-4 包裝對象
1-5 類型檢測

2 表達(dá)式和運算符
2-1 表達(dá)式
2-2 運算符

3 語句
3-1 block語句、var語句
3-2 try-catch語句
3-3 函數(shù)、switch、循環(huán)
3-4 JavaScript嚴(yán)格模式

4 對象
4-1 對象概述
4-2 創(chuàng)建對象、原型鏈
4-3 屬性操作
4-4 get/set方法
4-5 屬性標(biāo)簽
4-6 對象標(biāo)簽、對象序列化

5 數(shù)組
6 函數(shù)和作用域（函數(shù)，this）
7 函數(shù)和作用域（閉包，作用域）
8 oop(上)
9 oop(下)
10 正則和模式匹配

1 數(shù)據(jù)類型

demo

1-2 六種數(shù)據(jù)類型

//數(shù)據(jù)在沒有被定義的情況下，會被進(jìn)行隱式轉(zhuǎn)化
var num = 32; //
num = "this is a string"; //即使之前被定義為數(shù)字，可以重新定義為字符串
32 + 32；//64,理解為兩個數(shù)字相加
“32”+32；//"3232",理解為兩個字符串的連接
“32” - 32；//0,理解為兩個數(shù)字的相減

//數(shù)據(jù)類型,包括5種原始類型，一種對象類型
object(function, array, date....)
number
string
boolean
null
undefined

**1-3隱式轉(zhuǎn)換 **

//進(jìn)行隱式轉(zhuǎn)化
“37”-7 //30,這里“-”號使得左側(cè)的字符串轉(zhuǎn)換為數(shù)值類型。
"37"+7 //377,這里“+”號使得右側(cè)的數(shù)值轉(zhuǎn)換為字符串類型。

//巧用+/-規(guī)則轉(zhuǎn)換類型
num-0 //若num為null,則這條語句變?yōu)閿?shù)值0
num+"" //若num為數(shù)值，則這條數(shù)值變?yōu)樽址?
//等于"=="，嘗試類型轉(zhuǎn)換并比較
null == undefined;//相等
number == string; //string轉(zhuǎn)number
boolean == ?; //boolean轉(zhuǎn)化為數(shù)字，true為1，false為0
object ==number|string;//嘗試對象轉(zhuǎn)為基本類型new String("hi") == "hi" //true

//嚴(yán)格等于“===”，首先會判斷兩邊的類型，類型不同，返回false
//類型相同的情況下
null === null; //true
undefined === undefined; //true
NaN === NaN; //false
new Object === new Object; //false,是用引用做比較

1-4 包裝對象

//數(shù)據(jù)類型,包括5種原始類型，一種對象類型
object(function, array, date....)
number
string
boolean
null
undefined

//number boolean string都有包裝類型
var str = "string"; //基本數(shù)據(jù)類型
var st = new String("string"); //對象類型，也是string基本類型對應(yīng)的包裝類
//當(dāng)一個基本類型嘗試用對象去訪問的時候，js會把基本數(shù)據(jù)類型轉(zhuǎn)換為包裝類型對象，執(zhí)行包裝類的方法之后，包裝類作為一個臨時對象就會消失。
str.length; //3
str.a = "demo";//賦值成功
str.a;//undefined，包裝類消失

1-5 類型檢測

//類型檢測方法
typeof
instanceof
Object.prototype.toString
constructor
duck type

//typeof
typeof 100; //number
typeof true; //boolean
typeof function; //function
typeof undefined; //undefined
typeof new Object(); //object
typeof [1, 2]; //object
typeof NaN; //number
typeof null; //object,這個需要注意,記住就好

//obj instanceof Object ;//判斷左邊的原型鏈上是否有右邊的prototype屬性,
[1, 2] instanceof Array === true;
new Object() instanceof Array === false;

//Object.prototype.toString
Object.prototype.toString.apply([]);//"[object Array]"
Object.prototype.toString.apply(function(){});//"[object Function]"
Object.prototype.toString.apply(null);//"[object Null]"
Object.prototype.toString.apply(undefined);//"[object Undefined]"

//類型檢測小結(jié)
typeof;//適合基本類型及function檢測，遇到null失效
[[Class]];//通過{}.toString拿到，適合內(nèi)置對象和基本類型，遇到null和undefined失效，IE678等返回[object Object]
instanceof;//適合自定義對象，也可以用來檢測原生對象，在不同iframe和window間檢測時失效。

2-1表達(dá)式
表達(dá)式是指能計算出值的任何可用程序單元（wiki）;表達(dá)式是一種js短語，可使js解釋其用來產(chǎn)生一個值（js權(quán)威指南）。

//原始表達(dá)式
3.14；
i;

//復(fù)合表達(dá)式
2*3

//數(shù)組、對象的初始化表達(dá)式
[1,2];// new Array(1,2)
[1,,,4];//[1, undefined, undefined,4]
{x:1, y:2};// var o =new Object(); o.x=1; o.y=2;

//函數(shù)表達(dá)式
var fe = function(){};
(function(){console.log("hello world");})();

//屬性訪問表達(dá)式
var o = {x: 1};
o.x;
o["x"];

//調(diào)用表達(dá)式
func();

//對象創(chuàng)建表達(dá)式
new Func(1,2);
new Object;

2-2運算符

//按照操做數(shù)進(jìn)行劃分
一元運算符：+num;
二元運算符： a+b;
三元運算符：c?a:b;

//特殊運算符

//逗號運算符
var val=(1,2,3);//val=3,這是逗號運算符，取最后一個值

//delete obj.x,刪除對象的屬性
var obj = {x:1};
obj.x; //1
delete obj.x;
obj.x;  //undefined
//使用Object.defineProperty方法,只有configurable為true時才可以刪除
var obj = {};
Object.defineProperty(obj,'x',{
  configurable: false,
  value: 1
})
delete obj.x; //false
obj.x;//1

//"in"運算符
window.x=1;
'x' in window; //true

//運算符instanceof和typeof
{} instanceof Object; //true
type 100 === 'number'; //true

//運算符new
function Foo(){};
Foo.prototype.x = 1;
var obj = new Foo();
obj.x; //1
obj.hasOwnProperty('x'); //false
obj._proto_.hasOwnProperty('x'); //true

//this運算符
this;//window(瀏覽器)
var obj = {
  func: function(){return this;}
};
obj.func(); //代表對象obj

//void運算符
void 0 //undefined
void(0) //undefined

3-1 block語句、var語句

//block用于花括號定義,常用語組合使用
a={x:1, y:2};
//沒有塊級作用域,就是在塊外面也可以訪問塊里面的值
for(var i=0; i<10; i++){
  var str = "hi";
  console.log(str);
}
var i=0;
for(;i<10;i++){
  var str="hi";
  console.log(str);
}
//存在函數(shù)作用域，函數(shù)外面訪問不到函數(shù)里面定義的值
function foo(){
  var a=1;
  console.log(a); //1
}
foo();
console.log(typeof a);//undefined

//定義方式var
var a=1;//通常定義方式
var a=1, b=1;//定義兩個變量的方式
var a=b=1;//會將變量b定義為全局變量
function foo(){
  var a=b=1;
}
foo();
console.log(typeof a);//undefined,沒有訪問到，存在函數(shù)作用域
console.log(typeof b);//number，訪問到，因為b被定義為全局變量

3-2 try-catch語句

//流程和格式
try{
  throw "test";
}catch(ex){
  console.log(ex); //test
}finally{
  console.log("finally");
}

3-3 函數(shù)、switch、循環(huán)

//函數(shù)聲明和函數(shù)表達(dá)式的區(qū)別是函數(shù)聲明可以前置，而函數(shù)表達(dá)式不行
//函數(shù)聲明
fd(); //true
function fd(){
  //do sth;
  return true;
}
//函數(shù)表達(dá)式
fe();//TypeError
var fe = function(){
  //do sth;
};

//for..in
//for..in中存在的問題：順序不確定；enumerable為false時不會出現(xiàn)，for in對象屬性受原型鏈影響
var p;
var obj={x:1, y:2}
for(p in obj){
...
}

//switch條件分支語句
var val=2
switch(val){
  case 1:
    console.log(1);
    break;
  case 2:
    console.log(2);
    break;
  default 3:
    console.log(0);
    break;
}

//循環(huán)語句
whild(isTrue){
//do sth.
}

do{
//do sth.
}while(isTrue)

var i;
for(i=0;i<n;i++){
//do sth.
}

//with可以修改當(dāng)前的作用域,已經(jīng)不建議被使用，在嚴(yán)格模式下已經(jīng)禁止使用
with({x: 1}){
  console.log(x);
}

with(document.forms[0]){
  console.log(name.value);
};//可以通過下面的定義變量的方式來代替
var form = document.forms[0];
console.log(form.name.value);

3-4 JavaScript嚴(yán)格模式
嚴(yán)格模式是一種特殊的執(zhí)行模式，它修復(fù)了部分語言上的不足，提供更強(qiáng)的錯誤檢查，并增強(qiáng)安全性

//通過添加use strict來使用安全模式
//通過在函數(shù)內(nèi)添加use strict使用
function func(){
  'use strict';
}
//通過在文件頭添加use strict使用
‘use strict’ 
function func(){
...
}

嚴(yán)格模式下的說明
1、不能使用with語句
2、不允許未聲明的變量被賦值（即是需要使用var進(jìn)行聲明，不然會報referenceerror）
3、argumens變?yōu)閰?shù)的靜態(tài)副本（不懂，需要看看）
4、delete參數(shù)，函數(shù)名報syntax error

!function(a){
  'use strict';
  delete a;
}(1);

5、delete不可配置的屬性報錯typeerror

!function(a){
  'use strict';
  var obj={};
  Object.defineProperty(obj, 'a', {configurable: false}); 
  delete obj.a;
}(1);

6、對象字面量重復(fù)屬性名錯誤
7、禁止八進(jìn)制字面量
8、eval,arguments變?yōu)殛P(guān)鍵字，不能作為變量，函數(shù)名
9、eval獨立作用域,eval外面不能獲取eval內(nèi)定義的變量值

!function(){
  'use strict';
  eval('val evalVal = 2');
  console.log(typeof evalVal); //undefined
}

10、一般韓式調(diào)用時（不是對象的方法調(diào)用，也不使用apply/call/bind等修改this）this指向null，而不是全局對象。
11、若使用apply/call時，當(dāng)傳入null或undefined時，this指向null或者undefined,而不是全局對象。
12、試圖修改不可寫屬性（writable=false），在不可擴(kuò)展的對象上添加屬性時報TypeError,而不是忽略。
13、arguments.caller,arguments.callee被禁用。

4 對象
4-1 對象概述 **
對象中包含一系列屬性，這些屬性是無序的，每個屬性都有一個字符串**key和對應(yīng)的value。

//說明屬性的key是字符串
var obj={};
obj[1]=1;
obj;//Object {1: 1}
obj['1']=1;
obj;//Object {1: 1},和shang

//下面的例子沒看懂
var obj={};
obj[{}]=true;
obj[{x: 1}]=true;
obj;//{[object Object]: true}

4-2 創(chuàng)建對象、原型鏈

//對象創(chuàng)建-字面量形式
var obj1 = {x: 1, y: 2};

var obj2 = {  //嵌套形式
  x: 1;
  y: 2;
  o:{
    z: 3;
  }
}

//使用new構(gòu)造器的方式創(chuàng)建
function fun(){}
foo.prototype.z=3;  //foo.prototype=>Object;Object.prototype=>null;

var obj = new foo();
obj.x=1;
obj.y=2;

obj.x;//1
obj.y;//2
obj.z;//3
typeof obj.toString();//function
'z' in obj;//true
obj.hasOwnProperty("z");//false

obj.z = 5; //為obj對象添加z這個屬性
obj.hasOwnProperty("z"); //true
foo.prototype.z;//3
obj.z;//5

obj.z=undefined;
obj.z;//undefined;

delete obj.z;//只會刪除對象上的屬性，不會影響原型鏈
obj.z;//3


//使用Object.creat創(chuàng)建
var obj = Object.create({x: 1});
obj.x; //1
typeof obj.toString //"function"
obj.hasOwnProperty("x");//false

var obj = Object.create(null);
obj.toString;//undefined

**4-3 屬性操作 **
**4-4 get/set方法 **
**4-5 屬性標(biāo)簽 **
4-6 對象標(biāo)簽、對象序列化