ECMAScript 5官方标准手册：2009年修订版

需积分: 9 21 浏览量更新于2024-08-02 收藏 3.38MB PDF 举报

《JavaScript标准手册》是ECMA国际在2009年4月发布的第五版官方文档，该手册详细规定了ECMAScript语言的规格和标准。ECMAScript（通常简称为JavaScript）是一种广泛应用于Web开发的脚本语言，特别是在客户端浏览器环境中，用于增强网页交互性和动态功能。该手册基于多种起源技术，旨在提供一个统一且权威的标准，确保JavaScript在不同平台和浏览器之间的兼容性。ECMA-262是该语言的标准规范，它定义了语法、数据类型、函数、对象模型、异常处理、DOM操作等一系列核心概念。这份候选草案可供开发者进行评审和评估，以了解新的语言特性和变化，比如在这一版本中可能出现的新特性或改进。值得注意的是，这份文档作为候选标准，其内容可能会有所调整。所有反馈意见应于2009年7月15日之前提交至ES5-feedback@Ecma-International.org，以便于进一步修订和完善。这表明JavaScript的发展是开放且持续的过程，它随着技术进步和市场需求不断进化。阅读《JavaScript标准手册》，开发者可以深入了解诸如严格模式、尾调用优化、let和const关键字（块级作用域变量）、箭头函数、Promise和Generator等现代JavaScript特性。同时，它还涵盖了对API的详细描述，如Date对象、Array方法、正则表达式等，这些都是构建高效、可维护的Web应用的基础。对于Web开发者而言，这份手册是深入学习和理解JavaScript语言的最佳资源，无论是初学者还是经验丰富的工程师，都可以从中受益匪浅。掌握标准手册中的内容，能够帮助开发者编写出兼容性强、性能优良的代码，同时也为未来的JavaScript发展提供了规范指导。

- 2 -

Some of the facilities of ECMAScript are similar to those used in other programming languages; in particular

Java, Self, and Scheme as described in:

 Gosling, James, Bill Joy and Guy Steele. The Java



Language Specification. Addison Wesley Publishing

Co., 1996.

 Ungar, David, and Smith, Randall B. Self: The Power of Simplicity. OOPSLA '87 Conference

Proceedings, pp. 227–241, Orlando, FL, October 1987.

 IEEE Standard for the Scheme Programming Language. IEEE Std 1178-1990.

4.1 Web Scripting

A web browser provides an ECMAScript host environment for client-side computation including, for

instance, objects that represent windows, menus, pop-ups, dialog boxes, text areas, anchors, frames, history,

cookies, and input/output. Further, the host environment provides a means to attach scripting code to events

such as change of focus, page and image loading, unloading, error and abort, selection, form submission,

and mouse actions. Scripting code appears within the HTML and the displayed page is a combination of

user interface elements and fixed and computed text and images. The scripting code is reactive to user

interaction and there is no need for a main program.

A web server provides a different host environment for server-side computation including objects

representing requests, clients, and files; and mechanisms to lock and share data. By using browser -side and

server-side scripting together, it is possible to distribute computation between the client and server while

providing a customised user interface for a Web-based application.

Each Web browser and server that supports ECMAScript supplies its own host environment, completing the

ECMAScript execution environment.

4.2 Language Overview

The following is an informal overview of ECMAScript—not all parts of the language are described. This

overview is not part of the standard proper.

ECMAScript is object-based: basic language and host facilities are provided by objects, and an

ECMAScript program is a cluster of communicating objects. An ECMAScript object is a collection of

properties each with zero or more attributes that determine how each property can be used—for example,

when the Writable attribute for a property is set to false, any attempt by executed ECMAScript code to

change the value of the property fails. Properties are containers that hold other objects, primitive values, or

methods. A primitive value is a member of one of the following built-in types: Undefined, Null, Boolean,

Number, and String; an object is a member of the remaining built-in type Object; and a method is a

function associated with an object via a property.

ECMAScript defines a collection of built-in objects that round out the definition of ECMAScript entities.

These built-in objects include the Global object, the Object object, the Function object, the Array object,

the String object, the Boolean object, the Number object, the Math object, the Date object, the RegExp

object, the JSON object, and the Error objects Error, EvalError, RangeError, ReferenceError,

SyntaxError, TypeError and URIError.

ECMAScript also defines a set of built-in operators. ECMAScript operators include various unary

operations, multiplicative operators, additive operators, bitwise shift operators, relational operators,

equality operators, binary bitwise operators, binary logical operators, assignment operators, and the comma

operator.

ECMAScript syntax intentionally resembles Java syntax. ECMAScript syntax is relaxed to enable it to

serve as an easy-to-use scripting language. For example, a variable is not required to have its type declared

nor are types associated with properties, and defined functions are not required to have their declarations

appear textually before calls to them.

4.2.1 Objects

ECMAScript does not contain classes such as those in C++, Smalltalk, or Java. Instead objects may be

created in various ways including via a literal notation or via constructors which create objects by

executing code that allocates storage for the objects and initialises all or part of them by assigning initial

values to their properties. Each constructor has a property named ―prototype‖ that is used to

- 3 -

implement prototype-based inheritance and shared properties. Objects are created by using constructors

in new expressions; for example, new Date(2009,11) creates a new Date object. Invoking a

constructor without using new has consequences that depend on the constructor. For example, Date()

produces a string representation of the current date and time rather than an object.

ECMAScript supports prototype-based inheritance. Every object created by a constructor has an implicit

reference (called the object‘s prototype) to the value of its constructor‘s ―prototype‖ property.

Furthermore, a prototype may have a non-null implicit reference to its prototype, and so on; this is called

the prototype chain. When a reference is made to a property in an object, that reference is to the property

of that name in the first object in the prototype chain that contains a property of that name. In other

words, first the object mentioned directly is examined for such a property; if that object contains the

named property, that is the property to which the reference refers; if that object does not contain the

named property, the prototype for that object is examined next; and so on.

In a class-based object-oriented language, in general, state is carried by instances, methods are carried by

classes, and inheritance is only of structure and behaviour. In ECMAScript, the state and methods are

carried by objects, and structure, behaviour, and state are all inherited.

All objects that do not directly contain a particular property that their prototype contains share that

property and its value. The following diagram illustrates this:

CF is a constructor (and also an object). Five objects have been created by using new expressions: cf

, cf

, and cf

. Each of these objects contains properties named q1 and q2. The dashed lines

represent the implicit prototype relationship; so, for example, cf

‘s prototype is CF

. The constructor,

CF, has two properties itself, named P1 and P2, which are not visible to CF

, cf

, or cf

. The

property named CFP1 in CF

is shared by cf

, cf

, and cf

(but not by CF), as are any properties

found in CFp‘s implicit prototype chain that are not named q1, q2, or CFP1. Notice that there is no

implicit prototype link between CF and CF

Unlike class-based object languages, properties can be added to objects dynamically by assigning values

to them. That is, constructors are not required to name or assign values to all or any of the constructed

object‘s properties. In the above diagram, one could add a new shared property for cf

, cf

, and

by assigning a new value to the property in CF

4.2.2 The Strict Variant of ECMAScript

The ECMAScript Language recognizes the possibility that some users of the language may wish to

restrict their usage of some features available in the language. They might do so in the interests of

security, to avoid what they consider to be error prone features, to get enhanced error checking, or for

CFP1

prototype

implicit prototype link

explicit prototype property

- 4 -

other reasons of their choosing. In support of this possibility, ECMAScript defines a strict variant of the

language. The strict variant of the language excludes some specific syntactic and semantic features of the

regular ECMAScript language and modifies the detailed semantics of some features. The strict variant

also specifies additional error conditions that must be reported by throwing error exceptions in situations

that are not specified as errors by the non-strict form of the language.

The strict variant of ECMAScript is commonly referred to as the strict mode of the language. Strict mode

selection and use of the strict mode syntax and semantics of ECMAScript is explicitly made at the level

of individual ECMAScript code units. Because strict mode is selected at the level of a syntactic code

unit, strict mode only imposes restrictions that have local effect within such a code unit. Strict mode

does not restrict or modify any aspect of the ECMAScript semantics that must operate consistently

across multiple code units. A complete ECMAScript program may be composed for both strict mode and

non-strict mode ECMAScript code units. In this case, strict mode only applies when actually executing

code that is defined within a strict mode code unit.

In order to conform to this specification, an ECMAScript implementation must implement both the full

unrestricted ECMAScript language and the strict mode variant of the ECMAScript language as defined

by this specification. In addition, an implementation must support the combination of unrestricted and

strict mode code units into a single composite program.

4.3 Definitions

The following are informal definitions of key terms associated with ECMAScript.

4.3.1 Type

A type is a set of data values as defined in section 8 of this specification.

4.3.2 Primitive Value

A primitive value is a member of one of the types Undefined, Null, Boolean, Number, or String. A

primitive value is a datum that is represented directly at the lowest level of the language implementation.

4.3.3 Object

An object is a member of the type Object. It is a collection of properties.

4.3.4 Constructor

A constructor is a Function object that creates and initialises objects. The value of a constructor‘s

―prototype‖ property is a prototype object that is used to implement inheritance and shared

properties.

4.3.5 Prototype

A prototype is an object used to implement structure, state, and behaviour inheritance in ECMAScript.

When a constructor creates an object, that object implicitly references the constructor‘s ―prototype‖

property for the purpose of resolving property references. The constructor‘s ―prototype‖ property can

be referenced by the program expression constructor.prototype, and properties added to an

object‘s prototype are shared, through inheritance, by all objects sharing the prototype. Alternatively, a

new object may be created with an explicitly specified prototype by using the Object.create built-in

function.

4.3.6 Native Object

A native object is any object supplied by an ECMAScript implementation independent of the host

environment. Standard native objects are defined in this specification. Some native objects are built-in;

others may be constructed during the course of execution of an ECMAScript program.

4.3.7 Built-in Object

A built-in object is any object supplied by an ECMAScript implementation, independent of the host

environment, which is present at the start of the execution of an ECMAScript program. Standard built-in

objects are defined in this specification, and an ECMAScript implementation may specify and define

others. Every built-in object is a native object. A built-in constructor is a built-in object that is also a

constructor.

- 5 -

4.3.8 Host Object

A host object is any object supplied by the host environment to complete the execution environment of

ECMAScript. Any object that is not native is a host object.

4.3.9 Undefined Value

The undefined value is a primitive value used when a variable has not been assigned a value.

4.3.10 Undefined Type

The type Undefined has exactly one value, called undefined.

4.3.11 Null Value

The null value is a primitive value that represents the null, empty, or non-existent reference.

4.3.12 Null Type

The type Null has exactly one value, called null.

4.3.13 Boolean Value

A boolean value is a primitive value that is a member of the type Boolean and is one of two unique

values, true and false.

4.3.14 Boolean Type

The type Boolean represents a logical entity and consists of exactly two unique values. One is called

true and the other is called false.

4.3.15 Boolean Object

A Boolean object is a member of the type Object and is an instance of the built-in Boolean object. That

is, a Boolean object is created by using the Boolean constructor in a new expression, supplying a

boolean as an argument. The resulting object has an implicit (unnamed) property that is the boolean. A

Boolean object can be coerced to a boolean value.

4.3.16 String Value

A string value is a primitive value that is a member of the type String and is a finite ordered sequence of

zero or more 16-bit unsigned integer values.

NOTE

Although each value usually represents a single 16-bit unit of UTF-16 text, the language does not place

any restrictions or requirements on the values except that they must be 16-bit unsigned integers.

4.3.17 String Type

The type String is the set of all string values.

4.3.18 String Object

A String object is a member of the type Object and is an instance of the built-in String object. That is, a

String object is created by using the String constructor in a new expression, supplying a string as an

argument. The resulting object has an implicit (unnamed) property that is the string. A String object can

be coerced to a string value by calling the String constructor as a function (15.5.1).

4.3.19 Number Value

A number value is a primitive value that is a member of the type Number and is a direct representation

of a number.

4.3.20 Number Type

The type Number is a set of primitive values representing numbers. In ECMAScript, the set of values

represents the double-precision 64-bit format IEEE 754 values including the special ―Not-a-Number‖

(NaN) values, positive infinity, and negative infinity.

4.3.21 Number Object

A Number object is a member of the type Object and is an instance of the built-in Number object. That

is, a Number object is created by using the Number constructor in a new expression, supplying a number

- 6 -

as an argument. The resulting object has an implicit (unnamed) property that is the number. A Number

object can be coerced to a number value by calling the Number constructor as a function (15.7.1).

4.3.22 Infinity

The primitive value Infinity represents the positive infinite number value. This value is a member of the

Number type.

4.3.23 NaN

The primitive value NaN represents the set of IEEE 754 ―Not-a-Number‖ values. This value is a member

of the Number type.

4.3.24 Function

A function is a member of the type Object that may be invoked as a subroutine. In addition to its named

properties, a function contains executable code and state that determine how it behaves when invoked. A

function‘s code may or may not be written in ECMAScript.

4.3.25 Built-in Function

A built-in function is a native function that is a built-in object of the language, such as parseInt and

Math.exp. An implementation may also provide implementation-dependent built-in functions that are

not described in this specification.

4.3.26 Property

A property is an association between a name and a value that is part of an object. Depending upon the

form of the property the value may be represented either directly as a data value (a primitive value, an

object, or a function) or indirectly by a pair of accessor functions.

4.3.27 Method

A method is a function that is the value of a property.

4.3.28 Attribute

An attribute is an internal value that defines some characteristic of a property.

4.3.29 Own Property

An own property of an object is a property that is directly present on that object.

4.3.30 Inherited Property

An inherited property is a property of an object that is not one of its own properties but is a property

(either own or inherited) of the object‘s prototype.

4.3.31 Built-in Method

A built-in method is any method that is a built-in function. Standard built-in methods are defined in this

specification, and an ECMAScript implementation may specify and define others. A built-in method is a

Built-in function.

剩余241页未读，继续阅读

wuxyun

粉丝: 1
资源: 1

ECMAScript 5官方标准手册：2009年修订版

JavaScript标准手册JavaScript标准手册

HTML+CSS+Javascript详细手册大全 含9个chm文档资料合集

Javascript 完全手册(PDF)

javascript学习手册十一：json

html,css,javascript手册chm

javascript学习手册

javascript学习手册十四：html dom——文档元素的操作（二）

HTML学习手册网页

w3c离线手册2023

w3c离线手册2019

最新资源

HTML+CSS+Javascript详细手册大全含9个chm文档资料合集