Apply your JS skills to key Mozilla projects as an MDN Fellow! http://mzl.la/MDNFellowship

mozilla

比较版本

使用对象

更改版本

修订版 578701:

由 teoli 在 进行的修订 578701

修订版 610885:

由 smartkid 在 进行的修订 610885

标题:
使用对象
使用对象
网址缩略名:
Web/JavaScript/Guide/Working_with_Objects
Web/JavaScript/Guide/Working_with_Objects
内容:

修订版 578701
修订版 610885
n11      JavaScript被设计一个简单的基于对象的范。一个对象就是一系列属性的集合,一个属性包含一个名字和一个值。属性n11      JavaScript 是在一个简单的基于对象的范型基础上设计的。一个对象就是一系列属性的集合,一个属性包含一个名字和一
>的值可以是function稍后我们会得知它就是对象的method。除了浏览器里面预定义的那些对象之外,你也可以定义你自己的对象。>个值。一个属性的值可以是函数这种情况下属性也被称为<em>方法</em>。除了浏览器里面预定义的那些对象之外,你也可以定义你自己
 >的对象。
12    </p>
13    <p>12    </p>
14      This chapter describes how to use objects, properties, func
>tions, and methods, and how to create your own objects. 
15    </p>13    <p>
14      <span style="line-height: 1.5;">本章描述了怎样使用对象,属性,function和met
 >hod,以及怎样创建你自己的对象。</span>
16    <p>15    </p>
17      本章描述了怎样使用对象,属性,function和method,以及怎样创建你自己的对象。16    <h2 id="Objects_overview(.E5.AF.B9.E8.B1.A1.E4.B8.80.E8.A7.88
 >)">
18    </p>
19    <h2 id="Objects_overview">
n23      Objects in JavaScript, just as many other programming langun
>ages, can be compared to objects in real life. The concept of obj 
>ects in JavaScript can be understood with real life, tangible obj 
>ects. 
24    </p>
25    <p>
26      <span style="line-height: 1.5;">In JavaScript, an object is
> a standalone entity, with properties and type. Compare it with a 
> cup for example. A cup is an object, with properties. A cup has  
>a colour, a design, weight, a material it is made of, etc. The sa 
>me way, JavaScript objects can have properties, which define thei 
>r characteristics.</span> 
27    </p>
28    <p>
29      javascript中的对象(物体),和其它编程语言中的对象一样,可以比照现实生活中的对象(物体)来理解它。javas20      <span style="line-height: 1.5;">javascript中的对象(物体),和其它编程语言中
>cript中对象(物体)的概念可以比照着现实生活中实实在在的物体来理解他。>的对象一样,可以比照现实生活中的对象(物体)来理解它。javascript中对象(物体)的概念可以比照着现实生活中实实在在的物体来
 >理解他。</span>
n34    <h2 id="Objects_and_properties">n25    <h2 id="Objects_and_properties(.E5.AF.B9.E8.B1.A1.E5.92.8C.E5
 >.B1.9E.E6.80.A7)">
n38      A JavaScript object has properties associated with it. A prn
>operty of an object can be explained as a variable that is attach 
>ed to the object. Object properties are basically the same as ord 
>inary JavaScript variables, except for the attachment to objects. 
> The properties of an object define the characteristics of the ob 
>ject. You access the properties of an object with a simple dot-no 
>tation: 
39    </p>
40    <p>
41      一个javascript对象有很多属性。一个对象的属性可以被解释称一个附加到对象上的一个变量。对象的属性和普通的jav29      <span style="line-height: 1.5;">一个javascript对象有很多属性。一个对象的属性
>ascript变量基本没什么区别,仅仅是属性属于某个对象。属性定义了对象的特征(译注:动态语言面向对象的鸭子类型)。你可以通过点符>可以被解释称一个附加到对象上的一个变量。对象的属性和普通的javascript变量基本没什么区别,仅仅是属性属于某个对象。属性定义
>号来访问一个对象的属性。>了对象的特征(译注:动态语言面向对象的鸭子类型)。你可以通过点符号来访问一个对象的属性。</span>
n49      Like all JavaScript variables, both the object name (which n
>could be a normal variable) and property name are case sensitive. 
> You define a property by assigning it a value. For example, let' 
>s create an object named <code>myCar</code> and give it propertie 
>s named <code>make</code>, <code>model</code>, and <code>year</co 
>de> as follows: 
50    </p>
51    <p>
52      和其他javascript变量一样,对象的名字(可以是普通的变量)和属性的名字都是大小写敏感的。你可以在定义一个属性的37      <span style="line-height: 1.5;">和其他javascript变量一样,对象的名字(可以是
>时候就给它赋值。例如,我们创建一个myCar的对象然后给他三个属性,make,model,year。具体如下所示:>普通的变量)和属性的名字都是大小写敏感的。你可以在定义一个属性的时候就给它赋值。例如,我们创建一个myCar的对象然后给他三个属性
 >,make,model,year。具体如下所示:</span>
n58myCar.year = 1969;n43myCar.year = 1969; 
n61      Properties of JavaScript objects can also be accessed or sen46      JavaScript 对象的属性也可以通过方括号访问. 对象有时也被叫作关联数组, 因为每个属性都有一个用于访问它的字
>t using a bracket notation. Objects are sometimes called <em>asso>符串值。例如,你可以按如下方式访问 myCar 对象的属性:
>ciative arrays</em>, since each property is associated with a str 
>ing value that can be used to access it. So, for example, you cou 
>ld access the properties of the <code>myCar</code> object as foll 
>ows: 
n69      An object property name can be any valid JavaScript string,n54      一个对象的属性名可以是任何有效的 JavaScript 字符串,,或者可以被转换为字符串的任何东西,包括空字符串。然而
> or anything that can be converted to a string, including the emp>,一个属性的名称如果不是一个有效的 JavaScript 标识符(例如,一个有空格或短横线,或者以数字开头的属性名),就只能通过方
>ty string. However, any property name that is not a valid JavaScr>括号标记访问。这个标记法在属性名称是动态判定(属性名只有到运行时才能判定)时非常有用。例如:
>ipt identifier (for example, a property name that has space or da 
>sh, or starts with a number) can only be accessed using the squar 
>e bracket notation. This notation is also very useful when proper 
>ty names are to be dynamically determined (when the property name 
> is not determined until runtime). Examples are as follows: 
n87      You can also access properties by using a string value thatn72      你也可以通过存储在变量中的字符串来访问属性:
> is stored in a variable: 
n99      You can use the bracket notation with <a class="internal" hn84      <span style="line-height: 1.5;">你可以在&nbsp;</span><span styl
>ref="/zh-CN/docs/JavaScript/Guide/Statements#for...in_Statement" >e="line-height: 1.5;">&nbsp;</span><a class="internal" href="/zh-
>title="zh-CN/docs/JavaScript/Guide/Statements#for...in Statement">CN/docs/JavaScript/Guide/Statements#for...in_Statement" style="li
>>for...in</a> to iterate over all the enumerable properties of an>ne-height: 1.5;" title="zh-CN/docs/JavaScript/Guide/Statements#fo
> object. To illustrate how this works, the following function dis>r...in Statement">for...in</a><span style="line-height: 1.5;">&nb
>plays the properties of the object when you pass the object and t>sp;语句中使用方括号标记以枚举一个对象的所有属性。为了展示它如何工作,下面的函数当你将对象及其名称作为参数传入时,显示对象的属性
>he object's name as arguments to the function:>:</span>
n113      So, the function call <code>showProps(myCar, "myCar")</coden98      因而,对于函数调用&nbsp;<code>showProps(myCar, "myCar")</code>&nbsp;
>> would return the following:>将返回以下值:
n121      Object everythingn106      对象即就全部
n124      In JavaScript, almost everything is an object. All primitivn109      在 JavaScript 中,几乎所有的东西都是对象。所有的原生类型除了 <code>null</code> 与 <c
>e types except <code>null</code> and <code>undefined</code> are t>ode>undefined</code> 之外都被当作对象。它们可以被赋予属性(某些类型的被赋予的属性不能被持久化),并且它们都有
>reated as objects. They can be assigned properties (assigned prop>对象的全部特征。
>erties of some types are not persistent), and they have all chara 
>cteristics of objects. 
n127      Enumerating all properties of an objectn112      枚举一个对象的所有属性
n130      Starting with <a href="/zh-CN/docs/JavaScript/ECMAScript_5_n115      从&nbsp;<a href="/zh-CN/docs/JavaScript/ECMAScript_5_support
>support_in_Mozilla" title="zh-CN/docs/JavaScript/ECMAScript 5 sup>_in_Mozilla" title="zh-CN/docs/JavaScript/ECMAScript 5 support in
>port in Mozilla">ECMAScript 5</a>, there are three native ways to> Mozilla">ECMAScript 5</a>&nbsp;开始有三种原生的方法用于列出或枚举对象的属性:
> list/traverse object properties: 
n134        <a href="/zh-CN/docs/JavaScript/Reference/Statements/for.n119        <a href="/zh-CN/docs/JavaScript/Reference/Statements/for.
>..in" title="zh-CN/docs/JavaScript/Reference/Statements/for...in">..in" title="zh-CN/docs/JavaScript/Reference/Statements/for...in"
>>for...in</a> loops<br>>>for...in</a>&nbsp;循环<br>
135        This method traverses all enumerable properties of an obj120        该方法依次访问一个对象及其原型链中所有可枚举的属性。
>ect and its prototype chain 
n139        This method returns an array with all the own (not in then124        该方法返回一个对象 <code>o</code> 自身包含(不包括原型中)的所有属性的名称的数组。
> prototype chain) enumerable properties names ("keys") of an obje 
>ct <code>o</code>. 
n143        This method returns an array containing all own propertien128        该方法返回一个数组,它包含了对象 <code>o</code> 所有拥有的属性(无论是否可枚举)的名称。
>s names (enumerable or not) of an object <code>o</code>. 
n147      In ECMAScript 5, there is no native way to list all propertn132      在 ECMAScript 5 中,没有原生的方法枚举一个对象的所有属性。然而,可以通过以下函数完成:
>ies of an object. However, this can be achieved with the followin 
>g function: 
n162      This can be useful to reveal "hidden" properties (propertien147      这在展示 “隐藏”(在原型中的不能通过对象访问的属性,因为另一个同名的属性存在于原型链的早期)的属性时很有用。可以通过
>s in the prototype chain which are not accessible through the obj>在数组中去除同名元素即可轻松地列出访问的属性。
>ect, because another property has the same name earlier in the pr 
>ototype chain). Listing accessible properties only can easily be  
>done by removing duplicates in the array. 
n165      Creating new objectsn150      创建新对象
n168      JavaScript has a number of predefined objects. In addition,n153      JavaScript 拥有一系列预定义的对象。另外,你可以创建你自己的对象。从 &nbsp;JavaScript 1.
> you can create your own objects. In JavaScript 1.2 and later, yo>2 之后,你可以通过对象初始化器(Object Initializer)创建对象。或者你可以创建一个构造函数并使用该函数和 new
>u can create an object using an object initializer. Alternatively> 操作符初始化对象。
>, you can first create a constructor function and then instantiat 
>e an object using that function and the <code>new</code> operator 
>. 
n171      Using object initializersn156      使用对象初始化器
172    </h3>
173    <p>157    </h3>
174      In addition to creating objects using a constructor functio
>n, you can create objects using an object initializer. Using obje 
>ct initializers is sometimes referred to as creating objects with 
> literal notation. "Object initializer" is consistent with the te 
>rminology used by C++. 
175    </p>158    <p>
159      除了通过构造函数创建对象之外,你也可以通过对象初始化器创建对象。使用对象初始化器也被称作通过字面值创建对象。对象初始化
 >器与 C++ 术语相一致。
176    <p>160    </p>
177      The syntax for an object using an object initializer is:161    <p>
162      通过对象初始化器创建对象的语法如下:
n186      where <code>obj</code> is the name of the new object, each n171      这里 <code>obj</code> 是新对象的名称,每一个&nbsp;<code>property_<em>i</
><code>property_<em>i</em></code> is an identifier (either a name,>em></code>&nbsp;是一个标识符(可以是一个名称、数字或字符串字面量),并且每个&nbsp;<code>value_<
> a number, or a string literal), and each <code>value_<em>i</em><>em>i</em></code>&nbsp;是一个其值将被赋予&nbsp;<span style="line-height: 1.
>/code> is an expression whose value is assigned to the <code>prop>5; font-family: 'Courier New', 'Andale Mono', monospace;">propert
>erty_<em>i</em></code>. The <code>obj</code> and assignment is op>y_</span><em style="line-height: 1.5; font-family: 'Courier New',
>tional; if you do not need to refer to this object elsewhere, you> 'Andale Mono', monospace;">i</em> <span style="line-height: 1.5;
> do not need to assign it to a variable. (Note that you may need >">的表达式。</span><code style="font-style: normal; line-height: 1.5;"
>to wrap the object literal in parentheses if the object appears w>>obj</code><span style="line-height: 1.5;">&nbsp;与赋值是可选的;如果你不需要在其
>here a statement is expected, so as not to have the literal be co>他地方引用对象,你就不需要将它赋给一个变量。(注意在接受一条语句的地方,你可能需要将对象字面量括在括号里,从而避免将字面量与块语句
>nfused with a block statement.)>相混淆)</span>
187    </p>
188    <p>172    </p>
189      If an object is created with an object initializer in a top
>-level script, JavaScript interprets the object each time it eval 
>uates an expression containing the object literal. In addition, a 
>n initializer used in a function is created each time the functio 
>n is called. 
190    </p>173    <p>
174      如果一个对象是通过在顶级脚本的对象初始化器创建的,则 JavaScript 在每次遇到包含该对象字面量的表达式时都会创
 >建对象。同样的,在函数中的初始化器在每次函数调用时也会被创建。
191    <p>175    </p>
192      The following statement creates an object and assigns it to176    <p>
> the variable <code>x</code> if and only if the expression <code> 
>cond</code> is true. 
177      下面的语句只有当 <code>cond</code> 表达式的值为 <code>true</code> 时创建对象并将
 >其赋给变量 <code>x</code>。
n198      The following example creates <code>myHonda</code> with thrn183      下例创建了有三个属性的&nbsp;<code>myHonda</code>&nbsp;对象。注意它的&nbsp;<co
>ee properties. Note that the <code>engine</code> property is also>de>engine</code>&nbsp;属性也是一个拥有自己属性的对象。
> an object with its own properties. 
n204      You can also use object initializers to create arrays. See n189      你也可以用对象初始化器来创建数组。参见 {{ web.link("Values%2C_variables%2C_and
>{{ web.link("Values%2C_variables%2C_and_literals#Array_literals",>_literals#Array_literals", "array literals") }}.
> "array literals") }}. 
205    </p>
206    <p>190    </p>
207      In JavaScript 1.1 and earlier, you cannot use object initia191    <p>
>lizers. You can create objects only using their constructor funct 
>ions or using a function supplied by some other object for that p 
>urpose. See {{ anch("Using a constructor function") }}. 
192      在 JavaScript 1.1 及更早版本中,你不能使用对象初始化器。你只能通过使用构造函数或其他对象的函数来创建对
 >象。参见 {{ anch("Using a constructor function") }}.
n210      Using a constructor functionn195      使用构造函数
211    </h3>
212    <p>196    </h3>
213      Alternatively, you can create an object with these two step197    <p>
>s: 
198      作为另一种方式,你可以通过两步来创建对象:
n216      <li>Define the object type by writing a constructor function201      <li>通过创建一个构造函数来定义对象的类型。首字母大写是非常普遍而且很恰当的惯用法。
>n. There is a strong convention, with good reason, to use a capit 
>al initial letter. 
n218      <li>Create an instance of the object with <code>new</code>.n203      <li>通过&nbsp;<code>new 创建对象实例。</code>
n222      To define an object type, create a function for the object n207      为了定义对象类型,为对象类型创建一个函数以声明类型的名称、属性和方法。例如,你想为汽车创建一个类型,并且将这类对象称为
>type that specifies its name, properties, and methods. For exampl> <code>car</code>&nbsp;,并且拥有属性 make, model, 和 year,你可以创建如下的函数:
>e, suppose you want to create an object type for cars. You want t 
>his type of object to be called <code>car</code>, and you want it 
> to have properties for make, model, and year. To do this, you wo 
>uld write the following function: 
n232      Notice the use of <code>this</code> to assign values to then217      注意通过使用 this 将传入函数的值赋给对象的属性。
> object's properties based on the values passed to the function. 
233    </p>
234    <p>218    </p>
235      Now you can create an object called <code>mycar</code> as f219    <p>
>ollows: 
220      现在你可以象这样创建一个 <code>mycar</code> 对象:
n241      This statement creates <code>mycar</code> and assigns it thn226      该创建了 <code>mycar 并且将指定的值赋给它的属性。因而 mycar.make 的值是字符串 "Eagle"
>e specified values for its properties. Then the value of <code>my>, mycar.year 的值是整数 1993,依此类推。</code>
>car.make</code> is the string "Eagle", <code>mycar.year</code> is 
> the integer 1993, and so on. 
242    </p>
243    <p>227    </p>
244      You can create any number of <code>car</code> objects by ca228    <p>
>lls to <code>new</code>. For example, 
229      你可以通过调用 <code>new</code> 创建任意数量的 <code>car</code> 对象。例如:
n251      An object can have a property that is itself another objectn236      一个对象的属性值可以是另一个对象。例如,假设你按如下方式定义了&nbsp;<code>person</code>&nb
>. For example, suppose you define an object called <code>person</>sp;对象:
>code> as follows: 
n261      and then instantiate two new <code>person</code> objects asn246      然后按如下方式创建了两个&nbsp;<code>person</code> 实例:
> follows: 
n268      Then, you can rewrite the definition of <code>car</code> ton253      那么,你可以重写&nbsp;<code>car</code>&nbsp;的定义以包含一个拥有它的&nbsp;<code
> include an <code>owner</code> property that takes a <code>person>>owner</code>&nbsp;属性,如:
></code> object, as follows: 
n279      To instantiate the new objects, you then use the following:n264      你可以按如下方式创建新对象:
n286      Notice that instead of passing a literal string or integer n271      注意在创建新对象时,上面的语句将 <code>rand</code> 和 <code>ken</code> 作为 <c
>value when creating the new objects, the above statements pass th>ode>owner</code> 的参数值,而不是传入字符串字面量或整数值。接下来你如果想找出 car2 的拥有者的姓名,你可以访
>e objects <code>rand</code> and <code>ken</code> as the arguments>问如下属性:
> for the owners. Then if you want to find out the name of the own 
>er of car2, you can access the following property: 
n292      Note that you can always add a property to a previously defn277      注意你总是可以为之前定义的对象增加新的属性。例如,语句
>ined object. For example, the statement 
n298      adds a property <code>color</code> to car1, and assigns it n283      为 <code>car1</code> 增加了&nbsp;<code>color</code>&nbsp;属性,并将其
>a value of "black." However, this does not affect any other objec>值设为 "black." 然而,这并不影响其他的对象。想要为某个类型的所有对象增加新属性,你必须将属性加入到 <code>car<
>ts. To add the new property to all objects of the same type, you >/code> 对象类型的定义中。
>have to add the property to the definition of the <code>car</code 
>> object type. 
n301      Using the Object.create methodn286      使用 Object.create 方法
302    </h3>
303    <p>287    </h3>
304      Objects can also be created using the <code>Object.create</288    <p>
>code> method. This method can be very useful, because it allows y 
>ou to choose the prototype object for the object you want to crea 
>te, without having to define a constructor function. For more det 
>ailed information on the method and how to use it, see {{ web.lin 
>k("/zh-CN/docs/JavaScript/Reference/Global_Objects/Object/create" 
>, "Object.create method") }} 
289      对象也可以用&nbsp;<code>Object.create</code>&nbsp;方法创建。该方法非常有用,因为
 >它允许你为创建的对象选择其原型对象,而不用定义一个构造函数。该函数更多的信息及详细用法,参见 {{ web.link("/zh-C
 >N/docs/JavaScript/Reference/Global_Objects/Object/create", "Objec
 >t.create method") }}
n307      Inheritancen292      继承
308    </h3>
309    <p>293    </h3>
310      All objects in JavaScript inherit from at least one other o294    <p>
>bject. The object being inherited from is known as the prototype, 
> and the inherited properties can be found in the <code>prototype 
></code> object of the constructor. 
295      所有的 JavaScript 对象继承于至少一个对象。被继承的对象被称作原型,并且继承的属性可能通过构造函数的 <co
 >de>prototype</code> 对象找到。
n313      Indexing object propertiesn298      对象属性索引
314    </h3>
315    <p>299    </h3>
316      In JavaScript 1.0, you can refer to a property of an object
> either by its property name or by its ordinal index. In JavaScri 
>pt 1.1 and later, however, if you initially define a property by  
>its name, you must always refer to it by its name, and if you ini 
>tially define a property by an index, you must always refer to it 
> by its index. 
317    </p>300    <p>
301      在 JavaScript 1.0 中,你可以通过名称或序号访问一个属性。但是在 JavaScript 1.1 及之后版
 >本中,如果你最初使用名称定义了一个属性,则你必须通过名称来访问它;而如果你最初使用序号来定义一个属性,则你必须通过索引来访问它。
318    <p>302    </p>
319      This restriction applies when you create an object and its 
>properties with a constructor function (as we did previously with 
> the <code>Car</code> object type) and when you define individual 
> properties explicitly (for example, <code>myCar.color = "red"</c 
>ode>). If you initially define an object property with an index,  
>such as <code>myCar[5] = "25 mpg"</code>, you can subsequently re 
>fer to the property only as <code>myCar[5]</code>. 
320    </p>303    <p>
304      这个限制发生在你通过构造函数创建一个对象和它的属性(就象我们之前通过 <code>Car</code> 对象类型所做的
 >那样)并且显式地定义了单独的属性(如 m<span style="font-family: 'Courier New', 'And
 >ale Mono', monospace; line-height: 1.5;">yCar.color = "red")</spa
 >n><span style="line-height: 1.5;">之时。如果你最初使用索引定义了一个对象属性,例如 <code>
 >myCar[5] = "25"</code>,则你之可只能通过 <code>myCar[5]</code> 引用它。</span>
321    <p>305    </p>
322      The exception to this rule is objects reflected from HTML, 
>such as the <code>forms</code> array. You can always refer to obj 
>ects in these arrays by either their ordinal number (based on whe 
>re they appear in the document) or their name (if defined). For e 
>xample, if the second <code>&lt;FORM&gt;</code> tag in a document 
> has a <code>NAME</code> attribute of "myForm", you can refer to  
>the form as <code>document.forms[1]</code> or <code>document.form 
>s["myForm"]</code> or <code>document.myForm</code>. 
323    </p>306    <p>
324    <h3 id="Defining_properties_for_an_object_type">307      <span style="line-height: 1.5;">这条规则的例外是从与HTML对应的对象,例如 <cod
 >e>forms</code> 数组。对于这些数组的元素,你总是既可以通过其序号(依据其在文档中出现的顺序),也可以按照其名称(如果
 >有的话)访问它。举例而言,如果文档中的第二个 <code>&lt;form&gt;</code>&nbsp;标签有一个 <code
 >>NAME</code> 属性且值为 <code>"myForm",访问该 form 的方式可以是 document.forms[
 >1],document.forms["myForm"]或 document.myForm。</code></span>
325      Defining properties for an object type
326    </h3>
327    <p>308    </p>
328      You can add a property to a previously defined object type 309    <p>
>by using the <code>prototype</code> property. This defines a prop 
>erty that is shared by all objects of the specified type, rather  
>than by just one instance of the object. The following code adds  
>a <code>color</code> property to all objects of type <code>car</c 
>ode>, and then assigns a value to the <code>color</code> property 
> of the object <code>car1</code>. 
310      <span style="font-size: 1.7142857142857142rem; letter-spaci
 >ng: -0.5px; line-height: 24px;">为对象类型定义属性</span>
311    </p>
312    <p>
313      你可以通过 <code>prototype</code> 属性为之前定义的对象类型增加属性。这为该类型的所有对象,而不
 >是仅仅一个对象增加了一个属性。下面的代码为所有类型为 <code>car</code> 的对象增加了 <code>color</c
 >ode> 属性,然后为对象 <code>car1</code> 的 <code>color</code> 属性赋值:
n335      See the <a href="/zh-CN/docs/JavaScript/Reference/Global_Obn320      参见<span style="line-height: 1.5;">&nbsp;</span><a href="/zh
>jects/Function/prototype" title="zh-CN/docs/JavaScript/Reference/>-CN/docs/JavaScript/Reference" style="line-height: 1.5; text-deco
>Global Objects/Function/prototype"><code>prototype</code> propert>ration: underline;" title="zh-CN/docs/JavaScript/Reference">JavaS
>y</a> of the <code>Function</code> object in the <a href="/zh-CN/>cript Reference</a><span style="line-height: 1.5;">&nbsp;中</span>
>docs/JavaScript/Reference" title="zh-CN/docs/JavaScript/Reference><span style="line-height: 1.5;">&nbsp;Function 对象的&nbsp;</span><a
>">JavaScript Reference</a> for more information.> href="/zh-CN/docs/JavaScript/Reference/Global_Objects/Function/p
 >rototype" style="line-height: 1.5;" title="zh-CN/docs/JavaScript/
 >Reference/Global Objects/Function/prototype"><code>prototype</cod
 >e>&nbsp;属性</a><span style="line-height: 1.5;">&nbsp;。</span>
n338      Defining methodsn323      定义方法
339    </h3>
340    <p>324    </h3>
341      A <em>method</em> is a function associated with an object, 325    <p>
>or, simply put, a method is a property of an object that is a fun 
>ction. Methods are defined the way normal functions are defined,  
>except that they have to be assigned as the property of an object 
>. Examples are: 
326      一个<em>方法</em>是关联到某个对象的函数,或者简单地说,一个方法是一个值为某个函数的对象属性。定义方法就象定义
 >普通的函数,除了它们必须被赋给对象的某个属性。例如:
n353      where <code>objectName</code> is an existing object, <code>n338      这里&nbsp;<code>objectName</code>&nbsp;是一个已经存在的函数,<code>metho
>methodname</code> is the name you are assigning to the method, an>dname</code>&nbsp;是方法的名称,而&nbsp;<code style="font-style: normal; 
>d <code>function_name</code> is the name of the function.>line-height: 1.5;">function_name</code><span style="line-height: 
 >1.5;">&nbsp;</span><span style="line-height: 1.5;">是函数的名称。</span>
354    </p>
355    <p>339    </p>
356      You can then call the method in the context of the object a340    <p>
>s follows: 
341      你可以在对象的上下文中象这样调用方法:
n362      You can define methods for an object type by including a men347      你可以在对象的构造函数中包含方法定义来<span style="line-height: 1.5;">为某个对象类型定
>thod definition in the object constructor function. For example, >义方法。例如,你可以为之前定义的 car 对象定义一个函数格式化并显示其属性:</span>
>you could define a function that would format and display the pro 
>perties of the previously-defined <code>car</code> objects; for e 
>xample, 
n372      where <code>pretty_print</code> is a function to display a n357      这里&nbsp;<code>pretty_print</code>&nbsp;是一个显示横线和一个字符串的函数。注意使
>horizontal rule and a string. Notice the use of <code>this</code>>用 this 指代方法所属的对象。
> to refer to the object to which the method belongs. 
373    </p>
374    <p>358    </p>
375      You can make this function a method of <code>car</code> by 359    <p>
>adding the statement 
360      你可以在对象定义中通过增加下述语句将这个函数变成 <code>car</code> 的方法:
n381      to the object definition. So, the full definition of <code>n366      因此,<code>car</code> 的完整定义看上去将是:
>car</code> would now look like 
n393      Then you can call the <code>displayCar</code> method for ean378      然后你可以按如下方式为每个对象调用 <code>displayCar</code>&nbsp;方法:
>ch of the objects as follows: 
n400      This produces the output shown in the following figure.n385      这样导致如下图所示的输出结果:
n409      Using <code>this</code> for object referencesn394      通过&nbsp;<code>this</code>&nbsp;引用对象
410    </h3>
411    <p>395    </h3>
412      JavaScript has a special keyword, <code>this</code>, that y396    <p>
>ou can use within a method to refer to the current object. For ex 
>ample, suppose you have a function called <code>validate</code> t 
>hat validates an object's <code>value</code> property, given the  
>object and the high and low values: 
397      JavaScript 有一个特殊的关键字&nbsp;<code>this</code>,它可以在方法中使用以指代当前对
 >象。例如,假设你有一个名为&nbsp;<code>validate</code>&nbsp;的函数,它根据给出的最大与最小值检查某
 >个对象的 <code>value</code> 属性:
n421      Then, you could call <code>validate</code> in each form elen406      然后,你可以在每个元素的 <code>onchange</code> 事件处理器中调用 <code>validate<
>ment's <code>onchange</code> event handler, using <code>this</cod>/code>,并通过 <code>this</code> 传入相应元素,代码如下:
>e> to pass it the element, as in the following example: 
n428      In general, <code>this</code> refers to the calling object n413      总的说来,&nbsp;<code>this</code>&nbsp;在一个方法中指调用的对象。
>in a method. 
429    </p>
430    <p>414    </p>
431      When combined with the <code>form</code> property, <code>th415    <p>
>is</code> can refer to the current object's parent form. In the f 
>ollowing example, the form <code>myForm</code> contains a <code>T 
>ext</code> object and a button. When the user clicks the button,  
>the value of the <code>Text</code> object is set to the form's na 
>me. The button's <code>onclick</code> event handler uses <code>th 
>is.form</code> to refer to the parent form, <code>myForm</code>. 
416      当与 <code>form</code> 属性一起使用时,<code>this</code> 可以指代当前对象的父窗体
 >。在下面的例子中,窗体 <code>myForm</code> 包含一个 <code>Text</code> 对象和一个按钮,当用
 >户点击按键,<code>Text</code> 对象的值被设为窗体的名称。按钮的 <code>onclick</code> 事件处
 >理器使用 <code>this.form</code> 以指代其父窗体,即 <code>myForm</code>。
n442      Defining getters and settersn427      定义 getter 与 setter
443    </h3>
444    <p>428    </h3>
445      A <em>getter</em> is a method that gets the value of a spec429    <p>
>ific property. A <em>setter</em> is a method that sets the value  
>of a specific property. You can define getters and setters on any 
> predefined core object or user-defined object that supports the  
>addition of new properties. The syntax for defining getters and s 
>etters uses the object literal syntax. 
430      一个&nbsp;<em>getter</em>&nbsp;是一个获取某个特定属性的值的方法。一个&nbsp;<em>s
 >etter</em>&nbsp;是一个设定某个属性的值的方法。你可以为预定义的或用户定义的对象定义 getter 和 setter
 > 以支持新增的属性。定义 getter 和 setter 的语法采用对象字面量语法。
n565      Deleting propertiesn550      删除属性
566    </h3>
567    <p>551    </h3>
568      You can remove a property by using the <code>delete</code> 552    <p>
>operator. The following code shows how to remove a property. 
553      你可以用&nbsp;<code>delete</code>&nbsp;操作符删除一个不是继承而来的属性。下面的例子说明
 >如何删除一个属性:
n580      You can also use <code>delete</code> to delete a global varn565      如果一个全局变量不是用 <code>var</code> 关键字声明的话,你也可以用&nbsp;<code>delet
>iable if the <code>var</code> keyword was not used to declare the>e</code>&nbsp;删除它:
> variable: 
t587      See <code>{{ web.link("Expressions_and_operators#delete", "t572      参见<code>{{ web.link("Expressions_and_operators#delete", "de
>delete") }}</code> for more information.>lete") }}</code>&nbsp;以获取更多信息。

返回历史