继承模式，命名空间，对象枚举

Grand.prototype.lastName = ‘张‘;

function Grand(){

this.name = ‘国庆‘;

}

var grand = new Grand();

Father.prototype = grand;

function Father(){

this.name = ‘改革‘;

}

var father = new Father();

Son.prototype = father;

function Son(){

this.name = ‘小宝‘;

}

var son = new Son();

//son这里只想用Grand.prototype上的属性，可是这样一继承，不但继承了Grand.prototype上的属性，

// 也继承了一些不必要的属性，如father上的属性

this.name = name;

this.age = age;

this.sex = sex;

}

function PersonTwo(name,age,sex,color){

//var this = { __proto__:PersonTwo.prototype }

PersonOne.call(this,name,age,sex);

this.color = color;

}

var person1 = new PersonTwo(‘小李‘,23,‘男‘,‘blue‘);

console.log(person1);

function inherit(Target,Origin){

Target.prototype = Origin.prototype;

}

//应用

Father.prototype = {

name:‘小张‘,

age:29

}

function Father(){

}

function Son(){

}

inherit(Son,Father);

var son = new Son();

console.log(son.name); //小张

//缺点：不能随便改变自己的原型，因为自己的原型和原来的函数用的是

//一个原型，自己的改，原来的相应的也会去改

var father = new Father();

Son.prototype.name = ‘小红‘;

console.log(son.name);  //小红

console.log(father.name);  //小红

//封装

function inherit(Target,Origin){

function F(){}    //①

F.prototype = Origin.prototype; //②

Target.prototype = new F();  //③

}

//上面的代码中的②和③是不能调换位置的，因为这样的话Target会在继承Origin

//原型之前，从而先继承了F的原型

//应用

Father.prototype = {

name:‘小张‘,

age:29

}

function Father(){

}

function Son(){

}

inherit(Son,Father);

var son = new Son();

console.log(son.name); //小张

var father = new Father();

Son.prototype.name = ‘小红‘;

console.log(son.name);  //小红

console.log(father.name);  //小张

function inherit(Target,Origin){

function F(){}    //①

F.prototype = Origin.prototype; //②

Target.prototype = new F();  //③

Target.prototype.constructor = Target;  //④  让Target.prototype指向的构造函数从Origin处转回到Target处

Target.prototype.uber = Origin.prototype; //⑤ 让构造出来的对象找到自己的超类（超级父级）（就是它最终继承于谁）

}

var F = function (){};

return function(Target,Origin){

F.prototype = Origin.prototype;

Target.prototype = new F();

Target.prototype.constructor = Target;

Target.prototype.uber = Origin.prototype;

}

}())

function Deng(name,wife){

var preperewife = ‘xiaozhang‘;

this.name = name;

this.wife = wife;

this.divorce = function(){      //①

this.wife = preperewife; // 这个对象里面的属性为什么可以用外部的变量呢

},

this.changePreparewife = function(target){  //②

preperewife = target;

},

this.sayPreparewife = function(){ //③

console.log(preperewife);

}

}

var deng = new Deng(‘deng‘,‘xiaoliu‘);

//①②③函数和Deng函数形成了闭包

//preperewife这个属性拿走了，形成了自己的私有化变量

//为什么通过deng.preperewife访问属性时，返回undefined，因为this对象上根本没有这个属性

//只是this上的①②③方法通过AO拿到了这个变量（preperewife），所以通过this上相应的方法可以

//访问到它，这个preperewife就好比自己的私人变量，从表面上直接是访问不到的

// var inherit = (function (){

//     var F = function (){};

//     return function(Target,Origin){

//         F.prototype = Origin.prototype;

//         Target.prototype = new F();

//         Target.prototype.constructor = Target;

//         Target.prototype.uber = Origin.prototype;

//     }

// }())

//这样肯定会在一个html文件中引入多个js文件，这样的话，每个js文件中可能有

//变量名的冲突，出现变量名覆盖的现象，从而想出了命名空间

var obj = {

department1:{

zhangsan:{

name:‘xiaolizi‘

},

lisi:{

name:‘xiaowangba‘

}

},

department2:{

wangmazi:{

name:‘xiaokeai‘

}

}

}

//调用

obj.department1.zhangsan.name;

//但是这样写太麻烦,可以改进一下

var zhangsan =  obj.department1.zhangsan;

zhangsan.name;

//但是命名空间现在因为各种工具的出现（如：webpack）已经被弃用了

//虽然命名空间这种方法已经不用了，但是我们依然可以在不使用工具的情况下

//解决上面的问题

//解决上面的问题

//这种方法就是闭包+立即执行函数，这也正是闭包的第四点应用：模块化开发，

//防止污染全局变量

var name = ‘bcd‘;

var init = (function(){

var name = ‘abc‘;

function callName(){

console.log(name);

}

return function(){

callName();

}

}())

init();

var deng = {

smoke : function() {

console.Log(‘ Smoking,... xuan cool!!!‘);

return this;

},

drink: function () {

console.log(‘drinking..., ye cool!‘);

return this;

},

perm: function () {

console.Log(‘ preming.... cool!‘);

return this;

}

}

deng.smoke().drink().perm().smoke().drink();

wife1: { name: "xiaoliu" },

wife2: { name: "xiaozhang" },

wife3: { name: "xiaomeng" },

wife4: { name: "xiaowang" },

sayWife: function (num) {

return this[‘wife‘ + num];

}

}

//  隐式转换

//obj.属性名  ————————————>  obj[‘属性名‘]

//     name:‘xiaolizi‘,

//     age:23,

//     sex:‘男‘

// }

// for( var i in obj ){

//     console.log(obj.i);  //undefined

// }

//为什么会打印出undefined，因为

//obj.i ————>  obj[‘i‘]  ————>  它认为这个i是一个字符串（属性）

//解决方案

var obj = {

name:‘xiaolizi‘,

age:23,

sex:‘男‘

}

for( var i in obj ){

console.log(obj[i]);

}

var obj = {

name:‘xiaolizi‘,

age:23,

sex:‘男‘,

__proto__:{

lastName:‘zhang‘

}

}

for( var i in obj ){

if( obj.hasOwnProperty(i) ){//判断是i（自己）的属性还是原型上的属性

console.log(obj[i]);

}

}