js原型,对象，面向对象，构造函数

单例模式和工厂模式

	单例模式   把描述同一个事物特征的信息进行分组归类，放到同一个命名空间下(减少全局变量的污染)

		 var name  = 'erya';
         var age = 18;

         var name = 'jinyu';
         var age = 23;
         console.log(name)//jinyu
    
         let person1 = {
            name:'jinyu',
             age:18
         }
         let person2 = {
             name : 'erya',
             age : 22
         }
         console.log(person1)//{name: "jinyu", age: 18}

	高级单列模式

let person1 = (function(){
            let fn = function(){};
            let name = 'erya';
            return{
                name:name,
                age:18,
                fn:fn
            }
        })()
        console.log(person1)//{name: "erya", age: 18, fn: ƒ}

        let person2 = (function(){
            let fn = function(){};
            let name = 'jinyu'
            let age = 23
            return{
                name:name,
                age:age,
                fn:fn
            }
        })()
        console.log(person2)//{name: "jinyu", age: 23, fn: ƒ}

	工厂模式
       	   如果用单例模式去写很多个person就会变得很麻烦，就有了工厂模式
           特点：批量生产  把实现相同功能的代码封装到函数里，以后想运行这个方法，就直接执行这个函数就好了
      	   高内聚：提高代码的复用率
      	   低藕合：减少页面的重复代码

 function createPerson(name,age){
                var name = name;
                var age = age;
                var sex = 'girl'
                return{
                    name,
                    age,
                    sex
                }
            }
            let person1 = createPerson('erya',18)
            let person2 = createPerson('jinyu',18)
            console.log(person1,person2)//{name: "erya", age: 18, sex: "girl"} {name: "jinyu", age: 18, sex: "girl"}

面向对象

 		标记语言：HTML / CSS3
        编程语言：JavaScript，PHP，C....
        面向过程：C
        面向对象：


    把抽象得对象按照特点进行分类（大类 / 小类），把类的公共特征进行提取和封装，放到对应的类别中
    类就是对对象的一种细分，和公共部分的抽取
    在类中具体派生出来的具体事物就是类的实例，而且实例拥有自己私有的特征，还拥有所属类上的特征
    我们研究面向对象，其实就是研究对象、类、实例之间的关系和各自的知识点

    我们研究一个实例：（1）研究实例的私有属性（2）研究实例的所属类的共有属性（3）一层一层找类的属性和方法

构造函数

new操作符

  把new放在函数前面,函数执行
      	1.在代码执行之前，函数中会首先创建一个空对象
        2.让当前函数this指向这个空对象
        3.当代码执行完成后，会默认返回this
	 new后面的函数就是构造函数 也叫类;那么通过构造函数获取的返回值就是叫							
	 	实例，实例是构造函数new出来的

构造函数

		• let f = Fn()  //普通的函数执行
		• let f = new Fn()  //构造函数运行模式，此时的Fn就是Fn类（构造函数），函数执行之后的返回结果就是一个对象，叫做实例对象(f就是Fn的实例)
		• 执行原理：
		ⅰ. 默认生成一个空对象 {}
		ⅱ. 让函数里的this指向这个对象,也就是指向这个类的实例
		ⅲ. 代码执行
		ⅳ. 默认return 这个对象
		• 类就是函数数据类型的
		• 实例就是对象数据类型的
		• 构造函数中的this指向当前实例
			1.js为了区分构造函数和普通函数，一般将构造函数首字母大写
		  	2.构造函数this指向当前实例
		    3. 构造函数：形成私有作用域->形参赋值->变量提升->创建一个空对象，并且让当前作用域this指向这个对象->代码从上到下执行->返回this->作用域是否销毁
		    4.instanceof 数据类型检测   检测当前实例是否属于某个类；如果是返回true，不是返回false
		    5.内置类： Number  String  Boolean  Null Undefined   Object  Array RegExp  Date...
		    6.类一定是函数，函数不一定是类 

构造函数普通函数区别

	1. 运行上的不同
		• 普通函数-->形成私有作用域-->形参赋值-->变量提升-->代码执行-->作用域是否销毁
		• 构造函数-->形成私有作用域-->形参赋值-->变量提升-->默认生成一个对象-->把this指向这对象-->代码执行-->默认把这个对象return出去-->作用域是否销毁
	2. 执行上的不同
		• 构造函数如果不传实参，可以不加小括号
	3. return的不同
			• 构造函数如果手动return一个基本数据值，不能过改变人家的返回值，但是手动return引用数据类型，可以改变构造函数的返回值，此时return的东西已经不是当前类的实例了

	 console.log(Number);//ƒ Number() { [native code] }
    console.log(Array);//ƒ Array() { [native code] }
    console.log(String);//ƒ String() { [native code] }
    console.log(Object);//ƒ Object() { [native code] }
    console.log(Function);//ƒ Function() { [native code] }
    console.log(Boolean);//ƒ Boolean() { [native code] }
    console.log(Date);//ƒ Date() { [native code] }
    console.log(RegExp)//ƒ RegExp() { [native code] }

    //console.log(Null)  //特殊的2个 也是内之类  浏览器限制调用
    //console.log(Undefined)//
    console.log(new Number(1) == 1)//true  
    console.log(new Number(1) === 1)//false    默认有一个 primitiveValue  

    console.log(Math)//Math {abs: ƒ, acos: ƒ, acosh: ƒ, asin: ƒ, asinh: ƒ, …}  对象 特殊的

    var obj = {};
    console.log(obj instanceof Object)//true
    var arr = [];
    console.log(arr instanceof Array)//true
    console.log(obj instanceof Array)//false
    
    //var num = 10;
    //num.substring(0,1)//报错  substring不是Number上的方法
    let a ="0x12"
    console.log(parseInt(a))

    function Gn(){}
    function Fn(){
        console.log(100);  //100
        this.x=x;
        this.y = y;
        this.getX = function(){
            console.log(this.x)
        }
    }
    //new fn//如果这个函数需要参数，那么这个需要小括号   如果不需要参数， 那么小括号可以省略
    var f = new Fn;//这是小f叫实例   new后面的函数就是构造函数 也叫类
    Fn()        
    console.log(f);//Fn {}
    console.log(f instanceof Fn)//true
    console.log(f instanceof Gn)//false

原型

	• 构造函数，解决了实例的私有属性问题
	• 原型模式，解决了实例的共有属性问题
	• 类就是函数数据类型的
	• 实例就是对象数据类型的
	• 构造函数中的this指向当前实例
		• 每一个函数（普通函数、构造函数）都天生自带一个prototype属性，属性值是一个对象，它里面储存的是实例的共有属性（原型）
		• 每一个原型都天生自带一个constructor属性，其属性值指向当前类
		• 每一个对象（实例，原型）都天生自带一个__proto__属性，其属性值指向当前所属类的原型

原型链

		原型链 ：当获取对象属性名对应的属性名，先找自己的私有属性，如果私有属性不存在，会默认通过__proto__继续向上查找，如果上一级还没,就继续通过__proto__往上查找 查找到Object原型为止，如果还没有 为undefined，这种方式就叫原型链
    	对象优先找到Object基类

```javascript
 function Fn(a,b){
            this.x = a;
            this.y = b;
            this.getX = function(){
                console.log(1);
                
            }
            Fn.prototype.getX = function(){
                console.log(2);
                
            }

        }
        var f = new Fn(100,200)
        console.log(f.getX);//f(){}
        console.log(f.hasOwnProperty);//ƒ hasOwnProperty() { [native code] }

        console.log(Fn.prototype instanceof Object); //true
         
        var obj = {num:1}
        console.log(typeof obj.num);//number    //obj.num= 1
        
        console.log(Object.prototype);
        console.log(f.hasOwn);//找不到为undefined
        console.log(f.__proto__.__proto__
        .__proto__);//null