通过Object构造函数或者字面量创建对象
var obj01 = new Object();
var obj02 = {};
- 弊端:无论通过Object来创建对象, 还是通过字面量来创建对象都存在一个弊端,每次创建都需要重新编写一次, 如果创建的多个对象的属性和方法名称一样,浪费时间
通过工厂函数创建对象
//所以我们可以通过工厂函数来创建对象
*/
// 工厂函数
function createPerson(name, age) {
// 1.通过Object创建一个空对象
// var obj = new Object();
var obj = {};
// 2.动态的给空对象添加属性和方法
obj.name = name;
obj.age = age;
obj.say = function () {
console.log("hello");
};
// 3.将函数中创建的对象返回给调用者
return obj;
}
var obj1 = createPerson("luodou", 13);
var obj2 = createPerson("doudou", 18);
console.log(obj1);
console.log(obj2);
console.log(typeof obj1); // object
console.log(obj1.constructor); // ƒ Object() { [native code] }
- 工厂函数实质上是Object或字面量创建对象的封装,调用函数即可创建对象
- 弊端:通过Object对象, 或者通过字面量, 或者通过工厂函数创建的对象, 我们无法判断这个对象是谁创建出来的,代码最后一行constructor指向的是一个Object
通过构造函数创建对象
-
什么是构造函数?
- 构造函数也是一个函数, 只不过是专门用于创建对象的函数而已
-
构造函数和普通函数的区别?
- 构造函数的函数名称首字母必须大写
- 构造函数必须使用new 来调用
-
构造函数本质上是对工厂函数的简化
- 在构造函数中默认会创建一个空的对象, 会将创建的对象赋值给this,会将创建的对象返回给调用者
过去通过Object对象, 或者通过字面量, 或者通过工厂函数创建的对象, 我们无法判断这个对象是谁创建出来的,但是通过构造函数创建的对象, 我们可以判断这个对象是谁创建出来的(见代码里obj.constructor)
默认情况下每一个对象都有一个隐藏的属性, 叫做constructor, 这个属性指向了创建当前对象的构造函数
// 1.自定义一个构造函数
function Person(name, age) {
// 1.var obj = new Object();
// 2.this = obj;
this.name = name; // obj.name = name;
this.age = age;
this.say = function () {
console.log("hello");
}
// 3.return obj;
}
/*
new Person("luodou", 13);做了什么事情?
1.会在构造函数中创建一个空的对象
2.将创建好的空对象赋值给this
3.将创建好的对象返回给调用者
*/
var obj = new Person("luodou", 13);
console.log(obj);
console.log(typeof obj); // object
console.log(obj.constructor); // ƒ Person(name, age) {}
// 判断obj对象是否是Person构造函数创建出来的
// console.log(obj.constructor === Person); // 不推荐
// 如果想判断某个对象时候是某个构造函数创建出来的
// 可以使用 对象名称 instanceof 构造函数名称, 来判断
console.log(obj instanceof Person); // true
function Student(name, age, score) {
this.name = name; // obj.name = name;
this.age = age;
this.score = score;
}
var obj2 = new Student("dou", 11, 99);
console.log(obj2 instanceof Person); //false
console.log(obj2 instanceof Student); //true
- 弊端:默认情况下, 只要创建一个对象就会在对象中开辟一块存储空间,该存储空间中会存储对象的所有数据,浪费空间
function Person(name, age) {
this.name = name;
this.age = age;
this.say = function () {
// obj1.name, obj1.age
// obj2.name, obj2.age
console.log(this.name, this.age);
};
}
var obj1 = new Person("lnj", 13);
obj1.say();
var obj2 = new Person("zq", 18);
obj2.say();
// 这里的===是在判断两个函数的地址是否相同
console.log(obj1.say === obj2.say); //false
- 解决方案:
- 将方法定义在外面, 将定义在外面函数的地址赋值给属性,每次创建对象, 对象中say保存的都是函数的地址, 就不会重复保存了
/*
注意点: 在JavaScript中, 函数也是一个对象
*/
function say() {
console.log(this.name, this.age);
}
// var say = function () {
// console.log(this.name, this.age);
// };
// var say = new Function("console.log(this.name, this.age);");
// 定义了一个构造函数
function Person(name, age) {
this.name = name;
this.age = age;
this.say = say;
}
var obj1 = new Person("luodou", 13);
obj1.say();
var obj2 = new Person("dou", 18);
obj2.say();
// 这里的===是在判断两个函数的地址是否相同
console.log(obj1.say === obj2.say); // true
弊端:因为将函数定义在了全局作用域中, 所以如果定义了多个函数, 会导致全局作用域的名称匮乏
-
解决方案2.0
- 将所有函数都封装到另外一个对象中, 这样函数名称就不在全局作用域中了, 这就不会导致全局作用域命名匮乏问题了,然后将对象中方法的地址复制给使用者即可
var fns = {
say: function() {
console.log(this.name, this.age);
},
eat: function () {
console.log("eat");
}
};
// 定义了一个构造函数
function Person(name, age) {
this.name = name;
this.age = age;
this.say = fns.say;
this.eat = fns.eat;
}
var obj1 = new Person("luodou", 13);
obj1.say();
var obj2 = new Person("dou", 18);
obj2.say();
// 这里的===是在判断两个函数的地址是否相同
console.log(obj1.say === obj2.say); // true
终极解决方案
前面的通通忘掉!
在JavaScript中,每一个构造函数都有一个默认的属性, 这个属性叫做prototype,prototype属性指向一个对象, 这个对象我们称之为构造函数的原型对象
既然构造函数的prototype就对应一个对象, 所以我们就可以将方法都放到这个对象中
注意点:所有通过同一个构造函数创建出来的对象, 都可以访问该构造函数的原型对象,并且所有通过同一个构造函数创建出来的对象, 访问的都是同一个原型对象
// 定义了一个构造函数
function Person(name, age) {
this.name = name;
this.age = age;
}
/*
私有成员(一般就是非函数成员)放到构造函数中
共享成员(一般就是函数)放到原型对象中
如果重置了 prototype 记得修正 constructor 的指向
*/
Person.prototype.say = function () {
console.log(this.name, this.age);
};
// console.log(Person.prototype);
var obj1 = new Person("luodou", 13);
obj1.say();
var obj2 = new Person("dou", 18);
obj2.say();
// 这里的===是在判断两个函数的地址是否相同
console.log(obj1.say === obj2.say); // true