1、日常开发中，一般使用构造函数与原型结合的方式，构造函数用于定义实例属性，原型对象用于定义方法和要共享的属性。这样每个实例都会拥有一份实例的副本并且又有共享的内容，极大节省了内存。

function Sll(name, age, bf){
    this,name = name;
    this.age = age;
    this.bf = ['cty'];
}
Sll.prototype = {
    constructor: Sll,
    sayName(){
        console.log('我家傻萝莉是智障障...');
    }
}
const sll = new Sll('yjm', 21);
const zzz = new Sll('loly', 22);
sll.bf.push('大叔');
console.log(sll.bf,zzz.bf); //[ 'cty', '大叔' ] [ 'cty' ]

2、寄生构造函数方式，类似于工厂模式，创建一个表面上像是构造函数的函数，但仅仅用来封装创建对象，并返回新创建的对象。(注意，不能用instanceof来确定对象类型)

function Sll(name, age){
    const o = new Object();
    o.name = name;
    o.age = age;
    return o;
}
const yjm = new Sll('mdzz', 21);
console.log(yjm.name);//mdzz

例子: 假设我们需要创建一个具有额外方法的数组，因为不能在Array构造函数上修改。

function ExtraArray(){
    const arr = new Array();
    arr.push.apply(arr, arguments);
    arr.extraFunction(){
        return this.join('+');
    }
    return arr;
}
const arrayTest = new ExtraArray('sll', 'is', 'zzz');
console.log(arrayTest.extraFunction());//sll+is+zzz

3、原型链(继承)，这个东西直接上代码吧

function Father(){
    
}
Father.prototype.getFather = function(name){
    console.log(name);
}
function Child(){

}
Child.prototype = new Father();
Child.prototype.getChild = function(child){
    console.log(child);
}
const child1 = new Child();
child1.getChild('yjm');//yjm
child1.getFather('cty');//cty
function GrandChild(){

}
GrandChild.prototype = new Child();
GrandChild.prototype.getGrandChild = function(grandChild){
    console.log(grandChild);
}
const grandChild1 = new GrandChild();
grandChild1.getFather('ctyzz');//ctyzz
grandChild1.getChild('yjmzz');//yjmzz
grandChild1.getGrandChild('mdzz');/mdzz
console.log(grandChild1 instanceof Father, grandChild1 instanceof Child, grandChild1 instanceof GrandChild);//true true true

GrandChild继承Child，Child继承Father,所以GrandChild的实例grandChild1也是Child、Father的实例，所以代码中三个instanceof结果都是true。
(注意，不能用对象字面量的形式创建原型方法，不然会重写原型链。）

***.prototype = {
    //function
    //function
};