ECMA-262英文版JavaScript语言规范详解

需积分: 15 156 浏览量更新于2024-07-25 收藏 2.93MB PDF 举报

ECMA-262标准规范，全称为"ECMAScript Language Specification"，是由Ecma International（欧洲计算机协会）制定的一套官方文档，用于定义JavaScript编程语言的语法规则、特性和行为。该标准的最新版本为第五版，发布于2011年6月，其编号为ECMA-262:2011。这份文档对于开发人员来说至关重要，它是理解JavaScript的基础，也是浏览器厂商实现兼容性、开发者遵循的标准依据。在ECMA-262中，章节5.1涵盖了该语言的核心特性，包括变量声明、数据类型、操作符、控制结构等关键概念。它详述了如何正确编写符合标准的JavaScript代码，以及处理错误和异常的机制。此外，文档还规定了版权保护，允许在未经修改的前提下，复制、分发和翻译这份规范，但必须保留原版的版权声明和相关条款，如禁止随意修改原规范，除非是为了开发Ecma International自身的产品或进行非商业性质的语言翻译。标准中的"Referencenumber ECMA-123:2009"可能是另一个相关的技术规格，它可能与ECMA-262有所关联，但具体内容并未在提供的部分中给出。对于不熟悉英语的读者，理解和掌握这个规范可能会有一定的挑战，因为它是英文版的，所以建议具备一定的英语基础或者借助翻译工具来查阅。 ECMA-262标准规范不仅是JavaScript开发者必备的学习资料，同时也是浏览器引擎和工具开发者的参考指南。熟悉并遵循这些规则，可以确保代码的可读性、可维护性和跨平台兼容性。对于那些希望深入研究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页未读，继续阅读

CN-Richard-He

粉丝: 1
资源: 6

ECMA-262英文版JavaScript语言规范详解

ECMA-262标准

ECMA-262官方规范

ECMA-262.pdf

Ecma-262.rar_ECMA-262_ECMAScript_javascript

Ecma-262规范

《ECMA-262》js标准-英文版

ECMA-262-5.1中文版

ECMA-262标准：JavaScript语言规范详析

ECMA-262 JavaScript 标准

Ecma标准Ecma-262.pdf

最新资源