什么是对象
属性组成
属性的分类:
特别的对象
对象是一种复合数据类型,可以保存不同类型的属性;
创建对象
var obj = new object();
向对象中添加属性
obj.属性名 = 属性值;
obj[‘属性名’] = 属性值;
使用[]去操作属性时,[]中传递的是一个字符串
。能传字符串的地方就能传变量
;var p = {
name: 'Tom',
age: 23,
setName: function (name) {
this.name = name
}
}
console.log(p.name, p.age)
p.setName('JACK')
console.log(p.name, p.age)
var p2 = {
name: 'BOB',
age: 24,
setName: function (name) {
this.name = name
}
}
// 一个人: name:"Tom", age: 12
var p = new Object()
p = {}
p.name = 'Tom'
p.age = 12
p.setName = function (name) {
this.name = name
}
p.setaAge = function (age) {
this.age = age
}
console.log(p)
// 工厂函数: 返回一个需要的数据的函数
function createPerson(name, age) {
var p = {
name: name,
age: age,
setName: function (name) {
this.name = name
}
}
return p
}
var p1 = createPerson('Tom', 12)
var p2 = createPerson('JAck', 13)
console.log(p1)
console.log(p2)
function Person(name, age) {
this.name = name
this.age = age
this.setName = function (name) {
this.name = name
}
}
var p1 = new Person('Tom', 12)
var p2 = new Person('Tom2', 13)
console.log(p1, p1 instanceof Person)
1、prototype本质上还是一个JavaScript对象;
2、每个函数都有一个默认的prototype属性;
3、通过prototype我们可以扩展Javascript的内建对象
// 构造函数
function Base(){}
var baseObj = new Base()
var obj = {};
obj.__proto__ = Base.prototype;
Base.call(obj);
var new2 = function (func) {
//创建对象,Object.create()方法创建一个新对象,使用现有的对象来提供新创建的对象的__proto__。
var o = Object.create(func.prototype);
//改变this指向,把结果付给k
var k = func.call(o);
//判断k的类型是不是对象
if (typeof k === 'object') {
//是,返回k
return k;
} else {
//不是返回返回构造函数的执行结果
return o;
}
}
// 创建父对象
var parentObj = {
name: 'parentName',
age: 25,
showName:function(){
console.log(this.name);
}
}
// 创建需要继承的子对象
var childrenObj= {}
// 开始拷贝属性(使用for...in...循环)
for(var i in parentObj){
childrenObj[i] = parentObj[i]
}
console.log(childrenObj); //{ name: 'parentName', age: 25, showName: [Function: showName] }
console.log(parentObj); // { name: 'parentName', age: 25, showName: [Function: showName] }
// 创建父构造函数
function Parent(){}
// 设置父构造函数的原型对象
Parent.prototype.age = 25;
Parent.prototype.friends = ['小名','小丽'];
Parent.prototype.showAge = function(){
console.log(this.age);
};
// 创建子构造函数
function Child(){}
// 设置子构造器的原型对象实现继承
Child.prototype = Parent.prototype
// 因为子构造函数的原型被覆盖了, 所以现在子构造函数的原型的构造器属性已经不再指向Child,而是Parent。此时实力化Child和实力化parent的区别是不大的,所以再次创建Child是没有意义的,并且Child.prototype添加属性,也是会影响到Parent.prototype;
console.log(Child.prototype.constructor == Parent);// true
console.log(Parent.prototype.constructor == Parent);// true
// 问题就在这里!!!!
// 所以我们需要修正一下
Parent.prototype.constructor = Child;
// 上面这行代码之后, 就实现了继承
var childObj = new Child();
console.log(childObj.age);// 25
console.log(childObj.friends);// ['小名','小丽']
childObj.showAge();// 25
// 定义父构造函数
function Parent(){
this.name = 'me';
this.sex = ['male','female']
}
Parent.prototype.test = function(){};
// 定义子构造函数
function Child(){
this.age = '12'
}
// 将子构造函数的原型指定父函数的实例
Child.prototype = new Parent();
// 但是
console.log(Child.prototype.constructor);
//function Parent(){
// this.name = 'me';
// this.sex = ['male','female']
//}
// 所以,把Child的原型的构造函数修复为child
Child.prototype.constructor = Child
var childObj = new Child(); //有test()
function Parent(xxx){this.xxx = xxx}
Parent.prototype.test = function(){};
function Child(xxx,yyy){
Parent.call(this, xxx);
}
var child = new Child('a', 'b'); //child.xxx为'a', 但child没有test()
// 创建父构造函数
function Parent(){
this.name = 'me';
this.sex = ['male','female']
}
Parent.prototype.test = function(){};
// 定义子构造函数
function Child(){
// 复制父级构造函数的属性和方法
// 使得每一个子对象都能复制一份父对象的属性且不会相互影响
Parent.call(this);
this.age = '12'
}
// 将子构造函数的原型对象指向父级实例
var parentObj = new Parent();
Child.prototype = parentObj; //得到test()
var childObj = new Child(); //childObj.xxx为'a', 也有test()
// 创建父构造函数
function Parent(){
this.name = 'me';
this.sex = ['male','female']
}
Parent.prototype.test = function(){};
// 定义子构造函数
function Child(){
// 复制父级构造函数的属性和方法
// 使得每一个子对象都能复制一份父对象的属性且不会相互影响
Parent.call(this);
this.age = '12'
}
// 定义空函数
function F(){}
// 把空函数的原型指向Parent.prototype
F.prototype = Parent.prototype
// 将子构造函数的原型对象指向空函数F的实例对象fObj
var fObj = new F();
Child.prototype = fObj;
// 将子构造函数Child原型的构造函数修复为Child
Child.prototype.constructor = Child;
var childObj = new Child();