get 在外面调用 set往里面书写，可在函数的参数中取得赋值

val=+val 将val转换为数字

在原型链上查找是有get 和set方法时访问会走get set 方法不会给当前对象添加新属性

1：函数4调用方式

直接调用

对象方法

构造器

call/apply/bind

正则基础

.          任意字符（换行符除外）    /.../.test('1a@')

\d        数字0-9

\D        非\d,即不是数字0-9是的字符

\w        数字0-9，或字母a-z及A-Z，或下划线

\W        非\w

\s          空格符，TAB，换页符，换行符

\S          非\s

\t\r\n\v\f   tab  回车  换行   垂直制表符   换页符

三个标识位：

global   匹配所有情况

ignoreCase  不区分大小写

multiline 分行跨行检索

实现继承的方式：
function Person() {}
function Student() {}

Student.prototype = Person.prototype;//!!!不可以这么赋值，会相互影响
Student.prototype = new Person();//会有Person原型，但是还是会有问题,只是类还没有实例化
Student.prototype = Object.create(Person.prototype);// 新创建一个对象，对象的原型指向Person
ES5之才支持

ES5之前
if(!Object.create){
    Object.create = function(proto){
        function F() {}
        F.prototype = proto;
        return new F;    
    };
}

new Object() instanceof Array === false

[1,2] instanceof Array === true

右边构造器的prototype属性是否出现在左边的对象的原型链上

右边必须是函数（不是函数会报错），左边是对象（不是的话，直接返回false）

！！！不同window或iframe间的对象类型检测不能使用instanceof

//改变prototype
Student.prototype.x = 101;
bosn.x;//101

Student.prototype = {y:2};
bosn.y;// undefined
bosn.x;//101

var nunnly - new Student('Nunnly', 3, 'Class LOL KengB');
nunnly.x;//undefined
nunnly.y;//2

动态修改prototype的属性的时候会影响已创建和新创建的实例
修改整个prototype赋值新对象的时候，对已经创建的实例
是不会修改的，但是会影响后续创建的实例。

执行上下文（Execution Context, EC）

VO按照下列顺序填充：

1. 函数参数（若未传入，初始化该参数值为undefined）
   

2. 函数声明（若发生命名冲突，会覆盖）

3. 变量声明（初始化变量值为undefined，若发生命名冲突，会忽略）
   

alert(x);//function

var x = 10;
alert(x);// 10
x = 20;

function x(){
    alert(x);// 20
}
if(){
    var a = 1;
} else {
    var b = true;
}

alert(a);//1
alert(b);// undefined  var前置处理

全局，函数，eval

javascript中没有块级作用域

作用域链：从内到外都可以访问到

(function(){
    var a,b;
})();//把函数内部的变量变成函数的局部变量，而不是全局变量

!function() {
var a,b;
}
+function() {
var a,b;
}
以上两种方法加！+把函数变成函数表达式而不是函数声明
函数声明会被前置处理掉

闭包
function outer(){
    var localVal = 30;
    return localVal;
}
outer();//30
函数调用返回时，局部变量localVal就被释放掉了



function outer(){
    var localVal = 30;
    return function() {
        return localVal;
    }
}

var func = outer();
func();//30

localVal是不能被释放的；因为调用outer后返回的是一个
匿名函数，这个匿名函数仍然可以访问外部的outer的局部变量
localVal，函数outer调用结束后，再次调用func，仍可以访问
到外部outer函数的局部变量==》这就是闭包

闭包的作用：在计算机科学中，闭包（词法闭包，函数闭包）是指一个

函数或函数的引用，与一个引用环境绑定在一起。这个引用环境是一个

存储该函数每个非局部变量（自由变量）的表

闭包，不同于一般的函数，它允许一个函数在立即词法作用域外调用时，

仍可访问非本地变量。

回调函数仍有能力调用外部函数的局部变量

缺点： 复杂作用域内，函数调用后，没有被释放掉，造成空间浪费

内存泄漏，性能消耗

创建自定义属性并设置枚举属性

defineProperty()

检测一个属性是否可以枚举

propertyIsEnumerable("porperty")参数为属性

函数属性&arguments

arguments是一个类数组对象，原型不是Array.prototype，所以它没有join等数组对象才有的方法

可以通过索引访问arguments对象

function foo(x,y,z){//形参
    arguments.length;// 2
    arguments[0];//1
    arguments[0] = 10;
    x;//10  绑定关系
    
    arguments[2] = 100;
    z;//undefined  未传参数，失去绑定关系
    arguments.callee === foo;//true
}

foo(1,2)
foo.length;// 3 形参个数
foo.name;// "foo" 函数名
arguments.length 实参个数

function foo(x,y){
    console.log(x,y,this);
}

foo.call(100,2,,3);// 2,3,Number(100)不是对象的会转变成对象
foo.apply(true,[3,4]);// 3,4,Boolean
foo.apply(null);//undefined,undefined,window
foo.apply(undefined);//undefined,undefined,window

this.x = 9;
var module = {
    x: 81,
    getX:function() {
        return this.x;
    }
}
 module.getX();//81对象.属性
 
 var getX = module.getX;
 getX();// 9 直接赋值给变量调用
 
 var boundGetX = getX.bind(module);
 改变函数运行是的this，绑定了module
 
 bondGetX();// 81

bind与new
function foo(){
    this.b = 100;
    return this.a;
}

var func = foo.bind({a: 1});

func();//1
new func();// {b:100}

toString方法是Object.prototype原型上方法

全局作用域下，this指向window；

严格模式下，this是undefined

作为对象方法的函数的this

对象原型链上的this，不管是原型链上的还是本身，都可以拿到

get／set方法与this

构造器中的this，若没有return，this的指向会作为返回值

call/apply方法与this

function add(c,d){
    return this.a + this.b + c + d;
}
var o = {a: 1,b: 3};

add.call(o, 5,7);//1+3+5+7 = 16

add.apply(o, [10,20]);// 1+3+10+20 = 34

function bar(){
    console.log(Object.prototype.toString.call(this));
}
bar.call(7);// "[object Number]"

bind方法与this
function f(){
    return this.a;
}
var g = f.bind({a:"test"});
console.log(g());//test

var o = {a:37,f:f,g:g};
console.log(o.f(),o.g());//37,test,使用bind绑定this

for-in会遍历原型链上可枚举的属性