javacript object

使用array时我们会说element ,使用object 时我们会所 property,在javascript中没有任何的不同，仅仅是被当作terminology,
properties是来自于其他语言。
一个object 的property可能包含一个function,这个function 被称为他的method如：
var dog = {
name:'Benji',
talk:function (){
alert('wang!wang!');
}
};

当然它也是可以存储到数组中：
var a = [];
a[0] = function(what) {
alert(what);
};
a[0]('Boo');

/**
*2、联合数组 、hashes
*/
一些语言里，这个会有一些不同
*普通的array可以被索引，或者说是可以被列举,key是number
*associative array 被称作hash ，key是string。
javascript 中，arrray 是 索引数组（indexed array）
object 是 联合数组（assiociative array),如果你想使用hash 你就可以使用object.
/**
*3、访问object 的properties
*/

有两种方式去访问object 的properties
.使用方括号标识 如 hero['name']
.使用点号标识 如： hero.name

点号访问容易被书写和阅读，但是有些特殊的是不能使用的，但这个properties 的name 不是一个有效的 variable时，你就不能使用
点号标识。
让我们看看这个object
var hero = {name:'Turtle',occupation:'Ninja'};
访问属性 hero.name    “Turtle" 
访问不存在的属性将会得到一个undefined,如： >>>hero.haircolor         "undefined"

object 可以包含任意数据，任意object.
var book = {name:'Catch-22',published:'1961',author:{firstname:'Joseph',lastname:'Heller'}};
book对象里有一个author object.
可以如此访问：
>>>book.author.firstname
"Joseph"
或者
>>>book['author']['firstname']
也可以混淆着用：
>>>book['author'].firstname
有的时候你可能需要方括号,当访问的属性未知时：
>>>var key = "firstname";
>>>book.author["firstname"]

调用一个对象的方法
method 只是一个属性是function 所以你可以用相同的方法来访问这个属性，只是在后面添加一个小括号就好了.

var hero = {breed:'Turtle',occupation:'Ninja',say:function(){return 'I am '+ hero.occupation;}};
>>> hero.say()
传递参数给这个方法，就像使用普通方法一样就可以了，也可以使用括号的调用方式去调用。
>>>hero["say"]
建议：
×尽量使用点号去访问属性和方法
×尽量不使用引号去设置属性和方法名

methods 和 properties 的更改
javascript 是一个dynami language ,它允许在使用时更改属性和方法，这包括创建新的和删除存在的，如：一个空对象：
>>> var hero = {};
访问不存在属性
>>> hero.breed
"undefined"
添加属性和方法。
hero.breed = 'turtle';
hero.name = 'Lenoardo';
hero.sayName=function(){ return hero.name;};

调用方法:
hero.sayName()；
“Lenoardo”
删除这个属性
>>>delete hero.name
true
然后再调用
>>>hero.sayName()
"reference to  undefined property hero.name"

使用这个值，在前一个例子里，这个方法使用sayName来访问这个hero 的object的属性name来访问
在前一个例子的基础我在定义一个
var hero = {
name: 'Rafaelo',
sayName: function() {
return this.name;
}
}；
>>>hero.name
"Rafaelo"
当你访问这个对象时，它得到的是当前对象（current object or this object)

/**
*4、function constructor
*/
使用构造function 去创建对象
function Hero(){
this.occupation = 'Ninja';
}
在使用这样的function 创建对象时，你必须使用new来创建这个对象。
>>>var hero  = new Hero();
>>>hero.occupation
"Ninja"

使用构造的好处在于创建新对像时，可以通过传递参数，给对象的属性分配value.
function Hero (name){
this.name = name';
this.occapation = 'Ninja';
this.whoAreYou = function (){
return "I am " +this.name + ", I'm a" this.occapation;
};
}
你可以创建不同的对象，通过相同的构造。
>>> var h1 = new Hero('Miche');
>>> var h2 = new Hero('Donate');
>>>h1.whoAreYou()
“I am Miche ,I'm a Ninja"
>>>h2.whoAreYou()
“I am Donate ,I'm a Ninja"

......

根据规定，constructor function 首字母应该大写，所以当年看到function 的首字母大写你就一概知道这不是一个寻常的function,
当你调用一个function 当作constructor 来调用的话，但是你又忘记了写new这个关键字，那么将会的到一个undefined
如果没有new我们就不能创建新的对象，function 会像普通的function 被调用，但是这个function没有return ,那么它就会变成一个
undefiend

/**
* 5、全局的object
*/
浏览器的javascript 提供了一个全局的对象window，你定义的全局变量实际上是这个全局对象的属性。
如：
var a = 1; 这是一个全局变量可以这么访问它。
>>>a
1
也可以以全局对象window的属性的方式访问它。
>>>window.a
1
>>>window["a"]
1

再回头看上面的例子，
>>>function Hero(name){this.name = name；}
>>>var h = Hero('Bob');
>>>typeof h
"undefined"
>>> h.name
"h has no property"
因为你在Hero内部使用了this,这样就相当于定义了一个全局的对象，
你可以这样访问它

>>>name
"Bob"
>>>window.name
"Bob"
>>>window["name"]
"Bob"
.....

但是你用new调用同样的constructor 时，那么这个new object 将会被return 掉
>>> var h2 = new Hero('Michelangelo');
>>> typeof h2
"object"
>>> h2.name
"Michelangelo"
全局的function 你可能在前面也用到过：parseInt() winodw.parseFloat()....

/**
*6、constructor property
*/
当一个对象被创建的时候，constructor属性将后被后面悄悄的被赋值，你可以在你新创建的对象里直接调用这个属性。可以这样:
>>> var h3 = new h2.constructor("zhangsan");
>>>h3.name
"zhangsan"
如果一个对象不创建，那么他的constructor将在内部被创建，
>>>var o = {}
>>>o.constructor
>>> typeof o.constructor
"function"
/**
*7、instanceof 的使用
*/
使用instanceof 可以知道你创建的对象的特殊构造是什么

>>> function Hero(){}
>>> var hero  = new Hero();
>>> var o = {}
>>> h instanceof Hero
true
>>> h instanceof Object
false
>>>o instanceof Object

**注意
在function 后面不使用圆括号，因为这不是一次调用只是被当作一次参考而已。

/**
*7、function return object
*/
也可以通过一个普通的function 创建一个constructor function 而不使用 new .一个function 一些属性的执行，然后再把这个得到的
value 再return 掉，如
function factory (name){
return {name:name};
}
使用这个function
>>> var o = factory('one');
>>>o.name
"one"
>>>o.constructor
Object
现在你也可以通过constructor function 和return object 这就意味你可以更改它的一些默认行为。
普通的构造：
function C(){
this.a = 1;
}

>>>var c = new C();
>>>c.a
1

使用现在的方法
function C2(){ this.a = 1; return {b:2}}
>>> var c2 = new C2();
>>>typeof c2.a
"undefined"
>>> c2.b
2
这是因为return 了object 包含属性a的那个constructor 它return 了其他的object它包含了b,都是因为return 一个object .
另外构造也是可以return其他的东西。

/**
*8、object 的传递
*/
当你copy或者传入一个object时，这仅仅这是一个referenece 的传递，所以说当你更改一个对象的copy对象时，或者是这个的对像
的传递对象时，实际更改的是这个对象的原始对象如：
>>>var  original = {howMany :1} ;
>>> var copy = original;
>>>copy.howMany
1
>>>copy.howMany = 100
>>>original.howMany
100
同样当进行传递后：
>>> var original = {howmany: 100};
>>> var nullify = function(o) {o.howmany = 0;}
>>> nullify(original);
>>> original.howmany
0

/**
*9、对象的比较
*/
当你进行相同对象的不同引用，进行比较就会得到一个true，当进行两个实际对象的比较精确到method property 相同也会得到一个
false.
>>>var fido = {breed:'dog'};
>>>var benji = {breed:'dog'};
>>> fido == benji
false
>>> fido === benji

然后你创建一个新的对象分配给它一个对象，这个时候再进行比较
>>> var mydog = benji;
>>> mydog == benji
true