7、JavaScript对象

JavaScript语言是基于对象的（Object-Based），而不是面向对象的（object-oriented）。之所以说它是一门基于对象的语言，主要是因为它没有提供象抽象、继承、重载等有关面向对象语言的许多功能。而是把其它语言所创建的复杂对象统一起来，从而形成一个非常强大的对象系统。

虽然JavaScript语言是一门基于对象的，但它还是具有一些面向对象的基本特征。它可以根据需要创建自己的对象，从而进一步扩大JavaScript的应用范围，增强编写功能强大的Web文档。

• 概念

ECMA-262把对象（object）定义为“属性的无序集合，每个属性存放一个原始值、对象或函数 ”。
每个对象都由类定义，可以把类看作对象的配方。
程序使用类创建对象时，生成的对象叫做类的实例（instance）。
由类创建对象实例的过程叫做实例化（instantiation）。
每个实例的行为相同，但实例处理一组独立的数据。
JavaScript即使类并不真正存在，也把对象定义叫做类，因为大多数开发者对此术语更熟悉，而且从功能上说，两者等价。
对象定义存放在一个函数——构造函数中。构造函数不是一种特殊函数，它只不过是用于创建对象的常规函数。

• 面向对象语言的要求

一种面向对象语言需要向开发者提供四种基本能力：
(1) 封装——把相关的信息（无论数据或方法）存储在对象中的能力。
(2) 聚集——把一个对象存储在另一个对象内的能力。
(3) 继承——由另一个类（或多个类）得来类的属性和方法的能力。
(4) 多态——编写能以多种方法运行的函数或方法的能力。
ECMAScript支持这些要求，因此可被看作面向对象的。

• 对象的构成

在ECMAScript中，对象由特性（attribute）构成，特性可以是原始值，也可以是引用值。如果特性存放的是函数，它将被看作对象的方法（method），否则该特性被看作属性（property）。

• 实例化

对象是用关键字new后跟要实例化的类的名字创建的：

var o = new Object();

var oStr= new String();

一行代码创建了Object类的一个实例，并把它存储在变量oObject中。第二行代码创建了String类的一个实例，把它存储在变量oStringObject中。如果构造函数无参数，括号则不是必需的：

var o = new Object;

ar oStr= new String; 

如果只是创建一个Object对象，则还可以以下方式创建： 

var o ={};

• 对象直接量

对象直接量提供了另一种创建并初始化新对象的方式。使用对象直接量，可以把对象的说明直接嵌入Javascript代码，就像把文本数据作为引用的字符串嵌入Javascript代码一样。对象直接量由属性说明列表构成，列表包含在大号中，其中属性说明由逗号隔开。对象直接量中的每个属性说明都由属性加上冒号和属性值构成，例如：

var obj = {x:0,y:1,f:function(z){alert(z);}};
alert(obj.x);
alert(obj.y);
obj.f(3);

• 属性的设置和查询

//设置嵌套对象属性
book.chapter1 = new Object();
book.chapter1.title = 'Introduction to JavaScript';
book.chapter1.pages = 19;
book.chapter2 = {title:'Lexical Structure', pages: 6};

//读取该对象的某些属性
alert('Outline:' + book.title + '\n\t' +
			'Chapter 1 ' + book.chapter1.title + '\n\t' +
			'Chapter 2 ' + book.chapter2.title );

• 对象属性的枚举

for/in循环提供了一种遍历对象属性的方法，在调试一个脚本或者在使用一个对象时非常有用，该对象可以具有任何我们无法获知的属性。下面的代码展示了一个函数，可以用它来列出对象的所有属性名：

function displayPropertyNames(obj){
	var names = '';
	for(var name in obj){
		names += name + '\n';		
	}
	alert(names);
}

var obj = {x:0,y:1,f:function(z){alert(z);}};
displayPropertyNames(obj);//x y f

注：for/in循环列出的属性并没有特定顺序，而且虽然它能枚举出所有的用户定义的属性，但是却不能枚举出某些预定义的属性或方法。

• 未定义的属性

如果要读取一个不存在的属性或赋值是赋的本身就是undefined的值，那得到的结棍是一个undefined值：

var o = {};
o.name = 'jzj'
o.undefine = undefined;
displayPropertyNames(o);//name undefine

alert(o.a);//undefined
alert(o.undefine);//undefined
alert(o.name);//jzj

• 删除属性

可以使用运算符delete来删除一个对象的属性：

var o = {};
o.name = 'jzj'
displayPropertyNames(o);//name
delete o.name;
displayPropertyNames(o);//空

 注：删除一个属性并不仅仅把该属性设为undefined，而是真正从对象中移除了该属性。

• 构造函数

构造函数是具有几个特性的JavaScript函数：

• 它由new运算符调用。
• 传递给它的是一个新创建的空对象的引用（相当于 var o = {}），将该引用作为关键字this的值（即this指向o对象），而且它还要对新创建的对象进行适当的初始化，最后返回this所引用的对象给new表达式。 

• 构造函数通常没有返回值。它们只是初始化由this值传递进来的对象，并且什么也不返回。但是，构造函数可以返回一个“对象”，如果这样做，被返回的对象就成了new表达式的值。在这种情况下，this值所引用的对象就被丢弃了：

function c(name,age){
	this.age = age;
	//如果返回的是一个对象，则可以正确的返回此对象
	return {name:name};	
}

var o = new c('jzj',30);
alert(o.name);//jzj
alert(o.age);//undefined

 但如果返回的不是对象，而是一个基本类型时，则return不起作用：

function c(name, age){
	this.name = name;
	this.age = age;
	//即使明确指定返回也不起作用
	return 'x';	
}

var o = new c('jzj',30);
alert(o);//[object]
alert(o.age);//30

• 函数中的this

JavaScript函数中的this与Java、C++等面向对象的语言不同，它们都是指向当前的对象，不可修改，它在对象创建时就已确定。但JavaScript中的this就不一样了，它是在运行时确定的。

为了理解this关键字,如果你只想记住一句话,那应该是 this关键字总是指向当前函数的所有者对象(执行空间或函数调用者) , 至于这句话如何理解, 可以参见下面的详细说明.

那么什么是 scope 呢?

scope 中文即是所谓的 作用域, 它指明的是一个数值或者表达式所关联的上下文(能够被引用的执行空间)。

scope 与this有什么关系呢? 如果从上面的定义来看, this指向的总是当前引用此函数的对象,而当你要判断当前引用的对象时, 这时你就得弄清楚当前函数所在的 scope. 具体可见下面的分析。

请看下面例子：

window.name = "zhutao from window";
var get_name = function () {
	return this.name;   // this的具体指向只能在运行时才能确定,也就是确定运行时调用其的对象
};
alert(get_name());  // 输出zhutao from window, get_name调用的对象为window
var obj = {};
obj.name = "zhutao from obj";
alert(get_name.apply(obj)); // 输出zhutao from obj, 我们强制地使用了 apply来更改调用的对象,使其指向obj
var innerobj = {"name":"zhutao from innerobj"};
innerobj.get_name = get_name;   // 使得innerobj的get_name方法指向了global scope的get_name函数
alert(innerobj.get_name()); // 输出zhutao from innerobj, 此时this指向的是innerobj

 那么从上面的简单例子来看，this 总是在 运行时 才能确定其具体的指向，也才能知道它的调用对象。而这点也正是 动态语言 一个重要特性。

那么如何确定当前this指向的引用对象呢? 通常可以这样判断:

1. 如果在global的scope(可以参见下面的说明来明确什么是global scope)来调用，则指向的是bowser的顶级对象window 例如: get_name()。
2. 如果, 有类似于这样的引用, innerobj.get_name() 则很显然this指向的是innerobj。
3. 如果我们使用了apply, call来进行强制的引用对象指向, 则也会很显然地指向强制的对象,如 get_name.apply(obj)。

 

• 原型对象和继承

用构造函数把方法赋予它要初始化的对象，效率非常低，因为构造函数创建的每个对象都会有相同的方法属性的副本。有一种更为有效的方式可以用来声明方法、常量以及其他能被类的所有对象共享的属性。这就是现在我们要讲的JavaScript中的原型。

JavaScript对象都会“继承”原型对象的属性。每个对象都有原型对象，原型对象的所有属性是以它为原型的对象的属性。也就是说每个对象都继承原型对象的所有属性。

一个对象的原型是由创建并初始化该对象的构造函数定义的。JavaScript中的所有函数都有prototype属性（注：也只有函数才有该属性），它引用了一个对象（该原型对象的constructor 属性就是该构造函数） 。虽然原型对象初始化时是空的（不是null，是指该原型对象中无任何属性），但是你在其中定义的任何属性都会被该构造函数创建的所有对象继承。

 

原型对象是存放方法和其他常量属性的理想场所。

 

注：继承是在查询一个属性值时自动发生的。属性并非从原型对象复制到新的对象的，它们只不过看起来像是那些对象的属性 。这其中有两点重要的含义。一是使用原型对象可以大量减少每个对象对内存的需求量，因为对象可以继承许多属性。二是即使属性在对象创建之后才添加到它的原型对象中，对象也能够继承这些属性（即先创建对象，再给构造函数的原型属性prototype赋值新的属性，以前创建的对象实例一样还能继承这些原型中的新添加的属性）。

 

每个类（确确的说是构造函数）都有一个原型对象，这个原型对象都具有一套属性。但是实际上却有大量的类实例，每个实例都能继承原型的属性。由于一个原型对象能够被多个对象继承，所以JavaScript必须强化读写属性值之间的不对称性。在读对象o的属性p时，JavaScript首先检查o是否具有一个名为p的属性。如果o没有这个属性，JavaScript就会再检查o的原型对象中是否具有这个属性。这样才使得以原型为基础的继承机制起作用。

而当你写一个属性的值时，JavaScript并不使用用原型对象，实质上是给自己对象上添加（以前本来就没有该属性时）或修改（以前就已经有该属性）该属性，而原型对象中的同名的属性是不会被修改到的 。要明白为什么，就考虑一下如果这样做会出现什么样的后果。假设你在对象o还没有一个名为p的属性时要设置属性o.p的值。进一步假设JavaScript继续在o的原型对象中查询属性p，并且允许你设置原型对象的这一属性，那就改变了整个对象类的p值，页不是仅仅改变了自己想要改变的属性值。

function f() {
}
f.prototype.attr = "attr1";
var o = new f("jzj", 30);
o.attr = "attr2";//不会修改原型对象中attr属性
for (var x in o) {
	//o[attr]=attr2
	alert("o[" + x + "]=" + o[x]);
}
var o1 = new f("jzj", 30);
//原型中的属性也会遍历出来
for (var x in o1) {
	//o1[attr]=attr1 该属性值为原型对象中的属性
	alert("o1[" + x + "]=" + o1[x]);
}

因此，属性的继承只发生在读属性必值时，而在写属性值时不会发生 。如果你设置的对象o的属性p是对象o从它的原型对象继承而来的，那么结棍是你直接在对象o中创建了一个新属性p。现在o已经有了自己的名为p的属性，它就不会再从它的原型对象继承p的值了。此时，当你读p的值时，JavaScript首先查询o对象自己的属性。由于它发现了o中定义了p，它就不必再查询原型对象，也就不会再发现原型对象中定义的p值了。我们有时说o中的p“隐藏”了原型对象中的属性p。

 

因为原型对象的属性被一个类的所有对象共享，所以通常只用它们来定义类中所有对象的相同的属性。这使得原型对象适用于方法定义。另外原型属性还适合于那些具有常量值的属性的定义。如果你在类中定义了一个属性，它有一个非常常用的默认值，那么你可以在原型对象中定义这个属性和它的默认值。然后，那些不想使用默认值的少数对象可以创建自己专有的、非共享的属性副本，并且将它定义为自己的、非默认的值。

• 实例属性

每个对象都有它自己单独的实例属性的副本。例如，在Circle类中，每个Circle对象都有一个属性r，它指定了这个圆的半径，这里的r就是一个实例属性。在默认情况下，Javascript中的任何对象里的属性都是实例属性。但是为了真实地模拟面向对象的程序设计语言，我们说Javascript中的实例属性就是那些在对象中用构造函数创建的或初始化的属性。

• 实例方法

实例方法和实例属性非常相似，只不过它是方法而不是值。实例方法是由特定对象或实例调用的。实例方法使用了关键字this来引用它们要操作的对象或实例。虽然一个类的任何实例可以调用实例方法，但是这并不意味着每个对象都像实例属性那样含有自己专有的方法副本，相反，每个实例方法得了是由类的怕有实例共享的。在Javascript中，给类定义一个实例方法，是通过把构造函数的原型对象中的一个属性设置为函数值来实现的。这样，由那个构造函数创建的所有对象都会共享一个已继承的对实例函数的引用。

• 类属性

类属是一个与类相关联的变量，而不是和类的每个实例相关联的变量。无论一个类创建多少个实例，每个类属性都只有一个副本。就像实例属性是通过类的实例存取的的一样，类属是通过类存取的。在JavaScript中的类属性实现是通过给函数设置一个属性，就像创建对象的属性一样，因为JavaScript中的函数本身就是一个对象。

• 类方法

类方法是一个与类关联在一起的方法，而不是和类的实例关联在一起的方法。要调类方法，就必须使用类本身，而不能使用该类的特定实例。方法Date.parse()就是一个类方法。通过构造函数对象Date才能调用这个方法，而不能通地过Date类的一个特殊实例来调用它，因为类的方法不同于构造函数原型中的定义的原型方法，它可以被所有类实例继承使用。

• 超类和子类

Javascript是以原型为基础的继承机帛，而不是以类为基础的继承机制，但还是有为似的的类层次结构。在JavaScript中，类Object是最通用的类，其也所有类都是Object的子类。Object是所有类的超类，所有类都继承了Object的基本方法。

我们知道对象是如何从构造函数的原型对象中继承属性的，那么我们又是如何继承类Object的属性的呢？因为原型对象本身就是一个对象，它是由构造函数Object()创建的。这就意味着原型对象继承了Object.prototype属性。因此，类的对象实例就继承了构造函数的prototype属性对象的里的属性，而构造函数的prototype属性对象又继承了Object.prototype属性。由此可以知，对象实例继承了两个对象的属性。在对象实例中查询某个属性时，首先查询的是这个对象本身，如果在这个对象中没有发现要查询的属性，就查询构造函数的prototype属性对象，如果也没查找，则查询Object.prototype对象。注：实例对象中的属性会隐藏构造器中prototype对象与Object.prototype中同名属性。

• 对象的属性与方法

所有对象，无论它的类是什么，都支持类Object类定义的属性和方法。由于这些属性和方法的一般性，使得它们具有特殊的重要必。

对象的constructor属性

每个对象都具有constructor属性，它引用的是用来初始化该对象的构造函数。例如，如果用构造函数Complex()创建了一个对象o，那么属性o.construtor引用的就是Complex。并且每一个对象实例的constructor都继承自该实例对象的构造函数的prototype中的construtor属性，这种会有一个问题就是，在我们修改过构造函数的prototype属性后，重新创建的对象的constructor属性也就会改变，这样如果用insanceof操作来判断一个实例是否是某个类的实例时就会有问题，具体作法我们可以把prototype.constructor属性重新设置成构造函数即可，请看：

function a(){
}
alert(a.constructor == Function);//true
var o1 = new a();
//对象的constructor为创建它的对象，也即初始化它的对象
alert(o1.constructor == a);//true

function b(){
}

alert(b.constructor == Function);//true
//创建一个对象时，如果未修改其默认的prototype的值，则默认就是
//指向该函数本身的，即该prototype对象是由该函数初始化出来的
alert(b.prototype.constructor == b);//true
var o2 = new b();
alert("o2 instanceof b  =  " + (o2 instanceof b));//true
//其实每个对象的实例的constructor都继承自prototype.constructor属性，
//进一步证实请看最后面修改prototype对象值代码
alert(o2.constructor == b);//true
b.prototype = o1;

//当一个类的prototype属性被重新设置后，prototype.constructor也会
//相应的变为被设置的对象的构造函数，上面b.prototype = o1后，
//b.prototype.constructor就会变成o1的构造函数，即函数a
alert(b.prototype.constructor == a);//true

//现在用instanceof 判断出错，因为prototype.constructor属性被修改了
alert("o2 instanceof b  =  " + (o2 instanceof b));//false

//重新设置回去，以保持正确属性
b.prototype.constructor = b;//true

//注：即使修改过来后，修改以前创建的对象还是错误的，这样也是
//合情合理的，因为是由谁(哪个constructor)创建的已定，不可更改
//这不像一个创建一个对象后，向它的构造函数中添加新的属性，这个
//对象还能看得见。
alert("o2 instanceof b  =  " + (o2 instanceof b));//false

//新创建的对象判断会正确
alert("new b() instanceof b  =  " + (new b() instanceof b));//true

//现修改成Object对象
b.prototype = {};
alert(b.prototype.constructor == Object);//true
var o3 = new b();
//现在o2的constructor却变成了Object，因为constructor继承自
//prototype.constructor的，prototype.constructor被修改成了
//Object实例了，所以o3.constructor也就跟就修改了，但我们可以
//把prototype.constructor重新设置回去，以保持正确属性
alert(o3.constructor == Object);//true


//重新设置回去，以保持正确属性
b.prototype.constructor = b;//true

var o4 = new b();
//现在正确了
alert(o4.constructor == b);//true

对象的toString()方法

方法toString()没有任何参数，它返回的是一个字符串，该字符串代表了调用它的对象的类型或值。当将一个对象转换成字符串时就调用这个对象的toString()方法。例如，当用运算符"+"把一个字符串和一个对象连接在一起进，或者要把一个对象传递给alert()或document.write()方法时，就会调用toString()。

默认的toString()方法提供的信息并不多，例如，下面的代码只能使用浏览器显示出字符串"[object Object]":

function a(){
}
var o1 = new a();
alert(o1);

 注：在Netscape浏览器中，如果显示地将<script>标记的language属性设置成"JavaScript1.2"，那么toString()方法将用对象直接量表示法来显示对象的所有字段的名称和值。不过这违反了ECMAScript规范。

 

由于默认的方法并不能显示出太多有用的信息，所以许多类都定义了自己的toString()方法。toString()的目的是每个对象类都有自己特定的字符串表示，所以应该定义一个合适的toString()方法将对象转换成相应的字符串形式。当你定义一个类的时候，就应该为它定义一个toString()谅地，以便能将这个类的实例转换成有意义的字符串。

 

由类Object定义的默认toString()方法有一个有趣的特性，那就是它提示了一些有关内置对象的内部类信息。这个默认的toString()方法返回的字符串形式总是：

[object class]

 class是对象的类型，通常一般对应于该对象的构造函数名。一般用户自定义的对象的class为 Object。其他不同的类对象有不同的显示。如果有自己的toString()，则显示toString()实现。

 

有时我们有自己的toString()方法，这时如果还想调用默认的toString()方法时，必须明确地引用Object.prototype对象的默认toString()函数，我们应该这样做：

alert(Object.prototype.toString.apply(new Date));//[object Date]

对象的toLocaleString()方法

在ECMAScript v3 和 JavaScript 1.5中，除了 toString()方法外，Object类还定义了toLocalString()方法，该方法的作用是返回对象局部化的字符串表示。Object类定义的默认toLocalString()方法自身不做任何局部化（本地化），返回的结果与toString()方法返回的完全相同。但是Object类的子类则可能定义自己的toLocalString()方法。在ECMAScript v3中，Array、Date 和 Number 类都定义了自己的toLocalString()方法，返回的是本地化的值。

对象的valueof()方法

方法valueof()和方法toString()非常相似，当JavaScript需要将一个对象转换成字符串之外的原始类型（通常是数字）是地，就需要调用用它。这个函数返回的是能代表关键字this所引用的对象的值的数据。

由于对象没有定义为原始类型的值，所以大多数对象都没有等价的原始值。因些由Object类定义的valueof()方法不执行任何转换，只是返回调用它的对象。

function a(){
 this.name = 'jzj';
}
var o1 = new a();
//o1.valueOf()返回的是调用它的对象
alert(o1.valueOf().name);//jzj
alert(Object.prototype.valueOf.apply(o1).name);//jzj
//函数valueof()返回本身代码串
alert(a.valueOf());

 

像Number和Boolean这样的类具有明显的原始等价值，所以它们就覆盖了方法valueof()，让它返回合适的值。

对象的hasOwnProperty()方法

如果对象自身定义了一个非继承的属性，那么该方法将返回true。否则，它将返回false，例如：

 

var o = new Object;
//false:没有定义该属性
alert(o.hasOwnProperty('undef')); 
//false:toString是一个继承属性，它继承自Object.prototype中的toString
alert(o.hasOwnProperty('toString')); 
//true:max为Math类的类方法，而不是某个实例方法
alert(Math.hasOwnProperty('max')); 

function f(name){
	this.name = name;
	this.toString = function(){
		alert(this.name);	
	}	
}
var o1 = new f('jzj');
//如果重写了父类的某方法后这个方法还是能为true，这与
//下面的propertyIsEnumerable不一样
alert(o1.hasOwnProperty('toString')); //true

var arr = new Array(1,2,3);
alert(arr);//1,2,3
 //false:因为这里的toString方法还是继承自Array.prototype的
alert(arr.hasOwnProperty('toString'));

 

此方法无法检查该对象的原型链中是否具有该属性；该属性必须是对象本身的一个成员。

var s = new String("JScript");
print(s.hasOwnProperty("split"));//false
print(String.prototype.hasOwnProperty("split"));//true

对象的propertyIsEnumerable()方法

如果对象定义了一个属性，属性名是由一个字符串实际参数指定的，而且该属性可以用for/in循环枚举出来，那么该方法返回true，否则，返回false。

典型地，预定义的属性不是可列举的，而用户定义的属性总是可列举的。还有就是propertyIsEnumerable 属性不考虑原型链中的对象，即不考虑类的属性，除非是自己重了父类非预定义的属性。

 

例如：

var o = {x:1,valueOf:function(){return 1;}};
//true:该属性存在，而且可枚举
alert(o.propertyIsEnumerable('x'));
//fals:该属性不存在
alert(o.propertyIsEnumerable('y'));
//false:该属性不可枚举，即使你重写后还是不能枚举出来，因为它是JavaScript
//类Object预定义的方法，非预定义方法子类重写后在子类对象中是可以枚举出来的
//请看后面的例子
alert(o.propertyIsEnumerable('valueOf'));

function a (){
	
}
a.prototype.func = function(){alert('func');}

function b(){	
	this.func2 = function(){
		alert('func2');	
	}
}
b.prototype = new a();
b.prototype.func1 = function(){alert('func1');}
var o1 = new b();
o1.func();
o1.func1();
alert(b.prototype.constructor.prototype.constructor === a);//true
//父类的父类（b.prototype.constructor.prototype）方法不可枚举
alert(o1.propertyIsEnumerable('func'));//false
//父类方法不可枚举
alert(o1.propertyIsEnumerable('func1'));//false

//重写父类方法
o1.func1 = function(){
	alert('func1');	
}	
//父类方法非预定义方法重写后可枚举
alert(o1.propertyIsEnumerable('func1'));//true
//只有自己定义的方法才能枚举
alert(o1.propertyIsEnumerable('func2'));//true

注：ECMAScriptScript标准规定proertyIsEnumberable()方法只考虑对象直接定义的属性，而不考虑继承的属性。

对象的isPrototypeOf()方法

如果调用对象是实际参数指定的对象的原型对象，该方法返回true，否则返回false。该方法的用途和对象的constructor属性相似。例如：

var o = new Object;

//true: o.constructor == Object
alert(Object.prototype.isPrototypeOf(o));
//false
alert(Object.isPrototypeOf(o));
//false
alert(o.isPrototypeOf(Object.prototype));
//true: Object.Constructor == Function
//由此可见自己所定义的函数或类，它们的都是继承自Function.prototype
//的，比如说有Function.prototype.valueOf()方法，它能打印源码
alert(Function.prototype.isPrototypeOf(Object));

var o = function (){};
alert(o);
alert(Function.prototype.valueOf.apply(o));

• 对象分类

JavaScript对象可分为以下三类：

 

ECMA-262把本地对象（native object） 定义为“独立于宿主环境的ECMAScript实现提供的对象”。简单说来，本地对象就是ECMA-262定义的类（引用类型）。它们包括：
Object Function Array String Boolean Number Date RegExp
Error EvalError RangeError ReferenceError SyntaxError TypeError URIError

 

ECMA-262把内置对象（built-in object） 定义为“由ECMAScript实现提供的、独立于宿主环境的所有对象，在ECMAScript程序开始执行时出现”。这意味着开发者不必明确实例化内置对象，它已被实例化了。ECMA-262只定义了两个内置对象，即Global 和Math （它们也是本地对象，根据定义，每个内置对象都是本地对象）。

注：Math 对象并不像 Date 和 String 那样是对象的类，因此没有构造函数 Math()。Global（全局对象）是预定义的对象，作为 JavaScript 的全局函数和全局属性的占位符。通过使用全局对象，可以访问所有其他所有预定义的对象、函数和属性。全局对象不是任何对象的属性，所以它没有名称。全局对象只是一个对象，而不是类。既没有构造函数，也无法实例化一个新的全局对象。

 

所有非本地对象都是宿主对象 （host object），即由ECMAScript实现的宿主环境提供的对象。所有BOM和DOM对象都是宿主对象。