JS高级-原型等概念深入理解

一
 数据类型：
     基本（值）数据类型：
     string
     number
     undefined
     null
     boolean
     对象（引用）类型
     【
         查找对象的属性时，会查找原型链
         设置属性时，一般在构造函数里面设置，不会查找原型链，如果不存在，就添加进这个属性，并设置值
         方法一般在原型中定义
     】
     【
         没有显示指定构造函数的实例对象，构造函数默认都是Object函数。
         如果你希望你的当前实例对象继承别的实例对象，你就要用你的实例对象的原型去继承别的实例对象
         __proto__ 就是保存原型对象的地址值

         只要是对象，不管是实例对象还是函数对象，他都有构造函数。
          构造函数的prototype属性指向一个空对象，称为显示原型，实例对象或函数对象的__proto__属性指向一个空对象，称为隐示原型，这两个是相等的，指向同一个空对象
          构造函数的prototype 会被赋值给 实例对象或者函数对象的__proto__。通常同一个函数的这两个属性是不相等的，只有在Function的时候才会始终相等
     】
     Object
     声明方式： 使用构造函数  function Object(){}; Object var samp = new Object();
                表达式声明 var samp = {
                            对象实体
                            };
                由函数构造器生成  function test(){};    var samp = new test();
          可以使用samp.construcor去替换设置构造函数
     1.包含数据和操作的封装体，隐藏细节，
     2.调用属性和方法：【如果调用没有的属性和方法，就会添加这个属性和方法可以添加属性到对象中】
      2.1通过点号，
      2.2 使用['属性名']   ：
      2.2.1属性命中包含- 空格的，
      调函数：p['属性名']()    编码简单，有时不能用
      调属性：p['属性名']  编码复杂，但通用
      2.2.2 属性名不确定
           这个parameterName是不确定的，也不知道叫啥，只是知道，就会这么执行。这个parameterName必须是对象中的属性名。
            var parameterName = ''
            p[parameterName]

     Function
     注意：   对构造函数prototype做变化，实例对象都是找__proto__确定属性和别的
              关键看创建构造函数做了什么（this.prototpe = {}），创建实例对象又做了什么(this.__proto__ = this.prototype),如果之后构造函数的显示原型发生变化，之间创建的实例对象的隐示原型链不会变化（因为地址值没有被再次赋予）。
              只要是能创建实例对象的构造函数，他的原型就在隐示连条上，，而Object的显示原型是一切对象的终点，在所有实例对象的隐示原型链上
     【
     只有构造函数才有prototype，对象的是undefined，其他则是异常，不存在。
     Function = new Function() 自己创建自己
     var test = new Function(); Function函数对象创建了test函数对象，那Function是谁创建的那。 只能是Function = new Function()； 那么就是Function自己创建了自己
     function test(){}

     所有函数的__proto__属性都相同，指向Function的显示原型
     Function的__proto__和prototype都是Function的显示原型，就是自己创建了自己

     所有对象的原型都是一个 Object函数对象的实例  ，除了Object.prototype不是  console.log(Object。prototype instanceof  Object); // false
     Function.prototype = f(){native code}
     Function.__prototype = f(){native code}
     console.log(Function.prototype === Function.__proto__);// true

     console.log(Function.prototype.__proto__ === Object.prototype);// ture  Function函数对象的显示原型 的隐示原型 指向 Object函数对象的的显示原型 所以Object函数对象的显示原型为原型链的终点
     var anyFunciton = new Function(); // 任何函数对象本质是这样的。 但是Function也是一个函数对象啊，总要有一个终点，那么就自己创建自己吧
     】
     1.实现n语句的封装体，只有函数可以执行，其他不能执行。
     2.提高代码复用度
     3.便于阅读交流
     4.声明方式： 函数声明 function fn(){}, 表达式声明  var fn2 = function （）{}
     5.调用： 直接调用，  通过对象调用， new函数调用，funciton.apply/call(obj)，让function临时成为obj的对象
     6. 调用函数时，不会检查函数的实参的数量的类型
     7. 返回值
         可以在函数内部写一个return，如果return后不跟值，返回undefined
                                 不屑return也会返回undefined
     Array 数组内可以存储多个类型的数据
     声明方式  new Array()  未定义长度,   new Array(长度) 定义长度  ，

 二
 判断类型
 typeof  不可以辨别 null Object Array 这三种类型的都不被识别为Object
 instaceof 辨别具体对象类型
     怎么判断的 A instanceof B
             B 是构造函数   ，  A是实例对象
             如果B的显示原型在 A的隐示原形链上， 则是
             Object是一个函数对象，即是构造函数，也是一个实例对象   Object（看作Function实例对象） instanceof Function 是对的，  Function instanceof Object没错（Function的隐示原型链上存在Object的显示原型）
             Function技术一个构造函数，也是一个实例对象
 === 可以辨别undefined null

 undefined 和 null区别
 undefined 未定义或者定义了什么都没赋值
 null 定义并且赋值null
 什么时候给变量赋值null
 初始赋值， 表明将要赋值为对象
 结束前，让对象成为垃圾对象

 区分数据类型和变量类型
 变量类型：基本类型，引用类型（保存对象的地址）
 数据类型：基本类型，对象类型

 三
 回掉函数：
     1. 你定义的
     2. 你没有调用
     3. 但最后执行了
  常见的回掉函数
     dom事件回掉函数
     定时器回掉函数
     ajax请求毁掉函数
     生命周期回掉函数

  四
  匿名函数自调用 （function（）{}）()
  作用：
  1.隐藏实现
  2.不会污染外部命名空间
  3.用匿名函数自调用编写js模块
  $ 是一个函数，返回的是一个对象

 五，确定this
 1.this是那个
    1.1 函数必须是由对象来调用的。如果没有指定，默认是window
    1.2 如果指定了，就是所指定的对象
    1.3 所有函数内部都有一个this
 2.如何确定：
    2.1 test() window
    2.2 new test() 所创建的对象
    2.3 p.test() p
    2.4 p.test.call(obj) obj

六，原型prototype   何为原型，以我理解，原型就是被实例对象继承的那个对象（由构造函数创建的空对象）
   注意：所有实例对象的显示原型都是undefined，只有函数对象有显示对象，隐示原型要么是构造函数和实例对象相同的空对象，要么就是Object对象
       1. 原型是一个空对象【没有我们写的属性】，这个空对象的构造函数是函数对象
       2.利用函数对象创建的势力对象的构造函数也是这个函数对象
       3. 给我的感觉有点像分身，对的。原型是本体，而实力对象是分身，分身可以继承本体的特点，分身（实例对象）的后期开发的特性本体（原型）却不能拥有，而连接他们关系的就是这个函数对象(血脉)
                   继承的级别和关系：  实例对象  函数对象  原型 ，
                   对函数对象来说，原型是显示的，用一个prototype属性存储原型的地址值。
                   对实例对象来说，原型是隐示原型，用一个__proto__属性存储地址值  ，然后原型又继承Object，Object的没有隐示对象的，因为他是根对象，所以__proto__属性值是null
                   从原型及以上所有对象继承的函数，都能在实例对象中直接调用
       4. Object.prototype是所有对象的终极原型，任何对象都会继承他,但是他不是对象

       5. 原型/构造函数（函数对象）/实例对象（实体对象），原型链之间的关系。
            5.1 可以在函数对象内部通过this 给实例对象添加属性和方法
              function test() {
                    /*
                   * 给实例对象添加方法和属性
                   * */
                   this.value = 'this is value';
                   this.setCall = function () {
                    console.log('this call')
            }
            }
            5.2 直接在函数对象实体外 函数对象名.属性名或方法名 = function 或 数据， 为函数对象添加属性和方法
              /*
 * 给函数对象添加属性和方法，如下所示，也可以跟对象一样，在原型中添加属性和方法。
 * */
 test.setPrint = function () {
     console.log('新的玩意')
 }
 test.call = '随意写的s';
            5.3 除此之外，其他直接在函数体内部写的语句都是内部执行的，不可调用
            5.4 原型的特性，只有实例对象才能继承。函数对象不能继承。Object的原型对象是终点
            比如，在原型中添加一个函数，函数对象是不能调用的，只有实例对象才能调用.所有的特性继承下来，都是通过__proto__属性延伸下来。这天链又叫 隐示原型链
            使用函数对象可以创建实例对象

            5.5  原型和实体对象的构造函数是相同的
            5.6  函数和属性都是可以继承的，和java的特点一样，也可以被重构

   1 每一个函数对象都有一个prototype属性，指向显示原型对象Object（空对象），
   2 对象的显示原型是undefined。隐示原型是objectName.__proto__  原型指向一个空对象
   当定义一个函数对象时，做了一个事， fun.prototype = {};
   当利用函数对象创建实例对象时， 做了一个事情，object.__proto__ = fun.prototype

   程序员可以调用显示原型，es6之后不能调用隐示原型

  七，
      函数提升和变量提升
      通过var定义的函数和变量，在定义之前调用都是undefined
      函数通过function定义，可以在定义之前调用

      先变量提升，然后函数提升.
      如果属性和函数的名字一样，会在预定义处理的时候，先给变量入栈，然后函数入栈，函数同名，会取代同名变量。如果上下文在执行代码的时候给变量赋值，按顺序取代

 八，
     全局变量和window上下文
     在开始执行全局代码之前，会预处理全局上下文。
                 1. var 都会被赋值undefined
                 2. function定义的函数，被赋值为定义的对象
                 3. this为window
                 4.开始执行代码
     函数调用时的准备：
                和执行全局代码差不多
                有几点不同： 执行上下文指的是当前函数内部的声明代码体
                有一个argument属性，指的是当前形参的伪数组，就是形参的数值

     在上下文中声明的变量，只要是var生成的，（不算函数内部的，只在当前上下文）不管是局部的还是全局的，都会在当前上下文开始执行代码前，在上下文中被处理，值被赋予undefined，添加进当前上下文

 九，作用域
 就这三种作用域
 1.全局作用域，
 2.函数作用域
    如果在函数作用域中找不到，就会找全局作用域，所以在对象内部，必须添加this才能调用在对象内的属性和函数
 3.没有块作用域（ES6之后有），和java不同。在if中内定义的变量，外部能访问到。

 十，作用域和执行上下文的区别
   1. 全局作用域之外，每个函数都会创建自己的作用域，作用域在函数定义时就确定了
      执行上下文，在js代码执行之前，才确定
   2. 作用域是静态的，只要定义好就一直存在，且不会变化
      上下文环境是动态的，调用函数时创建，函数调用结束后才会被释放
   3. 上下文环境（对象）从属于所在的作用域

 循环执行
 setInterval()
 延迟执行
 setTimeout()

 十一：
 闭包：
 1，如何产生闭包：
     当嵌套的内部函数引用外部父函数的变量(函数)，就产生闭包
     引用变量的内部函数被定义
 2，如何理解闭包：
     1. 闭包是内部嵌套函数
     2. 闭包是引用父函数的对象
     闭包存在于嵌套的内部函数中
3， 闭包产生条件：
   1. 一定是函数内的嵌套函数
   2. 一定要引用父函数中的变量或函数
4，内部的嵌套函数产生闭包的时机：
     函数定义执行的时候

5，常见的使用方式
1.将函数作为另一个函数的返回值
    function f1(){
        function f2(){}
        return f2
    }
    父函数被调用几次，闭包就创建几个
2. 将函数作为实参传递给另一个函数调用

6. 作用：
   1. 使函数内部的变量在函数执行完之后（函数执行完之后，会释放内部变量和没有被引用的函数对象，），任然存活在内存中。 只有在闭包存在的才会存活下来
   2. 函数外部能够利用内部函数仍然可操作被引用的变量

7，死亡：
   包含闭包的对象成为垃圾对象