> 变量、作用域和内存问题
js为弱类型的语言 变量的值和数据类型可以在脚本的生命周期内改变。
5种基本类型：string, number, undefined, null, boolean,基本数据类型是按值访问的。
引用类型是保存在内存中的对象，js不能直接操作对象的内存空间。引用类型是按引用访问的。

动态的属性
对象的属性可以随时添加和删除 delete运算符
不能给基本类型添加属性 如：
var name = "myname";
name.age = 18;
console.log(name.age); //undefined

基本类型和引用类型的赋值，基本类型赋的是值，引用类型赋的是引用 ~~~引用类型变量中存储的是对象的指针 堆内存 栈内存
var n = 1; var m = n; n = 100; console.log(m,n);
var arr1 =[1,2]; var arr2 = arr1; arr1.push(3); console.log(arr1,arr2);

参数传递
ES中所有函数的参数传递都是按值传递的(基本类型变量保存的是真实的值，引用类型变量保存的是指针)，实参会被复制一份 赋值给形参。
arguments对象默认自动创建，除非在函数内声明了同名的arguments局部变量

> in搜索原型链，如果继承层次深 性能会不太好， hasOwnProperty只搜索本地属性
in
for in
遍历出可枚举的属性
自定义的属性默认都可枚举 o.a='33'

> Object.prototype对象提供的方法

hasOwnProperty()
propertyIsEnumerable()
isPrototypeOf
toString()
toLocaleString()
valueOf()

~~~instanceof 运算符 和 isPrototypeOf 检测原型对象和实例的关系

~~~原型链中查找属性，作用域链中查找变量
~~~执行上下文EC (变量对象 活动对象, 作用域链， thisValue )

~~~实例化之后，重写构造函数的原型对象，会导致之前的实例和新原型之间无任何关系
如
function Foo(){}
Foo.prototype.hi = 'night';
var f = new Foo();
Foo.prototype={hi:'hello'};
var f2 = new Foo()
console.log(f.hi, f2.hi);

> 创建自定义类的方式
1. 工厂模式 ~~~函数内部创建对象，添加属性和方法，然后返回该对象 缺点无法确定实例类型 占内存
function foo(n){
var o = new Object();
o.a = 100
o.name = n
o.say = function(){ alert(this.a) }
return o;
}
var o1 = foo('a'); var o2 = foo('b');
2. 构造函数模式 ~~~ new一个对象 所有属性和方法都在构造函数内指定 缺点 占内存
function Foo(n){
this.a = 100;
this.n = n;
this.say = function(){ alert(this.n);}
}
var o1 = new Foo('1'); o2 = new Foo('b');
3. 原型模式 ~~~ 空构造函数 所有属性和方法都在原型中指定 缺点：无法传参数 实例共享引用类型的属性，对其修改会影响所有其他实例
function Foo(n){}
Foo.prototype = { a:100, n:'hi', say:function(){ alert(this.a)}, arr:[1,2,3]}
var o1=new Foo(); var o2 = new Foo(); o1.arr.push(4);
4.组合模式 ~~~ 在构造函数中添加实例属性，在原型中添加共有属性
function Foo(n){
this.a = 100;
this.n = n;
}
Foo.prototype= {hi:function(){alert(this.n);}, constructor: Foo };
5. 动态原型模式 ~~~无需在构造函数和原型中分别定义 才构成一个类，直接在构造函数中初始化原型对象 ** 推荐 组合方式或动态原型方式创建类 **
function Foo(n){
this.a = 100;
this.n = n;
if(!Foo.prototype.hi){ //假设hi是 原型对象中肯定会有的属性，从而判断原型是否已经初始化, 只在第一次实例化时会执行
Foo.prototype.hi = function(){ alert(this.n);};
Foo.prototype.go = function(){ console.log( 'go school');};
}
}

> 实现私有数据成员
function Foo(n,a){ //n a 为私有数据成员 ，只有o可以访问
var o = new Object();
o.say = function(){
return a;
}
return o
}

> 接口继承和实现继承