1 数据类型
1-2 六种数据类型
1-3 隐式转换
1-4 包装对象
1-5 类型检测
2 表达式和运算符
2-1 表达式
2-2 运算符
3 语句
3-1 block语句、var语句
3-2 try-catch语句
3-3 函数、switch、循环
3-4 JavaScript严格模式
4 对象
4-1 对象概述
4-2 创建对象、原型链
4-3 属性操作
4-4 get/set方法
4-5 属性标签
4-6 对象标签、对象序列化
5 数组
6 函数和作用域（函数，this）
7 函数和作用域（闭包，作用域）
8 oop(上)
9 oop(下)
10 正则和模式匹配
1 数据类型
demo
1-2 六种数据类型
//数据在没有被定义的情况下，会被进行隐式转化
var num = 32; //
num = "this is a string"; //即使之前被定义为数字，可以重新定义为字符串
32 + 32；//64,理解为两个数字相加
“32”+32；//"3232",理解为两个字符串的连接
“32” - 32；//0,理解为两个数字的相减
//数据类型,包括5种原始类型，一种对象类型
object(function, array, date....)
number
string
boolean
null
undefined
**1-3隐式转换 **
//进行隐式转化
“37”-7 //30,这里“-”号使得左侧的字符串转换为数值类型。
"37"+7 //377,这里“+”号使得右侧的数值转换为字符串类型。
//巧用+/-规则转换类型
num-0 //若num为null,则这条语句变为数值0
num+"" //若num为数值，则这条数值变为字符串
//等于"=="，尝试类型转换并比较
null == undefined;//相等
number == string; //string转number
boolean == ?; //boolean转化为数字，true为1，false为0
object ==number|string;//尝试对象转为基本类型new String("hi") == "hi" //true
//严格等于“===”，首先会判断两边的类型，类型不同，返回false
//类型相同的情况下
null === null; //true
undefined === undefined; //true
NaN === NaN; //false
new Object === new Object; //false,是用引用做比较
1-4 包装对象
//数据类型,包括5种原始类型，一种对象类型
object(function, array, date....)
number
string
boolean
null
undefined
//number boolean string都有包装类型
var str = "string"; //基本数据类型
var st = new String("string"); //对象类型，也是string基本类型对应的包装类
//当一个基本类型尝试用对象去访问的时候，js会把基本数据类型转换为包装类型对象，执行包装类的方法之后，包装类作为一个临时对象就会消失。
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]"
//类型检测小结
typeof;//适合基本类型及function检测，遇到null失效
[[Class]];//通过{}.toString拿到，适合内置对象和基本类型，遇到null和undefined失效，IE678等返回[object Object]
instanceof;//适合自定义对象，也可以用来检测原生对象，在不同iframe和window间检测时失效。
2-1表达式
表达式是指能计算出值的任何可用程序单元（wiki）;表达式是一种js短语，可使js解释其用来产生一个值（js权威指南）。
//原始表达式
3.14；
i;
//复合表达式
2*3
//数组、对象的初始化表达式
[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;
//函数表达式
var fe = function(){};
(function(){console.log("hello world");})();
//属性访问表达式
var o = {x: 1};
o.x;
o["x"];
//调用表达式
func();
//对象创建表达式
new Func(1,2);
new Object;
2-2运算符
//按照操做数进行划分
一元运算符：+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);
}
//存在函数作用域，函数外面访问不到函数里面定义的值
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,没有访问到，存在函数作用域
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 函数、switch、循环
//函数声明和函数表达式的区别是函数声明可以前置，而函数表达式不行
//函数声明
fd(); //true
function fd(){
//do sth;
return true;
}
//函数表达式
fe();//TypeError
var fe = function(){
//do sth;
};
//for..in
//for..in中存在的问题：顺序不确定；enumerable为false时不会出现，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;
}
//循环语句
whild(isTrue){
//do sth.
}
do{
//do sth.
}while(isTrue)
var i;
for(i=0;i<n;i++){
//do sth.
}
//with可以修改当前的作用域,已经不建议被使用，在严格模式下已经禁止使用
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严格模式
严格模式是一种特殊的执行模式，它修复了部分语言上的不足，提供更强的错误检查，并增强安全性
//通过添加use strict来使用安全模式
//通过在函数内添加use strict使用
function func(){
'use strict';
}
//通过在文件头添加use strict使用
‘use strict’
function func(){
...
}
严格模式下的说明
1、不能使用with语句
2、不允许未声明的变量被赋值（即是需要使用var进行声明，不然会报referenceerror）
3、argumens变为参数的静态副本（不懂，需要看看）
4、delete参数，函数名报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、对象字面量重复属性名错误
7、禁止八进制字面量
8、eval,arguments变为关键字，不能作为变量，函数名
9、eval独立作用域,eval外面不能获取eval内定义的变量值
!function(){
'use strict';
eval('val evalVal = 2');
console.log(typeof evalVal); //undefined
}
10、一般韩式调用时（不是对象的方法调用，也不使用apply/call/bind等修改this）this指向null，而不是全局对象。
11、若使用apply/call时，当传入null或undefined时，this指向null或者undefined,而不是全局对象。
12、试图修改不可写属性（writable=false），在不可扩展的对象上添加属性时报TypeError,而不是忽略。
13、arguments.caller,arguments.callee被禁用。
4 对象
4-1 对象概述 **
对象中包含一系列属性，这些属性是无序的，每个属性都有一个字符串**key和对应的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 创建对象、原型链
//对象创建-字面量形式
var obj1 = {x: 1, y: 2};
var obj2 = { //嵌套形式
x: 1;
y: 2;
o:{
z: 3;
}
}
//使用new构造器的方式创建
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创建
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 属性标签 **
4-6 对象标签、对象序列化
