ECMAScript for XML (E4X)规范：简化XML编程模型

需积分: 10 91 浏览量更新于2024-08-02 收藏 1.81MB PDF 举报

ECMA-357规范英文文档是关于ECMAScript for XML (E4X) 的第二版标准，发布于2005年12月。该标准由BEA Systems领导的一群公司提出，旨在为ECMAScript（JavaScript的核心语言）增加原生的XML支持，以提供一种简单、熟悉的通用XML编程模型。E4X的设计目标是利用JavaScript社区已有的技能和知识，降低学习曲线，简化代码编写，加快开发速度，减少XML资源的需求，并实现代码与XML数据的更松散耦合。在2002年6月13日，Ecma TC39-TG1（ECMAScript标准化小组）一致同意接受这个提案，并成立了专门小组来标准化这些扩展的语法和语义。这个被称为ECMA-357的标准化工作致力于创建一个跨平台、供应商中立的编程语言扩展集，它能够无缝融入到JavaScript环境中，使得开发者能够更高效地处理XML数据，无论是DOM操作还是XPath表达式，都能在JavaScript中以自然的方式实现。 E4X的引入使得JavaScript能够直接操作XML文档，无需通过繁琐的解析过程，提高了代码的可读性和性能。这对于构建富客户端应用、Web服务交互以及XML驱动的数据处理场景具有重要意义。然而，随着HTML5和更现代Web技术的发展，E4X的使用逐渐减少，XML在现代Web开发中的角色已经被JSON等轻量级格式取代。尽管如此，了解和理解E4X规范对于理解早期Web开发历史和技术演变仍有其价值。 ECMA-357规范文档是JavaScript开发者研究和理解XML编程的一个重要参考，它展示了如何将XML的强大功能与JavaScript的灵活性相结合，为开发者提供了丰富的工具来处理和操作XML数据。

object [ propertyName ]

When used on the left hand side of an assignment operation, this property access convention is equivalent to

calling the Object [[Put]] method with object as the this object, passing ToString(propertyName) and the value from

the right hand side of the assignment operator as arguments. For example, the following algorithm fragment:

1. Let item[1] = item2

is equivalent to the following algorithm fragment:

1. Call the Object [[Put]] method with item as the this object and arguments ToString(1) and item2

When used in other contexts, this property access convention is equivalent to calling the Object [[Get]] method with

object as the this object and argument ToString(propertyName). For example, the following algorithm fragment:

1. Let item2 = item[1]

is equivalent to the following algorithm fragment:

1. Let item2 be the result of calling the Object [[Get]] method with item as the this object and argument

ToString(1)

This is a convenient and familiar notation for specifying numeric property names used as array indices.

The convention for accessing internal property names, including those that refer to internal methods, is specified

using the following notation:

object . [[ internalPropertyName ]]

When used on the left hand side of an assignment operation, this property access convention is equivalent to

setting the value of the [[ internalPropertyName ]] of the specified object to the value from the right hand side of the

assignment operator. For example, the following algorithm fragment:

1. Let x.[[Class]] = "element"

is equivalent to the following algorithm fragment:

1. Let the value of the [[Class]] property of x be "element"

When used in other contexts, this property access convention is equivalent to getting the value of the

[[internalPropertyName]] property of object. For example, the following algorithm fragment:

1. Let class = x.[[Class]]

is equivalent to the following algorithm fragment:

1. Let class be the value of the [[Class]] property of x

7.1.3 Iteration

This specification extends the notation used for describing ECMAScript Edition 3 by defining two iteration

conventions. These iteration conventions are used by this specification for expressing that a set of steps shall be

taken once for each item in a collection or once for each integer in a specified range.

The first iteration convention is defined for expressing a sequence of steps that shall be taken once for each

member of a collection. It is expressed using the following for each notation:

For each item in collection steps

This for each notation is equivalent to performing the given steps repeatedly with the variable item bound to each

member of collection. The value of collection is computed once prior to performing steps and does not change

while performing steps. The order in which item is bound to members of collection is implementation dependent.

The repetition ends after item has been bound to all the members of collection or when the algorithm exits via a

return or a thrown exception. The steps may be specified on the same line following a comma or on the following

lines using the indentation style described in section

7.1.1. For example,

- 6-

1. Let total = 0

2. For each product in groceryList

a. If product.price > maxPrice, throw an exception

b. Let total = total + product.price

In this example, steps 2.a and 2.b are repeated once for each member of the collection groceryList or until an

exception is thrown in line 2.a. The variable product is bound to the value of a different member of groceryList

before each repetition of these steps.

The second iteration convention defined by this specification is for expressing a sequence of steps that shall be

repeated once for each integer in a specified range of integers. It is expressed using the following for notation:

For variable = first to last steps

This for notation is equivalent to computing first and last, which will evaluate to integers i and j respectively, and

performing the given steps repeatedly with the variable variable bound to each member of the sequence i, i+1 … j

in numerical order. The values of first and last are computed once prior to performing steps and do not change

while performing steps. The repetition ends after variable has been bound to each item of this sequence or when

the algorithm exits via a return or a thrown exception. If i is greater than j, the steps are not performed. The steps

may be specified on the same line following a comma or on the following lines using the indentation style described

above. For example,

1. For i =

0 to priceList.length-1, call ToString(priceList[i])

In this example, ToString is called once for each item in priceList in sequential order.

A modified version of the for notation exists for iterating through a range of integers in reverse sequential order. It

is expressed using the following notation:

For variable = first downto last steps

The modified for notation works exactly as described above except the variable variable is bound to each member

of the sequence i, i-1, .. j in reverse numerical order. If i is less than j, the steps are not performed.

7.1.4 Conditional Repetition

This specification extends the notation used in the ECMAScript Edition 3 specification by defining a convention for

expressing conditional repetition of a set of steps. This convention is defined by the following notation:

While ( expression ) steps

The while notation is equivalent to computing the expression, which will evaluate to either true or false and if it is

true, taking the given steps and repeating this process until the expression evaluates to false or the algorithm exits

via a return or a thrown exception. The steps may be specified on the same line following a comma or on the

following lines using the indentation style described above. For example,

1. Let log2 = 0

2. While (n > 1)

a. Let n = n / 2

b. Let log2 = log2 +

In this example, steps 2.a and 2.b are repeated until the expression n > 1 evaluates to false.

7.1.5 Method Invocation

This specification extends the notation used in the ECMAScript Edition 3 specification by defining a method

invocation convention. The method invocation convention is used in this specification for calling a method of a

given object passing a given set of arguments and returning the result. This convention is defined by the following

notation:

object . methodName ( arguments )

- 7-

where arguments is a comma separated list of zero or more values. The method invocation notation is equivalent

to constructing a new Reference r with base object set to object and property name set to a string literal containing

the same sequence of characters as methodName, constructing an internal list list of the values in arguments,

invoking the CallMethod operator (section

11.2.2.1) passing r and list as arguments and returning the result. For

example, the following algorithm fragment:

1. Let sub = s.substring(2, 5)

Is equivalent to the following algorithm fragment:

1. Let r be a new Reference with base object = s and property name = "substring"

2. Let list be an internal list containing the values 2 and 5

3. Let sub = CallMethod(r, list)

8 Lexical Conventions

This section introduces the lexical conventions E4X adds to ECMAScript.

E4X modifies the existing lexical grammar productions for InputElementRegExp and Punctuators. It also introduces

the goal symbols InputElementXMLTag and InputElementXMLContent that describe how sequences of Unicode

characters are translated into parts of XML initialisers.

The InputElementDiv symbol is used in those syntactic grammar contexts where a division (/), division-assignment

(/=), less than (<), less than or equals (<=), left shift (<<) or left shift-assignment (<<=) operator is permitted. The

InputElementXMLTag is used in those syntactic contexts where the literal contents of an XML tag are permitted.

The InputElementXMLContent is used in those syntactic contexts where the literal contents of an XML element are

permitted. The InputElementRegExp symbol is used in all other syntactic grammar contexts.

The addition of the production InputElementRegExp :: XMLMarkup and extended use of the existing production

InputElementRegExp :: Punctuator :: < allow the start of XML initialisers to be identified.

To better understand when these goal symbols apply, consider the following example:

order = <{x}>{item}</{x}>;

The input elements returned from the lexical grammar along with the goal symbol and productions used for this

example are as follows:

- 8-

Syntax

E4X extends ECMAScript by replacing the Identifier production and adding a ContextKeyword production as

follows:

Identifier::

IdentifierName but not ReservedWord or ContextKeyword

ContextKeyword

ContextKeyword ::

each

xml

namespace

8.2 Punctuators

E4X extends the list of Punctuators defined by ECMAScript by adding the descendent (..) input element to support

the XML descendent accessor (section

11.2.3), the attribute (@) input element to support XML attribute lookup

(section

11.1.1) and the name qualifier (::) input element to support qualified name lookup (section 11.1.2).

Syntax

E4X extends the Punctuator non-terminal with the following production:

Punctuator ::

8.3 XML Initialiser Input Elements

The goal symbols InputElementXMLTag and InputElementXMLContent describe how Unicode characters are

translated into input elements that describe parts of XML initialisers. These input elements are consumed by the

syntactic grammars described in sections

11.1.4 and 11.1.5.

The lexical grammar allows characters which may not form a valid XML initialiser. The syntax and semantics

described in the syntactic grammar ensure that the final initialiser is well formed XML.

Unlike in string literals, the back slash (\) is not treated as the start of an escape sequence inside XML initialisers.

Instead the XML entity references specified in the XML 1.0 specification should be used to escape characters. For

example, the entity reference ' can be used for a single quote ('), " for a double quote ("), and < for

less than (<).

The left curly brace ({) and right curly brace (}) are used to delimit expressions that may be embedded in tags or

element content to dynamically compute portions of the XML initialiser. The curly braces may appear in literal form

inside an attribute value, a CDATA, PI, or XML Comment. In all other cases, the character reference { shall

be used to represent the left curly brace ({) and the character reference } shall be used to represent the

right curly brace (}).

Syntax

XMLMarkup ::

XMLComment

XMLCDATA

XMLPI

XMLTagCharacters ::

SourceCharacters but no embedded XMLTagPunctuator

or left-curly { or quote ' or double-quote " or forward-slash / or XMLWhitespaceCharacter

XMLWhitespaceCharacter ::

<SP>

- 10-

剩余108页未读，继续阅读

trycopy

粉丝: 6
资源: 24

ECMAScript for XML (E4X)规范：简化XML编程模型

Ecma-262规范

ECMA-262.pdf

ECMA-368 (英文原版)

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

ECMA-262 specification

Ecma-262.pdf

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

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

ECMA-369：2005年12月发布：UWB无线收发器的MAC-PHY接口规范

Ecma-262（ECMAScript5.1中文版+英文版）

最新资源