闭包 原型 对象及对象创建的方法

闭包：

什么是闭包 就是函数嵌套函数，内部函数就是闭包，内部函数可以访问外部函数变量

正常情况  函数调用结束  函数内部的变量就变成垃圾处理了

闭包 函数内部的值  无法被垃圾回收(浪费内存)

函数内部的值 可以外部访问(保持私有属性);

  function fn(){

            var a =10;

            function gn() {

                //这个叫做引用这个值

                console.log(a);

             }

            return gn;

        }

var  f = fn()

  f();

 

闭包实现  属性的私有化  ：

  var model = (function () {

            var a = 10;

            var b = 20;

            function add() {

                return a + b;

            }

            function sub() {

                return a - b;

            }

            return {

                a:add,

                b:sub

            }

        })()

        var result = model.a();

        var  result1 = model.b()

        console.log(result,result1);

 

 

对象的创建及方法特点：

  1  通过new 关键字创建对象

    优点:这是标准的创建对象方式

    缺点:一个对象有多种属性的方式 比较繁琐

    var obj = new Object();

    obj.name = '张三';

    obj.age = 14

 2 通过字面量形式创建

    优点  解决了 一个对象有多种属性的时候繁琐;

    缺点 当有多个对象 有相同属性的时候 还是繁琐

    var obj1 = {

        name: '张三',

        age: 18

    }

    var obj2 = {

        name: '张三',

        age: 18

    }

 3 工厂模式 通过函数的封装去批量的创建对象

    创建人的对象

     解决了重复代码的问题

    缺点 造出的对象识别不清

    function createPeople(name, age, sex) {

        当 对象的key 和value这个变量名字一致的时候 可以简写

        return {

            name,

            age,

            sex

        }

 

4 构造函数创建对象  可以分得清除

    构造函数创建的对象  都有自己的属性和方法,这些属性或者方法 有可能一样

    function User(name, age) {

        this.name = name;

        this.age = age;

    }

    function Cat(name,age) {

        this.name=name;

        this.age=age;

      }

    var user1 = new User('水水',20);

    var cat1 = new Cat('喵喵',3)

5 原型创建

 function Student() {  }

        Student.prototype.name='张三';

        Student.prototype.age = '14';

        Student.prototype.skil = function () {

            console.log('学习')

         }

   var user = new Student();

         user.name='jj';

         console.log(user)

         console.log(user.__proto__);

　　优点：解决了内存浪费的问题

       缺点：不能传参，创建出来的都一样

6  混合创建：构造函数(可变的)+原型(共享的、不变的内容)

function Student(name,age,sex) {

            this.name=name;

            this.age=age;

            this.sex=sex

          };

          Student.prototype.address='郑州';

          Student.prototype.skill = function () {

              console.log('js编程.....')

           }

           var xiaoming = new Student('小明',12,'男')

           var xiaohong = new Student('小红',11,'女')

           xiaohong.skill()

           console.log(xiaohong,xiaoming)

           console.log(xiaoming.skill ===xiaohong.skill);

 

 

原型对象 : js中的函数都有prototype 指向他的原型,所有实例共享原型的属性和方法

        对象的原型属性: 即他的__proto__属性,指向创建对象的构造函数的原型

       

        通常我们创建对象 var obj = {}, 他的__proto__指向原生构造函数的Object.__proto__

        我们可以读写对象的原型

原型链:原型呈现递进关系,形成的链式结构,称为原型链,提供对象属性的查找方向,从当前对象向上寻找,返回查找最近的属性值

原型链的终点是null

 对象是函数的实例,函数本身也是个对象

        var  obj1 = {

            name:'obj1',

            toString:function(){

               return 'hello'

            }

        }

        var obj = {

            name:'obj',

            __proto__:obj1

        }

       console.log(obj.toString())