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
};
