JS中this的指向

1、普通函数中this的指向( 普通函数中的this指针指向于调用者)

 function fn (){
                this.name = 'wang';
                console.log(this);--window
                console.log(this.name);--wang
            }
            window.fn();
            console.log(name);--wang

 var name = '小王';
            var obj = {
                name : 'wang',
                fn : function () {
                    console.log(this);--Object(name:wang,fn:obj.fn())
                    console.log(this.name);--wang
                }
            }

   obj.fn();

2、定时器中的this的指向

  function CreatePerson () {
                this.name = '小璇';
                // this指向与构造函数创建的对象：this的调用者是new
                // setInterval(this.show, 2000);

                //  由new来给定时器绑定一个函数
                // setInterval(function(){
                //     // this指向于window；因为this是由定时器调起执行的
                //     console.log(this);
                // }, 2000);
                //

                //把this的指向固定在self变量中
                var self = this;
                setInterval(function(){
                    // 此时，self指向的是对象
                    self.show();
                }, 2000);



            }
            CreatePerson.prototype.show = function (){
                // console.log('hello');
                console.log(this);
            }
            var per =new CreatePerson();

3、在对象方法中的this指向

 var name = '小李子';
            var per = {
                name: '小璇',
                fn: function () {
                    console.log(this.name);
                }
            }

            var obj = per.fn;
            // fn方法交给了window对象调用，所以方法中的this指针指向了window对象
            window.obj();

4、在构造函数中的this的指向

  function CreatePerson() {
                this.name = '小璇';

                // 如果在构造函数中向外返回一个对象，则该对象会覆盖由new创建出来的对象
                // return {
                //     name: '小李子'
                // }
                // 构造函数不能向外返回引用类型，因为返回的引用类型会替换掉new创建出来的对象
                // 如果向外返回的是null对象，则不会替换
                return null;
            }
            // 因为new调用函数执行时：1、开辟一块内存空间；2、把函数中this的指向指为这块空间;3、把创建出来的空间交给变量
            var per = new  CreatePerson();
            console.log(per.name);

5、在事件函数中的this的指向

 function Btn() {
                this.b = 23;
                var _this = this;--object  Btn对象
                document.getElementById('btn').onclick = function (){
                    // this.show();--btn元素
                    _this.show();--Btn对象
                };
 //document.getElementById('btn').onclick =  this.show;若不改变指针的指向则this指向的是这个div，而不是new出来的对象

           }
            Btn.prototype.show = function() {

                console.log(this.b);--Object(b:23);23
           };

            window.onload = function () {

             new Btn();
           }

<div style='width:100px;height:100px;border:1px solid black' id="btn">

6、事件函数中嵌套函数的this指向

利用call修复bug：在事件函数中，this指向元素，但是在内部再包含一个函数后，在函数内再继续调用this的话，那么现在的this指针就指向了window了
  window.onload = function () {
                var btn = document.querySelector('#btn');
                btn.onclick = function () {
                    console.log(this);--btn

                    // 如果事件函数中嵌套了函数，该函数又出现了this指针，则该指针指向window对象
                    // hello()
                     //解决办法：
                    // hello.call(this);--btn
                          function hello() {
                                   console.log(this);--window 
                           }
                  }
            }

        <button type="button" id='btn' name="button">点我</button>

7、内存相关概念
1字节=8位
console.log(0.999999999999999999-0.1);

        内存分区：常量区、静态区、堆区、栈区、代码区
        常量区：存放定义的常量
        静态区：存放的是静态变量
        栈区: 由系统开辟并维护的空间，大部分的变量都在该区域存放
        堆区：由程序员开辟并维护的空间，手动开辟空间保存的内容存放在堆区
        代码区：存放代码的区域

        垃圾回收机制（GC）：js仿照java语言实现的内存管理方式，每隔若干时间，垃圾回收机制启动，                      把所有不再使用的变量、数据所占用的内存空间销毁掉。
        栈区管理内存的方式是使用“栈”这种数据结构管理的
        堆区管理内存是使用垃圾回收机制管理的