js知识点8

1.原型与原型链

我们把原型的原型链式关系成为原型链

<script>

        // 字符串的构造函数是？string

        // 数组的构造函数是？Array

        // 01 目标：给所有字符串实例添加一个翻转字符串方法

        // split 把字符串分割为数组，join把数组转换为字符串，reverse翻转数组

        String.prototype.reverse = function(){

            // this指向实例

            return this.split('').reverse().join('');

        }

    </script>

1.实现了js的继承
2.可以给所有的类的实例添加公用方法和属性

注意事项：

1.给个构造函数（类）都有个显示原型prototype
2.每个实例（对象）都有一个隐式模型__proto__
3.对象的隐式模型__proto__等于其构造函数（类）的显示原型
4.当查找对象的属性或方式，现在自身上找，找不到沿着原型的原型（__proto__.__proto__）向上查找

实际运用

        <script>

        // 用字面量方式创建了一个对象实例

        var obj = {name:"mumu",age:18};

        console.log(obj);

        // new WOW().init()

        // new Date()

        // 创建一个动物类(用函数的方式)

        function Animal(name,age){

            this.name = name;

            this.age = age;

        }

        // 我们可以把每一个实例的公用方法，写在构造函数（类）的显示原型上

        Animal.prototype.say = function(){

            alert(`大家好我的名字是${this.name},今年${this.age}岁`)

        }

         function Student(name,age,no){

            // 继承Animal的构造函数

            Animal.call(this,name,age);

         }      

                     

                   

        // 写一个studen类继承Animal

        function    Student(name,age,no){

            // this指向的student new出来的实例

            // 实现了对Animal构造函数的继承

            Animal.call(this,name,age);

        }

        // 实现对原型的继承 Object.creat 从现有的对象创建一个新的对象

        Student.prototype = Object.create(Animal.prototype);

        // 修改实例的构造函数

        Student.prototype.constructor = Student;

        // 添加student实例的公用方法 study学习

        Student.prototype.study = function(){

            alert(`大家好我是${this.name},我正在努力学习前端`);

        }

        // 创建2个学生实例

        var s1 = new Student("小明",17,"001");

        var s2 = new Student("小高",18,"002");

</script>

 2.闭包

特点：函数嵌套函数：函数作为返回值被返回，函数作为参数被传入

 作用：

1.创建局部作用域
2.在函数外部访问函数内部的局部变量
3.封装组件与插件

缺点：闭包中的自由变量不会被自动销毁，会常驻内存，使用不当容易造成内存泄漏

注意事项：

闭包中的自由遍历（在该作用域没有定义域使用的变量）在函数定义时候确定的，不是函数执行时候确定的

实际运用：

<script>

        // 函数作为返回值返回，形成闭包

        function outer(){

            var a = 100;

            return function(){

                a++;

                console.log(a);

            }

        }

        var inner = outer();

        inner();

        // 01 a会常驻内存，不会销毁；可以在outer的外部访问a（自由变量）

        var b =100;

        function fn (){

            b++;

            console.log(b);

        }

        function outer(callback){

            var b =500;

            callback();

        }

        outer(fn);

        // 02 闭包中的自由变量，是在函数定义时候确定的，不是执行的时候

        // 02 闭包中的自由遍历不会销毁

    </script>