对象类的创建和实例化

Object实例化、访问对象属性

创建Object实例的两种方式

• 使用new操作符后跟Object构造函数，new可省略

var person=new Object();
person.name="Cosmic";
person.age=18;

• 使用对象字面量表示法

var person={
name:"Cosmic",
age:18,
"sex":"male",
5:true
};

对象字面量是对象定义的一种简写形式，目的在于简化创建包含大量属性的对象的过程。数值属性名会自动转换为字符串。

访问对象属性的两种方式

• 点表示法，常用；方括号表示法，强大

alert(person.name);
alert(person["name"]);

• 通过变量访问对象属性，可用方括号表示法。

var person={name:"Stars"};
var pro="name";
alert(person[pro]); //Stars

• 属性名中包含会导致语法错误的字符，或使用的是关键字或保留字，也可用方括号表示法。

person["favorite food"]="Cake";
person["--"]="abc";
person["5"]="false";

对象字面量也是向函数传递大量可选参数的首选方式

function person(args){
    var output="";
    if(typeof args.name=="string"){
        output+="Name:"+args.name+"\n";
    }
    if(typeof args.age=="number"){
        output+="Age:"+args.age+"\n";
    }
    alert(output);
}
person({name:"Cosmic",age:18});
person({name:"Stars"});

JavaScript定义类的几种方式

1. 工厂方式

在JS中创建类和对象，对象的属性可以在对象创建后动态定义

//定义
var person = Object(); //对象
person.name = "Cosmic"; //属性
person.age = 18;
person.behavior = function(){ //方法
    alert(this.name)
};
//调用
person.behavior();

我们很容易使用person对象，要想创建多个person实例，可以使用一个函数封装上面的代码来实现。由此创造了能创建并返回特定类型的对象的工厂。

//定义、封装
function createMan(){
    var person = Object(); //对象、类
    person.name = "Cosmic"; //属性
    person.age = 18;
    person.behavior = function(){ //方法
        alert(this.name)
    };
    return person;
}
//调用
var Tom = createMan(); //实例
var Cary = createMan();
Tom.name = "Tom";
Tom.behavior();
Cary.behavior();

2. 构造函数

在构造函数内部创造对象使用this 关键字，使用new 运算符创建对象实例

//定义、构造函数
function person(name,sex){
    this.name = name;
    this.sex = sex;
    this.behavior = function(){ alert(this.name) };
}
//调用
var Tom = new person("Tom",18);
var Cary = new person("Cary",18);
Tom.behavior();
Cary.behavior();

3. 原型方式

利用对象的prototype属性，可把它看成创建新对象所依赖的原型

//定义
function person(){}
person.prototype.name = "Cosmic";
person.prototype.sex = 18;
person.prototype.teacher = new Array("Ann","Jane");
//可以用json方式简化prototype的定义:
person.prototype = {
    name: "Cosmic",
    sex: 18,
    teacher: ["Ann","Jane"],
    behavior: function(){ alert(this.name) }
};
//调用：
var Tom = new person();
var Cary = new person();
alert(Tom.teacher);
Tom.teacher.push("Vae");
alert(Tom.teacher); //结果：Ann,Jane,Vae
alert(Cary.teacher); //结果：Ann,Jane,Vae

4. 混合的构造函数/原型模式

属性放在内部定义，方法放在外边利用prototype定义

//定义
function person(name,sex){
    this.name = name;
    this.sex = sex;
    this.teacher = new Array("Ann","Jane");
}
person.prototype.behavior = function(){ alert(this.name) };

//调用：
var Tom = new person("Tom",18);
var Cary = new person("Cary",18);
Tom.behavior();
Cary.behavior();
alert(Tom.teacher);
Tom.teacher.push("Vae");
alert(Tom.teacher); //结果：Ann,Jane,Vae
alert(Cary.teacher); //结果：Ann,Jane
alert(Tom instanceof person); //结果：true

5. 动态原型

动态原型方法的基本想法与混合的构造函数/原型方式相同，即在构造函数内定义非函数属性，而函数属性则利用原型属性定义。唯一的区别是赋予对象方法的位置

//定义
function person(){
    this.name = "Cosmic";
    this.age = 18;
    this.teacher = new Array("Ann","Jane");
    if(typeof person._initialized == "undefined") {
        person.prototype.behavior = function(){ alert(this.name) };
    }
    //最后定义
    person._initialized = true;
}

参考资料：银河威尔的博客、脚本之家等