2011版ECMA-262 JavaScript语言规范详览

4星 · 超过85%的资源需积分: 15 156 浏览量更新于2024-07-28 收藏 2.93MB PDF 举报

ECMA Javascript 参考文档是标准ECMA-262的一部分，它详尽地定义了ECMAScript语言的规范。该文档由EcmaInternational发布，最新版本为第五版，出版日期为2011年6月。这份文档的核心内容围绕着JavaScript语言的关键特性、语法和API，是开发人员理解和实现JavaScript语言的基础。文档编号ECMA-123:2009表明这是一份早期的标准版本，而2009年版和2011年的版本之间可能存在显著的更新和改进。版权信息强调了文档的保护性质，用户在复制、分发或翻译时必须保留原始版权声明和相关条款，包括EcmaInternational的联系信息。 5.1版的"ECMAScript Language Specification"详细解释了变量声明、数据类型、控制结构（如循环、条件语句）、函数、对象和原型、以及异步编程等方面。这部分内容对开发者来说至关重要，因为它提供了如何正确编写符合标准的JavaScript代码的指导。值得注意的是，文档强调未经许可，不能随意修改文档本身，除非是为了开发由EcmaInternational生产的文档或交付物，或者为了将其翻译成非英语语言。这样的规定确保了信息的准确性和一致性，维护了标准化的权威性。对于那些深入研究和实践JavaScript编程的开发者来说，这份参考文档是不可或缺的工具，它不仅提供了语言的官方定义，还为了解决实际编程问题提供了权威依据。通过查阅和理解这份文档，开发者可以更好地遵循语言的最佳实践，提高代码质量，并确保其兼容性和可扩展性。

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

and its value. Figure 1 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 CF

‘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 cf

assigning a new value to the property in CF

4.2.2 The Strict Variant of ECMAScript

The ECMAScript Language recognises 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 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 Terms and definitions

For the purposes of this document, the following terms and definitions apply.

4.3.1

type

set of data values as defined in Clause 8 of this specification

4.3.2

primitive value

member of one of the types Undefined, Null, Boolean, Number, or String as defined in Clause 8

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

4.3.3

object

member of the type Object

NOTE An object is a collection of properties and has a single prototype object. The prototype may be the null value.

4.3.4

constructor

function object that creates and initialises objects

NOTE 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

object that provides shared properties for other objects

NOTE 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

object in an ECMAScript implementation whose semantics are fully defined by this specification rather than by

the host environment

NOTE 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

object supplied by an ECMAScript implementation, independent of the host environment, that is present at the

start of the execution of an ECMAScript program

NOTE 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.

4.3.8

host object

object supplied by the host environment to complete the execution environment of ECMAScript

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

4.3.9

undefined value

primitive value used when a variable has not been assigned a value

4.3.10

Undefined type

type whose sole value is the undefined value

4.3.11

null value

primitive value that represents the intentional absence of any object value

4.3.12

Null type

type whose sole value is the null value

4.3.13

Boolean value

member of the Boolean type

NOTE There are only two Boolean values, true and false.

4.3.14

Boolean type

type consisting of the primitive values true and false

4.3.15

Boolean object

member of the Object type that is an instance of the standard built-in Boolean constructor

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

value as an argument. The resulting object has an internal property whose value is the Boolean value. A Boolean object

can be coerced to a Boolean value.

4.3.16

String value

primitive value that is a finite ordered sequence of zero or more 16-bit unsigned integer

NOTE A String value is a member of the String type. Each integer value in the sequence usually represents a single

16-bit unit of UTF-16 text. However, ECMAScript does not place any restrictions or requirements on the values except that

they must be 16-bit unsigned integers.

4.3.17

String type

set of all possible String values

4.3.18

String object

member of the Object type that is an instance of the standard built-in String constructor

NOTE A String object is created by using the String constructor in a new expression, supplying a String value as

an argument. The resulting object has an internal property whose value is the String value. 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

primitive value corresponding to a double-precision 64-bit binary format IEEE 754 value

NOTE A Number value is a member of the Number type and is a direct representation of a number.

4.3.20

Number type

set of all possible Number values including the special ―Not-a-Number‖ (NaN) values, positive infinity, and

negative infinity

4.3.21

Number object

member of the Object type that is an instance of the standard built-in Number constructor

NOTE A Number object is created by using the Number constructor in a new expression, supplying a Number value

as an argument. The resulting object has an internal property whose value is the Number value. 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

number value that is the positive infinite Number value

4.3.23

NaN

number value that is a IEEE 754 ―Not-a-Number‖ value

4.3.24

function

member of the Object type that is an instance of the standard built-in Function constructor and that may be

invoked as a subroutine

NOTE 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

built-in object that is a function

NOTE Examples of built-in functions include parseInt and Math.exp. An implementation may provide

implementation-dependent built-in functions that are not described in this specification.

4.3.26

property

association between a name and a value that is a part of an object

NOTE 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 object) or indirectly by a pair of accessor functions.

4.3.27

method

function that is the value of a property

NOTE When a function is called as a method of an object, the object is passed to the function as its this value.

4.3.28

built-in method

method that is a built-in function

NOTE Standard built-in methods are defined in this specification, and an ECMAScript implementation may specify

and provide other additional built-in methods.

4.3.29

attribute

internal value that defines some characteristic of a property

4.3.30

own property

property that is directly contained by its object

4.3.31

inherited property

property of an object that is not an own property but is a property (either own or inherited) of the object‘s

prototype

5 Notational Conventions

5.1 Syntactic and Lexical Grammars

5.1.1 Context-Free Grammars

A context-free grammar consists of a number of productions. Each production has an abstract symbol called a

nonterminal as its left-hand side, and a sequence of zero or more nonterminal and terminal symbols as its

right-hand side. For each grammar, the terminal symbols are drawn from a specified alphabet.

Starting from a sentence consisting of a single distinguished nonterminal, called the goal symbol, a given

context-free grammar specifies a language, namely, the (perhaps infinite) set of possible sequences of

terminal symbols that can result from repeatedly replacing any nonterminal in the sequence with a right-hand

side of a production for which the nonterminal is the left-hand side.

5.1.2 The Lexical and RegExp Grammars

A lexical grammar for ECMAScript is given in clause 7. This grammar has as its terminal symbols characters

(Unicode code units) that conform to the rules for SourceCharacter defined in Clause 6. It defines a set of

productions, starting from the goal symbol InputElementDiv or InputElementRegExp, that describe how

sequences of such characters are translated into a sequence of input elements.

Input elements other than white space and comments form the terminal symbols for the syntactic grammar for

ECMAScript and are called ECMAScript tokens. These tokens are the reserved words, identifiers, literals, and

punctuators of the ECMAScript language. Moreover, line terminators, although not considered to be tokens,

also become part of the stream of input elements and guide the process of automatic semicolon insertion (7.9).

Simple white space and single-line comments are discarded and do not appear in the stream of input

elements for the syntactic grammar. A MultiLineComment (that is, a comment of the form ―/*…*/‖ regardless

of whether it spans more than one line) is likewise simply discarded if it contains no line terminator; but if a

MultiLineComment contains one or more line terminators, then it is replaced by a single line terminator, which

becomes part of the stream of input elements for the syntactic grammar.

A RegExp grammar for ECMAScript is given in 15.10. This grammar also has as its terminal symbols the

characters as defined by SourceCharacter. It defines a set of productions, starting from the goal symbol Pattern,

that describe how sequences of characters are translated into regular expression patterns.

Productions of the lexical and RegExp grammars are distinguished by having two colons ―::‖ as separating

punctuation. The lexical and RegExp grammars share some productions.

5.1.3 The Numeric String Grammar

Another grammar is used for translating Strings into numeric values. This grammar is similar to the part of the

lexical grammar having to do with numeric literals and has as its terminal symbols SourceCharacter. This

grammar appears in 9.3.1.

Productions of the numeric string grammar are distinguished by having three colons ―:::‖ as punctuation.

5.1.4 The Syntactic Grammar

The syntactic grammar for ECMAScript is given in clauses 11, 12, 13 and 14. This grammar has ECMAScript

tokens defined by the lexical grammar as its terminal symbols (5.1.2). It defines a set of productions, starting

from the goal symbol Program, that describe how sequences of tokens can form syntactically correct

ECMAScript programs.

When a stream of characters is to be parsed as an ECMAScript program, it is first converted to a stream of

input elements by repeated application of the lexical grammar; this stream of input elements is then parsed by

a single application of the syntactic grammar. The program is syntactically in error if the tokens in the stream

of input elements cannot be parsed as a single instance of the goal nonterminal Program, with no tokens left

over.

Productions of the syntactic grammar are distinguished by having just one colon ―:‖ as punctuation.

The syntactic grammar as presented in clauses 11, 12, 13 and 14 is actually not a complete account of which

token sequences are accepted as correct ECMAScript programs. Certain additional token sequences are also

accepted, namely, those that would be described by the grammar if only semicolons were added to the

sequence in certain places (such as before line terminator characters). Furthermore, certain token sequences

that are described by the grammar are not considered acceptable if a terminator character appears in certain

―awkward‖ places.

剩余257页未读，继续阅读

OmelasShell

粉丝: 5
资源: 76

2011版ECMA-262 JavaScript语言规范详览

ECMAScript中文最新(ECMA262)

ECMA2017官方文档-英文版

JavaScript参考手册中文版.doc

javascript帮助文档 参考技术

ECMA-262 JavaScript 标准

JavaScript帮助文档

javascript文档

javascript参考

JavaScript(ECMA262v5)

JavaScript帮助文档(中文)

最新资源

javascript帮助文档参考技术