一、prototype的应用

• 每一个函数都拥有一个属性 prototype
• 给构造函数提供共有的属性和方法

Array.prototype.sum = function () {  
            let count = 0 ;
            for(let i = 0 ; i < this.length ; i++) {
                count += this[i]
            }
            console.log(count);
            return count
        }


        const arr2 = [2,,3] ;
        arr2.sum()

        Array.prototype.noRepeat = function () {  

        }

• 构造函数中的this指向的是实例化的这个对象，而不是构造函数

Date.prototype.format = function () {  
            // this -> 实例化的这个对象，不是构造函数
            let y = this.getFullYear() ;
            let m = this.getMonth() + 1 ;
            let d = this.getDate() ;
            return y + '-' + m + '-' + d 
        }

        // let res = arr.sum() ;
        // console.log(res);

        let date = new Date() ;

        let res = date.format() ;
        console.log(res);

二、原型

• __proto__

• 每一个对象都有__proto__属性 -> 指向对应的构造函数的原型对象
• __proto__去查找一个对象是否有某个属性或方法
• 构造函数 + 原型对象 constructor __proto__

  function Dog(type) {  
            this.type = type ; 
            this.say = '汪'
        }
        Dog.prototype.color = 'red' ;

        const d = new Dog('二哈') ;

        console.log(d);

        console.log(d.say);

        console.log(d.color);

        console.log(d.constructor);  // 构造器

        console.log(d.__proto__);  //  原型对象

- hasOwnProperty()方法

1. 用于判断属性或者方法是不是自己的(还有可能是继承来的)，返回一个布尔值

- 原型链

- 对象的原型链

1. 原型会指向构造函数的原型对象

console.log(p.__proto__ == Person.prototype);  // true

2. 原型对象也是一个对象，因此也有原型 ，它的原型就是 Object.prototype

console.log(Person.prototype.__proto__ == Object.prototype);

3. Object.prototype 也是原型对象 ， 指向null

console.log(Object.prototype.__proto__ == null);

- 函数的原型链

• 函数也是对象，因此函数也有原型

        console.log(Person.__proto__ == Function.prototype);
        
        console.log(Function.prototype.__proto__ == Object.prototype);

        console.log(Object.prototype.__proto__ == null);

- 原型链小结

1. 每一个对象都有原型，也就是__proto__这个属性，这个属性会指向这个构造函数函数的原型对象，也就是prototype。构造函数的原型对象也是对象，也有原型，他指向对象也就是Object的原型对象。最终Object的原型对象也是对象，它的原型最终指向null
2. 原型链的作用：判断一个对象是否有某个属性或方法

三、对象中的常用属性和方法

- 对象的属性

1. constructor 构造器
2. __proto__
3. hasOwnProperty()

- 函数的属性

1. prototype

- 判断数据类型的方法

1. typeOf 判断数据类型 -- 可以准确的判断基本数据类型(只能知道是引用数据类型)
2. instanceOf 判断某个对象是不是某个构造函数的实例化对象

- 判断数组的方法

1. Array.isArray() // 布尔值
2. constructor // 可以判断数组
3. instanceOf 用于判断一个对象是否是一个构造函数的实例化对象

四、new

• new的贡献

1. 创建了一个对象
2. this指向了这个对象
3. 把这个对象的原型指向了构造函数的原型对象
4. 返回了这个对象

五、原型的引用

• 强行改变了原型的指向

 <p>1</p>
    <p>2</p>
    <p>3</p>


    <script>

        const oPs1 = document.querySelectorAll('p') ;   // NodeList

        const oPs2 = document.getElementsByTagName('p') ;   // HTMLCollection

        console.log(oPs1 , oPs2);

        // NodeList   forEach

        // HTMLCollection  没有forEach


        oPs1.forEach(v => {
            console.log(v);
        })

        const len = oPs2.length ;
        oPs2.__proto__ = Array.prototype ;  // 强行改变了原型的指向 length 没了
        oPs2.length = len ;

        console.log(oPs2);

        oPs2.forEach(v => {
            console.log(v);
        })

        // oPs2.push('a')  push会改变数组

六、es6的面向对象

面向对象是把实务分解成一个个对象，然后由对象之间分工合作。

面向对象是以对象功能来划分问题，而不是步骤。

在面向对象程序开发思想中，每一个对象就是功能中心，具有明确分工。

面向对象的特性：

• 封装性
• 继承性
• 多态性

类 class

在ES6中新增加了类的概念，可以使用class关键字声明一个类，之后以这个类来实例化对象。

类抽象了对象的公共部分，它泛指某一大类

对象特指某一个，通过类实例化一个具体的对象

- 语法

 class {
            constructor() {
                // 自身的属性和方法
            }
            // 共有的方法
        }
        
        
        
        class Dog {
            constructor(type , age) {
                this.type = type ;
                this.age = age ;
            }
            say() {
                console.log('汪');
            }
            speak() {
                console.log(666);
            }
        }


        const d = new Dog('二哈' , 3) ;
        console.log(d);
        d.say()
        console.log(d.age)