创建对象
1.工厂模式
//工厂模式,可以解决创建多个相似对象，无法识别对象是哪个类型
function createPerson(name,age,job) {
var o = new Object();//显示的创建对象
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
console.log(o.name);
}
return o; //返回对象才能被外部引用
}
var person = createPerson("工厂",12,"doctor");
person.sayName();
2.构造函数模式
//构造函数类型
function Person(name,age,job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
console.log(this.name);
}
}
//调用方式
//1.当构造函数来调用
var person1 = new Person("构造1",12,"doctor");//引用时new 创建对象，this指向了新对象
var person2 = new Person("构造person2",12,"doctor");//引用时new 创建对象，this指向了新对象
console.log(person1 instanceof Person);//true
//2.普通函数调用
Person("构造2",12,"doctor");//添加到window
Person("构造4",12,"doctor");//添加到window
window.sayName();//构造4
//3.在另一个函数的作用于中调用
var b = new Object();
Person.call(b,"构造3",12,"doctor");
b.sayName();//构造3
console.log(person1.sayName== person2.sayName ) //false 会创建两个做同样任务的函数实例
//改进的构造函数类型
function Person(name,age,job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName =sayName; //将函数定义成全局函数，但该函数只能某个特定的对象来调用
}
function sayName(){
console.log(this.name);
}
3.原型模式
//原型模式
function Original() {
}
Original.prototype.name = "Tom";
Original.prototype.age = 20;
Original.prototype.job = "Doctor";
Original.prototype.sayName = function () {
console.log(this.name);
};
var or1 = new Original();
var or2 = new Original();
or1.name = "JOiny"; //重新定义实例属性，但不改变原型属性
console.log(or1.name);//JOiny 来自实例
console.log(or1.hasOwnProperty("name")); //true hasOwnProperty 是否有实例属性
console.log("name" in or1); //true 给定属性是否在对象中，，实例和原型中皆可
console.log(or2.name);//Tom 来自原型
delete or1.name;//delete 删除实例属性
console.log(or1.name);//
//原型模式2 重写了默认的prototype对象，prototype 不在指向Original2 而是指向Object对象
function Original2(){
}
Original2.prototype = {
constructor : Person,
name : "Nicholas",
age : 29,
job: "Software Engineer",
sayName : function () {
console.log(this.name);
}
};
var friend = new Original2();
console.log(friend instanceof Object); //true
console.log(friend instanceof Original2); //true
console.log(friend.constructor == Original2); //false
console.log(friend.constructor == Object); //true
Original2.prototype.sayHi = function(){
console.log("hi");
};
friend.sayHi(); //"hi" ?works!
//实例中的指针仅指向原型，不指向构造函数，即重写的原型对象
function Student(){
}
var friend = new Student();
Student.prototype = {
constructor: Student,
name : "Nicholas",
age : 29,
job : "Software Engineer",
sayName : function () {
alert(this.name);
}
};
// friend.sayName(); //error
console.log("------------------------------------------eg");
console.log(typeof Array.prototype.sort); //"function"
console.log(typeof String.prototype.substring); //"function"
//通过原型模式给String 对象定义新的方法
String.prototype.startsWith = function (text) {
return this.indexOf(text) == 0;
};
var msg = "Hello world!";
console.log(msg.startsWith("Hello")); //true
//原型对象的问题
console.log("------------------------------------------原型对象的问题");
function Tea(){
}
Tea.prototype = {
constructor: Tea,
name : "Nicholas",
age : 29,
job : "Software Engineer",
friends : ["Shelby", "Court"],
sayName : function () {
console.log(this.name);
}
};
var tea1 = new Tea();
var tea2 = new Tea();
tea1.friends.push("Van");
console.log(tea1.friends); //"Shelby,Court,Van"
console.log(tea2.friends); //"Shelby,Court,Van"
console.log(tea1.friends === tea2.friends); //true
4.组合使用原型模式和构造函数模式 (常见的方式)
//组合使用原型模式和构造函数模式
function Person(name,age,job) {
this.name = name;
this.age = age;
this.job = job;
this.friends = ["Tom","Lily"];
}
Person.prototype = {
constructor : Person,
sayName:function () {
console.log(this.name);
}
}
var p1 = new Person("zz",21,'teacher');
var p2 = new Person("cc",21,'student');
p1.friends.push("Lucy");
console.log(p1.friends);
p1.sayName();
console.log(p2.friends);
p2.sayName();
5.动态原型模式
//动态原型模式
function Person(name, age, job){
//properties
this.name = name;
this.age = age;
this.job = job
//methods
if (typeof this.sayName != "function"){
Person.prototype.sayName = function(){
console.log(this.name);
};
}
}
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName()
6.寄生构造函数
//寄生构造函数，与工厂模式语法相同,在不改变原有的引用类型下返回新的值
function specArray() {
var newArr = new Array();
//赋值
newArr.push.apply(newArr,arguments);
newArr.toSpecString = function () {
return this.join("|");
}
return newArr;
}
var arr = new specArray("Gelei","Nazi")
var specArr = arr.toSpecString();
console.log(specArr); //Gelei|Nazi
7.稳妥构造函数模式
