1997年JavaScript首版标准：历史与概述

需积分: 9 21 浏览量更新于2024-07-19 收藏 318KB PDF 举报

JavaScript 1997年第一版标准API，即ECMAScript 1997标准，是由欧洲计算机制造商协会（ECMA）制定的一份通用、跨平台的编程语言规范。这份标准源于两个主要的技术基础：Netscape Communications的JavaScript™和Microsoft Corporation的JScript™。开发工作始于1996年11月，并在同年6月的ECMA全体会议上被采纳，随后提交给国际标准化组织/国际电工委员会的第一技术委员会（ISO/IEC JTC1），并采用了快速跟踪程序进行审议。标准的主要目标是标准化信息和通信系统的编程，为Web脚本编写提供了一套统一的规则。它定义了语言的核心特性，如对象模型和数据类型。以下是标准文档的一些关键部分： 1. **范围**：该部分概述了ECMAScript规范适用的领域，包括Web编程环境中的客户端脚本。 2. **符合性**：标准规定了开发者应如何实现与ECMAScript兼容的语言特性，以确保代码在各种平台上的一致性和互操作性。 3. **参考**：这部分列出了文档中引用的其他相关技术和标准，有助于读者进一步理解和应用。 4. **概述**： - **Web scripting**：介绍了JavaScript在网页交互中的角色，它是动态网页内容更新和用户交互的基础。 - **语言概述**：着重于语言的总体结构，包括其对象系统，强调了它是基于原型的、动态类型的语言。 - **对象**：详细解释了对象在ECMAScript中的概念，包括属性和方法，以及它们如何支持面向对象编程。 - **定义**：对关键字、数据类型（如null、undefined、基本类型和引用类型）等核心概念进行了明确的定义。这个1997年的标准为JavaScript的发展奠定了坚实的基础，虽然随着时间的推移，JavaScript经历了多次重大更新（如ES5, ES6, ES7, ES8等），但最初的标准API为后续版本的发展提供了语法和设计原则的指导。理解这些早期的标准对于研究JavaScript的历史演变和学习其底层原理至关重要。

- 4 -

4.3.4 Constructor

A constructor is a function object which creates and initializes objects. Each constructor has an associated

prototype object which is used to implement inheritance and shared properties.

4.3.5 Prototype

A prototype is an object used to implement structure, state, and behavior 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, that is present at the start of the execution of an ECMAScript program. Standard built-in objects are

defined in this specification, and the 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

Undefined 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

Null is a primitive value that represents the null, empty, or nonexistent 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 either 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 Boolean object which is a constructor.

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 which is the boolean. A boolean object can

be coerced to a boolean value. A boolean object can be used anywhere a boolean value is expected.

This is an example of one of the conveniences built into ECMAScript—in this case it is to accommodate

programmers of varying backgrounds. Those familiar with imperative or procedural programming languages may

find number values more natural, while those familiar with object-oriented languages may find number objects

more intuitive.

4.3.16 String value

A string value is a member of the type String and is the set of all finite ordered sequences of zero or more

Unicode characters.

- 5 -

4.3.17 String type

The type String is the set of all finite ordered sequences of zero or more Unicode characters.

4.3.18 String object

A string object is a member of the type Object and is an instance of the String object which is a constructor. 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 which is the string. A string object can be

coerced to a string value. A string object can be used anywhere a string value is expected.

4.3.19 Number value

A number value 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 represent the double-

precision 64-bit format IEEE 754 value along with a special “Not-a-Number” (NaN) value, 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 Number object which is a constructor.

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 which is the number. A number object can

be coerced to a number value. A number object can be used anywhere a number value is expected. Note that a

number object can have shared properties by adding them to the Number prototype.

4.3.22 Infinity

The primitive value

Infinity

represents the positive infinite number value.

4.3.23 NaN

The primitive value NaN represents the set of IEEE Standard “Not-a-Number” values.

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

A lexical grammar for ECMAScript is given in Section 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 Input, 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 (see section

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

elements for the syntactic grammar. A multi-line comment is likewise simply discarded if it contains no line

- 6 -

terminator; but if a multi-line comment 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.

Productions of the lexical grammar are distinguished by having two colons “::” as separating punctuation.

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 section 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 Sections 11, 12, 13, and 14. This grammar has ECMAScript

tokens defined by the lexical grammar as its terminal symbols (see section 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.

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

The syntactic grammar as presented in Sections 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 end-of-line characters). Furthermore, certain token sequences that are described

by the grammar are not considered acceptable if an end-of-line 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.

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 to say, 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:

- 7 -

VariableDeclaration :

Identifier Initializer

opt

is a convenient abbreviation for:

VariableDeclaration :

Identifier

Identifier Initializer

and that:

IterationStatement :

for (

Expression

opt

;

Expression

opt

;

Expression

opt

)

Statement

is a convenient abbreviation for:

IterationStatement :

for ( ;

Expression

opt

;

Expression

opt

)

Statement

for (

Expression ;

Expression

opt

;

Expression

opt

)

Statement

which in turn is an abbreviation for:

IterationStatement :

for ( ; ;

Expression

opt

)

Statement

for ( ;

Expression ;

Expression

opt

)

Statement

for (

Expression ; ;

Expression

opt

)

Statement

for (

Expression ;

Expression

opt

)

Statement

which in turn is an abbreviation for:

IterationStatement :

for ( ; ; ) Statement

for ( ; ; Expression ) Statement

for ( ; Expression ; ) Statement

for ( ; Expression ;

Expression

) Statement

for (

Expression

; ; ) Statement

for (

Expression

; ;

Expression

) Statement

for ( Expression ; Expression ; ) Statement

for ( Expression ; Expression ;

Expression

) Statement

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

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.

When the words “one of” follow the colon(s) in a grammar definition, they signify that each of the terminal

symbols on the following line or lines is an alternative definition. For example, the lexical grammar for

ECMAScript contains the production:

- 8 -

ZeroToThree :: one of

0123

which is merely a convenient abbreviation for:

ZeroToThree ::

When an alternative in a production of the lexical grammar or the numeric string grammar appears to be a

multicharacter token, it represents the sequence of characters that would make up such a token.

The right-hand side of a production may specify that certain expansions are not permitted by using the phrase

“but not” and then indicating the expansions to be excluded. For example, the production:

Identifier ::

IdentifierName but not ReservedWord

means that the nonterminal Identifier may be replaced by any sequence of characters that could replace

IdentifierName provided that the same sequence of characters could not replace ReservedWord.

Finally, a few nonterminal symbols are described by a descriptive phrase in roman type in cases where it would

be impractical to list all the alternatives:

SourceCharacter:

any Unicode character

5.2 Algorithm conventions

We often use a numbered list to specify steps in an algorithm. These algorithms are used to clarify semantics. In

practice, there may be more efficient algorithms available to implement a given feature.

When an algorithm is to produce a value as a result, we use the directive “return x” to indicate that the result of the

algorithm is the value of x and that the algorithm should terminate. We use the notation Result(n) as shorthand for

“the result of step n”. We also use Type(x) as shorthand for “the type of x”.

Mathematical operations such as addition, subtraction, negation, multiplication, division, and the mathematical

functions defined later in this section should always be understood as computing exact mathematical results on

mathematical real numbers, which do not include infinities and do not include a negative zero that is distinguished

from positive zero. Algorithms in this standard that model floating-point arithmetic include explicit steps, where

necessary, to handle infinities and signed zero and to perform rounding. If a mathematical operation or function is

applied to a floating-point number, it should be understood as being applied to the exact mathematical value

represented by that floating-point number; such a floating-point number mustbe finite, and if it is +0 or −0 then the

corresponding mathematical value is simply 0.

The mathematical function abs(x) yields the absolute value of x, which is −x if x is negative (less than zero) and

otherwise is x itself.

The mathematical function sign(x) yields 1 if x is positive and −1 if x is negative. The sign function is not used in

this standard for cases when x is zero.

The notation “x modulo y” (y must be finite and nonzero) computes a value k of the same sign as y such that abs(k)

< abs(y) and x−k = q⋅y for some integer q.

The mathematical function floor(x) yields the largest integer (closest to positive infinity) that is not larger than x.

Note that floor(x) = x−(x modulo 1).

If an algorithm is defined to “generate a runtime error”, execution of the algorithm (and any calling algorithms) is

terminated and no result is returned.

剩余109页未读，继续阅读

骑着扫把爬山

粉丝: 0
资源: 39

1997年JavaScript首版标准：历史与概述

JavaScript and jQuery

JavaScript快速入门.docx

javascript：javascript学习指南

JavaScript基础入门

高级软件人才培训专家-day02-JavaScript-Vue

html发展历程及各版本主要特点

ECMAScript语言规范：基于JavaScript和JScript的3rd版标准

ECMAScript：Javascript的历史与发展

JavaScript语言概述：从历史到应用

JavaScript语言深度解析：从入门到高级

最新资源