构造函数[ 原型重定向 ] 和内置类原型扩充方法的使用

构造函数（原型重定向）
应用场景：批量给构造函数的原型对象上扩充属性和方法。

问题：重定向之后，原始浏览器开辟的原型对象可能会被释放掉，这样导致原始原型对象上的属性和方法会被清除（包含constructor）

针对上面的问题有解决办法：

• 如果我们知道原始原型对象上除了constructor没有其余的属性和方法，我们只需要在重定向的原型对象上自己手动设置constructor即可。
• 如果我们确定或者不确定原始原型对象是否存在其余的属性和方法，我们此时需要把原型对象上面的内容copy一份，重新赋值给原型对象（对象合并）
• 内置类的原型是不允许重定向的，目的保证这些内置属性和方法不丢失，例如：Array.prototype = {}，不报错，但是没有任何的效果吗，虽然不允许重定向，但是可以把内置类的原型上的某个内置方法进行单一的重写；例如：Array.prototype.push = function() {}

代码：

function fun() {
    this.a = 0;
    this.b = function () {
        alert(this.a);
    }
}
fun.prototype = {
    b: function () {
        this.a = 20;
        alert(this.a);
    },
    c: function () {
        this.a = 30;
        alert(this.a)
    }
}
var my_fun = new fun();
my_fun.b();
my_fun.c();

-------------------------------------------------------------------------------

// Object.assign([obj1],[obj2],...):两个或者多个对象进行浅合并「右侧替换左侧」
//   注意：并没有返回全新的一个合并后的对象，返回的值依然是obj1这个堆，只是把obj2中的内容都合并到obj1中
let obj1 = {
    x: 10,
    y: 20,
    getX: function () {}
};
let obj2 = {
    x: 100,
    getY: function () {}
};
// console.log(Object.assign(obj1, obj2));
console.log(Object.assign({}, obj1, obj2)); 以一个新的对象返回

image.png

内置类的原型上，虽然提供很多供其实例调取的属性和方法，但是不一定能完全满足我们的需求，此时我们需要自己向内置类的原型上扩充方法....

• 好处：使用起来方便「实例.方法」；可以实现链式写法「核心：函数执行的返回值如果是某个类的实例，则可以直接继续调用这个类原型上的其他方法」；
• 弊端：自己写的方法容易覆盖内置的方法「所以起名字最好设置前缀，例如：myXxx」

例如在数组的原型上加一个去重的方法：
代码：

/* const unique = function unique(arr) {
    return Array.from(new Set(arr));
};
console.log(unique(arr)); */


Array.prototype.unique = function unique() {
    // this -> arr 一般都是当前要操作的实例「无需传递要处理的数组，因为this存储的值就是」
    return Array.from(new Set(this));
}; 

let arr = [1, 2, 3, 4, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6, 7, 2, 2, 3, 4, 6, 7];
// console.log(arr.unique());
let result = arr.unique().sort((a, b) => b - a);
console.log(result);

实现下面的代码：

let n = 10;
let m = n.plus(10).minus(5);
console.log(m); //=>15（10+10-5）

代码：

// 向Number.prototyp扩充方法
(function (proto) {
    const verification = function verification(num) {
        num = +num;
        return isNaN(num) ? 0 : num;
    };

    const plus = function plus(num) {
        // this -> 要操作的数字{对象类型}
        let self = this;
        num = verification(num);
        return self + num;
    };

    const minus = function minus(num) {
        // this -> 要操作的数字{对象类型}
        let self = this;
        num = verification(num);
        return self - num;
    };

    proto.plus = plus;
    proto.minus = minus;
})(Number.prototype);