ECMAScript 3rd Edition标准：JavaScript语言规范

4星 · 超过85%的资源需积分: 50 81 浏览量更新于2024-07-28 收藏 704KB PDF 举报

ECMA-262, 3rd edition,全称为"ECMAScript Language Specification", 是于1999年12月发布的标准，由欧洲计算机协会（ECMA）制定。这个标准的主要目标是标准化信息和通信系统的编程语言，尤其聚焦于JavaScript（最初由Netscape的Brendan Eich开发，首次出现在Netscape Navigator 2.0浏览器中）和Microsoft的JScript。JavaScript随后被广泛应用于各类浏览器，包括Netscape的后续版本和Microsoft从Internet Explorer 3.0开始的所有产品。标准的开发始于1996年11月，经过多次迭代和完善，其第一版在1997年6月的ECMA全体大会上被采纳。该版本标志着JavaScript作为一门正式的ECMAScript标准的诞生，为浏览器环境下的脚本编程提供了统一的规则和语法。在1999年的3rd edition中，ECMA-262包含了对JavaScript语言的详细规定，包括数据类型、语法结构、函数、对象模型、控制流以及错误处理等方面。此外，它还概述了JavaScript的历史背景，强调了其与其他技术的关系，如与Netscape Navigator和Internet Explorer的集成，以及与ISO/IEC JTC1（国际标准化组织/国际电工委员会信息技术委员会）合作的过程，以期得到国际认可并加速标准化进程。这份标准对于理解JavaScript的核心特性和实现一致性至关重要，是开发人员、浏览器厂商、工具供应商和学术研究者必备的参考文档。它不仅定义了语言的基础，还为JavaScript语言的发展奠定了基础，对于后来的版本（如ES6、ES7等）有着深远的影响。随着浏览器技术的进步和JavaScript生态系统的发展，ECMAScript-262标准也经历了多次修订，以适应现代Web开发的需求。

-4-

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.

4.3.2 Primitive Value

A primitive value is a member of one of the types Undefined, Null, Boolean, Number,orString.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 an unordered collection of properties each of which

contains a primitive value, object, or function. A function stored in a property of an object is called a

method.

4.3.4 Constructor

A constructor is a Function object that creates and initialises objects. Each constructor has an associated

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 associated

prototype for the purpose of resolving property references. The constructor’s associated prototype 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.

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.

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

-5-

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

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 Standard “Not-a-Number” values. This value is a

member of the Number type.

-6-

5 Notational Conventions

5.1 Syntactic and Lexical Grammars

This section describes the context-free grammars used in this specification to define the lexical and

syntactic structure of an ECMAScript program.

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 the

characters of the Unicode character set. It defines a set of productions, starting from the goal symbol

InputElementDiv or InputElementRegExp, that describe how sequences of Unicode 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.8.5). 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 of the Unicode character set. It defines a set of productions, starting from the goal symbol

Pattern, that describe how sequences of Unicode 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

A second 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 the characters

of the Unicode character set. 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 Unicode 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 syntax 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.

-7-

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

The syntactic grammar as presented in sections 0, 0, 0 and 0 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.

5.1.5 Grammar Notation

Terminal symbols of the lexical and string grammars, and some of the terminal symbols of the syntactic

grammar, are shown in fixed width font, both in the productions of the grammars and throughout

this specification whenever the text directly refers to such a terminal symbol. These are to appear in a

program exactly as written. All nonterminal characters specified in this way are to be understood as the

appropriate Unicode character from the ASCII range, as opposed to any similar-looking characters from

other Unicode ranges.

Nonterminal symbols are shown in italic type. The definition of a nonterminal is introduced by the name

of the nonterminal being defined followed by one or more colons. (The number of colons indicates to

which grammar the production belongs.) One or more alternative right-hand sides for the nonterminal

then follow on succeeding lines. For example, the syntactic definition:

WithStatement :

with ( Expression ) Statement

states that the nonterminal WithStatement represents the token with, followed by a left parenthesis

token, followed by an Expression, followed by a right parenthesis token, followed by a Statement.The

occurrences of Expression and Statement are themselves nonterminals. As another example, the syntactic

definition:

ArgumentList :

AssignmentExpression

ArgumentList , AssignmentExpression

states that an ArgumentList may represent either a single AssignmentExpression or an ArgumentList,

followed by a comma, followed by an AssignmentExpression. This definition of ArgumentList is

recursive, that is, it is defined in terms of itself. The result is that an ArgumentList may contain any

positive number of arguments, separated by commas, where each argument expression is an

AssignmentExpression. Such recursive definitions of nonterminals are common.

The subscripted suffix “opt”, which may appear after a terminal or nonterminal, indicates an optional

symbol. The alternative containing the optional symbol actually specifies two right-hand sides, one that

omits the optional element and one that includes it. This means that:

VariableDeclaration :

Identifier Initialiser

opt

is a convenient abbreviation for:

VariableDeclaration :

Identifier

Identifier Initialiser

and that:

IterationStatement :

for ( ExpressionNoIn

opt

; Expression

opt

; Expression

opt

) Statement

is a convenient abbreviation for:

IterationStatement :

for(;Expression

opt

; Expression

opt

) Statement

for ( ExpressionNoIn ; Expression

opt

; Expression

opt

) Statement

-8-

whichinturnisanabbreviationfor:

IterationStatement :

for(;;Expression

opt

) Statement

for(;Expression ; Expression

opt

) Statement

for ( ExpressionNoIn ;;Expression

opt

) Statement

for ( ExpressionNoIn ; Expression ; Expression

opt

) Statement

whichinturnisanabbreviationfor:

IterationStatement :

for(;;)Statement

for(;;Expression ) Statement

for(;Expression ;)Statement

for(;Expression ; Expression ) Statement

for ( ExpressionNoIn ;;)Statement

for ( ExpressionNoIn ;;Expression ) Statement

for ( ExpressionNoIn ; Expression ;)Statement

for ( ExpressionNoIn ; Expression ; Expression ) Statement

so the nonterminal IterationStatement actually has eight alternative right-hand sides.

If the phrase “

[empty]” appears as the right-hand side of a production, it indicates that the production's

right-hand side contains no terminals or nonterminals.

If the phrase “

[lookahead ∉ set]” appears in the right-hand side of a production, it indicates that the

production may not be used if the immediately following input terminal is a member of the given set.

The set can be written as a list of terminals enclosed in curly braces. For convenience, the set can also be

written as a nonterminal, in which case it represents the set of all terminals to which that nonterminal

could expand. For example, given the definitions

DecimalDigit :: one of

0123456789

DecimalDigits ::

DecimalDigit

DecimalDigits DecimalDigit

the definition

LookaheadExample ::

[lookahead ∉ {1, 3, 5, 7, 9}] DecimalDigits

DecimalDigit

[lookahead ∉ DecimalDigit ]

matches either the letter n followed by one or more decimal digits the first of which is even, or a

decimal digit not followed by another decimal digit.

If the phrase “

[no LineTerminator here]” appears in the right-hand side of a production of the syntactic

grammar, it indicates that the production is a restricted production: it may not be used if a

LineTerminator occurs in the input stream at the indicated position. For example, the production:

ReturnStatement :

return

[no LineTerminator here] Expression

opt

;

indicates that the production may not be used if a LineTerminator occurs in the program between the

return token and the Expression.

Unless the presence of a LineTerminator is forbidden by a restricted production, any number of

occurrences of LineTerminator may appear between any two consecutive tokens in the stream of input

elements without affecting the syntactic acceptability of the program.

剩余187页未读，继续阅读

smiky

粉丝: 1
资源: 21

ECMAScript 3rd Edition标准：JavaScript语言规范

ECMA javascript corejava: ECMA-262, 3rd edition, 2rd 5rd edition。三个版本英文版.rar

ECMA-262 JavaScript 标准

ECMA-340 & ECMA-352 3rd_edition, 2013. ISO_IEC_18092 & ISO_IEC_21481

ecma-262.pdf下载

ECMA-262第六版

Content-Type:application/json是否是标准的http规范

javascript.API 官方文档

Error in v-on handler: "TypeError: Cannot read properties of undefined (reading 'materialId')

如何查看每年发布的EcmaScript有哪些新内容

最新资源