Standard ECMA-357
2nd Edition / December 2005

ECMAScript for XML (E4X) 仕様

序文

2002 年 6 月 13 日、BEA Systems に率いられた会社の一団は ECMAScript (ECMA-262) にネイティブ XML サポートを追加するプログラミング言語拡張セットを提案した。このプログラミング言語拡張は、世界中のもっとも大きな開発者コミュニティのひとつの既存の知識と技術を活用することで XML の学習曲線を平坦化させる、単純で親しみやすい汎用 XML プログラミングモデルを提供するために設計された。この XML プログラミングモデルの利点には、コードの複雑さの削減、更新期間の短縮、製品化の高速化、XML の基礎的な要求の減少、そしてコードと XML データの間のよりゆるい結合が含まれる。

ECMAScript 部会 (Ecma TC39-TG1) は全会一致でその提案に賛成し、ECMAScript for XML (E4X) と呼ばれる汎用的でクロスプラットフォームなベンダー中立のプログラミング言語拡張の構文と動作のセットを標準化する下位部会を設置した。この標準の開発は 2002 年 8 月 8 日に開始された。この標準は ECMAScript 第 3 版の拡張として開発されたが、ほかの ECMAScript の版にも同様に適用してもよい。

この標準は ECMAScript にネイティブ XML データ型を追加し、よく知られた ECMAScript の演算子を XML データの操作のために拡張し、探索や選別といった一般的な XML の操作のための新しい演算子の小さなセットを追加する。これはまた、XML リテラル、名前空間、修飾名、そして XML の処理を容易にするためのほかの機構のサポートを追加する。

この標準は ECMA-262 (ECMAScript) の将来の版に統合されるだろう。ECMAScript 部会は、XML Schema を使って XML 型を定義する機構やクラスのサポートを含む ECMAScript 言語の将来の版のための重要な改良について作業している。

以下の人々がこの仕様に貢献した。

この Ecma 標準は 2005 年 12 月の総会で採択された。

目次

1 適用範囲

この標準は、ECMAScript にネイティブ XML サポートを追加するプログラミング言語拡張セットである ECMAScript for XML (E4X) の構文と動作を定義する。

2 適合性

E4X の適合実装はこの仕様に記述されるすべての必須の型、値、オブジェクト、プロパティ、関数、およびプログラム構文と動作を提供しサポートしなければならない。

この標準の適合実装は ISO/IEC 16262:2001 ECMAScript 言語仕様に適合しなければならない。

この標準の適合実装は、採択された符号化形式、実装水準 3 として、Unicode 標準バージョン 2.1 以降および UCS-2 または UTF-16 と ISO/IEC 10646-1 に適合して文字を解釈しなければならない。もし採択された ISO/IEC 10646-1 サブセットが特に指定されていなければ、BMP サブセット、集合 300 であると推定される。もし採択された符号化形式が特に指定されていなければ、UTF-16 符号化形式であると推定される。

E4X の適合実装はこの仕様の記述を超える追加の型、値、オブジェクト、プロパティ、関数を提供してもよい。特に、E4X の適合実装はこの仕様に記述されたオブジェクトに対して、この仕様に記述されていないプロパティとそれらのプロパティに対する値を提供してもよい。E4X の適合実装は XML.prototype と XMLList.prototype にこの仕様で記述されるもの以外のメソッドを提供してはならない。

3 参考文献

3.1 規範的文献

3.2 参考的文献

4 定義

この Ecma 標準の目的のために以下の定義が適用される:

4.1 XML

Extensible Markup Language (XML) は、World Wide Web をまたがってデータを送信し、受信し、処理するために World Wide Web Consortium (W3C) で承認された情報符号化標準である。XML は、文字データと呼ばれる実質的な情報だけでなく、マークアップと呼ばれる文字データの構造及びレイアウトに関するメタ情報をも含む文字の並びで構成される。

4.2 マークアップ

XML データの二つの基本的な構成要素のひとつ (もう一方は文字データ) 。マークアップは文字データの構造及びレイアウトに関する情報を提供する文字の並びである。マークアップの一般的な形式は開始タグ、終了タグ、空要素タグ、コメント、CDATA タグ区切り、および処理命令である。

4.3 文字データ

XML データの二つの基本的な構成要素のひとつ (もう一方はマークアップ) 。文字データは XML マークアップにより包まれた実質的なデータを表す文字の並びである。文字データはマークアップでない任意の文字の並びとして定義される。

4.4 タグ

文字データの区切りとして振る舞う単独のマークアップ実体。タグは開始タグ、終了タグ、または空要素タグのいずれかでありうる。開始タグは小なり文字 (<) で始まり大なり文字 (>) で終わる。終了タグは小なりとスラッシュ文字の対 (</) で始まり大なり文字 (>) で終わる。空要素タグは小なり文字 (<) で始まりスラッシュと大なり文字の対 (/>) で終わる。

4.5 要素

文字データまたは入れ子になった要素を区切る二つのタグ (開始タグと終了タグ) から成るデータ構成概念。もしある要素に文字データも入れ子になった要素も存在しなければ、その要素は単独の空要素タグによって定義されうる。すべての整形式 XML 文書はルート要素または文書要素と呼ばれる最低でもひとつの要素を含んでいる。

4.6 属性

タグの内部に現れうる、等号 (=) で分離された名前と値の任意的な組。属性は要素に関する情報または文字データとして格納されえた実際のデータを格納する。

4.7 名前空間

異なる名前空間で同一の名前の識別子が使用されたとき、それらの使用が名前の衝突を引き起こさないように、Uniform Resource Identifier (URI) に共同で結び付けられた、要素および属性に対する識別子の集団。

4.8 処理命令

XML を処理しているアプリケーションに対する命令または情報を含むマークアップ実体。処理命令タグは小なり文字 (<) と疑問符 (?) の組み合わせ (<?) で始まり逆順での同じ文字の組み合わせ (?>) で終わる。

4.9 型

データの値のセット。

5 動機付け

この章には ECMAScript for XML の背後にある動機付けの非規範的な概要が含まれる。

5.1 XML 処理の発生

XML データを作成し、巡回し、操作するソフトウェアの開発はすべての開発者の仕事の重要な一部である。開発者のもとには eXtensible Markup Language (XML) で符号化されたデータが殺到している。Web ページはますます XHTML と Scalable Vector Graphics (SVG) を含む XML 語彙を使って符号化される。携帯機器ではデータは Wireless Markup Language (WML) を使って符号化される。Web サービスは Simple Object Access Protocol (SOAP) を使って相互に作用し、Web Service Description Language (WSDL) を使って記述される。配置記述子、プロジェクトメイクファイル、または構成ファイルは今や、垂直産業に対して設計されたカスタム XML 語彙の終わりのないリストに言及されず、XML で符号化される。XML データそれ自身でさえ XML スキーマや XSL スタイルシートの形式で XML を使って記述され処理される。

5.2 現在の XML 処理方法

現在の XML 処理技術は ECMAScript プログラマに新しい概念とプログラミング技術の複雑な配列を学習し習得することを要求する。XML プログラミングモデルはしばしば ECMAScript プログラマにとって膨大で複雑でなじみのないものに思える。この章ではより一般的な XML 処理技術の簡単な概要を提供する。

5.2.1 Document Object Model (DOM)

XML を処理するもっとも一般的な方法のひとつは W3C XML DOM (Document Object Model) により定義されたインターフェースを実装するソフトウェアパッケージを使うことである。XML DOM は汎用的な木構造抽象概念を使って XML データを表現し、データを巡回し操作する木構造に基づいた API (例えば、getParentNode() 、getChildNodes() 、removeChild() など) を提供する。

データ構造にアクセスし操作するこの手法はネイティブ ECMAScript データ構造にアクセスし操作するのに使われる手法とは大きく異なる。ECMAScript プログラマはオブジェクト巡回アルゴリズムの代わりに木構造巡回アルゴリズムの書き方を学習しなくてはならない。さらに、彼らは XML DOM と相互に作用するために比較的複雑なインターフェース階層を学習しなければならない。結果的に生じた XML DOM コードは一般的に、ネイティブ ECMAScript データ構造を操作するコードよりも読みにくく、書きにくく、保守しにくい。それはより冗長であり、またしばしば長大な木構造巡回ロジックに関する開発者の意図をわかりにくくさせる。結果として、XML DOM プログラムは開発により多くの時間、知識、そして資源を必要とする。

5.2.2 eXtensible Stylesheet Language (XSLT)

XSLT は XML 文書をほかの XML 文書に変換するための言語である。XML DOM のように、それは木構造に基づいた抽象概念を使って XML データを表現するが、木構造を巡回するために設計された XPath と呼ばれる式言語をも提供する。さらにそれは、入力文書の一部に一致し、対応する出力文書を生成するための宣言型で規則に基づく言語を追加する。

この記述から、XSLT がデータ構造にアクセスし操作する手法が ECMAScript データ構造にアクセスし操作するのに使われるものとは完全に異なるのは明らかである。結果的に、ECMAScript プログラマの XSLT の学習曲線はかなりの急勾配である。新しいデータモデルの学習に加え、ECMAScript プログラマは宣言型プログラミングモデル、再起降下処理モデル、新しい式言語、新しい XML 言語構文、そしてさまざまな新しいプログラミング概念 (テンプレート、パターン、優先規則など) を学習しなければならない。これらの違いもまた XSLT コードを ECMAScript プログラマにとって読みにくく、書きにくく、保守しにくくさせる。それに加えて、よく知られた開発環境、デバッガ、テストツールを XSLT とともに使うの不可能である。

5.2.3 オブジェクトマッピング

幾人かはまた、XML データをネイティブオブジェクトへ、およびネイティブオブジェクトからマッピングすることでデータを巡回し操作することを試みた。そのアイデアは XML データを ECMAScript オブジェクトのセットにマッピングし、それらのオブジェクトを直接操作し、そしてそれらを XML へマッピングし直すというものである。これは ECMAScript プログラマが XML データを操作するのに彼らの ECMAScript オブジェクトの知識を再利用することを可能にする。

これは偉大なアイデアであるが、不幸なことに広範囲の XML 処理作業には機能しない。ネイティブ ECMAScript オブジェクトは元の XML データの順序を維持せず、順序は XML にとって重要である。XML 開発者は XML データの順序を維持する必要があるだけでなく、XML データの順序を制御し操作する必要もある。それに加えて、XML データは、名前空間、属性、コメント、処理命令、および混合要素内容といった、ECMAScript オブジェクトモデルでは容易に表せない結果を含んでいる。

5.3 E4X の方法

ECMAScript for XML はこれらの問題に対処するために計画された。E4X は ECMAScript オブジェクトモデルを XML データのネイティブサポートで拡張する。それは、ECMAScript を使ったことのある誰もが追加知識をほとんどまたはまったくなしで XML を使い始められるように、XML を作成し、巡回し、操作するためになじみのある ECMAScript 演算子を再利用する。この拡張にはネイティブ XML データ、XML リテラル (すなわち初期化子) 、そして探索や選別といった一般的な XML の操作に役立つ新しい演算子の小さなセットが含まれる。

E4X アプリケーションは ECMAScript 開発者にとって同等の XSLT または DOM アプリケーションよりも小さく直感的である。それらは読みやすく、書きやすく、保守しやすく、また、より少しの開発時間、技術、および専門的知識しか必要としない。正味の結果はインターネットアプリケーションに対するコードの複雑さの削減、更新期間の短縮、そして製品化の高速化である。それに加えて、E4X は広範囲なモバイルアプリケーションを可能にするより軽量の技術である。

6 設計方針

以下の非規範的な設計方針は E4X の開発を案内し一貫した設計の決定を促進するために使われる。それらは E4X の設計の根拠に対する洞察を提供し、望ましい E4X の特徴に関する議論を支えるためにここに記載される。

7 表記法

この仕様は ECMAScript 第 3 版仕様で使われている表記法を拡張する。特に、これは、この仕様の明瞭さ、読みやすさ、そして保守しやすさを改善するようにアルゴリズム記法を拡張する。新しいアルゴリズム規約はこの章に記述される。

7.1 アルゴリズム規約

この章では、ECMAScript 第 3 版の動作を記述するのに使われているものにこの仕様が追加するアルゴリズム規約を導入する。これらの規約は E4X 言語の一部ではない。それらは E4X の操作の動作を記述するためにこの仕様の中で使われる。

7.1.1 字下げ様式

この仕様はアルゴリズム字下げ様式を定義することで ECMAScript 第 3 版仕様で使われている記法を拡張する。新しいアルゴリズム字下げ様式は連れ立って実行されるステップの関連する集合を分類するためにこの仕様で使われる。この規約は、条件付きでまたは繰り返してとられるステップのセットを表現するのに役立つ。例えば、以下のアルゴリズムの断片は条件付きでとられるステップのセットを記述するのに字下げを使っている:

  1. もし resetParameters が true であるならば
    1. x = 0 とする
    2. y = 0 とする
    3. deltaX = 0.5 とする
  2. そうでなければ
    1. deltaX = deltaX + accelerationX とする

上の例では、もしステップ 1 で表現された条件が true と評価されたならば、ステップ 1.a から 1.c までがとられる。そうでなければ、ステップ 2.a がとられる。

標準的なアウトライン番号付け形式は、ページ付けによってそうでなければ明白でないかもしれないときに、ステップを識別し字下げの入れ子になった度合いを区別するために使われる。

7.1.2 プロパティアクセス

この仕様は三つのプロパティアクセス規約を定義することで ECMAScript 第 3 版仕様で使われている記法を拡張する。この仕様の代入操作の左辺側で使われたときは、プロパティアクセス規約は指定されたオブジェクトの指定されたプロパティの値を修正するのに使われる。この仕様のそのほかの文脈では、プロパティアクセス規約はそのプロパティ名に基づいて指定されたオブジェクトから取得された指定されたプロパティの値を指定するために使われる。

プロパティアクセス規約には三つの形式があり、二つは通常のプロパティにアクセスするためのものであり一つは内部プロパティにアクセスするためのものである。通常のプロパティにアクセスするための最初の規約は以下の記法を使って表現される:

object . propertyName

代入操作の左辺側で使われたときは、このプロパティアクセス規約は、引数として propertyName と同じパラメータの並びを含む文字列リテラルおよび代入演算子の右辺側から得られる値を渡して、object の [[Put]] メソッドを呼び出すのと同等である。例えば、以下のアルゴリズムの断片は:

  1. item.price = "5.95" とする

以下のアルゴリズムの断片と同等である:

  1. 引数 "price" および "5.95" とともに item の [[Put]] メソッドを呼び出す

そのほかの文脈で使われたときは、このプロパティアクセス規約は引数として propertyName と同じ文字の並びを含む文字列リテラルを渡して object の [[Get]] メソッドを呼び出すのと同等である。例えば、以下のアルゴリズムの断片は:

  1. currentPrice = item.price とする

以下のアルゴリズムの断片と同等である:

  1. currentPrice を、引数 "price" とともに item の [[Get]] メソッドを呼び出した結果とする

通常のプロパティにアクセスするための二つ目の規約は以下の記法を使って表現される:

object [ propertyName ]

代入操作の左辺側で使われたときは、このプロパティアクセス規約は、引数として ToString(propertyName) および代入演算子の右辺側から得られた値を渡し、object を this オブジェクトとして Object [[Put]] メソッドを呼び出すのと同等である。例えば、以下のアルゴリズムの断片は:

  1. item[1] = item2 とする

以下のアルゴリズムの断片と同等である:

  1. 引数 ToString(1) および item2 とともに item を this オブジェクトとして Object [[Put]] メソッドを呼び出す

そのほかの文脈で使われたときは、このプロパティアクセス規約は引数 ToString(propertyName) とともに object を this オブジェクトとして Object [[Get]] メソッドを呼び出すのと同等である。例えば、以下のアルゴリズムの断片は:

  1. item2 = item[1] とする

以下のアルゴリズムの断片と同等である:

  1. item2 を、引数 ToString(1) とともに item を this オブジェクトとして Object [[Get]] メソッドを呼び出した結果とする

これは配列の添字として使われる数字のプロパティ名を指定するために便利でよく知られた記法である。

内部メソッドを参照するものも含めて、内部プロパティ名にアクセスするための規約は以下の記法を使って指定される。

object . [[ internalPropertyName ]]

代入操作の左辺側で使われたときは、このプロパティアクセス規約は指定されたオブジェクトの [[ internalPropertyName ]] の値を代入演算子の右辺側から得られた値に設定することと同等である。例えば、以下のアルゴリズムの断片は:

  1. x.[[Class]] = "element" とする

以下のアルゴリズムの断片と同等である:

  1. x の [[Class]] プロパティの値を "element" とする

そのほかの文脈で使われたときは、このプロパティアクセス規約は object の [[internalPropertyName]] プロパティの値を取得することと同等である。例えば、以下のアルゴリズムの断片は:

  1. class = x.[[Class]] とする

以下のアルゴリズムの断片と同等である:

  1. class を、x の [[Class]] プロパティの値とする

7.1.3 反復

この仕様は二つの反復規約を定義することで ECMAScript 第 3 版を記述するのに使われている記法を拡張する。これらの反復規約は、ステップのセットが集合内の項目それぞれに対して 1 回ずつまたは指定された範囲の中の整数それぞれに対して 1 回ずつとられなければならないということを表現するためにこの仕様により使われる。

最初の反復規約は集合のそれぞれのメンバに対して 1 回ずつとられなければならないステップの並びを表現するために定義される。それは以下の for each 記法を使って表現される:

collection 中のそれぞれの item に対して steps

この for each 記法は collection のそれぞれのメンバに束縛された変数 item とともに与えられた steps を繰り返し実行することと同等である。collection の値は steps を実行する前に 1 回計算され、steps を実行する間は変化しない。itemcollection のメンバに束縛される順序は実装依存である。繰り返しは、itemcollection のすべてのメンバに束縛された後またはアルゴリズムが復帰か投げられた例外によって終了したときに終わる。steps は、読点に続く同じ行または章 7.1.1 で記述される字下げ様式を使う後続の行に指定してもよい。例えば、

  1. total = 0 とする
  2. groceryList 中のそれぞれの product に対して
    1. もし product.price > maxPrice ならば、例外を投げる
    2. total = total + product.price とする

この例において、ステップ 2.a および 2.b は集合 groceryList のそれぞれのメンバに対して 1 回ずつまたは例外が行 2.a で投げられるまで繰り返される。変数 product はこれらのステップのそれぞれの繰り返しの前に groceryList の異なったメンバの値に束縛される。

この仕様により定義される二つ目の反復規約は、指定された整数の範囲内のそれぞれの整数に対して 1 回ずつ繰り返されなければならないステップの並びを表現するためのものである。それは以下の for 記法を使って表現される:

variable = first から last までに対して steps

この for 記法は firstlast ――それは整数 ij へそれぞれ評価され、そして数値的な順序で ii+1 、…、j という並びのそれぞれのメンバに束縛された変数 variable とともに与えられた steps を繰り返し実行する――を計算することと同等である。firstlast の値は steps を実行する前に 1 回計算され、steps を実行する間は変化しない。繰り返しは、変数がこの並びのそれぞれの項目に束縛された後またはアルゴリズムが復帰か投げられた例外によって終了したときに終わる。もし ij よりも大きければ、steps は実行されない。steps は、読点に続く同じ行または上で記述された字下げ様式を使う後続の行に指定してもよい。例えば、

  1. i = 0 から priceList.length-1 までに対して、ToString(priceList[i]) を呼び出す

この例では、ToString は順次的な順序で priceList 中のそれぞれぞの項目に対して 1 回ずつ呼び出される。

for 記法の修正版が順次的な順序の逆順で整数の範囲を反復するために存在する。それは以下の記法を使って表現される:

variable = first から last までの減少に対して steps

修正された for 記法は、変数 variable が数値的な順序の逆順で ii-1 、…、j という並びのそれぞれのメンバに束縛されるということを除いて上で記述されたように正確に動作する。もし ij よりも小さければ、steps は実行されない。

7.1.4 条件つき繰り返し

この仕様はステップのセットの条件付き繰り返しを表現するための規約を定義することにより ECMAScript 第 3 版仕様で使われている記法を拡張する。この規約は以下の記法により定義される。

expression の間 steps

while 記法は expression ――それは true か false かのどちらかに評価され、もしそれが true ならば、expression が false と評価されるかあるいはアルゴリズムが復帰または投げられた例外によって終了するまで、与えられたステップをとり、この処理を繰り返す――を計算することと同等である。ステップは、読点に続く同じ行または上で記述された字下げ様式を使う後続の行に指定されてもよい。例えば、

  1. log2 = 0 とする
  2. n > 1 の間
    1. n = n / 2 とする
    2. log2 = log2 + 1 とする

この例において、ステップ 2.a および 2.b は式 n > 1 が false と評価されるまで繰り返される。

7.1.5 メソッド呼び出し

この仕様はメソッド呼び出し規約を定義することにより ECMAScript 第 3 版仕様で使われている記法を拡張する。メソッド呼び出し規約は、与えられた引数のセットを渡し与えられたオブジェクトのメソッドを呼び出してその結果を返すためにこの仕様で使われる。この規約は以下の記法により定義される:

object . methodName ( arguments )

ここで arguments はコンマで区切られた 0 個以上の値のリストである。メソッド呼び出し記法は、object に設定された基底オブジェクトおよび methodName と同じ文字の並びを含む文字列リテラルに設定されたプロパティ名とともに新しい Reference である r を構成し、arguments 中の値の内部リスト list を構成し、引数として r および list を渡し CallMethod 演算子 (章 11.2.2.1) を呼び出し、そしてその結果を返すことと同等である。例えば、以下のアルゴリズムの断片は:

  1. sub = s.substring(2, 5) とする

以下のアルゴリズムの断片と同等である:

  1. r を、基底オブジェクトsプロパティ名が "substring" である新しい Reference とする
  2. list を、値 2 および 5 を含む内部リストとする
  3. sub = CallMethod(r, list) とする

8 字句規約

この章では E4X が ECMAScript に追加する字句規約を導入する。

E4X は InputElementRegExp および Punctuator に対する既存の字句文法生成規則を修正する。それはまた、どのように Unicode 文字の並びが XML 初期化子の一部に翻訳されるかを記述する目標記号である InputElementXMLTag および InputElementXMLContent をも導入する。

InputElementDiv 記号は、除算演算子 (/) 、除算代入演算子 (/=) 、小なり演算子 (<) 、以下演算子 (<=) 、左シフト演算子 (<<) 、または左シフト代入演算子 (<<=) が許されるそれらの構文文法文脈で使われる。InputElementXMLTag は、XML タグのリテラル内容が許されるそれらの構文文脈で使われる。InputElementXMLContent は、XML 要素のリテラル内容が許されるそれらの構文文脈で使われる。InputElementRegExp 記号は他のすべての構文文法文脈で使われる。

生成規則 InputElementRegExp :: XMLMarkup および既存の生成規則 InputElementRegExp :: Punctuator :: < の拡張された使用は XML 初期化子の開始が識別されることを可能にする。

これらの目標記号が適用されたときのよりよい理解のために、以下の例を考えよ。

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

この例に使われる目標記号および生成規則に従う字句文法から返された入力要素は以下のとおりである:

入力要素 目標 生成規則
order InputElementRegExp Token::Identifier
= InputElementDiv Punctuator
< InputElementRegExp Punctuator
{ InputElementXMLTag {
x InputElementRegExp Token::Identifier
} InputElementDiv Punctuator
> InputElementXMLTag XMLTagPunctuator
{ InputElementXMLContent {
item InputElementRegExp Token::Identifier
} InputElementDiv Punctuator
</ InputElementXMLContent </
{ InputElementXMLTag {
x InputElementRegExp Token::Identifier
} InputElementDiv Punctuator
> InputElementXMLTag XMLTagPunctuator
; InputElementRegExp Token::Punctuator

構文

E4X は ECMAScript により定義された InputElementRegExp 目標記号を以下の生成規則で拡張する:

InputElementRegExp ::
XMLMarkup

E4X は以下の目標記号を追加することにより ECMAScript を拡張する。

InputElementXMLTag ::
XMLTagCharacters
XMLTagPunctuator
XMLAttributeValue
XMLWhitespace
{
InputElementXMLContent ::
XMLMarkup
XMLText
{
< [ 先読み ∉ { ?, ! } ]
</

8.1 文脈キーワード

E4X は文脈キーワードのセットを追加することにより ECMAScript を拡張する。文脈キーワードは、構文文法により識別子が許されない指定された文脈で使われたときに特定の意味を呈する。しかしながら、それらは、それらがまた識別子として使われてもよいという点で ECMAScript 第 3 版のキーワードとは異なる。E4X は ECMAScript にいかなる追加のキーワードも追加しない。

構文

E4X は以下のように Identifier 生成規則を置き換え ContextKeyword 生成規則を追加することにより ECMAScript を拡張する。

Identifier ::
ReservedWord または ContextKeyword ではない IdentifierName
ContextKeyword
ContextKeyword ::
each
xml
namespace

8.2 区切り子

E4X は、XML 子孫アクセサ (章 11.2.3) をサポートするために子孫入力要素 (..) を、XML 属性検索 (章 11.1.1) をサポートするために属性入力要素 (@) を、そして修飾名検索 (章 11.1.2) をサポートするために名前修飾子入力要素 (::) を追加することにより ECMAScript で定義された Punctuator のリストを拡張する。

構文

E4X は Punctuator 非終端記号を以下の生成規則で拡張する。

Punctuator ::
..
@
::

8.3 XML 初期化子入力要素

目標記号 InputElementXMLTag および InputElementXMLContent は、どのように Unicode 文字が XML 初期化子の一部を記述する入力要素へ翻訳されるかを記述する。これらの入力要素は章 11.1.4 および 11.1.5 で記述される構文文法により消費される。

字句文法は妥当な XML 初期化子を形成してはいけない文字を許可する。構文文法で記述される構文および動作は最終的な初期化子が整形式 XML であることを確定する。

文字列リテラルとは異なり、バックスラッシュ (\) は XML 初期化子の内部ではエスケープシーケンスの始まりとしては扱われない。代わりに XML 1.0 仕様で指定される XML 実体参照が文字をエスケープするのに使われるべきである。例えば、実体参照 &apos; は単独引用符 (') に対して、&quot; は二重引用符 (") に対して、&lt; は小なり (<) に対して使われることができる。

左波括弧 ({) および右波括弧 (}) は、XML 初期化子の一部を動的に計算するためにタグまたは要素内容に埋め込まれてもよい式を区切るために使われる。波括弧は属性値、CDATA 、PI 、または XML コメントの内部にリテラル形式で現れてもよい。他のすべての場合では、文字参照 &#x7B; が左波括弧 ({) を表現するために使われなければならず、文字参照 &#x7D; が右波括弧 (}) を表現するために使われなければならない。

構文

XMLMarkup ::
XMLComment
XMLCDATA
XMLPI
XMLTagCharacters ::
XMLTagPunctuator または左波括弧 { または引用符 ' または二重引用符 " またはスラッシュ / または XMLWhitespaceCharacter の埋め込まれていない SourceCharacters
XMLWhitespaceCharacter ::
<SP>
<TAB>
<CR>
<LF>
XMLWhitespace ::
XMLWhitespaceCharacter
XMLWhitespace XMLWhitespaceCharacter
XMLText ::
左波括弧 { または小なり < の埋め込まれていない SourceCharacters
XMLName ::
XMLNameStart
XMLName XMLNamePart
XMLNameStart ::
UnicodeLetter
アンダースコア _
コロン :
XMLNamePart ::
UnicodeLetter
UnicodeDigit
ピリオド .
ハイフン -
アンダースコア _
コロン :
XMLComment ::
<!-- XMLCommentCharactersopt -->
XMLCommentCharacters ::
-- という並びの埋め込まれていない SourceCharacters
XMLCDATA ::
<![CDATA[ XMLCDATACharactersopt ]]>
XMLCDATACharacters ::
]]> という並びの含まれていない SourceCharacters
XMLPI ::
<? XMLPICharactersopt ?>
XMLPICharacters ::
?> という並びの含まれていない SourceCharacters
XMLAttributeValue ::
" XMLDoubleStringCharactersopt "
' XMLSingleStringCharactersopt '
XMLDoubleStringCharacters ::
二重引用符 " の含まれていない SourceCharacters
XMLSingleStringCharacters ::
単独引用符 ' の含まれていない SourceCharacters
SourceCharacters ::
SourceCharacter SourceCharactersopt
XMLTagPunctuator :: 以下のうちのひとつ
= > />

9 型

E4X は XML オブジェクトおよび XML オブジェクトのリストを表現するための二つの新しい基礎データ型を追加することで ECMAScript を拡張する。将来の版はまた XML Schema を使い特定の XML 語彙のためのユーザーにより定義された型を導く機能をも提供するだろう。

9.1 XML 型

XML 型は、名前、XML 属性のセット、範囲内の名前空間のセット、そして親とともにある順序付けられたプロパティの集合である。XML オブジェクトのそれぞれのプロパティは、ToString(ToUint32(P)) が P と等しく、子ノードを表現する XML 型の値を持つような一意の数値的なプロパティ名 P を持つ。XML オブジェクトの名前は QName オブジェクトまたは null である。それぞれの XML 属性は XML 型のインスタンスである。それぞれの名前空間は Namespace オブジェクトである。親は XML 型の値または null である。メソッドは非数値的なプロパティ名を使い XML オブジェクトに関連付けられる。

XML 型のそれぞれの値は XML 要素、属性、コメント、処理命令、またはテキストノードを表現する。内部 [[Class]] プロパティは適切なように "element" 、"attribute" 、"comment" 、"processing-instruction" 、または "text" に設定される。XML 属性、コメント、処理命令 (PI) 、またはテキストノードを表現するそれぞれの XML オブジェクトはユーザーに可視のプロパティを持たず、Object 型から論理的に継承した [[Value]] プロパティに関連付けられた属性、コメント、PI 、またはテキストノードの値を表現する String 値を格納する。

E4X は故意に個別の XML オブジェクトとそのオブジェクトのみを含む XMLList との間の区別をあいまいにする。このために、XMLList に対して利用可能なすべての操作は XML オブジェクトに対しても利用可能である。E4X を拡張する実装はこの制約を保持するべきである。

注意 上で記述された内部 XML データモデルは数値的なプロパティ名を持つプロパティとして XML 子ノードを表現する。これらのプロパティの数値的な名前はその親の中での与えられた子の順序的な位置を指し示す。これらのプロパティの値は関連付けられた名前 (例えば、要素名) を持つ XML オブジェクトである。E4X は、それらの内部的な数値的プロパティ名よりもむしろプロパティの値の名前に基づく XML オブジェクトのプロパティへのアクセスを提供する XML [[Get]] および [[Put]] 演算子を (下で) 定義する。

9.1.1 内部プロパティおよびメソッド

内部プロパティおよびメソッドは E4X 言語の一部ではない。それらは純粋に説明的な目的のためにこの仕様により定義される。E4X の実装は、ここに記述された方法で内部プロパティを作り出し操作しているように振る舞わなければならない。この仕様は、内部プロパティの名前は二重角括弧 [[ ]] に囲まれるという内部プロパティに対する記法を ECMAScript 第 3 版仕様から再利用する。アルゴリズムがオブジェクトの内部プロパティを使いそのオブジェクトが指し示された内部プロパティを実装していないとき、TypeError 例外が投げられる。

XML 型は論理的に Object 型から派生しその内部プロパティを継承する。他に指定されない限り、XML 型は Object 型 (ECMAScript 第 3 版の章 9) に対して定義された型変換動作をも継承する。以下の表は Object 型により定義されたものに XML 型が追加する内部プロパティの要約である。

プロパティ パラメータ 説明
[[Name]] なし この XML オブジェクトの名前。
[[Parent]] なし この XML オブジェクトの親。
[[Attributes]] なし この XML オブジェクトに関連付けられた属性。
[[InScopeNamespaces]] なし この XML オブジェクトの範囲内の名前空間。
[[Length]] なし この XML オブジェクトの順序付けられたプロパティの数。
[[DeleteByIndex]] (PropertyName) 数値的な添字が PropertyName であるプロパティを削除する。
[[DeepCopy]] ( ) この XML オブジェクトの深いコピーを返す。
[[ResolveValue]] ( ) この XML オブジェクトを返す。このメソッドは空の XMLList の値を解決しようと試みるときに使われる。
[[Descendants]] (PropertyName) 名前が propertyName と一致するこの XML オブジェクトの子孫を含む XMLList を返す。
[[Equals]] (Value) この XML オブジェクトが与えられた XML Value と同じ XML 内容を持つかどうかを指し示すブール値を返す。
[[Insert]] (PropertyName, Value) 名前が PropertyName (数値的な添字) であるプロパティの前にひとつ以上の新しいプロパティを挿入する。
[[Replace]] (PropertyName, Value) 名前が PropertyName (数値的な添字) であるプロパティの値をひとつ以上の新しいプロパティで置き換える。
[[AddInScopeNamespace]] (Namespace) この XML オブジェクトの [[InScopeNamespaces]] プロパティに Namespace を追加する。

[[Name]] プロパティの値は null または正当な XML 要素名、属性名、PI 名を含む QName オブジェクトでなければならない。[[Name]] プロパティの値は、XML オブジェクトが XML コメントまたはテキストノードを表現しているときかつそのときに限り null である。処理命令を表現するそれぞれの XML オブジェクトの [[Name]] はその uri プロパティが空文字列に設定されるだろう。

[[Parent]] プロパティの値は XML オブジェクトか null かのどちらかでなければならない。XML オブジェクトが別の XML オブジェクトのプロパティ (すなわち、子) として現れたとき、[[Parent]] プロパティはそれを含む XML オブジェクト (すなわち、親) に設定される。

[[Attributes]] プロパティの値は 0 個以上の XML オブジェクトのセットである。新しいオブジェクトが [[Attributes]] セットに追加されるとき、それは同じセットの同一性を持つ [[Attributes]] 内の任意の既存のオブジェクトを置き換える。それぞれの XML オブジェクト x ∈ [[Attributes]] のセットの同一性は x.[[Name]] であると定義される。それゆえに、比較 x.[[Name]] == y.[[Name]] の結果が true であるような二つのオブジェクト x, y ∈ [[Attributes]] は存在しない。もし XML オブジェクトが XML 属性、コメント、PI 、またはテキストノードを表現しているならば、[[Attributes]] プロパティの値は空のセットである。

注意 名前空間は XML では属性構文を使って宣言されるが、それらは [[Attributes]] プロパティ内では表現されない。

[[InScopeNamespaces]] プロパティの値は、この XML オブジェクトの範囲内の名前空間宣言を表現する 0 個以上の Namespace オブジェクトのセットである。[[InScopeNamespaces]] プロパティ内のすべての Namespace オブジェクトは undefined ではない値を持つ prefix プロパティを持つ。新しいオブジェクトが [[InScopeNamespaces]] セットに追加されるとき、それは同じセットの同一性を持つ [[InScopeNamespaces]] セット内の任意の既存のオブジェクトを置き換える。それぞれの Namespace オブジェクト n ∈ [[InScopeNamespaces]] のセットの同一性は n.prefix であると定義される。それゆえに、比較 x.prefix == y.prefix の結果が true であるような二つのオブジェクト x, y ∈ [[InScopeNamespaces]] は存在しない。

[[Length]] プロパティの値は非負整数である。

ほかに指定されない限り、新しく作成された XML 型のインスタンスは [[Prototype]] を XML プロトタイプオブジェクト (章 13.4.4) で初期化され、[[Class]] を文字列 "text" で初期化され、[[Value]] を undefined で初期化され、[[Name]] を null で初期化され、[[Parent]] を null で初期化され、[[Attributes]] を空のセット { } で初期化され、[[InScopeNamespaces]] を空のセット { } で初期化され、そして [[Length]] を整数 0 で初期化される。

9.1.1.1 [[Get]] (P)

概要

XML 型は Object 型により定義された内部 [[Get]] メソッドを上書きする。XML [[Get]] メソッドは XML 属性をその名前によりまたは XML 要素のセットをそれらの名前により取得するために使われる。入力引数 P は、XML 属性 (先導する "@" 記号により XML 要素の名前から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、プロパティワイルドカード "*" 、または属性ワイルドカード "@*" であってもよい。入力引数 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力引数 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。

それに加えて、入力引数 P は数値的なプロパティ名であってもよい。もし P が数値的なプロパティ名であれば、XML [[Get]] メソッドはこの XML オブジェクトを XMLList リストに変換し引数 P とともにリストの [[Get]] メソッドを呼び出す。この処置は故意に単独の XML オブジェクトとひとつの値のみを含む XMLList との間の区別をあいまいにする。

注意 内部 Object [[Get]] メソッドとは異なり、内部 XML [[Get]] メソッドは XML オブジェクトに関連付けられたメソッドを取得するためには決して使われない。E4X は章 11.2.2 で記述されるように XML オブジェクトに対する ECMAScript メソッド検索動作を修正する。

動作

XML オブジェクト x の [[Get]] メソッドがプロパティ名 P とともに呼び出されたとき、以下のステップがとられる:

  1. もし ToString(ToUint32(P)) == P ならば
    1. list = ToXMLList(x) とする
    2. 引数 P とともに list の [[Get]] メソッドを呼び出した結果を返す
  2. n = ToXMLName(P) とする
  3. list を、list.[[TargetObject]] = x および list.[[TargetProperty]] = n である新しい XMLList とする

    訳注 list.[[TargetProperty]] は list が返される直前に設定されるべきである。Mozilla Bug 336921 を見よ。

  4. もし Type(n) が AttributeName であるならば
    1. x.[[Attributes]] 中のそれぞれの a に対して
      1. もし (n.[[Name]].localName == "*" または n.[[Name]].localName == a.[[Name]].localName) かつ (n.[[Name]].uri == null または n.[[Name]].uri == a.[[Name]].uri) ならば
        1. 引数 a とともに list の [[Append]] メソッドを呼び出す
    2. list を返す
  5. k = 0 から x.[[Length]]-1 までに対して
    1. もし (n.localName == "*" または (x[k].[[Class]] == "element" かつ x[k].[[Name]].localName == n.localName)) かつ (n.uri == null または (x[k].[[Class]] == "element" かつ n.uri == x[k].[[Name]].uri)) ならば
      1. 引数 x[k] とともに list の [[Append]] メソッドを呼び出す
  6. list を返す
9.1.1.2 [[Put]] (P, V)

概要

XML 型は Object 型により定義される内部 [[Pur]] メソッドを上書きする。XML [[Put]] メソッドは XML オブジェクトのプロパティまたは XML 属性を置き換え挿入するのに使われる。パラメータ P は XML オブジェクトのどの部分が影響を受けるかを識別し、XML 属性 (先導する "@" 記号により XML と評価されるプロパティ名から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、またはプロパティワイルドカード "*" であってもよい。パラメータ P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。パラメータ P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。パラメータ V は XML オブジェクト、XMLList オブジェクト、または ToString() で String に変換されてもよい任意の値であってもよい。

もし P が数値的なプロパティ名であれば、XML [[Put]] メソッドは TypeError 例外を投げる。この操作は E4X の将来の版のために予約される。

注意 内部 Object [[Put]] メソッドとは異なり、内部 XML [[Put]] メソッドは XML オブジェクトに関連付けられたメソッドのセットを修正するためには決して使われない。

動作

XML オブジェクト x の [[Put]] メソッドがプロパティ名 P および値 V とともに呼び出されたときは、以下のステップがとられる:

  1. もし ToString(ToUint32(P)) == P ならば、TypeError 例外を投げる

    注意 この操作は E4X の将来の版のために予約される。

  2. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、返る
  3. もし Type(V) ∉ {XML, XMLList} または V.[[Class]] ∈ {"text", "attribute"} ならば
    1. c = ToString(V) とする
  4. そうでなければ
    1. c を、V の [[DeepCopy]] メソッドを呼び出した結果とする
  5. n = ToXMLName(P) とする
  6. もし Type(n) が AttributeName であるならば
    1. 引数 n.[[Name]] とともに関数 isXMLName (章 13.1.2.1) を呼び出し、もしその結果が false であるならば、返る
    2. もし Type(c) が XMLList であるならば
      1. もし c.[[Length]] == 0 であるならば、c を空文字列とする
      2. そうでなければ
        1. s = ToString(c[0]) とする
        2. i = 1 から c.[[Length]]-1 までに対して
          1. s を、s と文字列 " " (スペース) 、および ToString(c[i]) とを連結した結果とする
        3. c = s とする
    3. そうでなければ
      1. c = ToString(c) とする
    4. a = null とする
    5. x.[[Attributes]] 中のそれぞれの j に対して
      1. もし n.[[Name]].localName == j.[[Name]].localName かつ (n.[[Name]].uri == null または n.[[Name]].uri == j.[[Name]].uri) ならば
        1. もし a == null ならば、a = j
        2. そうでなければ、引数 j.[[Name]] とともに x の [[Delete]] メソッドを呼び出す
    6. もし a == null ならば
      1. もし n.[[Name]].uri == null ならば
        1. nons を、コンストラクタ new Namespace() を呼び出したかのように作成された新しい Namespace とする
        2. name を、コンストラクタ new QName(nons, n.[[Name]]) を呼び出したかのように作成された新しい QName とする
      2. そうでなければ
        1. name を、コンストラクタ new QName(n.[[Name]]) を呼び出したかのように作成された新しい QName とする
      3. a.[[Name]] = namea.[[Class]] == "attribute" 、a.[[Parent]] = x である新しい XML オブジェクト a を作成する
      4. x.[[Attributes]] = x.[[Attributes]] ∪ { a } とする
      5. ns を、引数なしで name の [[GetNamespace]] メソッドを呼び出した結果とする
      6. 引数 ns とともに x の [[AddInScopeNamespace]] メソッドを呼び出す
    7. a.[[Value]] = c とする
    8. 返る
  7. isValidName を、引数 n とともに関数 isXMLName (章 13.1.2.1) を呼び出した結果とする
  8. もし isValidName が false でありかつ n.localName が文字列 "*" と等しくないのならば、返る
  9. i = undefined とする
  10. primitiveAssign を、Type(c) ∉ {XML, XMLList} かつ n.localName が文字列 "*" と等しくないとする
  11. k = x.[[Length]]-1 から 0 までの減少に対して
    1. もし (n.localName == "*" または (x[k].[[Class]] == "element" かつ x[k].[[Name]].localName == n.localName)) かつ (n.uri == null または (x[k].[[Class]] == "element" かつ n.uri == x[k].[[Name]].uri)) ならば
      1. もし i が undefined でないのならば、引数 ToString(i) とともに x の [[DeleteByIndex]] プロパティを呼び出す
      2. i = k とする
  12. もし i == undefined ならば
    1. i = x.[[Length]] とする
    2. もし primitiveAssign == true ならば
      1. もし n.uri == null ならば
        1. name を、コンストラクタ new QName(GetDefaultNamespace(), n) を呼び出したかのように作成された新しい QName とする
      2. そうでなければ
        1. name を、コンストラクタ new QName(n) を呼び出したかのように作成された新しい QName とする
      3. y.[[Name]] = namey.[[Class]] = "element" 、y.[[Parent]] = x である新しい XML オブジェクト y を作成する
      4. ns を、引数なしで name の [[GetNamespace]] を呼び出した結果とする
      5. 引数 ToString(i) および y とともに x の [[Replace]] メソッドを呼び出す
      6. 引数 ns とともに y の [[AddInScopeNamespace]] を呼び出す
  13. もし primitiveAssign == true ならば
    1. XML オブジェクト x[i] のすべてのプロパティを削除する
    2. s = ToString(c) とする
    3. もし s が空文字列でないならば、引数 "0" および s とともに x[i] の [[Replace]] メソッドを呼び出す
  14. そうでなければ
    1. 引数 ToString(i) および c とともに x の [[Replace]] メソッドを呼び出す
  15. 返る
9.1.1.3 [[Delete]] (P)

概要

XML 型は Object 型により定義された内部 [[Delete]] メソッドを上書きする。XML [[Delete]] メソッドは XML 属性のセットを名前によりあるいは XML と評価されるプロパティのセットを名前により取り除くのに使われる。内部 Object [[Delete]] とは異なり、XML [[Delete]] メソッドは削除により作成された空の隙間を埋めるため、削除されたプロパティのすべての後続するプロパティを上位に移動する。入力引数 P は、XML 属性 (先導する "@" 記号により XML 要素の名前から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、プロパティワイルドカード "*" 、または属性ワイルドカード "@*" であってもよい。入力要素 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力要素 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。

もし P が数値的なプロパティ名であれば、XML [[Delete]] メソッドは TypeError 例外を投げる。この操作は E4X の将来の版のために予約される。

動作

XML オブジェクト x の [[Delete]] メソッドがプロパティ名 P とともに呼び出されたときは、以下のステップがとられる:

  1. もし ToString(ToUint32(P)) == P ならば、TypeError 例外を投げる

    注意 この操作は E4X の将来の版のために予約される。

  2. n = ToXMLName(P) とする
  3. もし Type(n) が AttributeName であるならば
    1. x.[[Attributes]] 中のそれぞれの a に対して
      1. もし (n.[[Name]].localName == "*" または n.[[Name]].localName == a.[[Name]].localName) かつ (n.[[Name]].uri == null または n.[[Name]].uri == a.[[Name]].uri) ならば
        1. a.[[Parent]] = null とする
        2. x.[[Attributes]] から属性 a を取り除く
    2. true を返す
  4. dp = 0 とする
  5. q = 0 から x.[[Length]]-1 までに対して
    1. もし (n.localName == "*" または (x[q].[[Class]] == "element" かつ x[q].[[Name]].localName == n.localName)) かつ (n.uri == null または (x[q].[[Class]] == "element" かつ n.uri == x[q].[[Name]].uri)) ならば
      1. x[q].[[Parent]] = null とする
      2. x から名前が ToString(q) であるプロパティを取り除く
      3. dp = dp + 1 とする
    2. そうでなければ
      1. もし dp > 0 であるならば、x のプロパティ ToString(q) の名前を ToString(q - dp) に変更する
  6. x.[[Length]] = x.[[Length]] - dp とする
  7. true を返す
9.1.1.4 [[DeleteByIndex]] (P)

概要

XML 型は Object 型により定義されたメソッドに内部 [[DeleteByIndex]] メソッドを追加する。XML [[DeleteByIndex]] メソッドは XML プロパティをその数値的なプロパティ名により取り除くために使われる。XML [[Delete]] メソッドのように、XML [[DeleteByIndex]] メソッドは削除により作成された空の隙間を埋めるため、削除されたプロパティのすべての後続プロパティを下位に移動する。入力要素 P は数値的なプロパティ名であってもよい。

動作

XML オブジェクト x の [[DeleteByIndex]] メソッドがプロパティ名 P とともに呼び出されたときは、以下のステップがとられる:

  1. i = ToUint32(P) とする
  2. もし ToString(i) == P ならば
    1. もし ix.[[Length]] よりも小さいならば
      1. もし x が名前が P であるプロパティを持つならば
        1. x[P].[[Parent]] = null とする
        2. x から名前が P であるプロパティを取り除く
      2. q = i+1 から x.[[Length]]-1 までに対して
        1. x のプロパティ ToString(q) の名前を ToString(q - 1) に変更する
      3. x.[[Length]] = x.[[Length]] - 1 とする
    2. true を返す
  3. そうでなければ、TypeError 例外を投げる
9.1.1.5 [[DefaultValue]] (hint)

概要

XML 型は Object 型により定義された内部 [[DefaultValue]] メソッドを上書きする。XML [[DefaultValue]] メソッドはこの XML オブジェクトを表現するプリミティブ値を返す。Object 型により定義された [[DefaultValue]] メソッドとは異なり、XML [[DefaultValue]] メソッドは常に文字列を返す。hint パラメータは無視される。

動作

XML オブジェクト x の [[DefaultValue]] メソッドがパラメータ hint とともに呼び出されたときは、以下のステップがとられる:

  1. ToString(x) を返す
9.1.1.6 [[HasProperty]] (P)

概要

XML 型は Object 型により定義された内部 [[HasProperty]] メソッドを上書きする。XML [[HasProperty]] メソッドはこの XML オブジェクトが XML 要素または属性を含んでいるかどうかをその名前により判定するために使われる。入力引数 P は、XML 属性 (先導する "@" 記号により XML 要素の名前から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、プロパティワイルドカード "*" 、または属性ワイルドカード "@*" であってもよい。入力引数 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力引数 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。

それに加えて、入力引数 P は数値的なプロパティ名であってもよい。もし P が "0" に等しい数値的なプロパティ名であるならば、XML [[HasProperty]] メソッドは true を返す。もし P が "0" ではない数値的なプロパティ名であるならば、XML [[HasProperty]] メソッドは false を返す。この処置は故意に単独の XML オブジェクトとひとつの値のみを含む XMLList との間の区別をあいまいにする。

動作

XML オブジェクト x の [[HasProperty]] メソッドがプロパティ名 P とともに呼び出されたときは、以下のステップがとられる:

  1. もし ToString(ToUint32(P)) == P ならば
    1. P == "0" を返す
  2. n = ToXMLName(P) とする
  3. もし Type(n) が AttributeName であるならば
    1. x.[[Attributes]] 中のそれぞれの a に対して
      1. もし (n.[[Name]].localName == "*" または n.[[Name]].localName == a.[[Name]].localName) かつ (n.[[Name]].uri == null または n.[[Name]].uri == a.[[Name]].uri) ならば
        1. true を返す
    2. false を返す
  4. k = 0 から x.[[Length]]-1 までに対して
    1. もし (n.localName == "*" または (x[k].[[Class]] == "element" かつ x[k].[[Name]].localName == n.localName)) かつ (n.uri == null または (x[k].[[Class]] == "element" かつ n.uri == x[k].[[Name]].uri)) ならば
      1. true を返す
  5. false を返す
9.1.1.7 [[DeepCopy]] ( )

概要

XML 型は Object 型により定義された内部プロパティに内部 [[DeepCopy]] メソッドを追加する。XML [[DeepCopy]] メソッドは、その属性、プロパティ、名前空間およびそのすべての子孫の属性、プロパティ、名前空間を含むこのオブジェクトの深いコピーを作成し、返すために使われる。返り値の内部 [[Parent]] プロパティは null に設定され、コピーされたそれぞれの子孫の内部 [[Parent]] プロパティはそれぞれに見合ったコピーされた親に設定される。

動作

XML オブジェクト x の [[DeepCopy]] メソッドが呼び出されたときは、以下のステップがとられる:

  1. y を、y.[[Prototype]] = x.[[Prototype]] 、y.[[Class]] = x.[[Class]] 、y.[[Value]] = x.[[Value]] 、y.[[Name]] = x.[[Name]] 、y.[[Length]] = x.[[Length]] である新しい XML オブジェクトとする
  2. x.[[InScopeNamespaces]] 中のそれぞれの ns に対して
    1. ns2 を、コンストラクタ new Namespace(ns) を呼び出したかのように作成された新しい Namespace とする
    2. y.[[InScopeNamespaces]] = y.[[InScopeNamespaces]] ∪ { ns2 } とする
  3. y.[[Parent]] = null とする
  4. x.[[Attributes]] 中のそれぞれの a に対して
    1. b を、a の [[DeepCopy]] メソッドを呼び出した結果とする
    2. b.[[Parent]] = y とする
    3. y.[[Attributes]] = y.[[Attributes]] ∪ { b } とする
  5. i = 0 から x.[[Length]]-1 までに対して
    1. c を、x[i] の [[DeepCopy]] メソッドを呼び出した結果とする
    2. y[i] = c とする
    3. c.[[Parent]] = y とする
  6. y を返す
9.1.1.8 [[Descendants]] (P)

概要

XML 型は Object 型により定義された内部プロパティに内部 [[Descendants]] メソッドを追加する。XML [[Descendants]] メソッドは、入力引数 P と一致する名前を持つこの XML オブジェクトのすべての XML と評価される子孫 (すなわち、子、孫、ひ孫など) を取得するために使われる。入力引数 P は、XML 属性 (先導する "@" 記号により XML 要素の名前から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、プロパティワイルドカード "*" 、または属性ワイルドカード "@*" であってもよい。入力引数 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力引数 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。

動作

XML オブジェクト x の [[Descendants]] メソッドがプロパティ名 P とともに呼び出されたときは、以下のステップがとられる:

  1. n = ToXMLName(P) とする
  2. list を、list.[[TargetObject]] = null である新しい XMLList とする
  3. もし Type(n) が AttributeName であるならば
    1. x.[[Attributes]] 中のそれぞれの a に対して
      1. もし (n.[[Name]].localName == "*" または n.[[Name]].localName == a.[[Name]].localName) かつ (n.[[Name]].uri == null または n.[[Name]].uri == a.[[Name]].uri) ならば
        1. 引数 a とともに list の [[Append]] メソッドを呼び出す
  4. k = 0 から x.[[Length]]-1 までに対して
    1. もし (n.localName == "*" または (x[k].[[Class]] == "element" かつ x[k].[[Name]].localName == n.localName)) かつ (n.uri == null または (x[k].[[Class]] == "element" かつ n.uri == x[k].[[Name]].uri)) ならば
      1. 引数 x[k] とともに list の [[Append]] メソッドを呼び出す
    2. dq を、引数 P とともに x[k] の [[Descendants]] メソッドを呼び出した結果とする
    3. もし dq.[[Length]] > 0 ならば、引数 dq とともに list の [[Append]] メソッドを呼び出す
  5. list を返す
9.1.1.9 [[Equals]] (V)

概要

XML 型は Object 型により定義された内部プロパティに内部 [[Equals]] メソッドを追加する。XML [[Equals]] メソッドはこの XML オブジェクトを他の XML オブジェクト V と XML 内容の等価性で比べるために使われる。もし V がこの XML オブジェクトと等しいと考えられる XML 型の値であるならば、[[Equals]] 演算子は true を返す。そうでなければ、それは false を返す。

動作

XML オブジェクト x の [[Equals]] メソッドが値 V とともに呼び出されたときは、以下のステップがとられる:

  1. もし Type(V) が XML でないならば、false を返す
  2. もし x.[[Class]] が V.[[Class]] と等しくないならば、false を返す
  3. もし x.[[Name]] が null でないならば
    1. もし V.[[Name]] が null であるならば、false を返す
    2. もし x.[[Name]].localName が V.[[Name]].localName と等しくないならば、false を返す
    3. もし x.[[Name]].uri が V.[[Name]].uri と等しくないならば、false を返す
  4. そうでなく、もし V.[[Name]] が null でないならば、false を返す
  5. もし x.[[Attributes]] が V.[[Attributes]] と同じ数の項目を含まないならば、false を返す
  6. もし x.[[Length]] が V.[[Length]] と等しくないならば、false を返す
  7. もし x.[[Value]] が V.[[Value]] と等しくないならば、false を返す
  8. x.[[Attributes]] 中のそれぞれの a に対して
    1. もし V.[[Attributes]] が b.[[Name]].localName == a.[[Name]].localName 、b.[[Name]].uri == a.[[Name]].uri 、b.[[Value]] == a.[[Value]] であるような属性 b を含まないならば、false を返す
  9. i = 0 から x.[[Length]]-1 までに対して
    1. r を、引数 V[i] とともに x[i] の [[Equals]] メソッドを呼び出した結果とする
    2. もし r == false ならば、false を返す
  10. true を返す
9.1.1.10 [[ResolveValue]] ( )

概要

XML 型は Object 型により定義される内部プロパティに内部 [[ResolveValue]] メソッドを追加する。XML [[ResolveValue]] メソッドはこの XML オブジェクトを返す。それは空の XMLList での [[Put]] 操作をサポートするために XMLList [[ResolveValue]] メソッドにより使われる。

動作

XML オブジェクト x の [[ResolveValue]] メソッドが呼び出されたときは、以下のステップがとられる:

  1. x を返す
9.1.1.11 [[Insert]] (P, V)

概要

XML 型は Object 型により定義された内部プロパティに内部 [[Insert]] メソッドを追加する。XML [[Insert]] メソッドは特定の位置 P に値 V を挿入するために使われる。入力引数 P は数値的なプロパティ名でなければならない。入力引数 V は XML 、XMLList 型の値、または ToString() で String に変換されうる任意の値であってもよい。

動作

XML オブジェクト x の [[Insert]] メソッドがプロパティ名 P および値 V とともに呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、返る
  2. i = ToUint32(P) とする
  3. もし ToString(i) が P と等しくないならば、TypeError 例外を投げる
  4. もし Type(V) が XML でありかつ Vx または x の祖先であるならば、Error 例外を投げる
  5. n = 1 とする
  6. もし Type(V) が XMLList であるならば、n = V.[[Length]] とする
  7. もし n == 0 ならば、返る
  8. j = x.[[Length]]-1 から i までの減少に対して、x のプロパティ ToString(j) の名前を ToString(j + n) に変更する
  9. x.[[Length]] = x.[[Length]] + n とする
  10. もし Type(V) が XMLList であるならば
    1. j = 0 から V.[[Length]]-1 までに対して
      1. V[j].[[Parent]] = x
      2. x[i + j] = V[j]
  11. そうでなければ
    1. 引数 i および V とともに x の [[Replace]] メソッドを呼び出す
  12. 返る
9.1.1.12 [[Replace]] (P, V)

概要

XML 型は Object 型により定義される内部プロパティに内部 [[Replace]] メソッドを追加する。XML [[Replace]] メソッドは特定の位置 P のプロパティを値 V で置き換えるために使われてもよい。入力引数 P は数値的なプロパティ名でなければならない。入力引数 V は XML 、XMLList 型の値、または ToString() で String に変換されうる任意の値であってもよい。

動作

XML オブジェクト x の [[Replace]] メソッドがプロパティ名 P および値 V とともに呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、返る
  2. i = ToUint32(P) とする
  3. もし ToString(i) が P と等しくないならば、TypeError 例外を投げる
  4. もし ix.[[Length]] 以上であるならば
    1. P = ToString(x.[[Length]]) とする
    2. x.[[Length]] = x.[[Length]] + 1 とする
  5. もし Type(V) が XML でありかつ V.[[Class]] ∈ {"element", "comment", "processing-instruction", "text"} ならば
    1. もし V.[[Class]] が "element" でありかつ Vx または x の祖先であるならば、Error 例外を投げる
    2. V.[[Parent]] = x とする
    3. もし x が名前が P であるプロパティを持つならば
      1. x[P].[[Parent]] = null とする
    4. x[P] = V とする
  6. そうでなく、もし Type(V) が XMLList であるならば
    1. 引数 P とともに x の [[DeleteByIndex]] メソッドを呼び出す
    2. 引数 P および V とともに x の [[Insert]] メソッドを呼び出す
  7. そうでなければ
    1. s = ToString(V) とする
    2. t.[[Class]] = "text" 、t.[[Parent]] = xt.[[Value]] = s である新しい XML オブジェクト t を作成する
    3. もし x が名前が P であるプロパティを持つならば
      1. x[P].[[Parent]] = null とする
    4. x のプロパティ P の値を t とする
  8. 返る
9.1.1.13 [[AddInScopeNamespace]] ( N )

概要

XML 型は Object 型により定義される内部プロパティに内部 [[AddInScopeNamespace]] メソッドを追加する。XML [[AddInScopeNamespace]] メソッドは与えられた XML オブジェクトの [[InScopeNamespaces]] に新しい Namespace を追加するために使われる。入力引数 N はこの XML オブジェクトの [[InScopeNamespaces]] プロパティに追加される Namespace 型の値である。もし N.prefix が undefined であるならば、名前空間は [[InScopeNamespaces]] に追加されない。もし N.prefix が [[InScopeNamespaces]] 内の名前空間の接頭辞と一致するならば、一致物は N により置き換えられこの要素の中の同じ接頭辞である名前の接頭辞は undefined に設定される。

動作

XML オブジェクト x の [[AddInScopeNamespace]] メソッドが名前空間 N とともに呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、返る
  2. もし N.prefix != undefined ならば
    1. もし N.prefix == "" かつ x.[[Name]].uri == "" ならば、返る
    2. match を null とする
    3. x.[[InScopeNamespaces]] 中のそれぞれの ns に対して
      1. もし N.prefix == ns.prefix ならば、match = ns とする
    4. もし match が null ではなくかつ match.uri が N.uri と等しくないならば
      1. x.[[InScopeNamespaces]] から match を取り除く
    5. x.[[InScopeNamespaces]] = x.[[InScopeNamespaces]] ∪ { N } とする
    6. もし x.[[Name]].[[Prefix]] == N.prefix ならば
      1. x.[[Name]].prefix = undefined とする
    7. x.[[Attributes]] 中のそれぞれの attr に対して
      1. もし attr.[[Name]].[[Prefix]] == N.prefix ならば、attr.[[Name]].prefix = undefined とする
  3. 返る

9.2 XMLList 型

XMLList 型は順序付けられたプロパティの集合である。XMLList オブジェクトのそれぞれのプロパティは、ToString(ToUint32(P)) が P と等しく XML 型の値であるような一意の数値的なプロパティ名 P を持つ。メソッドは非数値的なプロパティ名を使って XMLList オブジェクトに関連付けられる。

XMLList 型の値は、XML 文書、XML 断片、または XML オブジェクトの任意の集合 (例えば、問い合わせ結果) を表現する。

E4X は故意に個別の XML オブジェクトととそのオブジェクトのみを含む XMLList との間の区別をあいまいにする。このために、XML オブジェクトに対して利用可能なすべての操作は XMLList オブジェクトに対しても利用可能である。E4X を拡張する実装はこの制約を保持するべきである。

9.2.1 内部プロパティおよびメソッド

XMLList 型は論理的に Object 型から派生しその内部プロパティを継承する。ほかに指定されない限り、XMLList 型は Object 型に対して定義された型変換動作 (ECMAScript 第 3 版の章 9) をも継承する。以下の表は Object 型により定義されたものに XMLList 型が追加する内部プロパティの要約である。

プロパティ パラメータ 説明
[[Length]] なし この XMLList オブジェクトに含まれるプロパティの数。
[[TargetObject]] なし 項目がこの XMLList に挿入されたとき影響を受けるであろうこのオブジェクトに関連付けられた XML または XMLList オブジェクト。
[[TargetProperty]] なし オブジェクトが空の XMLList に追加されるとき [[TargetObject]] の中に作成されてもよいプロパティの名前。
[[Append]] (Value) この XMLList オブジェクトの終端に新しいプロパティを追加する。
[[DeepCopy]] ( ) この XMLList オブジェクトの深いコピーを返す。
[[Descendants]] (PropertyName) propertyName と一致する名前を持つこの XMLList の中のすべての子孫の値を含む XMLList を返す。
[[Equals]] (Value) この XMLList オブジェクトが与えられた Value と同じ内容を持つまたはこの XMLList オブジェクトが与えられた Value と等しく比較されるオブジェクトを含むかどうかを指し示すブール値を返す。
[[ResolveValue]] ( ) この XML オブジェクトの値を解決する。もしこの XML オブジェクトが空でないならば、それが返される。 そうでなければ、[[ResolveValue]] は適切な値を作成するよう試みる。

[[Length]] プロパティの値は非負数である。

ほかに指定されない限り、新しく作成された XMLList 型のインスタンスは、[[Prototype]] を XMLList プロトタイプオブジェクトに初期化され、[[Class]] を文字列 "XMLList" に初期化され、[[Value]] を undefined に初期化され、[[Length]] を整数 0 に初期化され、[[TargetObject]] を null に初期化され、[[TargetProperty]] を null に初期化される。

9.2.1.1 [[Get]] (P)

概要

XMLList 型は Object 型により定義された内部 [[Get]] メソッドを上書きする。XMLList [[Get]] メソッドはこの XMLList オブジェクトの特定のプロパティをその数値的なプロパティ名により取得する、またはそれらの XML 属性を名前によりまたはそれらの XML と評価されるプロパティを名前により取得するこの XMLList オブジェクトの XML と評価されるプロパティ上を反復するために使われる。入力引数 P は、数値的なプロパティ名、XML 属性 (先導する "@" 記号により XML 要素の名前から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、プロパティワイルドカード "*" 、または属性ワイルドカード "@*" であってもよい。入力引数 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力引数 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。

注意 内部 Object [[Get]] メソッドとは異なり、内部 XMLList [[Get]] メソッドは XMLList オブジェクトに関連付けられたメソッドを取得するためには決して使われない。E4X は章 11.2.2 で記述されるように XMLList オブジェクトに対する ECMAScript メソッド検索動作を修正する。

動作

XMLList オブジェクト x の [[Get]] メソッドがプロパティ名 P とともに呼び出されたときは、以下のステップがとられる:

  1. もし ToString(ToUint32(P)) == P ならば
    1. 引数 P とともに x を this オブジェクトとして Object [[Get]] メソッドを呼び出した結果を返す
  2. list を、list.[[TargetObject]] = xlist.[[TargetProperty]] = P である新しい XMLList とする
  3. i = 0 から x.[[Length]]-1 までに対して
    1. もし x[i].[[Class]] == "element" ならば
      1. gq を、引数 P とともに x[i] の [[Get]] メソッドを呼び出した結果とする
      2. もし gq.[[Length]] > 0 ならば、引数 gq とともに list の [[Append]] メソッドを呼び出す
  4. list を返す
9.2.1.2 [[Put]] (P, V)

概要

XMLList 型は Object 型により定義される内部 [[Put]] メソッドを上書きする。XMLList [[Put]] メソッドは XMLList 内の XML オブジェクトおよびその親の文脈を修正し置き換えるために使われる。それに加えて、XMLList が単独の XML オブジェクトのプロパティを含むときは、[[Put]] メソッドはその値のプロパティまたは XML 属性を名前により修正し、置き換え、挿入するために使われる。入力引数 P は XMLList および関連付けられた XML オブジェクトのどの部分が影響を受けるかを識別し、数値的なプロパティ名、XML 属性 (先導する "@" 記号により XML と評価されるプロパティ名から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、またはプロパティワイルドカード "*" であってもよい。入力引数 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力引数 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。入力引数 V は XML 、XMLLList 型の値または ToString() で String に変換されうる任意の値であってもよい。

注意 内部 Ojbect [[Put]] メソッドとは異なり、内部 XMLList [[Put]] メソッドは XMLList オブジェクトに関連付けられたメソッドのセットを修正するためには決して使われない。

動作

XMLList オブジェクト x の [[Put]] メソッドがプロパティ名 P および値 V とともに呼び出されたときは、以下のステップがとられる:

  1. i = ToUint32(P) とする
  2. もし ToString(i) == P ならば
    1. もし x.[[TargetObject]] が null でないならば
      1. r を、x.[[TargetObject]] の [[ResolveValue]] メソッドを呼び出した結果とする
      2. もし r == null ならば、返る
    2. そうでなければ、r = null とする
    3. もし ix.[[Length]] 以上であるならば
      1. もし Type(r) が XMLList であるならば
        1. もし r.[[Length]] が 1 と等しくないならば、返る
        2. そうでなければ、r = r[0] とする
      2. もし r.[[Class]] が "element" と等しくないならば、返る
      3. y.[[Parent]] = ry.[[Name]] = x.[[TargetProperty]] 、y.[[Attributes]] = {} 、y.[[Length]] = 0 である新しい XML オブジェクト y を作成する
      4. もし Type(x.[[TargetProperty]]) が AttributeName であるならば
        1. attributeExists を、引数 y.[[Name]] とともに r の [[Get]] メソッドを呼び出した結果とする
        2. もし attributeExists.[[Length]] > 0 ならば、返る
        3. y.[[Class]] = "attribute" とする
      5. そうでなく、もし x.[[TargetProperty]] == null または x.[[TargetProperty]].localName == "*" ならば
        1. y.[[Name]] = null とする
        2. y.[[Class]] = "text" とする
      6. そうでなければ、y.[[Class]] = "element" とする
      7. i = x.[[Length]] とする
      8. もし y.[[Class]] が "attribute" と等しくないならば
        1. もし r が null でないならば
          1. もし i > 0 ならば
            1. j = 0 とする
            2. j < r.[[Length]]-1 かつ r[j] が x[i-1] と同じオブジェクトでない間
              1. j = j + 1 とする
          2. そうでなければ
            1. j = r.[[Length]]-1 とする
          3. 引数 ToString(j+1) および y とともに r の [[Insert]] メソッドを呼び出す
        2. もし Type(V) が XML であるならば、y.[[Name]] = V.[[Name]] とする
        3. そうでなく、もし Type(V) が XMLList であるならば、y.[[Name]] = V.[[TargetProperty]] とする
      9. 引数 y とともに x の [[Append]] メソッドを呼び出す
    4. もし Type(V) ∉ {XML, XMLList} または V.[[Class]] ∈ {"text", "attribute"} ならば、V = ToString(V) とする
    5. もし x[i].[[Class]] == "attribute" ならば
      1. z = ToAttributeName(x[i].[[Name]]) とする
      2. 引数 z および V とともに x[i].[[Parent]] の [[Put]] メソッドを呼び出す
      3. attr を、引数 z とともに x[i].[[Parent]] 上で [[Get]] を呼び出した結果とする
      4. x[i] = attr[0] とする
    6. そうでなく、もし Type(V) が XMLList であるならば
      1. V の浅いコピー c を作成する
      2. parent = x[i].[[Parent]] とする
      3. もし parent が null でないならば
        1. q を、parent[q] が x[i] と同じオブジェクトであるような parent のプロパティとする
        2. 引数 q および c とともに parent の [[Replace]] メソッドを呼び出す
        3. j = 0 から c.[[Length]]-1 までに対して
          1. c[j] = parent[ToUint32(q)+j] とする
      4. もし c.[[Length]] == 0 ならば
        1. j = i + 1 から x.[[Length]] - 1 までに対して、x のプロパティ j の名前を ToString(j-1) に変更する
      5. そうでなければ
        1. j = x.[[Length]]-1 から i + 1 までの減少に対して、x のプロパティ j の名前を ToString(j + c.[[Length]] - 1) に変更する
      6. j = 0 から c.[[Length]]-1 までに対して、x[i + j] = c[j] とする
      7. x.[[Length]] = x.[[Length]] + c.[[Length]] - 1 とする
    7. そうでなく、もし Type(V) が XML であるまたは x[i].[[Class]] ∈ {"text", "comment", "processing-instruction"} ならば
      1. parent = x[i].[[Parent]] とする
      2. もし parent が null でないならば
        1. q を、parent[q] が x[i] と同じオブジェクトであるような parent のプロパティとする
        2. 引数 q および V とともに parent の [[Replace]] メソッドを呼び出す
        3. V = parent[q] とする
      3. もし Type(V) が String であるならば
        1. t.[[Class]] = "text" 、t.[[Parent]] = xt.[[Value]] = V である新しい XML オブジェクト t を作成する
        2. x[i] = t とする
      4. そうでなければ
        1. x[i] = V とする
    8. そうでなければ
      1. 引数 "*" および V とともに x[i] の [[Put]] メソッドを呼び出す
  3. そうでなく、もし x.[[Length]] が 1 以下であるならば
    1. もし x.[[Length]] == 0 ならば
      1. r を、x の [[ResolveValue]] メソッドを呼び出した結果とする
      2. もし r == null または r.[[Length]] が 1 と等しくないならば、返る
      3. 引数 r とともに x の [[Append]] メソッドを呼び出す
    2. 引数 P および V とともに x[0] の [[Put]] メソッドを呼び出す
  4. 返る
9.2.1.3 [[Delete]] (P)

概要

XMLList 型は Object 型により定義された内部 [[Delete]] メソッドを上書きする。XMLList [[Delete]] メソッドは XMLList の特定のプロパティをその数値的なプロパティ名により取り除く、またはそれらの XML 属性または要素を名前により取り除く XMLList の XML と評価されるプロパティ上を反復するために使われる。入力引数 P は、数値的なプロパティ名、XML 属性 (先導する "@" 記号により XML 要素の名前から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、プロパティワイルドカード "*" 、または属性ワイルドカード "@*" であってもよい。入力引数 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力引数 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。

動作

XMLList オブジェクト x の [[Delete]] メソッドがプロパティ名 P とともに呼び出されたときは、以下のステップがとられる:

  1. i = ToUint32(P) とする
  2. もし ToString(i) == P ならば
    1. もし ix.[[Length]] 以上であるならば、true を返す
    2. そうでなければ
      1. parent = x[i].[[Parent]] とする
      2. もし parent が null でないならば
        1. もし x[i].[[Class]] == "attribute" ならば
          1. 引数 ToAttributeName(x[i].[[Name]]) とともに parent の [[Delete]] メソッドを呼び出す
        2. そうでなければ
          1. q を、parent[q] が x[i] と同じオブジェクトであるような parent のプロパティとする
          2. 引数 q とともに parent の [[DeleteByIndex]] メソッドを呼び出す
      3. x から名前が P であるプロパティを取り除く
      4. q = i + 1 から x.[[Length]] - 1 までに対して
        1. x のプロパティ ToString(q) の名前を ToString(q - 1) に変更する
      5. x.[[Length]] = x.[[Length]] - 1 とする
    3. true を返す
  3. x 中のそれぞれのプロパティ q に対して
    1. もし q.[[Class]] == "element" ならば
      1. 引数 P とともに q の [[Delete]] メソッドを呼び出す
  4. true を返す
9.2.1.4 [[DefaultValue]] (hint)

概要

XMLList 型は Object 型により定義される内部 [[DefaultValue]] メソッドを上書きする。XMLList [[DefaultValue]] メソッドはこの XMLList オブジェクトを表現するプリミティブ値を返す。Object [[DefaultValue]] メソッドとは異なり、XMLList [[DefaultValue]] メソッドは常に文字列を返す。hint パラメータは無視される。

動作

XMLList オブジェクト list の [[DefaultValue]] メソッドがパラメータ hint とともに呼び出されたとき、以下のステップがとられる:

  1. ToString(list) を返す
9.2.1.5 [[HasProperty]] (P)

概要

XMLList 型は Object 型により定義される内部 [[HasProperty]] メソッドを上書きする。XMLList [[HasProperty]] メソッドは、この XMLList オブジェクトが XML 要素または属性を含んでいるかどうかをその順序的な位置により、またはこの XMLList オブジェクトに含まれる任意のオブジェクトが XML 要素または属性を含んでいるかどうかをその名前により判定するために使われる。入力引数 P は、数値的なプロパティ名、XML 属性 (先導する "@" 記号により XML 要素の名前から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、プロパティワイルドカード "*" 、または属性ワイルドカード "@*" であってもよい。入力要素 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力要素 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。

動作

XMLList オブジェクト x の [[HasProperty]] メソッドがプロパティ名 P とともに呼び出されたとき、以下のステップがとられる:

  1. もし ToString(ToUint32(P)) == P ならば
    1. ToUint32(P) < x.[[Length]] を返す
  2. i = 0 から x.[[Length]]-1 までに対して
    1. もし x[i].[[Class]] == "element" かつ引数 P とともに x[i] の [[HasProperty]] メソッドを呼び出した結果が true であるならば、true を返す
  3. false を返す
9.2.1.6 [[Append]] (V)

概要

XMLList 型は Object 型により定義される内部プロパティに内部 [[Append]] メソッドを追加する。XMLList [[Append]] メソッドは V により指定された 0 個以上の値を XMLList の終端に追加するために使われる。入力引数 V は XMLList または XML 型の値でなければならない。

動作

XMLList オブジェクト x の [[Append]] メソッドが値 V とともに呼び出されたとき、以下のステップがとられる:

  1. i = x.[[Length]] とする
  2. n = 1 とする
  3. もし Type(V) が XMLList であるならば
    1. x.[[TargetObject]] = V.[[TargetObject]] とする
    2. x.[[TargetProperty]] = V.[[TargetProperty]] とする
    3. n = V.[[Length]] とする
    4. もし n == 0 ならば、返る
    5. j = 0 から V.[[Length]]-1 までに対して、x[i + j] = V[j] とする
  4. x.[[Length]] = x.[[Length]] + n とする
  5. 返る
9.2.1.7 [[DeepCopy]] ( )

概要

XMLList 型は Object 型により定義される内部プロパティに内部 [[DeepCopy]] メソッドを追加する。XMLList [[DeepCopy]] メソッドはそのすべてのプロパティの深いコピーを含むこの XMLList オブジェクトのコピーを作成し、返す。

動作

XMLList オブジェクト x の [[DeepCopy]] メソッドが呼び出されたときは、以下のステップがとられる:

  1. list を新しい XMLList オブジェクトとする
  2. x のすべての内部プロパティを list にコピーする
  3. i = 0 から x.[[Length]]-1 までに対して
    1. list[i] を、x[i] の [[DeepCopy]] メソッドを呼び出した結果とする
  4. list を返す
9.2.1.8 [[Descendants]] (P)

概要

XMLList 型は Object 型により定義された内部プロパティに内部 [[Descendants]] メソッドを追加する。XMLList [[Descendants]] メソッドは、入力引数 P と一致する名前を持つ子の XMLList のすべての XML と評価されるプロパティの子孫 (すなわち、子、孫、ひ孫など) を取得するために使われる。入力引数 P は、数値的なプロパティ名、XML 属性 (先導する "@" 記号により XML 要素の名前から区別される) または XML 要素のセットのための非修飾名、XML 要素のセットのための QName 、XML 属性のセットのための AttributeName 、プロパティワイルドカード "*" 、または属性ワイルドカード "@*" であってもよい。入力引数 P が非修飾 XML 要素名であるときは、それはデフォルト名前空間内の XML 要素を識別する。入力要素 P が非修飾 XML 属性名であるときは、それは名前空間に属さない XML 属性を識別する。

動作

XML オブジェクト x の [[Descendants]] メソッドがプロパティ名 P とともに呼び出されたときは、以下のステップがとられる:

  1. list を、list.[[TargetObject]] = null である新しい XMLList とする
  2. q = 0 から x.[[Length]] - 1 までに対して
    1. もし x[q].[[Class]] == "element" ならば
      1. dq を、引数 P とともに x[q] の [[Descendants]] メソッドを呼び出した結果とする
      2. もし dq.[[Length]] > 0 ならば、引数 dq とともに list の [[Append]] メソッドを呼び出す
  3. list を返す
9.2.1.9 [[Equals]] (V)

概要

XMLList 型は Object 型により定義される内部プロパティに内部 [[Equals]] メソッドを追加する。XMLList [[Equals]] メソッドは、この XMLList オブジェクトをほかの XMLList オブジェクト V と内容の等価性で比較する、またはこの XMLList オブジェクトが V と等しく比較される単独の XML オブジェクトを含むかどうかを判定するために使われる。もしこの XMLList オブジェクトが V と等しいと考えられるかまたは V と等しいと考えられる一つの XML オブジェクトのみを含むならば、[[Equals]] 演算子は true を返す。そうでなければ、それは false を返す。空の XMLList オブジェクトは undefined と等しいと考えられる。入力要素 V は XMLList 、XML 型の値、undefined 、または ToString() で String に変換されうる任意の値であってもよい。

動作

XML オブジェクト x の [[Equals]] メソッドが値 V とともに呼び出されたとき、以下のステップがとられる:

  1. もし V == undefined かつ x.[[Length]] == 0 ならば、true を返す
  2. もし Type(V) が XMLList であるならば
    1. もし x.[[Length]] が V.[[Length]] と等しくないならば、false を返す
    2. i = 0 から x.[[Length]] までに対して
      1. もし比較 x[i] == V[i] の結果が false であるならば、false を返す
    3. true を返す
  3. そうでなく、もし x.[[Length]] == 1 ならば
    1. 比較 x[0] == V の結果を返す
  4. false を返す
9.2.1.10 [[ResolveValue]] ( )

概要

XMLList 型は Object 型により定義される内部プロパティに内部 [[ResolveValue]] メソッドを追加する。XMLList [[ResolveValue]] メソッドは空の XMLList の値を解決するために使われる。もしこの XMLList オブジェクトが空でないならば、[[ResolveValue]] メソッドはそれを返すだろう。もしこの XMLList が空であるならば、[[ResolveValue]] メソッドは [[TargetObject]] および [[TargetProperty]] プロパティに基づいてそれを作成することを試みるだろう。もし XMLList が作成されることができないならば、[[ResolveValue]] は null を返す。

動作

XMLList オブジェクト x の [[ResolveValue]] メソッドが呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Length]] > 0 ならば、x を返す
  2. そうでなければ
    1. もし x.[[TargetObject]] == null または x.[[TargetProperty]] == null または type(x.[[TargetProperty]]) が AttributeName であるまたは x.[[TargetProperty]].localName == "*" ならば
      1. null を返す
    2. base を、再帰的に x.[[TargetObject]] の [[ResolveValue]] メソッドを呼び出した結果とする
    3. もし base == null ならば、null を返す
    4. target を、引数 x.[[TargetProperty]] とともに base 上の [[Get]] を呼び出した結果とする
    5. もし target.[[Length]] == 0 ならば
      1. もし Type(base) が XMLList でありかつ base.[[Length]] > 1 ならば、null を返す
      2. 引数 x.[[TargetProperty]] および空文字列とともに base 上で [[Put]] メソッドを呼び出す
      3. target を、引数 x.[[TargetProperty]] とともに base 上で [[Get]] メソッドを呼び出した結果とする
    6. target を返す

9.3 AttributeName 型

内部 AttributeName 型は言語のデータ型ではない。それは純粋に説明的な目的のためにこの仕様により定義される。E4X の実装は、それがここに記述された方法で AttributeName を作り出し操作しているかのように振る舞わなければならない。しかしながら、AttributeName 型の値は、式評価の中間結果としてのみ使われ、変数またはプロパティの値として格納されることはできない。

AttributeName 型は XML 属性の名前を指定する。AttributeName 型の値は AttributeIdentifier を使って指定されてもよい。もし属性の名前が QualifiedIdentifier で指定されないならば、関連付けられた QName の uri プロパティは名前空間に属さないことを表現する空文字列であろう。

9.3.1 内部プロパティ

AttributeName 型は論理的に Object 型から派生し、その内部プロパティを継承する。ほかに指定されない限り、AttributeName 型は Object 型に対して定義された型変換動作 (ECMAScript 第 3 版の章 9) をも継承する。以下の表は Object 型により定義されたものに AttributeName 型が追加する内部プロパティの要約である。

プロパティ パラメータ 説明
[[Name]] なし 属性の名前

[[Name]] プロパティの値は QName 型の値である。

9.4 AnyName 型

内部 AnyName 型は言語のデータ型ではない。それは純粋に説明的な目的のためにこの仕様により定義される。E4X の実装は、それがここに記述された方法で AnyName の値を作り出し操作しているかのように振る舞わなければならない。しかしながら、AnyName 型の値は式評価の中間結果としてのみ使われ、変数またはプロパティの値として格納されることはできない。

AnyName 型は、特定のプロパティの名前が WildcardIdentifier (すなわち、"*") として指定されたということを指し示すために使われる標識型である。AnyName 型は、anyname と呼ばれる正確に一つの値を持つ。

10 型変換

E4X は ECMAScript で定義された自動型変換演算子を拡張する。この章で指定されない限り、XML 型は Object 型に対して定義された型変換動作 (ECMAScript 第 3 版の章 9) を継承する。

注意 ECMAScript 第 3 版においては、これらの型変換関数は内部的であり、ユーザーにより直接アクセス可能ではなかった。これらは必要に応じて E4X のアルゴリズムに現れ、型変換動作の詳細を補助するためにここに記述される。それに加えて、ToString および ToXMLString は、章 13.4.4.3813.4.4.3913.5.4.21 、および 13.5.4.22 で定義される組み込みメソッド toString() および toXMLString() によってE4Xユーザーに間接的に公開される。

10.1 ToString

E4X は ToString 演算子の振る舞いを、以下の型に対するその振る舞いを指定することにより拡張する。

入力型 結果
XML 10.1.1 で定義されたように XML オブジェクトを文字列として返す。
XMLList 10.1.2 で定義されたように XMLList オブジェクトを文字列として返す。
AttributeName 入力引数 a を与えられたとき、文字列 "@" と ToString(a.[[Name]]) との連結の結果を返す。

10.1.1 XML 型に適用される ToString

概要

XML オブジェクト x を与えられたとき、演算子 ToString は x を文字列 s に変換する。もし XML 型の値が単純内容を持つ (すなわち、要素を含まない) ならば、それはプリミティブ値を表現し、ToString は開始タグ、属性、名前空間宣言、終了タグを省略する XML オブジェクトの文字列内容を返す。そうでなければ、ToString は開始タグ、属性、名前空間宣言、終了タグを含む XML オブジェクト全体を表現する文字列を返す。

注意 結果として生じる文字列内容の実際の形式は実装により定義される。

XMLList の ToString の処置 (章 10.1.2 を見よ) と結合して、この振る舞いは E4X プログラマに、彼らがオブジェクトのプロパティの値にアクセスするのと大体同じ方法で XML 葉ノードの値にアクセスすることを可能にする。例えば、以下の XML 値を代入された order と名づけられた変数を与えられたとき:

<order>
   <customer>
      <firstname>John</firstname>
      <lastname>Doe</lastname>
   </customer>
   <item>
      <description>Big Screen Television</description>
      <price>1299.99</price>
      <quantity>1</quantity>
   </item>
</order>

E4X プログラマは XML 値の個別の値にこのようにアクセスできる:

// 顧客のフルネームを構成する
var name = order.customer.firstname + " " + order.customer.lastname;

// 価格の合計を算出する
var total = order.item.price * order.item.quantity;

E4X はプログラマがそれぞれの葉要素に関連付けられたテキストノードを明示的に選択したり、それぞれの XMLList 返り値の最初の要素を明示的に選択したりすることを要求しない。これが望ましい振る舞いではない場合のために、ToXMLString 演算子が提供される (章 10.2 を見よ) 。

注意 上の例で、XML オブジェクト order.item.price および order.item.quantity に関連付けられた String に評価されるプロパティは、乗算操作を実行する前に Number 型に暗黙的に変換される。

[[Class]] が "attribute" または "text" に設定された XML オブジェクトに対して、ToString は単純にそれらの値を文字列として返す。

動作

XML オブジェクト x を与えられたとき、ToString は以下のステップを取る:

  1. もし x.[[Class]] ∈ {"attribute", "text"} ならば、x.[[Value]] を返す
  2. もし x.hasSimpleContent() == true ならば
    1. s を空文字列とする
    2. i = 0 から x.[[Length]]-1 までに対して
      1. もし x[i].[[Class]] ∉ {"comment", "processing-instruction"} ならば
        1. s を、s と ToString(x[i]) との連結の結果とする
    3. s を返す
  3. そうでなければ
    1. ToXMLString(x) を返す

10.1.2 XMLList 型に適用される ToString

概要

演算子 ToString は XMLList オブジェクト list を文字列 s に変換する。返り値は順番に一緒に連結された XMLList 中のそれぞれの項目の文字列表現である。

大きさが 1 であるリスト上で ToString を呼び出した結果は、XMLList に含まれる単独の項目上で ToString を呼び出した結果と同一であることに注意せよ。この処置は、プログラマの作業を単純化するために、故意に単独の XML オブジェクトとひとつの値のみを含む XMLList との間の区別をあいまいにする。それは E4X プログラマに、彼らがオブジェクトのプロパティにアクセスするのと大体同じ方法で単独のプリミティブ値のみを含む XMLList の値にアクセスすることを可能にする。

動作

XMLList オブジェクト list を与えられたとき、ToString は以下のステップを実行する:

  1. もし list.hasSimpleContent() == true ならば
    1. s を空文字列とする
    2. i = 0 から list.[[Length]]-1 までに対して
      1. もし x[i].[[Class]] ∉ {"comment", "processing-instruction"} ならば
        1. s を、s と ToString(list[i]) との連結の結果とする
    3. s を返す
  2. そうでなければ
    1. ToXMLString(list) を返す

10.2 ToXMLString ( input argument, [AncestorNamespaces], [IndentLevel] )

E4X は変換演算子 ToXMLString を ECMAScript に追加する。ToXMLString はその引数を XML で符号化された文字列に変換するために使われる ToString の変形である。ToString とは異なり、それは XML 要素に関連付けられた開始タグ、属性、名前空間宣言、終了タグを内容とは関係なく常に含む。これは既定の ToString の振る舞いが望まれない場合に有効である。ToXMLString の動作は以下の表によって指定される。

入力型 結果
Undefined TypeError 例外を投げる。
Null TypeError 例外を投げる。
Boolean ToString(入力引数) を返す
Number ToString(入力引数) を返す
String EscapeElementValue(入力引数) を返す
XML 10.2.1 で指定されるように XML オブジェクトの内容に基づいた XML に符号化された文字列の値を作成する。
XMLList 10.2.2 で指定されるように XMLList オブジェクトの内容に基づいた XML に符号化された文字列の値を作成する。
Object 以下のステップを適用する:
  1. p を、ToPrimitive(入力引数, ヒント文字列) を呼び出した結果とする
  2. s を、ToString(p) を呼び出した結果とする
  3. EscapeElementValue(s) を返す

10.2.1 XML 型に適用される ToXMLString

動作

XML オブジェクト x および任意的な引数 AncestorNamespaces および任意的な引数 IndentLevel を与えられたとき、ToXMLString は以下のステップを取ることによりそれを XML に符号化された文字列 s に変換する:

  1. s を空文字列とする
  2. もし IndentLevel が提供されていないならば、IndentLevel = 0 とする
  3. もし XML.prettyPrinting == true ならば
    1. i = 0 から IndentLevel-1 までに対して、s を、s とスペース文字 <SP> との連結の結果とする
  4. もし x.[[Class]] == "text" ならば
    1. もし XML.prettyPrinting == true ならば
      1. v を、x.[[Value]] からすべての先導するおよび後続する XMLWhitespace 文字列を取り除いた結果とする
      2. s と EscapeElementValue(v) との連結の結果を返す
    2. そうでなければ
      1. EscapeElementValue(x.[[Value]]) を返す
  5. もし x.[[Class]] == "attribute" ならば、s と EscapeAttributeValue(x.[[Value]]) との連結の結果を返す
  6. もし x.[[Class]] == "comment" ならば、s と文字列 "<!--" 、x.[[Value]] 、および文字列 "-->" との連結の結果を返す
  7. もし x.[[Class]] == "processing-instruction" ならば、s と文字列 "<?" 、x.[[Name]].localName 、スペース文字 <SP> 、x.[[Value]] 、および文字列 "?>" との連結の結果を返す
  8. もし AncestorNamespaces が提供されていないならば、AncestorNamespaces = { } とする
  9. namespaceDeclarations = { } とする
  10. x.[[InScopeNamespaces]] 中のそれぞれの ns に対して
    1. もし ans.uri == ns.uri かつ ans.prefix == ns.prefix であるような ansAncestorNamespaces が存在しないならば
      1. ns1 を、ns のコピーとする
      2. namespaceDeclarations = namespaceDeclarations ∪ { ns1 } とする

        注意 実装は namespaceDeclarations から使用されていない名前空間宣言をも除外してもよい

  11. x.[[Name]] および x.[[Attributes]] 中のそれぞれの属性の名前から成り立つ名前のセット中のそれぞれの name に対して
    1. namespace を、引数 AncestorNamespacesnamespaceDeclarations とともに name 上で [[GetNamespace]] を呼び出した結果のコピーとする
    2. もし namespace.prefix == undefined ならば
      1. namespace.prefix を、namespace.prefix == ns2.prefix である ns2 ∈ (AncestorNamespacesnamespaceDeclarations) が存在しないような、実装により定義される任意の名前空間接頭辞とする
      2. 注意: もしそれがすでにセット AncestorNamespacesnamespaceDeclarations の中で使われていないならば、実装は実装により定義された接頭辞として空文字列を選ぶべきである
      3. namespaceDeclarations = namespaceDeclarations ∪ { namespace } とする
  12. s を、s と文字列 "<" との連結の結果とする
  13. もし namespace.prefix が空文字列でないならば
    1. s を、snamespace.prefix および文字列 ":" との連結の結果とする
  14. s を、sx.[[Name]].localName との連結の結果とする
  15. attrAndNamespaces = x.[[Attributes]] ∪ namespaceDeclarations とする
  16. attrAndNamespaces 中のそれぞれの an に対して
    1. s を、s とスペース文字 <SP> との連結の結果とする
    2. もし Type(an) が XML でありかつ an.[[Class]] == "attribute" ならば
      1. ans を、引数 AncestorNamespaces とともに a.[[Name]] 上で [[GetNamespace]] を呼び出した結果のコピーとする
      2. もし ans.prefix == undefined ならば
        1. ans.prefix を、ans.prefix == ns2.prefix である ns2 ∈ (AncestorNamespacesnamespaceDeclarations) が存在しないような、実装により定義される任意の名前空間接頭辞とする
        2. もし ns2.uri == ans.uri かつ ns2.prefix == ans.prefix であるような ns2 ∈ (AncestorNamespacesnamespaceDeclarations) が存在しないならば
          1. namespaceDeclarations = namespaceDeclarations ∪ { ans } とする
      3. もし ans.prefix が空文字列でないならば
        1. s を、snamespace.prefix および文字列 ":" との連結の結果とする
      4. s を、s と a.[[Name]].localName との連結の結果とする
    3. そうでなければ
      1. s を、s と文字列 "xmlns" との連結の結果とする
      2. もし an.prefix == undefined ならば
        1. an.prefix を、an.prefix == ns2.prefix である ns2 ∈ (AncestorNamespacesnamespaceDeclarations) が存在しないような、実装により定義された任意の名前空間接頭辞とする
      3. もし an.prefix が空文字列でないならば
        1. s を、s と文字列 ":" および an.prefix との連結の結果とする
    4. s を、s と文字列 "=" および二重引用符文字 (すなわち、Unicode コードポイント \u0022) との連結の結果とする
    5. もし an.[[Class]] == "attribute" ならば
      1. s を、s と EscapeAttributeValue(an.[[Value]]) との連結の結果とする
    6. そうでなければ
      1. s を、s と EscapeAttributeValue(an.uri) との連結の結果とする
    7. s を、s と二重引用符文字 (すなわち、Unicode コードポイント \u0022) との連結の結果とする
  17. もし x.[[Length]] == 0 ならば
    1. s を、s と "/>" との連結の結果とする
    2. s を返す
  18. s を、s と文字列 ">" との連結の結果とする
  19. indentChildren = ((x.[[Length]] > 1) または (x.[[Length]] == 1 かつ x[0].[[Class]] が "text" と等しくない)) とする
  20. もし XML.prettyPrintiing == true かつ indentChildren == true ならば
    1. nextIndentLevel = IndentLevel + XML.PrettyIndent とする
  21. そうでなければ
    1. nextIndentLevel = 0 とする
  22. i = 0 から x.[[Length]]-1 までに対して
    1. もし XML.prettyPrinting == true かつ indentChildren == true ならば
      1. s を、sLineTerminator との連結の結果とする
    2. child = ToXMLString (x[i], (AncestorNamespacesnamespaceDeclarations), nextIndentLevel) とする
    3. s を、schild との連結の結果とする
  23. もし XML.prettyPrinting == true and indentChildren == true ならば
    1. s を、sLineTerminator との連結の結果とする
    2. i = 0 から IndentLevel までに対して、s を、s とスペース文字 <SP> との連結の結果とする
  24. s を、s と文字列 "</" との連結の結果とする
  25. もし namespace.prefix が空文字列でないならば
    1. s を、snamespace.prefix および文字列 ":" との連結の結果とする
  26. s を、sx.[[Name]].localName および文字列 ">" との連結の結果とする
  27. s を返す

注意 実装は ToXMLString() の中で重要でない (例えば、要素タグの内部および間の) 空白文字および属性引用規約をも保存してもよい。

10.2.1.1 EscapeElementValue ( s )

動作

文字列の値 s を与えられたとき、演算子 EscapeElementValue は以下のステップを実行する:

  1. r を空文字列とする
  2. s 中のそれぞれの文字 c に対して
    1. もし c == "<" ならば、r を、r と文字列 "&lt;" との連結の結果とする
    2. そうでなく、もし c == ">" ならば、r を、r と文字列 "&gt;" との連結の結果とする
    3. そうでなく、もし c == "&" ならば、r を、r と文字列 "&amp;" との連結の結果とする
    4. そうでなければ、r を、rc との連結の結果とする
  3. r を返す
10.2.1.2 EscapeAttributeValue ( s )

動作

文字列の値 s を与えられたとき、演算子 EscapeAttributeValue を以下のステップを実行する:

  1. r を空文字列とする
  2. s 中のそれぞれの文字 c に対して
    1. もし c が二重引用符文字 (すなわち、") であるならば、r を、r と文字列 "&quot;" との連結の結果とする
    2. そうでなく、もし c == "<" ならば、r を、r と文字列 "&lt;" との連結の結果とする
    3. そうでなく、もし c == "&" ならば、r を、r と文字列 "&amp;" との連結の結果とする
    4. そうでなく、もし c == \u000A ならば、r を、r と文字列 "&#xA;" との連結の結果とする
    5. そうでなく、もし c == \u000D ならば、r を、r と文字列 "&#xD;" との連結の結果とする
    6. そうでなく、もし c == \u0009 ならば、r を、r と文字列 "&#x9;" との連結の結果とする
    7. そうでなければ、r を、rc の連結の結果とする
  3. r を返す

10.2.2 XMLList 型に適用される ToXMLString

動作

XMLList オブジェクト x 、任意的な引数 AncestorNamespaces 、および任意的な引数 IndentLevel を与えられたとき、ToXMLString は以下のステップをとることにより x を XML に符号化された文字列 s に変換する:

  1. s を空文字列とする
  2. i = 0 から x.[[Length]]-1 までに対して
    1. もし XML.prettyPrinting == true かつ i が 0 と等しくないならば
      1. s を、s と LineTerminator との連結の結果とする
    2. s を、s と ToXMLString(x[i], AncestorNamespaces) との連結の結果とする
  3. s を返す

10.3 ToXML

E4X は ECMAScript に演算子 ToXML を追加する。ToXML はその引数を以下の表に従って XML 型の値に変換する:

入力型 結果
Undefined TypeError 例外を投げる。
Null TypeError 例外を投げる。
Boolean 入力引数を ToString を使って文字列に変換し、それからその結果を章 10.3.1 で指定されるように XML に変換する。
Number 入力引数を ToString を使って文字列に変換し、それからその結果を章 10.3.1 で指定されるように XML に変換する。
String 下の章 10.3.1 で指定されるように String から XML オブジェクトを作成する。
XML 入力引数を返す (変換なし) 。
XMLList もし XMLList がひとつのプロパティのみを含みそのプロパティの型が XML であるならば、そのプロパティを返す。そうでなければ、TypeError 例外を投げる。
Object もし入力引数の [[Class]] プロパティが "String" 、"Number" 、または "Boolean" であるならば、入力引数を ToString を使って文字列に変換し、それからその結果を章 10.3.1 で指定されるように XML に変換する。そうでなければ、TypeError 例外を投げる。
W3C XML 情報項目 下の章 10.3.2 で指定されるように W3C XML 情報項目から XML オブジェクトを作成する。

10.3.1 文字列型に適用される ToXML

概要

ToXML が文字列型に適用されたときは、それは文字列を XML として解析することによりそれを XML に変換する。変換の前に、文字列の連結が整形式性といった XML の制約と関係なく XML オブジェクトの部分を構成するために使われうる。例えば、以下を考えよ。

var John = "<employee><name>John</name><age>25</age></employee>";
var Sue = "<employee><name>Sue</name><age>32</age></employee>";
var tagName = "employees";
var employees = new XML("<" + tagName +">" + John + Sue + "</" + tagName +">");

この例の最後の行は単独の文字列の値を形成するためにいくつかの個別の文字列を連結し、それから結果として生じた文字列を XML コンストラクタ関数に渡す。XML コンストラクタ関数は与えられた文字列を XML オブジェクトに変換するために内部 ToXML 演算子を使う。

動作

文字列の値 s を与えられたとき、ToXML は以下のステップを使ってその文字列を XML オブジェクトに変換する:

  1. defaultNamespace = GetDefaultNamespace() とする
  2. parentString を、文字列 "<parent xmlns='" と defaultNamespace 、"'>" 、s 、および "</parent>" との連結の結果とする
  3. parentString を W3C 要素情報項目 e として解析し、もし解析が失敗したならば、SyntaxError 例外を投げる
  4. x = ToXML(e) とする
  5. もし x.[[Length]] == 0 ならば
    1. t.[[Class]] = "text" 、t.[[Parent]] = null 、t.[[Value]] = 空文字列である新しい XML オブジェクト t を返す
  6. そうでなく、もし x.[[Length]] == 1 ならば
    1. x[0].[[Parent]] = null とする
    2. x[0] を返す
  7. そうでなければ、SyntaxError 例外を投げる

注意 W3C XML 情報項目の使用は純粋に説明的なものである。W3C XML 情報項目はこの型変換を実行するために必要とはされず、実装は同じ動作を提供する任意の機構を使ってもよい。

10.3.2 W3C XML 情報項目に適用される ToXML

概要

ToXML が W3C XML 情報セット仕様に適合する W3C XML 情報項目の実装に適用されたときは、それは、E4X の演算子が与えられた情報項目に問い合わせ、巡回し、操作するために使われてもよいように、E4X データモデルを与えられた情報項目にマッピングする。

この章で提供される ToXML の定義は故意に汎用的である。それは実装が W3C DOM オブジェクト、XPath ノード、XQuery 項目、または W3C XML 情報項目にマッピングされうる任意のほかのデータモデルのインスタンスから XML オブジェクトを作成することを許可する。E4X は実装がこれらのデータモデルをサポートすることを要求しないし、またこれらのデータモデルをサポートする実装がそれらから XML オブジェクトを作成する能力を提供することも要求しない。むしろ、これはそれらを実装することを選択した実装に対してそれらの操作の動作を定義する。

例えば、実装は Web ブラウザの中で文書オブジェクトを操作することを容易にするために E4X を配備してもよい。したがって、E4X ユーザーは以下の E4X コードを書いてもよい:

function createTable() {
   var doc = XML(document);      // 文書に対する E4X のラッパを作成する
   var mytablebody = doc..body.TABLE.TBODY;

   for (var j=0;j<2;j++) {
      mytablebody.TR[j] = "";    // 空の表の行を追加する
      for (var i=0;i<2;i++)      // ある内容のセルを追加する
         mytablebody.TR[j].TD[i] = "cell is row " + j + ", column " + i;
   }
   doc..body.TABLE.@border = 2;  // 表の border 属性を設定する
}

下の同等の DOM コードを書く代わりに:

function createTable () {
   var mybody=document.getElementsByTagName("body").item(0);
   mytable = document.createElement("TABLE");
   mytablebody = document.createElement("TBODY");
   for (var j=0;j<2;j++) {
      mycurrent_row=document.createElement("TR");
      for (var i=0;i<2;i++) {
         mycurrent_cell=document.createElement("TD");
         currenttext=document.createTextNode("cell is row "+j+", column "+i);
         mycurrent_cell.appendChild(currenttext);
         mycurrent_row.appendChild(mycurrent_cell);
      }
      mytablebody.appendChild(mycurrent_row);
   }
   mytable.appendChild(mytablebody);
   mybody.appendChild(mytable);
   mytable.setAttribute("border","2");
}

注意 上の最初の例は W3C DOM オブジェクトの周りの E4X ラッパオブジェクトを作成するために XML コンストラクタ関数を使い (行 2) 、それから根底をなす DOM オブジェクトを操作するために結果として生じた E4X オブジェクト上の操作を実行する。実装は、根底をなす DOM オブジェクトを操作しない独立した XML オブジェクトを作成するために、new 式の中で XML コンストラクタを使う (例えば、"var doc = new XML(document);") 能力をも提供してもよい。上で述べられたように、E4X の実装は W3C DOM をサポートするまたは W3C DOM オブジェクトから XML オブジェクトを構築する能力を提供することを要求されない。

動作

W3C 情報項目 i が与えられたとき、ToXML は以下のようにそれを XML オブジェクト x にマッピングする:

  1. x = MapInfoItemToXML(i) とする
  2. もし x が null であるならば、x.[[Class]] = "text" 、x.[[Value]] = "" 、x.[[Parent]] = null である新しい XML オブジェクトを返す
  3. x を返す
10.3.2.1 MapInfoItemToXML ( i )

概要

MapInfoItemToXML が W3C XML 情報項目上で呼び出されたときは、それは null 値か XML オブジェクトかのどちらかを返す。null 値は、W3C XML 情報から E4X データモデルへのマッピングが存在しない、またはマッピングが空の結果を生成する場合に返される。例えば、MapInfoItemToXML は、文書型宣言情報項目上で呼び出されたとき、または XML.ignoreComments が true に設定されコメント情報項目上で呼び出されたときに null を返す。

MapInfoItemToXML で使われる Map-to 記法はその最初の引数と二つ目の引数との間の関係を主張する。特に、それは、最初の引数への変更が二つ目の引数への変更を生じさせ、逆もまた同様であるように、最初の引数と二つ目の引数がそれらが同じオブジェクトであるかのように振舞うことを主張する。例えば、以下のステップの後では:

  1. x.[[Value]] を、i の [content] プロパティにマッピングする

x.[[Value]] へのすべての変更は i の [content] プロパティに適用されるだろう。同様に、i の [content] プロパティへのすべての変更は x に適用されるだろう。

同様に、以下のステップの後では:

  1. x.[[Attributes]] を、i の [attributes] プロパティにマッピングする

セット x.[[Attributes]] に追加されたまたは取り除かれたそれぞれの属性は、i の [attributes] プロパティに同等の追加または削除を生じさせるだろう。同様に、i の [attributes] プロパティに追加されたまたは取り除かれたそれぞれの属性は、x.[[Attributes]] に同等の追加または削除を生じさせるだろう。

もし Map-to への引数の一方が定数値であるならば、引数のどちらも変更されることはできない。しかしながら、定数値にマッピングされた引数はその後異なる値にマッピングされてもよい。

注意 Map-to 関係が執行される機構は実装依存である。Map-to の動作は、ユーザーが E4X でないデータモデルのインスタンス (例えば、W3C DOM ノード) の周りに XML ラッパオブジェクトを作成したときのみ現れる。ほかの場合には、Map-to 記法は Let 記法のように扱われてもよい。

動作

W3C 情報項目 i が与えられたとき、MapInfoItemToXML は以下のようにそれを XML オブジェクト x または null にマッピングする:

  1. x.[[Parent]] を null にマッピングする
  2. もし i が文字情報項目であるならば
    1. x.[[Class]] を "text" にマッピングする
    2. x.[[Value]] を i から始まり文書順で前方に継続する同じ親を持つ文字情報項目の連続的な最大の並びにマッピングする。文字列 x.[[Value]] のそれぞれの文字を、並びの中のそれぞれの文字情報項目の対応する [character code] プロパティにマッピングする。
    3. もし XML.ignoreWhitespace == true かつ x.[[Value]] 中のそれぞれの文字が XMLWhitespaceCharacter であるならば、null を返す
    4. そうでなければ、x を返す
  3. もし i がコメント情報項目であるならば
    1. もし XML.ignoreComments == true ならば、null を返す
    2. x.[[Class]] を "comment" にマッピングする
    3. x.[[Value]] を、i の [content] プロパティにマッピングする
    4. x を返す
  4. もし i が処理命令情報項目であるならば
    1. もし XML.ignoreProcessingInstructions == true ならば、null を返す
    2. x.[[Class]] を "processing-instruction" にマッピングする
    3. x.[[Name]] を、i の [target] プロパティにマッピングする
    4. x.[[Value]] を、i の [content] プロパティにマッピングする
    5. x を返す
  5. もし i が属性情報項目であるならば
    1. x.[[Class]] を "attribute" にマッピングする
    2. x.[[Name]].localName を、i の [local name] プロパティにマッピングする
    3. x.[[Name]].uri を、i の [namespace name] プロパティにマッピングする

      注意 実装はまた、x.[[Name]].[[Prefix]] を、i の [prefix] プロパティにマッピングしてもよい。もし [prefix] が値を持たないならば、x.[[Name]].[[Prefix]] は空文字列にマッピングされる。

    4. x.[[Value]] を、i の [normalized value] プロパティにマッピングする
    5. x を返す
  6. もし i が要素情報項目であるならば
    1. x.[[Class]] を "element" にマッピングする
    2. x.[[Name]].localName を、i の [local name] プロパティにマッピングする
    3. x.[[Name]].uri を、i の [namespace name] プロパティにマッピングする

      注意 実装はまた、x.[[Name].[[Prefix]] を、i の [prefix] プロパティにマッピングしてもよい。もし [prefix] が値を持たないならば、x.[[Name]].[[Prefix]] は空文字列にマッピングされる。

    4. x.[[Attributes]] を、i の [attributes] プロパティにマッピングする
    5. i の [attributes] プロパティ中のそれぞれの属性情報項目 a に対して
      1. x.[[Attributes]] のメンバ attr を、MapInfoItemToXML(a) を呼び出した結果にマッピングする
      2. attr.[[Parent]] を x にマッピングする
    6. [prefix] プロパティが "xml" と等しい名前空間情報項目を除く、i の [in-scope namespaces] プロパティ中のそれぞれの名前空間情報項目 n に対して
      1. x.[[InScopeNamespaces]] のメンバ ns を、以下のように n にマッピングする:
        1. ns.prefix を、n の [prefix] プロパティにマッピングする。もし [prefix] が値を持たないならば、ns.prefix を空文字列にマッピングする。
        2. ns.uri を、n の [namespace name] プロパティにマッピングする
    7. j = 0 とする
    8. xmlChild = 0 とする
    9. x のプロパティのセットを、i の [children] プロパティにマッピングする
    10. numItemChildren を、i の [children] プロパティ中の情報項目の個数とする
    11. j < numItemChildren の間
      1. item を、i の [children] プロパティ中の j 番目の情報項目とする
      2. c = MapInfoItemToXML(item) とする
      3. もし c が null でないならば
        1. x[xmlChild] を、c にマッピングする
        2. x[xmlChild].[[Parent]] を、x にマッピングする
        3. もし c.[[Class]] == "text" ならば
          1. j = j + c.[[Value]].length - 1 とする
        4. xmlChild = xmlChild + 1 とする
      4. j = j + 1 とする
    12. x.[[Length]] を、xmlChild にマッピングする
    13. x を返す
  7. もし i が文書情報項目であるならば
    1. i の [document element] プロパティ上で MapInfoItemToXML を呼び出した結果を返す
  8. もし i が非展開実体参照情報項目であるならば
    1. TypeError 例外を投げる
  9. null を返す

注意 MapInfoItemToXML は文書型宣言情報項目を無視する。

10.4 ToXMLList

E4X は ECMAScript に演算子 ToXMLList を追加する。ToXMLList は以下の表に従ってその引数を XMLList 型の値に変換する:

入力型 結果
Undefined TypeError 例外を投げる
Null TypeError 例外を投げる
Boolean ToString を使って引数を文字列に変換し、それから章 10.4.1 で指定されるようにその結果を XMLList に変換する。
Number ToString を使って引数を文字列に変換し、それから章 10.4.1 で指定されるようにその結果を XMLList に変換する。
String 下の章 10.4.1 で指定されるように String から XMLList オブジェクトを作成する。
XML 入力引数 x を与えられたとき、list.[[Length]] = 1 、list[0] = xlist.[[TargetObject]] = x.[[Parent]] 、list.[[TargetProperty]] = x.[[Name]] である新しい XMLList オブジェクト list を返す。
XMLList 入力引数を返す (変換なし) 。
Object もし入力引数の [[Class]] プロパティが "String" 、"Number" 、または "Boolean" であるならば、ToString を使って入力引数を文字列に変換し、それから章 10.3.1 で指定されるようにその結果を XML に変換する。そうでなければ、TypeError 例外を投げる。

10.4.1 文字列型に適用される ToXMLList

概要

ToXMLList が文字列型に適用されるときは、それは文字列を XML 断片として解析することにより文字列型を XMLList に変換する。変換の前に、文字列の連結が XMLList の値の部分を構成するために使われうる。例えば、

var John = "<employee><name>John</name><age>25</age></employee>";
var Sue = "<employee><name>Sue</name><age>32</age></employee>";
var list = new XMLList(John + Sue);

この例の最後の行は、単独の文字列の値を形成するために二つの文字列を連結し、それから結果として生じた文字列を XMLList コンストラクタ関数に渡す。XMLList コンストラクタ関数は与えられた文字列を XML オブジェクトに変換するために内部 ToXMLList 演算子を使う。

動作

文字列の値 s が与えられたとき、ToXMLList は以下のステップを使いそれを XMLList に変換する:

  1. defaultNamespace = GetDefaultNamespace() とする
  2. parentString を、文字列 "<parent xmlns='" と defaultNamespace 、"'>" 、s 、および "</parent>" とを連結した結果とする
  3. parentString を W3C 要素情報項目 e として解析する
  4. もし解析が失敗したならば、SyntaxError 例外を投げる
  5. x = ToXML(e) とする
  6. list を、list.[[TargetObject]] = null である新しい XMLList とする
  7. i = 0 から x.[[Length]]-1 までに対して
    1. x[i].[[Parent]] = null とする
    2. 引数 x[i] とともに list の [[Append]] メソッドを呼び出す
  8. list を返す

注意 W3C XML 情報項目の使用は純粋に説明的なものである。W3C XML 情報項目はこの型変換を実行するために必要とはされず、実装は同じ動作を提供する任意のほかの機構を使ってもよい。

10.5 ToAttributeName

E4X は ECMAScript に ToAttributeName 演算子を追加する。ToAttributeName は以下の表に従ってその引数を AttributeName 型の値に変換する:

入力型 結果
Undefined TypeError 例外を投げる。
Null TypeError 例外を投げる。
Boolean TypeError 例外を投げる。
Number TypeError 例外を投げる。
String 下の章 10.5.1 で指定されるように文字列から AttributeName を作成する。
XML ToString を使って入力引数を文字列に変換し、それから章 10.5.1 で指定されるようにその結果を AttributeName に変換する。
XMLList ToString を使って入力引数を文字列に変換し、それから章 10.5.1 で指定されるようにその結果を AttributeName に変換する。
Object もし入力引数が QName オブジェクトである (すなわち、内部 [[Class]] プロパティが "QName" である) ならば、その [[Name]] プロパティが入力引数に設定された新しい AttributeName を返す。そうでなければ、ToString を使って入力引数を文字列に変換し、それから章 10.5.1 で指定されるようにその結果を AttributeName に変換する。
AttributeName 入力引数を返す (変換なし) 。
AnyName ToAttributeName("*") を呼び出した結果を返す。

10.5.1 文字列型に適用される ToAttributeName

文字列 s を与えられたとき、ToAttributeName 変換関数は AttributeName a を返す。a の [[Name]] プロパティは、局所名が与えられた文字列に設定され、URI が名前空間に属していないことを表現する空文字列に設定された新しい QName q に設定される。

動作

文字列の値 s が与えられたとき、ToAttributeName は以下のステップを使いそれを AttributeName に変換する:

  1. ns を、コンストラクタ new Namespace() を呼び出したかのように作成された新しい Namespace とする
  2. q を、コンストラクタ new QName(ns, s) を呼び出したかのように作成された新しい QName とする
  3. a.[[Name]] = q である新しい AttributeName a を返す

10.6 ToXMLName

E4X は ECMAScript に演算子 ToXMLName を追加する。ToXMLName は、以下の表に従いその引数を AttributeName 型の値または QName オブジェクトに変換する内部演算子である:

入力型 結果
Undefined TypeError 例外を投げる。
Null TypeError 例外を投げる。
Boolean TypeError 例外を投げる。
Number TypeError 例外を投げる。
String 下の章 10.6.1 で指定されるように、文字列から QName オブジェクトまたは AttributeName を作成する。
XML ToString を使って入力引数を文字列に変換し、それから章 10.6.1 で指定されるようにその結果を QName オブジェクトまたは AttributeName に変換する。
XMLList ToString を使って入力引数を文字列に変換し、それから章 10.6.1 で指定されるようにその結果を QName オブジェクトまたは AttributeName に変換する。
Object もし入力引数が QName オブジェクトである (すなわち、その [[Class]] プロパティが "QName" である) ならば、入力引数を返す。そうでなければ、ToString を使って入力引数を文字列に変換し、それから章 10.6.1 で指定されるようにその結果を QName オブジェクトまたは AttributeName に変換する。
AttributeName 入力引数を返す (変換なし) 。
AnyName ToXMLName("*") を呼び出した結果を返す。

10.6.1 文字列型に適用される ToXMLName

文字列 s が与えられたとき、ToXMLName 変換関数は QName オブジェクトまたは AttributeName を返す。もし s の最初の文字が "@" であるならば、ToXMLName は ToAttributeName 演算子を使って AttributeName を作成する。そうでなければ、それは QName コンストラクタを使って QName オブジェクトを作成する。

動作

文字列の値 s を与えられたとき、ToXMLName 演算子は以下のステップを使ってそれを QName オブジェクトまたは AttributeName に変換する:

  1. もし ToString(ToUint32(s)) == ToString(s) ならば、TypeError 例外を投げる
  2. もし s の最初の文字が "@" であるならば
    1. name = s.substring(1, s.length) とする
    2. ToAttributeName(name) を返す
  3. そうでなければ
    1. コンストラクタ new QName(s) を呼び出したかのように作成された QName オブジェクトを返す

11 式

11.1 主要式

構文

E4X は ECMAScript により定義される主要式を以下の生成規則により拡張する:

PrimaryExpression :
PropertyIdentifier
XMLInitialiser
XMLListInitialiser
PropertyIdentifier :
AttributeIdentifier
QualifiedIdentifier
WildcardIdentifier

動作

生成規則 PrimaryExpression : PropertyIdentifier は以下のように評価される:

  1. n を、PropertyIdentifier を評価した結果とする
  2. name = ToXMLName(n) とする
  3. true の間
    1. もしスコープチェーンにこれ以上オブジェクトがないならば
      1. ReferenceError 例外を投げる
    2. o を、スコープチェーンの次のオブジェクトとする

      注意 最初の反復では、o はスコープチェーンの最初のオブジェクトになるだろう

    3. もし Type(o) ∈ {XML, XMLList} ならば
      1. hasProp を、name をプロパティとして渡して o の [[HasProperty]] メソッドを呼び出した結果とする
      2. もし hasProp == true ならば
        1. 基底オブジェクトが o でありプロパティ名が name である Reference 型の値を返す

生成規則 PropertyIdentifier : AttributeIdentifier は以下のように評価される:

  1. AttributeIdentifier を評価した結果を返す

生成規則 PropertyIdentifier : QualifiedIdentifier および PropertyIdentifier : WildcardIdentifier は、ステップ 1 で AttributeIdentifierQualifiedIdentifier および WildcardIdentifier により置き換えられることを除いて、正確に同じ方法で評価される。

11.1.1 属性識別子

構文

E4X は属性識別子を追加することにより ECMAScript を拡張する。属性識別子の構文は以下の生成規則により指定される:

AttributeIdentifier :
@ PropertySelector
@ QualifiedIdentifier
@ [ Expression ]
PropertySelector :
Identifier
WildcardIdentifier

概要

AttributeIdentifier は XML 属性の名前を識別するために使われる。それは AttributeName 型の値に評価される。先行する "@" 文字は XML 属性を同じ名前の XML 要素から区別する。この AttributeIdentifier 構文はよく知られた XPath 構文との一貫性のために選択された。

動作

生成規則 AttributeIdentifier : @ PropertySelector は以下のように評価される:

  1. name を、PropertySelector において見られるのと同じ文字の並びを含む文字列の値とする
  2. ToAttributeName(name) を返す

生成規則 AttributeIdentifier : @ QualifiedIdentifier は以下のように評価される:

  1. q を、QualifiedIdentifier を評価した結果とする
  2. ToAttributeName(q) を返す

生成規則 AttributeIdentifier : @ [ Expression ] は以下のように評価される:

  1. e を、Expression を評価した結果とする
  2. ToAttributeName(GetValue(e)) を返す

11.1.2 修飾識別子

構文

E4X は修飾識別子を追加することにより ECMAScript を拡張する。修飾識別子の構文は以下の生成規則により指定される:

QualifiedIdentifier :
PropertySelector :: PropertySelector
PropertySelector :: [ Expression ]

概要

QualifiedIdentifier は特定の名前空間内で定義された値を識別するために使われる。それらは名前空間で修飾された XML 要素及び属性名にアクセスし、操作し、作成するために使われてもよい。例えば、

// SOAP メッセージを作成する
var message = <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
       soap:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
   <soap:Body>
      <m:GetLastTradePrice xmlns:m="http://mycompany.com/stocks">
         <symbol>DIS</symbol>
      </m:GetLastTradePrice>
   </soap:Body>
</soap:Envelope>

// SOAP および stocks 名前空間を宣言する
var soap = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
var stock = new Namespace ("http://mycompany.com/stocks");

// SOAP メッセージから SOAP 符号化様式及び本体を抽出する
var encodingStyle = message.@soap::encodingStyle;
var body = message.soap::Body;

// stock 記号を変更する
message.soap::Body.stock::GetLastTradePrice.symbol = "MYCO";

動作

QualifiedIdentifier は QName オブジェクトに評価される。生成規則 QualifiedIdentifier : PropertySelector :: PropertySelector は以下のように評価される:

  1. ns を、最初の PropertySelector を評価した結果とする
  2. もし ns == anyname ならば、ns = null とする
  3. localName を、二つ目の PropertySelector に見られるのと同じ文字の並びを含む文字列の値とする
  4. コンストラクタ new QName(GetValue(ns), localName) を呼び出したかのように作成された新しい QName を返す

生成規則 QualifiedIdentifier : PropertySelector :: [ Expression ] は以下のように評価される:

  1. ns を、PropertySelector を評価した結果とする
  2. もし ns == anyname ならば、ns = null とする
  3. e を、Expression を評価した結果とする
  4. コンストラクタ new QName(GetValue(ns), GetValue(e)) を呼び出したかのように作成された新しい QName を返す

11.1.3 ワイルドカード識別子

構文

E4X はワイルドカード識別子を追加することにより ECMAScript を拡張する。ワイルドカード識別子の構文は以下の生成規則により指定される:

WildcardIdentifier :
*

概要

WildcardIdentifier は任意の名前を識別するために使われる。それは名前空間、XML オブジェクトのプロパティ、または XML 属性に一致するために使われてもよい。ワイルドカード識別子は値 anyname に評価される。

動作

生成規則 WildcardIdentifier : * は以下のように評価される:

  1. anyname を返す

11.1.4 XML 初期化子

概要

XML 初期化子は、リテラルの形式で書かれる XML オブジェクトの初期化を記述する式である。それは普通の XML 構文を使って XML 要素、XML コメント、XML PI 、または CDATA セクションを指定してもよい。XML 要素に対しては、それは名前、XML 属性、および XML オブジェクトの XML プロパティを提供する。

XML 初期化子のための構文文法は XML 初期化子の終端を発見し、埋め込まれた式を評価するために使われる。それは妥当な XML 構文ではない文字の並びを許可する。すべての埋め込まれた式を評価した後は、結果として生じた XML 値を構成する文字の文字列は、より厳しい XML 文法に従ってそれを解析する XML コンストラクタに渡される。

XML 初期化子のための構文文法は、字句文法目標記号 InputElementXMLTag および InputElementXMLContent により生成される入力要素を処理する。これらの入力要素は章 8.3 で記述される。

下記は XML 初期化子の例である。

// 名前と年齢を持つ人物を表現する XML オブジェクト
var person = <person><name>John</name><age>25</age></person>;

// 二人の従業員を表現する XML オブジェクトを含む変数
var e = <employees>
   <employee id="1"><name>Joe</name><age>20</age></employee>
   <employee id="2"><name>Sue</name><age>30</age></employee>
</employees>;

式が XML 初期化子の一部を計算するために使われてもよい。式は波括弧により区切られ、タグまたは要素内容の内部に現れてもよい。タグの内部では、式はタグ名、属性名、または属性値を計算するために使われてもよい。要素の内部では、式は要素内容を計算するために使われてもよい。例えば、

for (var i = 0; i < 10; i++)
   e[i] = <employee id={i}>                  // id の値を計算する
      <name>{names[i].toUpperCase()}</name>  // name の値を計算する
      <age>{ages[i]}</age>                   // age の値を計算する
   </employee>;

それぞれの式はリテラル XML 値を解析する前に評価され、その値により置き換えられる。例えば以下の式は、

var tagname = "name";
var attributename = "id";
var attributevalue = 5;
var content = "Fred";

var x = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>;

変数 x に以下の XML 値を代入するだろう。

<name id="5">Fred</name>

構文

XMLInitialiser :
XMLMarkup
XMLElement
XMLElement :
< XMLTagContent XMLWhitespaceopt />
< XMLTagContent XMLWhitespaceopt > XMLElementContentopt </ XMLTagName XMLWhitespaceopt >
XMLTagContent :
XMLTagName XMLAttributesopt
XMLTagName :
{ Expression }
XMLName
XMLAttributes :
XMLWhitespace { Expression }
XMLAttributeopt XMLAttributes
XMLAttribute :
XMLWhitespace XMLName XMLWhitespaceopt = XMLWhitespaceopt { Expression }
XMLWhitespace XMLName XMLWhitespaceopt = XMLWhitespaceopt XMLAttributeValue
XMLElementContent :
{ Expression } XMLElementContentopt
XMLMarkup XMLElementContentopt
XMLText XMLElementContentopt
XMLElement XMLElementContentopt

動作

生成規則 XMLInitialiser : XMLMarkup は以下のように評価される:

  1. markup を、XMLMarkup と同じ文字の並びを含む文字列リテラルとする
  2. 引数 markup とともに XML コンストラクタを呼び出したかのように作成された新しい XML オブジェクトを返す

生成規則 XMLInitialiser : XMLElement は以下のように評価される:

  1. element を、XMLElement を評価した結果とする
  2. 引数 element とともに XML コンストラクタ (章 13.4.2) を呼び出したかのように作成された新しい XML オブジェクトを返す

生成規則 XMLElement : < XMLTagContent XMLWhitespaceopt /> は以下のように評価される:

  1. content を、XMLTagContent を評価した結果とする
  2. 文字列値 "<" 、後続する content 、後続する文字列値 "/>" を連結した結果を返す

生成規則 XMLElement : < XMLTagContent XMLWhitespaceopt > XMLElementContentopt </ XMLTagContent XMLWhitespaceopt > は以下のように評価される:

  1. startTag を、最初の XMLTagContent を評価した結果とする
  2. content を、XMLElementContent を評価した結果とする。もし存在しないならば、空文字列を使う
  3. endTag を、二つ目の XMLTagContent を評価した結果とする
  4. 文字列値 "<" 、後続する startTag 、後続する文字列値 ">" 、後続する content 、後続する文字列値 "</" 、後続する endTag 、後続する文字列値 ">" を連結した結果を返す

生成規則 XMLTagContent : XMLTagName XMLAttributesopt は以下のように評価される:

  1. name を、XMLTagName を評価した結果とする
  2. attributes を、XMLAttributesopt を評価した結果とする。もし存在しないならば、空文字列を使う
  3. name 、後続する attributes を連結した結果を返す

生成規則 XMLTagName : { Expression } は以下のように評価される:

  1. expRef を、Expression を評価した結果とする
  2. expression = GetValue(expRef) とする
  3. ToString(expression) を評価した結果を返す

生成規則 XMLTagName : XMLName は以下のように評価される:

  1. XMLName と同じ文字の並びを含む文字列リテラルを返す

生成規則 XMLAttributes : XMLWhitespace { Expression } は以下のように評価される:

  1. expRef を、Expression を評価した結果とする
  2. expression = GetValue(expRef) とする
  3. attribute = ToString(expression) とする
  4. 単独のスペース文字を含む文字列と attribute との連結の結果を返す

生成規則 XMLAttributes : XMLAttributeopt XMLAttributes は以下のように評価される:

  1. attribute を、XMLAttributeopt を評価した結果とする。もし存在しないならば、空文字列を使う
  2. attributes を、XMLAttributes を評価した結果とする
  3. attributeattributes とを連結した結果を返す

生成規則 XMLAttribute : XMLWhitespace XMLName XMLWhitespaceopt = XMLWhitespaceopt { Expression } は以下のように評価される:

  1. name を、XMLName と同じ文字の並びを含むリテラル文字列とする
  2. expRef を、Expression を評価した結果とする
  3. expression = GetValue(expRef) とする
  4. value を、EscapeAttributeValue(ToString(expression)) を呼び出した結果とする
  5. 単独のスペース文字を含む文字列と name 、'=' 文字を含む文字列、および value とを連結した結果を返す

生成規則 XMLAttribute : XMLWhitespace XMLName XMLWhitespaceopt = XMLWhitespaceopt XMLAttributeValue は以下のように評価される:

  1. name を、XMLName と同じ文字の並びを含むリテラル文字列とする
  2. value を、XMLAttributeValue と同じ文字の並びを含む文字列リテラルとする
  3. 単独のスペース文字を含む文字列と name 、'=' 文字を含む文字列、および value とを連結した結果を返す

生成規則 XMLElementContent : { Expression } XMLElementContentopt は以下のように評価される:

  1. expRef を、Expression を評価した結果とする
  2. expression = GetValue(expRef) とする
  3. もし Type(expression) ∈ {XML, XMLList} ならば
    1. value を、ToXMLString(expression) を呼び出した結果とする
  4. そうでなければ
    1. value を、EscapeElementValue(ToString(expression)) を呼び出した結果とする
  5. content を、XMLElementContentopt を評価した結果とする。もし存在しないならば、空文字列を使う
  6. value と後続する content とを連結した結果を返す

生成規則 XMLElementContent : XMLMarkup XMLElementContentopt は以下のように評価される:

  1. markup を、XMLMarkup を評価した結果とする
  2. content を、XMLElementContentopt を評価した結果とする。もし存在しないならば、空文字列を使う
  3. markup と後続する content とを連結した結果を返す

生成規則 XMLElementContent : XMLText XMLElementContentopt は以下のように評価される:

  1. text を、XMLText と同じ文字の並びを含む文字列リテラルとする
  2. content を、XMLElementContentopt を評価した結果とする。もし存在しないならば、空文字列を使う
  3. text と後続する content とを連結した結果を返す

生成規則 XMLElementContent : XMLElement XMLElementContentopt は以下のように評価される:

  1. element を、XMLElement を評価した結果とする
  2. content を、XMLElementContentopt を評価した結果とする。もし存在しないならば、空文字列を使う
  3. element と後続する content とを連結した結果を返す

11.1.5 XMLList 初期化子

概要

XMLList 初期化子は、リテラルのようである形式で書かれた XMLList オブジェクトの初期化を記述する式である。それは無名 XML 要素構文を使って順序付けされた XML プロパティのリストを記述する。XMLList 初期化子は文字の並び "<>" で始まり、文字の並び "</>" で終わる。

XML 初期化子のための構文文法は、字句文法目標記号 InputElementXMLTag および InputElementXMLContent により生成される入力要素を処理する。これらの入力要素は章 8.3 で記述される。

下記は XMLList 初期化子の例である、

var docfrag = <><name>Phil</name><age>35</age><hobby>skiing</hobby></>;

var emplist = <>
   <employee id="0" ><name>Jim</name><age>25</age></employee>
   <employee id="1" ><name>Joe</name><age>20</age></employee>
   <employee id="2" ><name>Sue</name><age>30</age></employee>
</>;

構文

XMLListInitialiser :
< > XMLElementContent </ >

動作

生成規則 XMLListInitialiser : < > XMLElementContentopt </ > は以下のように評価される:

  1. content を、XMLElementContent を評価した結果とする。もし存在しないならば、空文字列を使う
  2. 引数 content とともに XMLList コンストラクタを呼び出したかのように作成された新しい XMLList オブジェクトを返す

11.2 左辺式

E4X は ECMAScript で定義された左辺式を以下の生成規則で拡張する:

MemberExpression :
MemberExpression . PropertyIdentifier
MemberExpression .. Identifier
MemberExpression .. PropertyIdentifier
MemberExpression . ( Expression )
CallExpression :
CallExpression . PropertyIdentifier
CallExpression .. Identifier
CallExpression .. PropertyIdentifier
CallExpression . ( Expression )

それに加えて、E4X は XML および XMLList 型の値に適用される既存の左辺式に対する新しい動作を定義する。

11.2.1 プロパティアクセサ

構文

E4X は XML および XMLList 型の値のプロパティおよび XML 属性にアクセスするために ECMAScript のプロパティアクセサ構文を再利用し拡張する。XML プロパティは以下のどちらかを使って名前によりアクセスされてもよい。ドット記法か:

MemberExpression . Identifier
MemberExpression . PropertyIdentifier
CallExpression . Identifier
CallExpression . PropertyIdentifier

または角括弧記法:

MemberExpression [ Expression ]
CallExpression [ Expression ]

概要

MemberExpression または CallExpression が XML オブジェクトに評価されるときは、プロパティアクセサは結果を確定するために XML [[Get]] メソッドを使う。もし右オペランドが配列の添字に評価されるならば、XML [[Get]] メソッドは XML オブジェクトを XMLList に変換し、結果と生じた XMLList から要求されたプロパティを取得する。この処置は故意に単独の XML オブジェクトとただひとつの値のみを含む XMLList との間の区別をあいまいにする。そうでなければ、XML [[Get]] メソッドは左オペランドの XML プロパティおよび XML 属性を検査し、その右オペランドに一致する名前のものを順番に含む XMLList を返す。例えば、

var order = <order id = "123456" timestamp="Mon Mar 10 2003 16:03:25 GMT-0800 (PST)">
   <customer>
      <firstname>John</firstname>
      <lastname>Doe</lastname>
   </customer>
   <item>
      <description>Big Screen Television</description>
      <price>1299.99</price>
      <quantity>1</quantity>
   </item>
</order>;

var customer = order.customer;   // order から customer 要素を取得する
var id = order.@id;              // order から id 属性を取得する
var orderChildren = order.*;     // order 要素からすべての子要素を取得する
var orderAttributes = order.@*;  // order 要素からすべての属性を取得する

// 最初の (および唯一の) order を取得する [単独の要素をリストとして扱う]
var firstOrder = order[0];

MemberExpression または CallExpression が XMLList に評価されるときは、プロパティアクセサは結果を確定するために XMLList [[Get]] メソッドを使う。もし角括弧記法が数値的な識別子とともに使われたならば、XMLList [[Get]] メソッドは単純に数値的な識別子と一致するプロパティ名を持つ左オペランドのプロパティを返す。そうでなければ、XMLList [[Get]] メソッドはリスト中のそれぞれの XML オブジェクトにプロパティアクセサ操作を適用し、その結果を順番に含む新しい XMLList を返す。例えば、

var order = <order>
   <customer>
      <firstname>John</firstname>
      <lastname>Doe</lastname>
   </customer>
   <item id = "3456">
      <description>Big Screen Television</description>
      <price>1299.99</price>
      <quantity>1</quantity>
   </item>
   <item id = "56789">
      <description>DVD Player</description>
      <price>399.99</price>
      <quantity>1</quantity>
   </item>
</order>;

var descriptions = order.item.description;  // すべての item の説明のリストを取得する
var itemIds = order.item.@id;               // すべての item の id 属性のリストを取得する
var secondItem = order.item[1];             // 二つ目の item を数値的な添字により取得する
var itemChildren = order.item.*;            // すべての item のすべての子要素のリストを取得する
var secondItemChild = order.item.*[1];      // すべての item のリストから二つ目の子を取得する

上の最初のプロパティアクセサ文に置いて、式 "order.item" は "order" に束縛された XML オブジェクトの XML プロパティを検査し、"item" と名づけられた二つの XML オブジェクトを含む XMLList を返す。式 "order.item.description" はそれから結果として生じた XMLList 中のそれぞれの item の XML プロパティを検査し、"description" と名づけられた二つの XML オブジェクトを含む XMLList を返す。

MemberExpression または CallExpression が XML または XMLList 型の値に評価されず式の右辺側が Identifier であるときは、プロパティアクセサは ECMAScript 第 3 版で指定された動作に従って実行される。しかしながら、もし MemberExpression または CallExpression が XML または XMLList 型の値に評価されず式の右辺側が PropertyIdentifier であるときは、プロパティアクセサは TypeError 例外を投げる。

動作

ECMAScript 第 3 版のように、以下の生成規則の振る舞いは:

MemberExpression : MemberExpression . Identifier

以下の生成規則の振る舞いと同一である:

MemberExpression : MemberExpression [ <identifier-string> ]

同様に、以下の生成規則の振る舞いは:

CallExpression : CallExpression . Identifier

以下の生成規則の振る舞いと同一である:

CallExpression : CallExpression [ <identifier-string> ]

ただし <identifier-string>Identifier と同じ文字の並びを含む文字列リテラルである場合において。

生成規則 MemberExpression : MemberExpression [ Expression ] は以下のように評価される:

  1. oRef を、MemberExpression を評価した結果とする
  2. o = ToObject(GetValue(oRef)) とする
  3. pRef を、Expression を評価した結果とする
  4. p = GetValue(pRef) とする
  5. もし Type(p) ∈ {AttributeName, AnyName} または (Type(p) が Object でありかつ p.[[Class]] == "QName") ならば
    1. もし Type(o) ∈ {XML, XMLList} ならば
      1. 基底オブジェクトが o でありプロパティ名が ToXMLName(p) である Reference 型の値を返す
    2. そうでなければ
      1. TypeError 例外を投げる
  6. 基底オブジェクトが o でありプロパティ名が ToString(p) である Reference 型の値を投げる

生成規則 CallExpression : CallExpression [ Expression ] は、ステップ 1 で含まれる CallExpression が評価されることを除いて正確に同じ方法で評価される。

生成規則 MemberExpression : MemberExpression . PropertyIdentifier は、ステップ 3 で含まれる PropertyIdentifier が評価されることを除いて正確に生成規則 MemberExpression : MemberExpression [ Expression ] のように振舞う。同様に、生成規則 CallExpression : CallExpression . PropertyIdentifier は、ステップ 3 で含まれれる PropertyIdentifier が評価されることを除いて正確に生成規則 CallExpression : CallExpression [ Expression ] のように振舞う。

11.2.2 関数呼び出し

構文

E4X は XML および XMLList 型の値の上でメソッドを呼び出すために ECMAScript の関数呼び出し構文を再利用する。関数呼び出しのための ECMAScript 構文は以下の生成規則により記述される:

CallExpression :
MemberExpression Arguments
Arguments :
( )
( ArgumentList )
ArgumentList :
AssignmentExpression
ArgumentList , AssignmentExpression

概要

Object 型の値とは異なり、XML および XMLList 型の値は、XML メソッド名が XML プロパティ名と衝突しないようにメソッドから独立してプロパティを格納し取得する。例えば、

var rectangle = <rectangle>
   <x>50</x>
   <y>75</y>
   <length>20</length>
   <width>30</width>
</rectangle>;

var numRectangles = rectangle.length(); // <rectangle> 要素の数、1 を返す
var rectangleLength = rectangle.length; // <length> 要素の内容、20 を返す

rectangle.length = 50;                  // rectangle の length 要素を変更する

これを達成するために、E4X は呼び出し式の動作を操作 CallMethod (章 11.2.2.1 を見よ) を呼び出すように修正する。

動作

生成規則 CallExpression : MemberExpression Arguments は以下のように評価される:

  1. r を、MemberExpression を評価した結果とする
  2. args を、Arguments を評価し、引数の値の内部リストを生成した結果とする
  3. 操作 CallMethod(r, args) を呼び出した結果を返す
11.2.2.1 CallMethod ( r , args )

概要

CallMethod 抽象演算子は関数およびメソッドを呼び出すためにこの仕様で使われる。この演算子は言語の一部ではない。それは言語の詳細を補助するためにここで定義される。

操作 CallMethod が単独のパラメータ r とともに呼び出されたときは、それは最初に r が Reference であるかを確認する。もしそうでないならば、それは r を関数として呼び出すことを試みる。しかしながら、もし r が Reference であるならば、それは Reference r から基底およびプロパティ名を抽出する。それから、CallMethod は与えられたプロパティ名とともに基底オブジェクトのプロパティを取得するために Object [[Get]] メソッドを呼び出す。

注意 XML および XMLList [[Get]] メソッドはメソッド検索のためには決して呼び出されない。

もしそのようなプロパティが存在せず基底が大きさ 1 の XMLList であるならば、CallMethod はそれが含む単独のプロパティにメソッド呼び出しを委譲する。この処置は故意に XML オブジェクトと大きさ 1 の XMLList との間の区別をあいまいにする。

もしそのようなプロパティが存在せず基底が XML に評価される子を含まない XML オブジェクト (すなわち、属性、葉ノードまたは単純内容の要素) であるならば、CallMethod は葉ノードに含まれる文字列の値にメソッド検索を委譲することを試みる。この処置は、ユーザーが明示的にそれを選択することなく直接葉ノードの値に操作を実行することを可能にする。例えば、

var shipto= <shipto>
   <name>Fred Jones</name>
   <street>123 Foobar Ave.</street>
   <citystatezip>Redmond, WA, 98008</citystatezip>
</shipto>

// テキストノードの値上で String.toUpperCase を呼び出す
var upperName = shipto.name.toUpperCase();

// 住所を解析するためにテキストノード上で String.split() を呼び出す
var citystatezip = shipto.citystatezip.split(", ");

var state = citystatezip[1];  // 行を個別の都市、州、および郵便番号へ
var zip = citystatezip[2];

動作

Reference r および引数のリスト args を与えられたとき、操作 CallMethod は以下のステップを実行する:

  1. f = r とする
  2. base = null とする
  3. もし Type(r) が Reference であるならば
    1. base = GetBase(r) とする
    2. もし base == null ならば、ReferenceError 例外を投げる
    3. P = GetPropertyName(r) とする
    4. f を、引数 P とともに base を this オブジェクトとして Object [[Get]] メソッドを呼び出した結果とする
    5. もし f == undefined かつ Type(base) が XMLList でありかつ base.[[Length]] == 1 ならば
      1. r0 を、基底オブジェクト = base[0] でありプロパティ名 = P である新しい Reference とする
      2. 再帰的に CallMethod(r0, args) を呼び出した結果を返す
    6. もし f == undefined かつ Type(base) が XML でありかつ base.hasSimpleContent() == true ならば
      1. r0 を、基底オブジェクト = ToObject(ToString(base)) でありプロパティ名 = P である新しい Reference とする
      2. 再帰的に CallMethod(r0, args) を呼び出した結果を返す
  4. もし Type(f) が Object でないならば、TypeError 例外を投げる
  5. もし f が内部 [[Call]] メソッドを実装しないならば、TypeError 例外を投げる
  6. もし base が活性化オブジェクトであるならば、base = null
  7. base を this の値としておよびリスト args を引数の値として提供して f の [[Call]] メソッドを呼び出した結果を返す

11.2.3 XML 子孫アクセサ

構文

E4X は子孫アクセサを追加することにより ECMAScript を拡張する。以下の生成規則は子孫アクセサの構文を記述する:

MemberExpression :
MemberExpression .. Identifier
MemberExpression .. PropertyIdentifier
CallExpression :
CallExpression .. Identifier
CallExpression .. PropertyIdentifier

概要

MemberExpression または CallExpression が XML オブジェクトまたは XMLList に評価されるときは、子孫アクセサはその左オペランドのすべての子孫 XML プロパティ (すなわち、子、孫、ひ孫など) を検査し、その右オペランドに一致する名前のものを順番に含む XMLList を返す。例えば、

var e = <employees>
   <employee id="1"><name>Joe</name><age>20</age></employee>
   <employee id="2"><name>Sue</name><age>30</age></employee>
</employees>;

var names = e..name;  // e の中のすべての name を取得する

動作

生成規則 MemberExpression : MemberExpression .. Identifier は以下のように評価される:

  1. ref を、MemberExpression を評価した結果とする
  2. x = GetValue(ref) とする
  3. もし Type(x) ∉ {XML, XMLList} ならば、TypeError 例外を投げる
  4. P を、Identifier と同じ文字の並びを含む文字列の値とする
  5. 引数 P とともに x の [[Descendants]] メソッドを呼び出した結果を返す

生成規則 CallExpression : CallExpression .. Identifier は、ステップ 1 で含まれる CallExpression が評価されることを除いて正確に同じ方法で評価される。

生成規則 MemberExpression : MemberExpression .. PropertyIdentifier は以下のように評価される:

  1. ref を、MemberExpression を評価した結果とする
  2. x = GetValue(ref) とする
  3. もし Type(x) ∉ {XML, XMLList} ならば、TypeError 例外を投げる
  4. P を、PropertyIdentifier を評価した結果とする
  5. 引数 P とともに x の [[Descendants]] メソッドを呼び出した結果を返す

生成規則 CallExpression : CallExpression .. PropertyIdentifier は、ステップ 1 で含まれる CallExpression が評価されることを除いて正確に同じ方法で評価される。

11.2.4 XML 選別述語演算子

構文

E4X は選別述語演算子を追加することにより ECMAScript を拡張する。以下の生成規則は選別述語演算子の構文を記述する:

MemberExpression :
MemberExpression . ( Expression )
CallExpression :
CallExpression . ( Expression )

概要

左オペランドが XML オブジェクトに評価されるときは、選別述語は現在の実行文脈のスコープチェーンの先頭に左オペランドを追加し、拡大されたスコープチェーンとともに Expression を評価し、その結果をブール値に変換し、それからスコープチェーンを復元する。もしその結果が true であるならば、選別述語はその左オペランドを含む XMLList を返す。そうでなければ、それは空の XMLList を返す。

左オペランドが XMLList であるときは、選別述語は、XML オブジェクトを左オペランドとしておよび Expression を右オペランドとして使って、XMLList 中のそれぞれの XML オブジェクトに順番に適用される。それは結果を連結し、結果が true であったすべての XML プロパティを含む単独の XMLList としてそれらを返す。例えば、

var john = e.employee.(name == "John");                // 名前が John である従業員
var twoemployees = e.employee.(@id == 0 || @id == 1);  // id が 0 または 1 である従業員
var emp = e.employee.(@id == 1).name;                  // id が 1 である従業員の名前

選別述語の効果は SQL の WHERE 節または XPath の選別述語に似ている。

例えば、以下の文は:

// 述語を使って id が 0 または 1 である二人の従業員を取得する
var twoEmployees = e..employee.(@id == 0 || @id == 1);

以下の文のセットと同じ結果を生成する:

// for ループを使って id が 0 または 1 である二人の従業員を取得する
var i = 0;
var twoEmployees = new XMLList();
for each (var p in e..employee) {
   with (p) {
      if (@id == 0 || @id == 1) {
         twoEmployees[i++] = p;
      }
   }
}

動作

生成規則 MemberExpression : MemberExpression . ( Expression ) は以下のように評価される:

  1. objref を、MemberExpression を評価した結果とする
  2. x = GetValue(objref) とする
  3. もし Type(x) ∉ {XML, XMLList} ならば、TypeError 例外を投げる
  4. list = ToXMLList(x) とする
  5. r を、r.[[TargetObject]] = null である新しい XMLList とする
  6. i = 0 から list.[[Length]]-1 までに対して
    1. list[i] をスコープチェーンの先頭に追加する
    2. ref を、ステップ 6a で拡大されたスコープチェーンを使って Expression を評価した結果とする
    3. match = ToBoolean(GetValue(ref)) とする
    4. list[i] をスコープチェーンの先頭から取り除く
    5. もし match == true ならば、引数 list[i] とともに r の [[Append]] メソッドを呼び出す
  7. r を返す

生成規則 CallExpression : CallExpression . ( Expression ) は、ステップ 1 で含まれる CallExpression が評価されることを除いて、正確に同じ方法で記述される。

11.3 単項演算子

11.3.1 delete 演算子

この章は delete 演算子上での XML [[Delete]] 演算子の効果を記述するために提供される。E4X は、XML および XMLList [[Delete]] 演算子により指定されるものを超える、ECMAScript delete 演算子の構文または動作へのいかなる拡張をも定義しない。

構文

E4X は XML オブジェクトおよび XMLList から XML プロパティおよび XML 属性を削除するために ECMAScript delete 演算子を再利用する。delete 演算子の構文は以下の生成規則により記述される:

UnaryExpression :
delete UnaryExpression

概要

UnaryExpression が XML 型の基底オブジェクトを持つ Reference r に評価されるときは、delete 演算子は r のプロパティ名により指定される XML 属性またはプロパティを基底オブジェクトから取り除く。UnaryExpression が XMLList 型の基底オブジェクトを持つ Reference r に評価されるときは、delete 演算子は r のプロパティ名により指定される XML オブジェクトを基底オブジェクトまたは関連付けられた XML オブジェクトから取り除く。例えば、

delete order.customer.address;  // 顧客の住所を削除する
delete order.customer.@id;      // 顧客の ID を削除する
delete order.item.price[0];     // item の最初の price を削除する
delete order.item;              // すべての item を削除する

動作

E4X は、UnaryExpression が基底が XML または XMLList 型である Reference 型の値に評価されるときに使われる、より複雑な [[Delete]] メソッド (章 9.1.1.3 および 9.2.1.3 をそれぞれ見よ) を提供するために delete 演算子の動作を拡張する。もしオペランドの型が XMLList であるならば、TypeError 例外が投げられる。

11.3.2 typeof 演算子

構文

E4X は XML および XMLList オブジェクトの型を判別するために ECMAScript の typeof 演算子の構文を再利用する。typeof 演算子のための ECMAScript の構文は以下の生成規則により記述される:

UnaryExpression :
typeof UnaryExpression

概要

E4X は XML および XMLList オブジェクトの型を判定するために ECMAScript typeof 演算子の動作を拡張する。UnaryExpression が XML 型の値に評価されるときは、typeof 演算子は文字列 "xml" を返す。UnaryExpression が XMLList 型の値に評価されるときは、typeof 演算子は文字列 "xml" を返す。

動作

生成規則 UnaryExpression : typeof UnaryExpression は以下のように評価される:

  1. u を、UnaryExpression を評価した結果とする
  2. もし Type(u) が Reference でありかつ GetBase(u) が null であるならば、"undefined" を返す
  3. 以下の表に従って Type(GetValue(u)) により判定される文字列を返す:
結果
Undefined "undefined"
Null "object"
Boolean "boolean"
Number "number"
String "string"
XML "xml"
XMLList "xml"
Object (ネイティブでありかつ [[Call]] を実装していない) "object"
Object (ネイティブでありかつ [[Call]] を実装している) "function"

11.4 加法演算子

構文

E4X は XML または XMLList 型の二つの値を連結するために ECMAScript の加算演算子の構文を再利用する。加算演算子のための ECMAScript の構文は以下の生成規則により記述される:

AdditiveExpression :
AdditiveExpression + MultiplicativeExpression

11.4.1 加算演算子 (+)

概要

E4X は、文字列の連結か XML および XMLList の連結か数値的加算かのどれかをその引数に応じて実行するために ECMAScript の加算演算子の動作を拡張する。

AdditiveExpression および MultiplicativeExpression の両方が XML オブジェクトまたは XMLList のどちらかに評価されるときは、加算演算子は返り値として新しい空の XMLList を作成することから始める。もし左オペランドが XML オブジェクトに評価されるならば、それは返り値に追加される。もし左オペランドが XMLList に評価されるならば、その XMLList のそれぞれの XML プロパティは順に返り値に追加される。同様に、もし右オペランドが XML オブジェクトに評価されるならば、それは返り値に追加される。そうでなく、もしそれが XMLList であるならば、その XMLList のそれぞれの XML プロパティは順に返り値に追加される。

例えば、

// 要素 <name> 、<age> 、および <hobby> を含む XMLList を作成する
var employeedata = <name>Fred</name> + <age>28</age> + <hobby>skiing</hobby>;

// order 要素から抽出された三つの item 要素を含む XMLList を作成する
var myitems = order.item[0] + order.item[2] + order.item[3];

// ひとつ新しいものを加えた order 中のすべての item を含む新しい XMLList を作成する
var newitems = order.item + <item><description>new item</description></item>;

注意 XML および XMLList 型のオペランドとともに加算演算子を使うことは常に XMLList を生じさせる。XML オブジェクトの数値的加算が望まれるときは、オペランドは明示的に数値に強制されなければならない。これは単項 "+" 演算子または Number 変換関数を使うことにより達成されてもよい。例えば、

// order 中の最初および三つ目の item の price を加える (単項 + による強制)
var totalPrice = +order.item[0].price + +order.item[2].price

// order 中の二つ目および四つ目の item の price を加える (Number 変換関数を使った強制)
var totalPrice = Number(order.item[1].price) + Number(order.item[3].price)

同様に、XML オブジェクトの文字列連結が望まれるときは、少なくともひとつのオペランドは明示的に文字列に強制されなければならない。これはそれらを空文字列 ("") と連結するまたは String 変換関数を使うことにより達成されてもよい。例えば、

// customer の address の street および city を連結する (空文字列による強制)
var streetcity = "" + order.customer.address.street + order.customer.address.city;

// customer の address の state および zip を連結する (String 変換関数を使った強制)
var statezip = String(order.customer.address.state) + order.customer.address.zip;

動作

生成規則 AdditiveExpression : AdditiveExpression + MultiplicativeExpression は以下のように評価される:

  1. a を、AdditiveExpression を評価した結果とする
  2. left = GetValue(a) とする
  3. m を、MultiplicativeExpression を評価した結果とする
  4. right = GetValue(m) とする
  5. もし Type(left) ∈ {XML, XMLList} かつ Type(right) ∈ {XML, XMLList} ならば
    1. list を、新しい XMLList とする
    2. 引数 x とともに list の [[Append]] メソッドを呼び出す
    3. 引数 y とともに list の [[Append]] メソッドを呼び出す
    4. list を返す
  6. pLeft = ToPrimitive(left) とする
  7. pRight = ToPrimitive(right) とする
  8. もし Type(pLeft) が String であるまたは Type(pRight) が String であるならば
    1. ToString(pLeft) と ToString(pRight) とを連結した結果を返す
  9. そうでなければ
    1. ToNumber(pLeft) と ToNumber(pRight) に加算操作を適用し、その結果を返す。詳細は ECMAScript 第 3 版の章 11.6.3 を見よ。

11.5 等価演算子

11.5.1 抽象等価性比較アルゴリズム

概要

E4X は、QName および Namespace オブジェクトおよび XML および XMLList 型に関連する等価性比較を可能にするために、ECMAScript により定義される抽象等価性比較アルゴリズムを拡張する。

動作

x および y が値である比較 x == y は true または false を生成する。この比較は以下のステップを使って実行される:

  1. もし Type(x) が XMLList であるならば、引数 y とともに x の [[Equals]] メソッドを呼び出しその結果を返す
  2. もし Type(y) が XMLList であるならば、引数 x とともに y の [[Equals]] メソッドを呼び出しその結果を返す
  3. もし Type(x) が Type(y) と同じであるならば
    1. もし Type(x) が XML であるならば
      1. もし (x.[[Class]] ∈ {"text", "attribute"} かつ y.hasSimpleContent()) または (y.[[Class]] ∈ {"text", "attribute"} かつ x.hasSimpleContent()) ならば
        1. 比較 ToString(x) == ToString(y) の結果を返す
      2. そうでなければ、引数 y とともに x の [[Equals]] メソッドを呼び出した結果を返す
    2. もし Type(x) が Object でありかつ x.[[Class]] == "QName" かつ y.[[Class]] == "QName" ならば
      1. もし比較 x.uri == y.uri の結果が true でありかつ比較 x.localName == y.localName の結果が true であるならば、true を返す。そうでなければ、false を返す
    3. もし Type(x) が Object でありかつ x.[[Class]] == "Namespace" かつ y.[[Class]] == "Namespace" ならば、比較 x.uri == y.uri の結果を返す
    4. もし Type(x) が undefined ならば、true を返す
    5. もし Type(x) が null ならば、true を返す
    6. もし Type(x) が Number ならば
      1. もし x が NaN ならば、false を返す
      2. もし y が NaN ならば、false を返す
      3. もし xy と同じ数値であるならば、true を返す
      4. もし x が +0 でありかつ y が -0 であるならば、true を返す
      5. もし x が -0 でありかつ y が +0 であるならば、true を返す
      6. false を返す
    7. もし Type(x) が String であるならば、もし xy が正確に同じ文字の並び (同じ長さかつ対応する位置に同じ文字) ならば、true を返す。そうでなければ、false を返す
    8. もし Type(x) が Boolean であるならば、もし xy が両方とも true であるかまたは両方とも false であるならば、true を返す。そうでなければ、false を返す
    9. もし x および y が同じオブジェクトを参照しているかまたはもしそれらがお互いに結合されたオブジェクト (ECMAScript 第 3 版の章 13.1.2) を参照しているならば、true を返す。そうでなければ、false を返す
  4. もし (Type(x) が XML でありかつ x.hasSimpleContent() == true) または (Type(y) が XML でありかつ y.hasSimpleContent() == true) ならば
    1. 比較 ToString(x) == ToString(y) の結果を返す
  5. もし x が null でありかつ y が undefined であるならば、true を返す
  6. もし x が undefined でありかつ y が null であるならば、true を返す
  7. もし Type(x) が Number でありかつ Type(y) が String であるならば、比較 x == ToNumber(y) の結果を返す
  8. もし Type(x) が String でありかつ Type(y) が Number であるならば、比較 ToNumber(x) == y の結果を返す
  9. もし Type(x) が Boolean であるならば、比較 ToNumber(x) == y の結果を返す
  10. もし Type(y) が Boolean であるならば、比較 x == ToNumber(y) の結果を返す
  11. もし Type(x) が String または Number のどちらかでありかつ Type(y) が Object であるならば、比較 x == ToPrimitive(y) の結果を返す
  12. もし Type(x) が Object でありかつ Type(y) が String または Number のどちらかであるならば、比較 ToPrimitive(x) == y の結果を返す
  13. false を返す

11.6 代入演算子

11.6.1 XML 代入演算子

この章は代入演算子上での XML [[Put]] 演算子の効果を記述するために提供される。E4X は、XML および XMLList [[Put]] 演算子により指定されるものを超える、ECMAScript 代入演算子の構文または動作へのいかなる拡張をも定義しない。

構文

E4X は XML オブジェクトのプロパティおよび XML 属性を修正し、置き換え、挿入するために ECMAScript 代入演算子を再利用する。代入演算子のための ECMAScript 構文は以下の生成規則により記述される:

AssignmentExpression :
LeftHandSideExpression = AssignmentExpression

概要

代入演算子は、基底オブジェクト parent およびプロパティ名からなる参照 r に解決される LeftHandSideExpression を評価することから始まる。もし parent が XML オブジェクトであるならば、代入演算子はこの章で記述されるステップを実行する (parent が XMLList であるときに実行されるステップに対しては章 11.6.2 を見よ) 。

もしプロパティ名が文字 "@" で始まるならば、XML 代入演算子は parent 中の XML 属性を作成または修正する。もしその名前の XML 属性がすでに存在するならば、代入演算子はその値を修正し、そうでなければそれは与えられた名前と値を持つ新しい XML 属性を作成する。もし AssignmentExpression が XMLList に評価されるならば、その名前の属性の値は、XMLList 中のそれぞれの値を文字列に変換しスペースにより区切られたその結果を連結することにより構成される、スペースで区切られた値のリスト (すなわち、XML 属性リスト) であるだろう。もし AssignmentExpression が XMLList に評価されないならば、その名前の属性の値は、AssignmentExpression を評価しその結果上で ToString を呼び出すことにより導き出されるだろう。例えば、

// 二つ目の item の id 属性の値を変更する
order.item[1].@id = 123;

// 二つ目の item に新しい属性を追加する
order.item[1].@newattr = "new value";

// この order の中のすべての id を含む属性リストを構成する
order.@allids = order.item.@id;

もしプロパティ名が配列添字であるならば、XML 代入演算子は TypeError 例外を投げる。この操作は E4X の将来の版のために予約される。

もしプロパティ名が "@" で始まらず配列添字でもないならば、XML 代入演算子は XML 名により parent 中のひとつ以上の XML オブジェクトを置き換え、修正し、または追加する。もしただひとつの XML オブジェクトが与えられた名前で存在し AssignmentExpression が XML オブジェクトまたは XMLList に評価されるならば、代入演算子は識別された XML オブジェクトを与えられた値で置き換える。もし与えられた名前の XML プロパティが存在しないならば、与えられた名前と値を持つ新しい XML プロパティが parent の終端に追加される。もし複数の XML オブジェクトが与えられた名前で存在し AssignmentExpression が XML オブジェクトまたは XMLList に評価されるならば、代入演算子は一致する名前を持つ最初の XML プロパティを与えられた値で置き換え与えられた名前を持つ残った XML プロパティを削除し、本質的には与えられた名前を持つすべての XML オブジェクトを与えられた値で置き換える。もし AssignmentExpression が XML オブジェクトまたは XMLList に評価されないならば、代入演算子は与えられた値上で ToString を呼び出し (XML オブジェクトそれ自身を置き換えるのとは反対に) 適切な XML オブジェクトのプロパティ (すなわち、内容) を置き換える。これはその名前の XML プロパティの値をプリミティブ値に設定するための単純で直感的な構文を提供する。例えば、

item.price = 99.95;                 // item の price を変更する
item.description = "Mobile Phone";  // item の description を変更する

動作

E4X は、MemberExpression が XML または XMLList 型の値に評価されるときに使われるより複雑な [[Put]] メソッド (章 9.1.1.2 および 9.2.1.2 をそれぞれ見よ) を提供することにより代入演算子の動作を拡張する。

11.6.2 XMLList 代入演算子

この章は代入演算子上での XMLList [[Put]] 演算子の効果を記述するために提供される。E4X は、XML および XMLList [[Put]] 演算子により提供されるものを超える、ECMAScript 代入演算子の構文または動作へのいかなる拡張をも定義しない。

構文

E4X は XMLList およびそれらの関連付けられた XML オブジェクトの値を置き換えまたは追加するために ECMAScript 代入演算子を再利用する。代入演算子のための ECMAScript 構文は以下の生成規則により記述される:

AssignmentExpression :
LeftHandSideExpression = AssignmentExpression

概要

代入演算子は、基底オブジェクト parent およびプロパティ名からなる参照 r に解決される LeftHandSideExpression を評価することから始まる。もし parent が XMLList であるならば、代入演算子はこの章で記述されるステップを実行する (parent が XML オブジェクトであるときに実行されるステップに対しては章 11.6.1 を見よ) 。

もしプロパティ名が配列添字でないならば、XMLList 代入演算子はこの XMLList オブジェクトがただひとつの項目を含みその項目が XML 型であるかを確認する。もしそうならば、XMLList 代入演算子はその振る舞いをそれが含む XML オブジェクトの [[Put]] メソッドに委譲する (章 11.6.1 を見よ) 。この処置は故意に単独の XML オブジェクトとただひとつの XML オブジェクトのみを含む XMLList との間の区別をあいまいにする。例えば、

// order 中のただ一人の顧客の名前を Fred Jones に設定する
order.customer.name = "Fred Jones";

// order 中のただ一人の顧客のすべての hobby を置き換える
order.customer.hobby = "shopping";

// 単独の item の saledate を設定することを試みる
order.item.saledate = "05-07-2002";

// employee のすべての hobby をそれらの新しいお気に入りの娯楽で置き換える
emps.employee.(@id == 3).hobby = "working";

上の最初の文において、式 "order.customer" はただひとつの XML 項目のみを含む XMLList を返す。式 "order.customer.name" は暗黙的にこの XMLList を XML 値に変換し、値 "Fred Jones" をその値に代入する。

もしプロパティ名が配列添字であるならば、代入演算子は XMLList 中のプロパティ名により識別されるプロパティを置き換えるか、またはもしそのプロパティ名のものが存在しないならば新しいプロパティを追加する。それに加えて、もし識別されるプロパティが null でない parent を持つ XML 値であるならば、XML 値はその parent の文脈の中でも置き換えられる。もし AssignmentExpression が XML 値に評価されるならば、代入演算子はプロパティ名により識別されるプロパティの値を与えられた XML オブジェクトの深いコピーで置き換える。もし AssignmentExpression が XMLList に評価されるならば、代入演算子はプロパティ名により識別されるプロパティの値を XMLList 中のそれぞれの項目の深いコピーで順に置き換え、事実上元のプロパティを削除しその場所に XMLList の内容を挿入する。もし AssignmentExpression が XML または XMLList 型の値に評価されないならば、代入演算子は与えられた値上で ToString を呼び出し与えられた位置のプロパティをその結果で置き換える。ここにいくつかの例がある、

// 最初の従業員を George で置き換える
e.employee[0] = <employee><name>George</name><age>27</age></employee>;

// 従業員のリストの終端に新しい従業員を追加する
e.employee[e.employee.length()] = <employee><name>Frank</name></employee>;

動作

E4X は、MemberExpression が XML または XMLList 型の値に評価されるときに使われるより複雑な [[Put]] メソッド (章 9.1.1.2 および 9.2.1.2 をそれぞれ見よ) を提供することにより代入演算子の動作を拡張する。

11.6.3 複合代入 (op=)

この章は複合代入演算子上での XML および XMLList [[Get]] 、[[Put]] 、および加法演算子の効果を記述するために提供される。E4X は、XML および XMLList [[Get]] 、[[Put]] 、および加法演算子により提供されるものを超える、ECMAScript 複合代入演算子の構文または動作へのいかなる拡張をも定義しない。

構文

E4X は追加的な ECMAScript 拡張を必要とすることなく複合代入演算子 "+=" から利益を得る。複合代入 "+=" の構文は以下の生成規則により記述される:

AssignmentExpression :
LeftHandSideExpression += AssignmentExpression

概要

LeftHandSideExpression += AssignmentExpression は式 LeftHandSideExpression = LeftHandSideExpression + AssignmentExpression の省略形式であり完全に同じく振舞う。LeftHandSideExpression がひとつ以上の XML オブジェクトを識別し AssignmentExpression がひとつ以上の XML オブジェクトを識別するときは、"+=" 演算子は LeftHandSideExpression により識別される XML オブジェクトを LeftHandSideExpression により識別される XML オブジェクトと AssignmentExpression により識別される XML オブジェクトとの連結の結果で置き換える。これはそれらの親の文脈で LeftHandSideExpression により指定される XML オブジェクトのすぐ後に AssignmentExpression により指定される XML オブジェクトを挿入する一般的な効果を持つ。例えば、下の文を評価した後では、

var e = <employees>
   <employee id="1"><name>Joe</name><age>20</age></employee>
   <employee id="2"><name>Sue</name><age>30</age></employee>
</employees>;

// 最初の従業員の後に従業員 3 および 4 を挿入する
e.employee[0] += <employee id="3"><name>Fred</name></employee> +
      <employee id="4"><name>Carol</name></employee>;

変数 "e" は以下の XML 値を含むだろう:

<employees>
   <employee id="1"><name>Joe</name><age>20</age></employee>
   <employee id="3"><name>Fred</name></employee>
   <employee id="4"><name>Carol</name></employee>
   <employee id="2"><name>Sue</name><age>30</age></employee>
</employees>;

同様に、下の文を評価した後では、

var e = <employees>
   <employee id="1"><name>Joe</name><age>20</age></employee>
   <employee id="2"><name>Sue</name><age>30</age></employee>
</employees>;

// 従業員のリストの終端に従業員 3 および 4 を追加する
e.employee += <employee id="3"><name>Fred</name></employee> +
      <employee id="4"><name>Carol</name></employee>;

変数 "e" は以下の XML 値を含むだろう:

<employees>
   <employee id="1"><name>Joe</name><age>20</age></employee>
   <employee id="2"><name>Sue</name><age>30</age></employee>
   <employee id="3"><name>Fred</name></employee>
   <employee id="4"><name>Carol</name></employee>
</employees>;

しかしながら、"+=" 演算子は必ずしも LeftHandSideExpression により指定される XML オブジェクトの同一性を保持するわけではないことに注意せよ。

動作

E4X は、MemberExpression が XML または XMLList 型の値に評価されるときに使われるより複雑な [[Get]] および [[Put]] メソッド (章 9.1.1.19.1.1.29.2.1.1 、および 9.2.1.2 をそれぞれ見よ) を提供することにより複合代入演算子の動作を拡張する。

12 文

E4X は ECMAScript で提供される文を以下の生成規則で拡張する:

Statement :
DefaultXMLNamespaceStatement

12.1 default xml namespace 文

構文

E4X は default xml namespace 文を追加することで ECMAScript を拡張する。以下の生成規則は default xml namespace 文の構文を記述する:

DefaultXMLNamespaceStatement :
default xml namespace = Expression

概要

default xml namespace 文は現在の実行文脈 (ECMAScript 第 3 版の章 10 を見よ) に関連付けられた変数オブジェクトの内部プロパティ [[DefaultNamespace]] の値を設定する。グローバルスコープのデフォルト XML 名前空間は名前空間に属さない初期値を持つ。もし default xml namespace 文が FunctionDeclaration の内部に現れたならば、内部プロパティ [[DefaultNamespace]] が活性化変数オブジェクトに追加され、名前空間に属さない初期値を与えられる。この [[DefaultNamespace]] プロパティは外側のスコープの [[DefaultNamespace]] プロパティを隠す。

default xml namespace 文が実行されたときは、それは Expression を評価し、その結果を String s に変換し、コンストラクタ n = new Namespace("", s) を呼び出したかのように新しい Namespace オブジェクト n を作成し、現在の実行文脈に関連付けられたデフォルト XML 名前空間を n に設定する。現在のスコープ内でデフォルト XML 名前空間宣言に後続する非修飾 XML 要素名は Expression により指定されたデフォルト XML 名前空間に関連付けられるだろう。例えば、

// いくつかの名前空間と現在のスコープに対するデフォルト名前空間を宣言する
var soap = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
var stock = new Namespace("http://mycompany.com/stocks");
default xml namespace = soap; // alternately, may specify full URI

// デフォルト名前空間 (すなわち、soap) の中で XML 初期化子を作成する
var message = <Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
      soap:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
   <Body>
      <m:GetLastTradePrice xmlns:m="http://mycompany.com/stocks">
         <symbol>DIS</symbol>
      </m:GetLastTradePrice>
   </Body>
</Envelope>

// QualifiedIdentifier を使って soap 符号化様式を抽出する
// (非修飾属性は名前空間に属さない)
var encodingStyle = message.@soap::encodingStyle;

// デフォルト名前空間を使って soap メッセージから body を抽出する
var body = message.Body;

// デフォルト名前空間と修飾名を使って stock 記号を変更する
message.Body.stock::GetLastTradePrice.stock::symbol = "MYCO";

動作

生成規則 DefaultXMLNamespaceStatement : default xml namespace = Expression は以下のように評価される:

  1. uriRef を、Expression を評価した結果とする
  2. uri = GetValue(uriRef) とする
  3. namespace を、コンストラクタ new Namespace("", uri) を呼び出したかのように作成された新しい Namespace オブジェクトとする
  4. varObj を、現在の実行文脈 (ECMAScript 第 3 版の章 10.1.3 を見よ) に関連付けられた変数オブジェクトとする
  5. varObj.[[DefaultNamespace]] = namespace とする

12.1.1 GetDefaultNamespace ( )

概要

GetDefaultNamespace 抽象演算子はデフォルト XML 名前空間の値を取得するためにこの仕様で使われる。この演算子は言語の一部ではない。それは言語の詳細を補助するためにここで定義される。

動作

内部 GetDefaultNamespace メソッドが呼び出されたときは、以下のステップがとられる:

  1. スコープチェーンにまだオブジェクトが存在する間
    1. o を、スコープチェーン上での次のオブジェクトとする

      注意 最初の反復では、o はスコープチェーン上の最初のオブジェクトであるだろう

    2. もし o が内部プロパティ [[DefaultNamespace]] を持つならば、o.[[DefaultNamespace]] を返す
  2. TypeError 例外を投げる

    注意 グローバルオブジェクトが [[DefaultNamespace]] プロパティを持つので、このステップは起こるべきではない

12.2 for-in 文

構文

E4X は、オブジェクトのプロパティを反復するために使われる ECMAScript for-in 文の動作を拡張する。for-in 文の構文は以下の生成規則により指定される:

IterationStatement :
for ( LeftHandSideExpression in Expression ) Statement
for ( var VariableDeclarationNoIn in Expression ) Statement

概要

for-in 文は Expression を評価し、結果として生じるオブジェクトのそれぞれのプロパティを反復する。それぞれのプロパティに対して、for-in 文は LeftHandSideExpression または VariableDeclarationNoIn により識別される変数にプロパティの名前を代入し、Statement を評価する。例えば、

// すべての従業員の名前を表示する
for (var n in e..name) {
   print ("Employee name: " + e..name[n]);
}

// 最初の item のそれぞれの子を表示する
for (var child in order.item[0].*) {
   print("item child: " + order.item.[0].*[child]);
}

Expression が XML オブジェクトに評価されるときは、for-in 文は XML オブジェクトを XMLList に変換し、結果として生じる XMLList を反復する。この処置は故意に単独の XML オブジェクトとただひとつの値のみを含む XMLList との間の区別をあいまいにする。

動作

生成規則 IterationStatement : for ( LeftHandSideExpression in Expression ) Statement は以下のように評価される:

  1. ref を、Expression を評価した結果とする
  2. e = GetValue(ref) とする
  3. もし Type(e) が XML であるならば
    1. list = ToXMLList(e) とする
  4. そうでなく、もし Type(e) が XMLList でないならば
    1. list = ToObject(e) とする
  5. V = empty とする
  6. list がまだプロパティを持つ間
    1. p を、list の次のプロパティとする (下の注意を見よ)
    2. もし p が DontEnum 属性を持たないならば
      1. i を、LeftHandSideExpression を評価した結果とする
      2. name を、プロパティ p の名前とする
      3. PutValue(i, name)
      4. s を、Statement を評価した結果とする
      5. もし s.value が空でないならば、V = s.value とする
      6. もし s.type が break でありかつ s.target が現在のラベルセット内にあるならば、(normal, V, empty) を返す
      7. もし s.type が continue でないまたは s.target が現在のラベルセット内にないならば
        1. もし s が突然の完了であるならば、s を返す
  7. (normal, V, empty) を返す

生成規則 IterationStatement : for ( var VariableDeclarationNoIn in Expression ) Statement は以下のように評価される:

  1. varRef を、VariableDeclarationNoIn を評価した結果とする
  2. ref を、Expression を評価した結果とする
  3. e = GetValue(ref) とする
  4. もし Type(e) が XML であるならば
    1. list = ToXMLList(e) とする
  5. そうでなく、もし Type(e) が XMLList でないならば
    1. list = ToObject(e) とする
  6. V = empty とする
  7. list がまだプロパティを持つ間
    1. p を、list の次のプロパティとする (下の注意を見よ)
    2. もし p が DontEnum 属性を持たないならば
      1. i を、それが識別子 (ECMAScript 第 3 版の章 11.1.2 を見よ) であるかのように varRef を評価した結果とする
      2. name を、プロパティ p の名前とする
      3. PutValue(i, name)
      4. s を、Statement を評価した結果とする
      5. s.value が空でないならば、V = s.value とする
      6. もし s.type が break でありかつ s.target が現在のラベルセット内にあるならば、(normal, V, empty) を返す
      7. もし s.type が continue でないまたは s.target が現在のラベルセット内にないならば
        1. もし s が突然の完了であるならば、s を返す
  8. (normal, V, empty) を返す

列挙の順番はオブジェクトにより定義される (最初のアルゴリズムのステップ 6 および 6a および二つ目のアルゴリズムのステップ 7 および 7a) 。e が XML または XMLList 型の値に評価されるときは、プロパティはそれらの数値的なプロパティ名に従って昇順 (すなわち、XML オブジェクトの文書順) で列挙される。ほかのオブジェクトのプロパティは実装依存の順番で列挙される。

プロパティを列挙する (最初のアルゴリズムのステップ 6 および 6a および二つ目のステップ 7 および 7a) 機構は実装依存である。列挙されているオブジェクトのプロパティは列挙の間に削除されてもよい。もし列挙の間にまだ訪れられていないプロパティが削除されたならば、それは訪れられないだろう。もし新しいプロパティが列挙の間に列挙されているオブジェクトに追加されたならば、新しく追加されたプロパティは動作中の列挙内で訪れられることを保証されない。オブジェクトのプロパティを列挙することは、そのプロトタイプおよびそのプロトタイプのプロトタイプその他もろもろのプロパティを再帰的に列挙する――ただしプロトタイプチェーン上のいくつかの前のオブジェクトは同じ名前のプロパティを持つので、プロトタイプのプロパティはもしそれが「覆われている」ならば列挙されない――ことを含む。

12.3 for-each-in 文

構文

E4X は、オブジェクトのプロパティ値を反復するための for-each-in 文を追加することにより ECMAScript を拡張する。for-each-in 文の構文は以下の生成規則により指定される:

IterationStatement :
for each ( LeftHandSideExpression in Expression ) Statement
for each ( var VariableDeclarationNoIn in Expression ) Statement

概要

for-each-in 文は Expression を評価し、結果として生じるオブジェクトのそれぞれのプロパティを反復する。それぞれのプロパティに対して、for-each-in 文は LeftHandSideExpression または VariableDeclarationNoIn により識別される変数にプロパティの値を代入し Statement を評価する。例えば、

// すべての従業員の名前を表示する
for each (var n in e..name) {
   print ("Employee name: " + n);
}

// 最初の item のそれぞれの子を表示する
for each (var child in order.item[0].*) {
   print("item child: " + child);
}

上の最初の for-each-in 文において、式 "e..name" は、名前が "name" である XML オブジェクト "e" のすべての子孫 XML プロパティを含む XMLList を返す。for-each-in 文は結果として生じる XMLList のそれぞれのプロパティを順に反復する。list 中のそれぞれの XML プロパティに対して、それは XML プロパティの値を変数 "n" に代入し、波括弧内に入れ子になったコードを実行する。同様に、上の二つ目の for-each-in 文において、式 "order.item[0].*" は、"order" と名づけられた XML オブジェクトから最初の "item" と名づけられた XML オブジェクトのすべての子を含む XMLList を返す。for-each-in 文は XMLList オブジェクトのそれぞれのプロパティを順に反復し、XML プロパティの値を変数 "child" に代入し、波括弧内に入れ子になったコードを実行する。

Expression が XML オブジェクトに評価されるときは、for-each-in 文は XML オブジェクトを XMLList に変換し、結果として生じる XMLList を反復する。この処置は故意に単独の XML オブジェクトとただひとつの値のみを含む XMLList との間の区別をあいまいにする。

注意 for-each-in 文は for-in 文とは異なる振る舞いをする。特に、それはオブジェクトの定義域よりもオブジェクトの値域をループ変数に代入する。すなわち、for-each-in 文はプロパティ名よりも与えられたオブジェクトのプロパティ値にループ変数を束縛する。

動作

生成規則 IterationStatement : for each ( LeftHandSideExpression in Expression ) Statement は以下のように評価される:

  1. ref を、Expression を評価した結果とする
  2. e = GetValue(ref) とする
  3. もし Type(e) が XML であるならば
    1. list = ToXMLList(e) とする
  4. そうでなく、もし Type(e) が XMLList でないならば
    1. list = ToObject(e) とする
  5. V = empty とする
  6. list がまだプロパティを持つ間
    1. p を、list の次のプロパティとする (下の注意を見よ)
    2. もし p が DontEnum 属性を持たないならば
      1. i を、LeftHandSideExpression を評価した結果とする
      2. value を、プロパティ p の値とする
      3. PutValue(i, value)
      4. s を、Statement を評価した結果とする
      5. もし s.value が空でないならば、V = s.value とする
      6. もし s.type が break でありかつ s.target が現在のラベルセット内にあるならば、(normal, V, empty) を返す
      7. もし s.type が continue でないまたは s.target が現在のラベルセット内にないならば
        1. もし s が突然の完了であるならば、s を返す
  7. (normal, V, empty) を返す

生成規則 IterationStatement : for each ( var VariableDeclarationNoIn in Expression ) Statement は以下のように評価される:

  1. varRef を、VariableDeclarationNoIn を評価した結果とする
  2. ref を、Expression を評価した結果とする
  3. e = GetValue(ref) とする
  4. もし Type(e) が XML であるならば
    1. list = ToXMLList(e) とする
  5. そうでなく、もし Type(e) が XMLList でないならば
    1. list = ToObject(e) とする
  6. V = empty とする
  7. list がまだプロパティを持つ間
    1. p を、list の次のプロパティとする (下の注意を見よ)
    2. もし p が DontEnum 属性を持たないならば
      1. i を、それが識別子 (ECMAScript 第 3 版の章 11.1.2 を見よ) であるかのように varRef を評価した結果とする
      2. value を、プロパティ p の値とする
      3. PutValue(i, value)
      4. s を、Statement を評価した結果とする
      5. もし s.value が空でないならば、V = s.value とする
      6. もし s.type が break でありかつ s.target が現在のラベルセット内にあるならば、(normal, V, empty) を返す
      7. もし s.type が continue でないまたは s.target が現在のラベルセット内にないならば
        1. もし s が突然の完了であるならば、s を返す
  8. (normal, V, empty) を返す

列挙の順番はオブジェクトにより定義される (最初のアルゴリズムのステップ 6 および 6a および二つ目のアルゴリズムの 7 および 7a) 。e が XML または XMLList 型に評価されるときは、プロパティはそれらの数値的なプロパティ名に従って昇順 (すなわち、XML オブジェクトの文書順) で列挙される。

プロパティを列挙する (最初のアルゴリズムのステップ 6 および 6a 、二つ目のステップ 7 および 7a) 機構は実装依存である。列挙されているオブジェクトのプロパティは列挙の間に削除されてもよい。もし列挙の間にまだ訪れられていないプロパティが削除されたならば、それは訪れられなくてもよい。もし新しいプロパティが列挙の間に列挙されているオブジェクトに追加されたならば、新しく追加されたプロパティは動作中の列挙内で訪れられることを保証されない。オブジェクトのプロパティを列挙することは、そのプロトタイプおよびそのプロトタイプのプロトタイプその他もろもろのプロパティを再帰的に列挙する――ただしプロトタイプチェーン内のいくつかの前のオブジェクトは同じ名前のプロパティを持つので、プロトタイプのプロパティはもしそれが「覆われている」ならば列挙されない――ことを含む。

13 ネイティブ E4X オブジェクト

E4X は四つのネイティブオブジェクト、Namespace オブジェクト、QName オブジェクト、XML オブジェクトおよび XMLList オブジェクトを ECMAScript に追加する。それに加えて、E4X は新しいプロパティをグローバルオブジェクトに追加する。

13.1 グローバルオブジェクト

13.1.1 グローバルオブジェクトの内部プロパティ

E4X は以下の内部プロパティをグローバルオブジェクトに追加することにより ECMAScript を拡張する。

13.1.1.1 [[DefaultNamespace]]

概要

最初に、グローバルオブジェクトは、その値が引数なしで Namespace コンストラクタを呼び出したかのように作成された名前空間に属さないことを表現する Namespace オブジェクトに設定された内部プロパティ [[DefaultNamespace]] を持つ。したがって、default xml namespace 文 (章 12.1 を見よ) を使ってほかのが指定されない限り、XML オブジェクトのプロパティを指定するために使われる非修飾名は名前空間に属さない XML プロパティに一致するだろう。

13.1.2 グローバルオブジェクトの関数プロパティ

E4X は、以下の関数プロパティをグローバルオブジェクトに追加することにより ECMAScript を拡張する。

13.1.2.1 isXMLName ( value )

概要

isXMLName 関数は与えられた値を検査し、それが XML 要素または属性名として使われることのできる妥当な XML 名であるかどうかを判定する。もしそうならば、それは true を返し、そうでなければそれは false を返す。

動作

isXMLName 関数がひとつのパラメータ value とともに呼び出されたときは、以下のステップがとられる:

  1. q を、コンストラクタ new QName(value) を呼び出したかのように作成された新しい QName とし、もし TypeError 例外が投げられたならば、false を返す
  2. もし q.localName が生成規則 NCName と一致しないならば、false を返す
  3. true を返す

生成規則 NCName は XML 名前空間仕様の章 2 で定義されている。

13.1.3 グローバルオブジェクトのコンストラクタプロパティ

E4X は以下のコンストラクタプロパティを ECMAScript に追加することにより ECMAScript を拡張する。

13.1.3.1 Namespace ( . . . )

13.2.1 および 13.2.2 を見よ。

13.1.3.2 QName ( . . . )

13.3.1 および 13.3.2 を見よ。

13.1.3.3 XML ( . . . )

13.4.1 および 13.4.2 を見よ。

13.1.3.4 XMLList ( . . . )

13.5.1 および 13.5.2 を見よ。

13.2 Namespace オブジェクト

Namespace オブジェクトは XML 名前空間を表現し、名前空間接頭辞と Unique Resource Identifier (URI) との間の関連を提供する。接頭辞は undefined 値かまたは XML 値の字句表現内で名前区間を参照するために使われてもよい文字列値かのどちらかである。undefined である接頭辞を持つ名前空間を含む XML オブジェクトがメソッド ToXMLString() により XML として符号化されるときは、実装は自動的に接頭辞を生成するだろう。URI は名前空間を一意的に識別するために使われる文字列値である。

13.2.1 関数として呼び出される Namespace コンストラクタ

構文

Namespace ( )
Namespace ( uriValue )
Namespace ( prefixValue , uriValue )

概要

もし Namespace コンストラクタが正確にひとつの Namespace オブジェクトである引数とともに関数として呼び出されたならば、引数が変化せずに返される。そうでなければ、同じ引数がオブジェクト生成式 new Namespace ( ... ) に渡されたかのように新しい Namespace オブジェクトが作成され、返される。章 13.2.2 を見よ。

動作

Namespace が引数なしで、またはひとつの引数 uriValue とともに、または二つの引数 prefixValue および uriValue とともに関数として呼び出されたときは、以下のステップがとられる:

  1. もし prefixValue が指定されていないかつ Type(uriValue) が Object であるかつ uriValue.[[Class]] == "Namespace" ならば
    1. uriValue を返す
  2. 正確に Namespace コンストラクタが同じ引数とともに呼び出されたかのように新しい Namespace オブジェクトを作成し、返す (章 13.2.2)

13.2.2 Namespace コンストラクタ

構文

new Namespace ( )
new Namespace ( uriValue )
new Namespace ( prefixValue, uriValue )

概要

Namespace が new 式の一部として呼び出されたときは、それはコンストラクタであり新しい Namespace オブジェクトを作成する。

新しく構成されるオブジェクトの [[Prototype]] プロパティは元の Namespace プロトタイプオブジェクト、すなわち Namespace.prototype (章 13.2.4) の初期値であるものに設定される。新しく構成されるオブジェクトの [[Class]] プロパティは "Namespace" に設定される。

引数が指定されないときは、名前空間の uri および prefix は空文字列に設定される。uri が空文字列に設定された名前空間は名前空間に属さないことを表現する。名前空間に属さないことは、XML オブジェクトの中で名前が名前空間内にないことを明示的に指定するために使われ、空文字列以外の接頭辞に関連付けられてはならない。

uriValue 引数のみが指定され uriValue が Namespace オブジェクトであるときは、uriValue のコピーが返される。uriValue のみが指定されそれが空文字列であるときは、接頭辞は空文字列に設定される。uriValue のみが指定されるほかのすべての場合には、名前空間接頭辞は undefined 値に設定される。

prefixValue 引数が指定され空文字列に設定されたときは、Namespace はデフォルト名前空間を呼び出される。デフォルト名前空間は XML オブジェクトの中で修飾子を指定しない修飾名の名前空間を暗黙的に指定するために使われる。

動作

Namespace コンストラクタが引数なしで、またはひとつの引数 uriValue とともに、または二つの引数 prefixValue および uriValue とともに呼び出されたときは、以下のステップがとられる:

  1. 新しい Namespace オブジェクト n を作成する
  2. もし prefixValue が指定されていないかつ uriValue が指定されていないならば
    1. n.prefix を空文字列とする
    2. n.uri を空文字列とする
  3. そうでなく、もし prefixValue が指定されていないならば
    1. もし Type(uriValue) が Object でありかつ uriValue.[[Class]] == "Namespace" ならば
      1. n.prefix = uriValue.prefix とする
      2. n.uri = uriValue.uri とする
    2. そうでなく、もし Type(uriValue) が Object でありかつ uriValue.[[Class]] == "QName" かつ uriValue.uri が null でないならば
      1. n.uri = uriValue.uri とする

        注意 修飾名内の接頭辞を保存する実装は n.prefix = uriValue.[[Prefix]] とも設定してもよい

    3. そうでなければ
      1. n.uri = ToString(uriValue) とする
      2. もし n.uri が空文字列であるならば、n.prefix を空文字列とする
      3. そうでなければ、n.prefix = undefined
  4. そうでなければ
    1. もし Type(uriValue) が Object でありかつ uriValue.[[Class]] == "QName" かつ uriValue.uri が null でないならば
      1. n.uri = uriValue.uri とする
    2. そうでなければ
      1. n.uri = ToString(uriValue) とする
    3. もし n.uri が空文字列であるならば
      1. もし prefixValue が undefined であるまたは ToString(prefixValue) が空文字列であるならば
        1. n.prefix を空文字列とする
      2. そうでなければ、TypeError 例外を投げる
    4. そうでなく、もし prefixValue が undefined であるならば、n.prefix = undefined とする
    5. そうでなく、もし isXMLName(prefixValue) == false ならば
      1. n.prefix = undefined とする
    6. そうでなければ、n.prefix = ToString(prefixValue) とする
  5. n を返す

13.2.3 Namespace コンストラクタのプロパティ

Namespace コンストラクタの内部 [[Prototype]] プロパティの値は Function プロトタイプオブジェクトである。

内部プロパティおよび length プロパティ (その値は 2 である) に加えて、Namespace コンストラクタは以下のプロパティを持つ。

13.2.3.1 Namespace.prototype

Namespace.prototype プロパティの初期値は Namespace プロトタイプオブジェクト (章 13.2.4) である。

このプロパティは属性 { DontEnum, DontDelete, ReadOnly } を持つ。

13.2.4 Namespace プロトタイプオブジェクトのプロパティ (組み込みメソッド)

Namespace プロトタイプオブジェクトは、それ自身その uri および prefix プロパティが空文字列に設定された Namespace オブジェクト (その [[Class]] は "Namespace" である) である。

Namespace プロトタイプオブジェクトの内部 [[Prototype]] プロパティの値は Object プロトタイプオブジェクト (ECMAScript 第 3 版の章 15.2.3.1) である。

13.2.4.1 Namespace.prototype.constructor

Namespace.prototype.constructor の初期値は組み込み Namespace コンストラクタである。

13.2.4.2 Namespace.prototype.toString()

概要

toString() メソッドはこの Namespace オブジェクトの文字列表現を返す。

toString 関数は汎用的でない。もしそのその this 値が Namespace オブジェクトでないならば、それは TypeError 例外を投げる。それゆえに、それはメソッドとしての使用のために他の種類のオブジェクトに転用されることはできない。

動作

Namespace オブジェクト n の toString メソッドが引数なしで呼び出されたときは、以下のステップがとられる:

  1. もし Type(n) が Object でないまたは n.[[Class]] が "Namespace" と等しくないならば、TypeError 例外を投げる
  2. n.uri を返す

13.2.5 Namespace インスタンスのプロパティ

Namespace インスタンスは Namespace プロトタイプオブジェクトからプロパティを継承し、また prefix プロパティおよび uri プロパティをも持つ。

13.2.5.1 prefix

prefix プロパティの値は undefined 値か文字列値かのどちらかである。prefix プロパティの値が空文字列であるときは、Namespace はデフォルト名前空間を呼び出される。デフォルト名前空間は XML オブジェクトの中で修飾子を指定しない名前の名前空間を決定するために使われる。

このプロパティは属性 { DontDelete, ReadOnly } を持つ。

13.2.5.2 uri

uri プロパティの値は文字列値である。uri プロパティの値が空文字列であるときは、その Namespace は名づけられていない名前空間を表現する。名づけられていない名前空間は XML オブジェクトの中で名前が名前空間内にないということを明示的に指定するために使われる。

このプロパティは属性 { DontDelete, ReadOnly } を持つ。

13.3 QName オブジェクト

QName オブジェクトは XML 要素および属性の修飾名を表現するために使われる。それぞれの QName オブジェクトは文字列型の局所名および文字列型または null の名前空間 URI を持つ。名前空間 URI が null であるときは、修飾名は任意の名前空間に一致する。

実装は E4X ユーザーには直接見えない内部 [[Prefix]] プロパティを含めてもよい。QName オブジェクトが Namespace オブジェクト引数を使って作成されたときは、内部 [[Prefix]] プロパティが Namespace オブジェクトの接頭辞を保存するために使われてもよい。もし名前空間接頭辞が関連付けられた Namespace に指定されていないならば、[[Prefix]] プロパティは undefined であってもよい。

QName 型の値は QualifiedIdentifier を使って指定されてもよい。もし XML 要素の QName が名前空間を識別することなく (すなわち、非修飾識別子として) 指定されるならば、関連付けられた QName の uri プロパティは範囲内のデフォルト名前空間 (章 12.1) に設定されるだろう。もし XML 属性の QName が名前空間を識別することなく指定されるならば、関連付けられた QName の uri プロパティは名前空間に属さないことを表現する空文字列であるだろう。

13.3.1 関数として呼び出される QName コンストラクタ

構文

QName ( )
QName ( Name )
QName ( Namespace , Name )

概要

もし QName コンストラクタが正確にひとつの QName オブジェクトである引数とともに関数として呼び出されたならば、引数が変更なしで返される。そうでなければ、同じ引数がオブジェクト関係式 new QName ( ... ) に渡されたかのように新しい QName オブジェクトが作成され、返される。章 13.3.2 を見よ。

動作

QName 関数が呼び出されたときは、以下のステップがとられる。

  1. もし Namespace が指定されていないかつ Type(Name) が Object であるかつ Name.[[Class]] == "QName" ならば
    1. Name を返す
  2. 正確に QName コンストラクタが同じ引数で呼び出されたかのように新しい QName オブジェクトを作成し、返す (章 13.3.2 を見よ)

13.3.2 QName コンストラクタ

構文

new QName ( )
new QName ( Name )
new QName ( Namespace , Name )

概要

QName が new 式の一部として呼び出されたときは、それはコンストラクタであり新しい QName オブジェクトを作成する。

新しく構成されたオブジェクトの [[Prototype]] プロパティは元の QName プロトタイプオブジェクト、すなわち QName.prototype (章 13.3.3.1 を見よ) の初期値であるものに設定される。新しく構成されたオブジェクトの [[Class]] プロパティは "QName" に設定される。

もし Name が undefined または指定されないならば、空文字列が名前として使われる。

もし Name が QName でありかつ Namespace が指定されないならば、QName コンストラクタは与えられた Name のコピーを返す。

Namespace および Name 引数の両方が指定されたときは、新しく作成されたオブジェクトの localName プロパティは与えられた Name に従って設定され、新しく作成されたオブジェクトの uri プロパティは Namespace 引数に従って設定される。もし Name が QName オブジェクトであるならば、新しく作成された QName の localNameNamelocalName と等しいだろう。もし Namespace 引数が Namespace オブジェクトであるならば、新しく作成されたオブジェクトの uri プロパティは Namespace オブジェクトの uri プロパティに設定される。もし Namespace 引数が null であるならば、新しく作成されたオブジェクトの uri プロパティは任意の名前空間内の名前に一致することを意味する null であるだろう。

動作

QName コンストラクタがひとつの引数 Name または二つの引数 Namespace および Name とともに呼び出されたときは、以下のステップがとられる:

  1. もし Type(Name) が Object でありかつ Name.[[Class]] == "QName" ならば
    1. もし Namespace が指定されていないならば、Name のコピーを返す
    2. そうでなければ、Name = Name.localName とする
  2. もし Name が undefined であるまたは指定されていないならば
    1. Name = "" とする
  3. そうでなければ、Name = ToString(Name) とする
  4. もし Namespace が undefined であるまたは指定されていないならば
    1. もし Name == "*" ならば
      1. Namespace = null とする
    2. そうでなければ
      1. Namespace = GetDefaultNamespace() とする
  5. q を、q.localName = Name である新しい QName とする
  6. もし Namespace == null ならば
    1. q.uri = null とする

      注意 修飾名の中で接頭辞を保存する実装はまた q.[[Prefix]] を undefined に設定してもよい。

  7. そうでなければ
    1. Namespace を、コンストラクタ new Namespace(Namespace) を呼び出したかのように作成された新しい Namespace とする
    2. q.uri = Namespace.uri とする

      注意 修飾名の中で接頭辞を保存する実装はまた q.[[Prefix]] を Namespace.prefix に設定してもよい。

  8. q を返す

13.3.3 QName コンストラクタのプロパティ

QName コンストラクタの内部 [[Prototype]] プロパティの値は Function プロトタイプオブジェクトである。

内部プロパティおよび length プロパティ (その値は 2 である) に加えて、QName コンストラクタは以下のプロパティを持つ。

13.3.3.1 QName.prototype

QName.prototype プロパティの初期値は QName プロトタイプオブジェクト (章 13.3.4) である。

このプロパティは属性 { DontEnum, DontDelete, ReadOnly } を持つ。

13.3.4 QName プロトタイプオブジェクトのプロパティ

QName プロトタイプオブジェクトは、それ自身その uri および localName プロパティが空文字列にセットされた QName オブジェクト (その [[Class]] は "QName" である) である。

QName プロトタイプオブジェクトの内部 [[Prototype]] プロパティの値は Object プロトタイプオブジェクト (ECMAScript 第 3 版の章 15.2.3.1) である。

13.3.4.1 QName.prototype.constructor

QName.prototype.constructor の初期値は組み込み QName コンストラクタである。

13.3.4.2 QName.prototype.toString()

概要

toString メソッドはこの QName オブジェクトの文字列表現を返す。

toString 関数は汎用的でない。もしその this 値が QName オブジェクトでないならば、それは TypeError 例外を投げる。それゆえに、それはメソッドとしての使用のために他の種類のオブジェクトに転用されることはできない。

動作

QName オブジェクト n の toString メソッドが引数なしで呼び出されたときは、以下のステップがとられる:

  1. もし Type(n) が Object でないまたは n.[[Class]] が "QName" と等しくないならば、TypeError 例外を投げる
  2. s を空文字列とする
  3. もし n.uri が空文字列でないならば
    1. もし n.uri == null ならば、s を、文字列 "*::" とする
    2. そうでなければ、s を、n.uri と文字列 "::" とを連結した結果とする
  4. s を、sn.localName とを連結した結果とする
  5. s を返す

13.3.5 QName インスタンスのプロパティ

QName インスタンスは QName プロトタイプオブジェクトからプロパティを継承し、また uri プロパティ、localName プロパティ、および修飾名の中で接頭辞を保存する実装により使われてもよい任意的な内部 [[Prefix]] プロパティをも持つ。

13.3.5.1 localName

localName プロパティの値は文字列型の値である。localName プロパティの値が "*" であるときは、それは任意の名前に一致するワイルドカードを表現する。

このプロパティは属性 { DontDelete, ReadOnly } を持たなくてはならない。

13.3.5.2 uri

uri プロパティの値は null またはこの QName の名前空間を識別する文字列型の値である。uri プロパティの値が空文字列であるときは、この QName は名前空間に属さないといわれる。名前空間に属さないことは XML オブジェクトの中で名前が名前空間内にないということを明示的に指定するために使われる。uri プロパティの値が null であるときは、QName は任意の名前空間内の名前に一致する。

このプロパティは属性 { DontDelete, ReadOnly } を持たなくてはならない。

13.3.5.3 [[Prefix]]

[[Prefix]] プロパティは直接ユーザーには見えない任意的な内部プロパティである。それは修飾名の中で接頭辞を保存する実装により使われてもよい。[[Prefix]] プロパティの値は文字列型の値または undefined である。もし [[Prefix]] プロパティが undefined であるならば、この QName に関連付けられた接頭辞は不明である。

13.3.5.4 [[GetNamespace]] ( [ InScopeNamespaces ] )

概要

[[GetNamespace]] メソッドはこの QName の URI に一致する URI を持つ Namespace オブジェクトを返す内部メソッドである。InScopeNamespaces は任意的なパラメータである。もし InScopeNamespaces が指定されないならば、それは空のセットに設定される。もしこの QName の URI に一致する URI を持つ Namespace がひとつ以上 InScopeNamespaces 内に存在するならば、一致した Namespace のひとつが返されるだろう。もしそのような名前空間が InScopeNamespaces 内に存在しないならば、[[GetNamespace]] はこの QName のものに一致する URI を持つ新しい Namespace を作成し、返す。QName 内の接頭辞を保存する実装に対して、[[GetNamespace]] は接頭辞にも一致する Namespace を返してもよい。入力引数 InScopeNamespaces は Namespace オブジェクトのセットである。

動作

QName q の [[GetNamespace]] メソッドが引数なしでまたはひとつの引数 InScopeNamespaces とともに呼び出されたときは、以下のステップがとられる:

  1. もし q.uri が null であるならば、TypeError 例外を投げる

    注意 上の例外は、[[GetNamespace]] がこの使用の中で呼び出されるやり方のために、決して発生するべきではない

  2. もし InScopeNamespaces が指定されていないならば、InScopeNamespaces = { } とする
  3. ns.uri == q.uri であるような InScopeNamespaces 内の Namespace ns を見つける。もしそのような Namespace ns が複数存在するならば、実装は一致する Namespace の一つを任意に選択してもよい

    注意 修飾名の中で接頭辞を保存する実装は、ns.prefix == q.[[Prefix]] というように ns に追加的な制約をしてもよい。

  4. もしそのような名前空間が存在しないならば
    1. ns を、コンストラクタ new Namespace(q.uri) を呼び出したかのように作成された新しい名前空間とする

      注意 接頭辞及び修飾名を保存する実装は、コンストラクタ Namespace(q.[[Prefix]], q.uri) を呼び出したかのように新しい名前空間を作成してもよい

  5. ns を返す

13.4 XML オブジェクト

13.4.1 関数として呼び出される XML コンストラクタ

構文

XML ( [ value ] )

概要

XML がコンストラクタとしてよりも関数として呼び出されたときは、それは型変換を実行する。もし引数が提供されないならば、XML 関数は空のテキストノードを表現する XML オブジェクトを返す。

動作

XML 関数が引数なしで、またはひとつの引数 value とともに呼び出されたときは、以下のステップがとられる:

  1. もし value が null 、undefined 、または提供されないならば、value を空文字列とする
  2. ToXML(value) を返す

    注意 ToXML 演算子は W3C 情報セットの実装 (例えば、W3C DOM ノード) から XML オブジェクトを構成するための機構を定義する。E4X の実装は XML コンストラクタを通してユーザーにこの機能を公開してもよい、しかしながら、これは E4X への適合性のためには要求されない。追加的な情報のために章 10.3.2 を見よ。

13.4.2 XML コンストラクタ

構文

new XML ( [ value ] )

概要

XML が new 式の一部として呼び出されたときは、それはコンストラクタであり新しい XML オブジェクトを作成してもよい。XMLList コンストラクタが引数なしで呼び出されたときは、それは空のテキストノードを表現する XML オブジェクトを返す。

動作

XML コンストラクタが引数なしで、またはひとつの引数 value とともに呼び出されたときは、以下のステップがとられる:

  1. もし value が null 、undefined 、または提供されないならば、value を空文字列とする
  2. x = ToXML(value) とする

    注意 ToXML 演算子は W3C 情報セットの実装 (例えば、W3C DOM ノード) から XML オブジェクトを構成するための機構を定義する。E4X の実装は XML コンストラクタを通してユーザーにこの機能を公開してもよい、しかしながら、これは E4X への適合性のためには要求されない。追加的な情報のために章 10.3.2 を見よ。

  3. もし Type(value) ∈ {XML, XMLList, W3C XML 情報項目} ならば
    1. x の [[DeepCopy]] メソッドを呼び出した結果を返す
  4. x を返す

13.4.3 XML コンストラクタのプロパティ

XML コンストラクタの内部 [[Prototype]] プロパティの値は Function プロトタイプオブジェクトである。

内部プロパティと length プロパティ (その値は 1 である) に加えて、XML コンストラクタは以下のプロパティを持つ:

13.4.3.1 XML.prototype

XML.prototype プロパティの初期値は XML プロトタイプオブジェクト (章 13.4.3.1) である。

このプロパティは属性 { DontEnum, DontDelete, ReadOnly } を持つ。

13.4.3.2 XML.ignoreComments

ignoreComments プロパティの初期値は true である。もし ignoreComments が true であるならば、新しい XML オブジェクトを構成するときに XML コメントは無視される。

このプロパティは属性 { DontEnum, DontDelete } を持つ。

13.4.3.3 XML.ignoreProcessingInstructions

ignoreProcessingInstructions プロパティの初期値は true である。もし ignoreProcessingInstructions が true であるならば、新しい XML オブジェクトを構成するときに XML 処理命令は無視される。

このプロパティは属性 { DontEnum, DontDelete } を持つ。

13.4.3.4 XML.ignoreWhitespace

ignoreWhitespace プロパティの初期値は true である。もし ignoreWhitespace が true であるならば、新しい XML オブジェクトを構成する処理をするときに重要でない空白文字は無視される。要素タグおよび埋め込み式またはそのどちらかが空白文字のみにより区切られているときは、それらの空白文字は重要でないと定義される。空白文字はスペース (\u0020) 、復帰 (\u000D) 、改行 (\u000A) およびタブ (\u0009) であると定義される。

このプロパティは属性 { DontEnum, DontDelete } を持つ。

13.4.3.5 XML.prettyPrinting

prettyPrinting プロパティの初期値は true である。もし prettyPrinting が true であるならば、ToString および ToXMLString 演算子は定形式で美的な体裁を達成するために特定のタグの間の空白文字を正規化するだろう。

このプロパティは属性 { DontEnum, DontDelete } を持つ。

13.4.3.6 XML.prettyIndent

prettyIndent プロパティの初期値は 2 である。もし XML コンストラクタの prettyPrinting プロパティが true であるならば、ToString および ToXMLString 演算子は定形式で美的な体裁を達成するために特定のタグの間の空白文字を正規化するだろう。特定の子ノードはそれらの親ノードと比較して prettyIndent により指定された数のスペースだけ字下げされるだろう。

このプロパティは属性 { DontEnum, DontDelete } を持つ。

13.4.3.7 XML.settings ( )

概要

setting メソッドは XML コンストラクタのプロパティとして格納されたグローバル XML 設定 (章 13.4.3.2 から 13.4.3.6 まで) の集合を管理するために便利なメソッドである。それは XML 設定を格納するために使われる XML コンストラクタのプロパティを含むオブジェクトを返す。このオブジェクトは後ほど関連付けられた設定を復元するために setSettings メソッドに引数として渡されてもよい。例えば、

// XML 設定を保存し復元するために必要であってもよい汎用的な関数を作成する
function getXMLCommentsFromString(xmlString) {
   // 以前の XML 設定を保存しコメントが無視されないことを確認する
   var settings = XML.settings();
   XML.ignoreComments = false;

   var comments = XML(xmlString).comment();

   // 設定を復元し結果を返す
   XML.setSettings(settings);
   return comments;
}

動作

XML コンストラクタの settings メソッドが呼び出されたときは、以下のステップがとられる:

  1. s を、コンストラクタ new Object() を呼び出したかのように作成された新しい Object とする
  2. s.ignoreComments = XML.ignoreComments とする
  3. s.ignoreProcessingInstructions = XML.ignoreProcessingInstructions とする
  4. s.ignoreWhitespace = XML.ignoreWhitespace とする
  5. s.prettyPrinting = XML.prettyPrinting とする
  6. s.prettyIndent = XML.prettyIndent とする
  7. s を返す
13.4.3.8 XML.setSettings ( [ Settings ] )

setSettings メソッドは XML コンストラクタのプロパティとして格納されたグローバル XML 設定 (章 13.4.3.2 から 13.4.3.6 まで) の集合を管理するために便利なメソッドである。それは関連付けられた settings メソッドを使って以前に捕捉された XML 設定の集合を復元するために使われてもよい。単独の引数 settings とともに呼び出されたときは、setSettings メソッドは settings オブジェクトから XML 設定を格納するために使われる XML コンストラクタのプロパティをコピーする。引数なしで呼び出されたときは、setSettings メソッドはデフォルト XML 設定を復元する。

動作

XML コンストラクタの setSettings メソッドが引数なしで、または単独の引数 settings とともに呼び出されたときは、以下のステップがとられる:

  1. もし settings が null 、undefined 、または提供されないならば
    1. XML.ignoreComments = true とする
    2. XML.ignoreProcessingInstructions = true とする
    3. XML.ignoreWhitespace = true とする
    4. XML.prettyPrinting = true とする
    5. XML.prettyIndent = 2 とする
  2. そうでなく、もし Type(settings) が Object であるならば
    1. もし Type(settings.ignoreComments) が Boolean であるならば
      1. XML.ignoreComments = settings.ignoreComments とする
    2. もし Type(settings.ignoreProcessingInstructions) が Boolean であるならば
      1. XML.ignoreProcessingInstructions = settings.ignoreProcessingInstructions とする
    3. もし Type(settings.ignoreWhitespace) が Boolean であるならば
      1. XML.ignoreWhitespace = settings.ignoreWhitespace とする
    4. もし Type(settings.prettyPrinting) が Boolean であるならば
      1. XML.prettyPrinting = settings.prettyPrinting とする
    5. もし Type(settings.prettyIndent) が Number であるならば
      1. XML.prettyIndent = settings.prettyIndent とする
  3. 返る
13.4.3.9 XML.defaultSettings ( )

defaultSettings メソッドは XML コンストラクタのプロパティとして格納されたグローバル XML 設定 (章 13.4.3.2 から 13.4.3.6 まで) の集合を管理すために便利なメソッドである。それはデフォルト XML 設定を含むオブジェクトを取得するために使われてもよい。このオブジェクトはデフォルト設定を判別するために調査されるかまたはデフォルト XML 設定を復元するために setSettings メソッドに引数として渡されてもよい。

動作

XML コンストラクタの defaultSettings メソッドが引数なしで呼び出されたときは、以下のステップがとられる:

  1. s を、コンストラクタ new Object() を呼び出したかのように作成された新しい Object とする
  2. s.ignoreComments = true とする
  3. s.ignoreProcessingInstructions = true とする
  4. s.ignoreWhitespace = true とする
  5. s.prettyPrinting = true とする
  6. s.prettyIndent = 2 とする
  7. s を返す
13.4.3.10 [[HasInstance]] ( V )

概要

XML コンストラクタはほかの関数オブジェクトよりも複雑な [[HasInstance]] メソッドを持つ。XML コンストラクタ [[HasInstance]] メソッドは、XML オブジェクトまたは XMLList オブジェクト x が与えられたとき、式 x instanceof XML が true を返すように定義される。この処置は故意に単独の XML オブジェクトとただひとつの値のみを含む XMLList との間の区別をあいまいにする。

動作

XML コンストラクタオブジェクト F の [[HasInstance]] メソッドが値 V とともに呼び出されたときは、以下のステップがとられる:

  1. もし V がオブジェクトでないならば、false を返す
  2. xmlProto = XML.prototype とする
  3. listProto = XMLList.prototype とする
  4. もし xmlProto がオブジェクトでないまたは listProto がオブジェクトでないならば、TypeError 例外を投げる
  5. objProto = V.[[Prototype]] とする
  6. objProto が null でない間
    1. もし xmlProto および objProto が同じオブジェクトを参照するまたはもしそれらがお互いに結合されたオブジェクト (ECMAScript 第 3 版の章 13.1.2) を参照するならば、true を返す
    2. もし listProto および objProto が同じオブジェクトを参照するまたはもしそれらがお互いに結合されたオブジェクト (ECMAScript 第 3 版の章 13.1.2) を参照するならば、true を返す
    3. objProto = objProto.[[Prototype]] とする
  7. false を返す

13.4.4 XML プロトタイプオブジェクトのプロパティ (組み込みメソッド)

XML 型のそれぞれの値は一般的な操作を実行するために利用可能な組み込みメソッドのセットを持つ。これらの組み込みメソッドは XML プロトタイプオブジェクトのプロパティであり以下の章で記述される。

XML プロトタイプオブジェクトは、それ自身その値が空文字列である XML オブジェクト (その [[Class]] プロパティは "text" である) である。

XML プロトタイプオブジェクトの内部 [[Prototype]] プロパティの値は Object プロトタイプオブジェクト (ECMAScript 第 3 版の章 15.2.3.1) である。

XML.prototype 上で定義された組み込み関数はいずれも汎用的でない。もし this 値が XML オブジェクトでないならば、それらは TypeError 例外を投げる。それゆえに、それらはメソッドとしての使用のために他の種類のオブジェクトに転用されることはできない。

13.4.4.1 XML.prototype.constructor

XML.prototype.constructor の初期値は組み込み XML コンストラクタである。このプロパティは E4X の将来の版のために予約される。

注意 このプロパティの値はアクセスされることができず、それはこのプロパティを実用上書き込み専用にする。

13.4.4.2 XML.prototype.addNamespace ( namespace )

概要

addNamespace メソッドはこの XML オブジェクトの範囲内の名前空間に名前空間宣言を追加し、この XML オブジェクトを返す。もし XML オブジェクトの範囲内の名前空間が与えられたパラメータのものと一致する接頭辞を持つ名前空間をすでに含むならば、既存の名前空間の接頭辞は undefined に設定される。

動作

XML オブジェクト x の addNamespace メソッドがひとつのパラメータ namespace とともに呼び出されたときは、以下のステップがとられる:

  1. ns を、関数 Namespace(namespace) を呼び出したかのように構成された Namespace とする
  2. パラメータ ns とともに x の [[AddInScopeNamespace]] メソッドを呼び出す
  3. x を返す
13.4.4.3 XML.prototype.appendChild ( child )

概要

appendChild メソッドは与えられた child をこの XML オブジェクトのプロパティの終端に追加し、この XML オブジェクトを返す。例えば、

var e = <employees>
   <employee id="0" ><name>Jim</name><age>25</age></employee>
   <employee id="1" ><name>Joe</name><age>20</age></employee>
</employees>;

// Jim の employee 要素の終端に新しい子要素を追加する
e.employee.(name == "Jim").appendChild(<hobby>snorkeling</hobby>);

動作

XML オブジェクト x の appendChild メソッドがひとつの引数 child とともに呼び出されたときは、以下のステップがとられる:

  1. children を、引数 "*" とともに x の [[Get]] メソッドを呼び出した結果とする
  2. 引数 children.[[Length]] および child とともに children の [[Put]] メソッドを呼び出す
  3. x を返す
13.4.4.4 XML.prototype.attribute ( attributeName )

概要

attribute メソッドは与えられた attributeName を持つこの XML オブジェクトに関連付けられた 0 個またはひとつの XML 属性を含む XMLList を返す。例えば、

// Jim と名のつく従業員の id を取得する
e.employee.(name == "Jim").attribute("id");

動作

XML オブジェクト x の attribute メソッドがパラメータ attributeName とともに呼び出されたときは、以下のステップがとられる:

  1. name = ToAttributeName(attributeName) とする
  2. 引数 name とともに x の [[Get]] メソッドを呼び出した結果を返す
13.4.4.5 XML.prototype.attributes ( )

概要

attributes メソッドはこのオブジェクトの XML 属性を含む XMLList を返す。例えば、

// XML オブジェクトの属性を表示する
function printAttributes(x) {
   for each (var a in x.attributes()) {
      print("The attribute named " + a.name() + " has the value " + a);
   }
}

動作

XML オブジェクト x の attributes メソッドが呼び出されたときは、以下のステップがとられる:

  1. 引数 ToAttributeName("*") とともに x の [[Get]] メソッドを呼び出した結果を返す
13.4.4.6 XML.prototype.child ( propertyName )

概要

child メソッドは与えられた propertyName と一致するこの XML オブジェクトの中の子のリストを返す。もし propertyName が数値的な添字であるならば、child メソッドは propertyName により識別される順序的な位置の子を含むリストを返す。例えば、

var name = customer.child("name");    // 次と等しい : var name = customer.name;
var secondChild = customer.child(1);  // 次と等しい : var secondChild = customer.*[1]

動作

XML オブジェクト x の child メソッドが呼び出されたときは、それは以下のステップを実行する:

  1. もし ToString(ToUint32(propertyName)) == propertyName ならば
    1. children を、引数 "*" とともに x の [[Get]] メソッドを呼び出した結果とする
    2. temporary を、引数 propertyName とともに children の [[Get]] メソッドを呼び出した結果とする
    3. もし temporary が undefined であるならば、temporary = new XMLList() とする
    4. temporary を返す
  2. temporary を、引数 propertyName とともに x の [[Get]] メソッドを呼び出した結果とする
  3. ToXMLList(temporary) を返す
13.4.4.7 XML.prototype.childIndex ( )

概要

childIndex メソッドはその親の文脈内での子の XML オブジェクトの順序的な位置を表現する Number を返す。例えば、

// Joe と名の付く従業員の順序的な添字を取得する
var joeindex = e.employee.(name == "Joe").childIndex();

動作

XML オブジェクト x の childIndex メソッドが呼び出されたときは、それは以下のステップを実行する:

  1. parent = x.[[Parent]] とする
  2. もし parent == null または x.[[Class]] == "attribute" ならば、-1 を返す
  3. q を、parent[q] が x と同じオブジェクトである parent のプロパティとする
  4. ToNumber(q) を返す
13.4.4.8 XML.prototype.children ( )

概要

children メソッドはこの XML オブジェクトのすべてのプロパティを順に含む XMLList を返す。例えば、

// 最初の従業員の子要素を取得する : 以下を含む XMLList を返す :
// <name>Jim</name>, <age>25</age> and <hobby>Snorkeling</hobby>
var emps = e.employee[0].children();

動作

XML オブジェクト x の children メソッドが呼び出されたときは、それは以下のステップを実行する:

  1. 引数 "*" とともに x の [[Get]] メソッドを呼び出した結果を返す
13.4.4.9 XML.prototype.comments ( )

概要

comments メソッドは XML コメントを表現するこの XML オブジェクトのプロパティを含む XMLList を返す。

動作

XML オブジェクト x の comments メソッドが呼び出されたときは、それは以下のステップを実行する:

  1. list を、list.[[TargetObject]] = x および list.[[TargetProperty]] = null である新しい XMLList とする
  2. i = 0 から x.[[Length]]-1 までに対して
    1. もし x[i].[[Class]] == "comment" ならば、引数 x[i] とともに list の [[Append]] メソッドを呼び出す
  3. list を返す
13.4.4.10 XML.prototype.contains ( value )

概要

contains メソッドはこの XML オブジェクトを与えられた value と比較した結果を返す。この処置は故意に単独の XML オブジェクトとただひとつの値のみを含む XMLList との間の区別をあいまいにする。

動作

contains メソッドがパラメータ value とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. 比較 x == value の結果を返す
13.4.4.11 XML.prototype.copy ( )

概要

copy メソッドは内部プロパティ [[Parent]] が null に設定されたこの XML オブジェクトの深いコピーを返す。

動作

copy メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. x の [[DeepCopy]] メソッドを呼び出した結果を返す
13.4.4.12 XML.prototype.descendants ( [ name ] )

概要

descendants メソッドは与えられた name を持つこの XML オブジェクトのすべての XML に評価される子孫 (子、孫、ひ孫など) を返す。もし name パラメータが省略されたならば、それはこの XML オブジェクトのすべての子孫を返す。

動作

descendants メソッドが任意的なパラメータ name とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし name が指定されていないならば、name = "*" とする
  2. 引数 name とともに x の [[Descendants]] メソッドを呼び出した結果を返す
13.4.4.13 XML.prototype.elements ( [ name ] )

概要

elements メソッドがひとつのパラメータ name とともに呼び出されたときは、それは与えられた name を持つ XML 要素であるこの XML オブジェクトのすべての子を含む XMLList を返す。elements メソッドが引数なしで呼び出されたときは、それはそれらの名前に関係なく XML 要素であるこの XML オブジェクトのすべての子を含む XMLList を返す。

動作

elements メソッドが任意的なパラメータ name とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし name が指定されていないならば、name = "*" とする
  2. name = ToXMLName(name) とする
  3. list を、list.[[TargetObject]] = x および list.[[TargetProperty]] = name である新しい XMLList とする
  4. i = 0 から x.[[Length]]-1 までに対して
    1. もし x[i].[[Class]] == "element" ならば
      1. もし (name.localName == "*" または name.localName == x[i].[[Name]].localName) かつ (name.uri == null または n.uri == x[i].[[Name]].uri) ならば
        1. 引数 x[i] とともに list の [[Append]] メソッドを呼び出す
  5. list を返す
13.4.4.14 XML.prototype.hasOwnProperty ( P )

概要

hasOwnProperty メソッドはこのオブジェクトが P により指定されるプロパティを持つかどうかを指し示す Boolean 値を返す。XML プロトタイプオブジェクトを除くすべての XML オブジェクトに対して、これは内部メソッド [[HasProperty]] により返されるのと同じ結果である。XML プロトタイプオブジェクトに対しては、hasOwnProperty はまた与えられた名前を持つメソッドプロパティが存在するかを判別するために局所プロパティのリストをも検査する。

動作

XML オブジェクト x の hasOwnProperty メソッドが引数 P とともに呼び出されたときは、以下のステップがとられる:

  1. もし引数 P とともにこのオブジェクトの [[HasProperty]] メソッドを呼び出した結果が true であるならば、true を返す
  2. もし x が名前が ToString(P) であるプロパティを持つならば、true を返す
  3. false を返す
13.4.4.15 XML.prototype.hasComplexContent( )

概要

hasComplexContent メソッドは、この XML オブジェクトが複合内容を含むかどうかを指し示す Boolean 値を返す。XML オブジェクトは、もしそれが子要素を持つ XML 要素を表現するならば、複合内容を含むと考えられる。属性、コメント、処理命令、およびテキストノードを表現する XML オブジェクトは複合内容を持たない。XML オブジェクト内での属性、コメント、処理命令、およびテキストノードの存在は、それが複合内容を持つか判別するのに重要ではない。

動作

hasComplexContent メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"attribute", "comment", "processing-instruction", "text"} ならば、false を返す
  2. x 中のそれぞれのプロパティ p に対して
    1. もし p.[[Class]] == "element" ならば、true を返す
  3. false を返す
13.4.4.16 XML.prototype.hasSimpleContent( )

概要

hasSimpleContent メソッドはこの XML オブジェクトが単純内容を含むかどうかを指し示す Boolean 値を返す。XML オブジェクトは、もしそれがテキストノードを表現するか、属性ノードを表現するか、またはもしそれが子要素を持たない XML 要素を表現するならば、単純内容を含むと考えられる。コメントおよび処理命令を表現する XML オブジェクトは単純内容を持たない。XML オブジェクト内での属性、コメント、処理命令、およびテキストノードの存在は、それが単純内容を持つか判別するのに重要ではない。

動作

hasSimpleContent メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"comment", "processing-instruction"} ならば、false を返す
  2. x 中のそれぞれのプロパティ p に対して
    1. もし p.[[Class]] == "element" ならば、false を返す
  3. true を返す
13.4.4.17 XML.prototype.inScopeNamespaces( )

概要

inScopeNamespaces メソッドはその親の文脈内でこの XML オブジェクトに対する範囲内の名前空間を表現する Namespace オブジェクトの配列を返す。もしこの XML オブジェクトの親が修正されたならば、関連付けられた名前空間宣言は変化してもよい。このメソッドにより返される名前空間のセットはこの値により使われる名前空間の上位セットであってもよい。

動作

inScopeNamespaces メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. y = x とする
  2. inScopeNS = { } とする
  3. y が null でない間
    1. y.[[InScopeNamespaces]] 中のそれぞれの ns に対して
      1. もし n.prefix == ns.prefix であるような ninScopeNS が存在しないならば
        1. inScopeNS = inScopeNS ∪ { ns } とする
    2. y = y.[[Parent]] とする
  4. a を、コンストラクタ new Array() を呼び出したかのように作成された新しい Array とする
  5. i = 0 とする
  6. isScopeNS 中のそれぞれの ns に対して
    1. 引数 ToString(i) および ns とともに a の [[Put]] メソッドを呼び出す
    2. i = i + 1 とする
  7. a を返す
13.4.4.18 XML.prototype.insertChildAfter ( child1 , child2 )

概要

insertChildAfter メソッドはこの XML オブジェクト内の与えられた child1 の後に与えられた child2 を挿入し、この XML オブジェクトを返す。もし child1 が null であるならば、insertChildAfter メソッドはこの XML オブジェクトのすべての子の前 (すなわち、それらいずれの後でもない) に child2 を挿入する。もし child1 がこの XML オブジェクト内に存在しないならば、それはこの XML オブジェクトを修正することなく返る。

動作

insertChildAfter メソッドがパラメータ child1 および child2 とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、返る
  2. もし child1 == null ならば
    1. 引数 "0" および child2 とともに x の [[Insert]] メソッドを呼び出す
    2. x を返す
  3. そうでなく、もし Type(child1) が XML であるならば
    1. i = 0 から x.[[Length]]-1 までに対して
      1. もし x[i] が child1 と同じオブジェクトであるならば
        1. 引数 ToString(i + 1) および child2 とともに x の [[Insert]] メソッドを呼び出す
        2. x を返す
  4. 返る
13.4.4.19 XML.prototype.insertChildBefore ( child1 , child2 )

概要

insertChildBefore メソッドはこの XML オブジェクト内の与えられた child1 の前に与えられた child2 を挿入する。もし child1 が null であるならば、insertChildBefore メソッドはこの XML オブジェクトのすべての子の後 (すなわち、それらいずれの前でもない) に child2 を挿入する。もし child1 がこの XML オブジェクト内に存在しないならば、それはこの XML オブジェクトを修正することなく返る。

動作

insertChildBefore メソッドがパラメータ child1 および child2 とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、返る
  2. もし child1 == null ならば
    1. 引数 ToString(x.[[Length]]) および child2 とともに x の [[Insert]] メソッドを呼び出す
    2. x を返す
  3. そうでなく、もし Type(child1) が XML であるならば
    1. i = 0 から x.[[Length]]-1 までに対して
      1. もし x[i] が child1 と同じオブジェクトであるならば
        1. 引数 ToString(i) および child2 とともに x の [[Insert]] メソッドを呼び出す
        2. x を返す
  4. 返る
13.4.4.20 XML.prototype.length ( )

概要

length メソッドは XML オブジェクトに対しては常に整数 1 を返す。この処置は単独の XML オブジェクトとただひとつの値のみを含む XMLList との間の区別を故意にあいまいにする。

動作

length メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. 1 を返す
13.4.4.21 XML.prototype.localName ( )

概要

localName メソッドはこの XML オブジェクトの修飾名の局所名部分を返す。

動作

localName メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Name]] == null ならば、null を返す
  2. x.[[Name]].localName を返す
13.4.4.22 XML.prototype.name ( )

概要

name メソッドはこの XML オブジェクトに関連付けられた修飾名を返す。

動作

name メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. x.[[Name]] を返す
13.4.4.23 XML.prototype.namespace ( [ prefix ] )

概要

もし prefix が指定されないならば、namespace メソッドはこの XML オブジェクトの修飾名に関連付けられた Namespace を返す。

もし prefix が指定されたならば、namespace メソッドは与えられた prefix を持つこの XML オブジェクトの範囲内の名前空間を探し、もし見つかったならば、それを返す。もしそのような名前空間が見つからないならば、namespace メソッドは undefined を返す。

動作

namespace メソッドが 0 個の引数またはひとつの引数 prefix とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. y = x とする
  2. inScopeNS = { } とする
  3. y が null でない間
    1. y.[[InScopeNamespaces]] 中のそれぞれの ns に対して
      1. もし n.prefix == ns.prefix であるような ninScopeNS が存在するならば
        1. inScopeNS = inScopeNS ∪ { ns } とする
    2. y = y.[[Parent]] とする
  4. もし prefix が指定されないならば
    1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction"} ならば、null を返す
    2. 引数 inScopeNS とともに x.[[Name]] の [[GetNamespace]] メソッドを呼び出した結果を返す
  5. そうでなければ
    1. prefix = ToString(prefix) とする
    2. ns.prefix = prefix であるような nsinScopeNS である Namespace ns を見つける。もしそのような ns が存在しないならば、ns = undefined とする
    3. ns を返す
13.4.4.24 XML.prototype.namespaceDeclarations ( )

概要

namespaceDeclarations メソッドは、その親の文脈内でこの XML オブジェクトに関連付けられた名前空間宣言を表現する Namespace オブジェクトの Array を返す。もしこの XML オブジェクトの親が修正されたならば、関連付けられた名前空間宣言は変化してもよい。

動作

namespaceDeclarations メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. a を、コンストラクタ new Array() を呼び出したかのように作成された新しい Array とする
  2. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、a を返す
  3. y = x.[[Parent]] とする
  4. ancestorNS = { } とする
  5. y が null でない間
    1. y.[[InScopeNamespaces]] 中のそれぞれの ns に対して
      1. もし n.prefix == ns.prefix であるような nancestorNS が存在しないならば
        1. ancestorNS = ancestorNS ∪ { ns } とする
    2. y = y.[[Parent]] とする
  6. declaredNS = { } とする
  7. x.[[InScopeNamespaces]] 中のそれぞれの ns に対して
    1. もし n.prefix == ns.prefix かつ n.uri == ns.uri であるような nancestorNS が存在しないならば
      1. declaredNS = declaredNS ∪ { ns } とする
  8. i = 0 とする
  9. declaredNS 中のそれぞれの ns に対して
    1. 引数 ToString(i) および ns とともに a の [[Put]] メソッドを呼び出す
    2. i = i + 1 とする
  10. a を返す
13.4.4.25 XML.prototype.nodeKind ( )

概要

nodeKind メソッドはこの XML オブジェクトの [[Class]] を表現する文字列を返す。

動作

nodeKind メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. x.[[Class]] を返す
13.4.4.26 XML.prototype.normalize ( )

概要

normalize メソッドは、これおよびすべての子孫 XML オブジェクトの中のすべてのテキストノードを、隣接するテキストノードを併合し空のテキストノードを削除することにより正規形式にする。それはこの XML オブジェクトを返す。

動作

normalize メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. i = 0 とする
  2. i < x.[[Length]] の間
    1. もし x[i].[[Class]] == "element" ならば
      1. x[i] の normalize メソッドを呼び出す
      2. i = i + 1 とする
    2. そうでなく、もし x[i].[[Class]] == "text" ならば
      1. (i+1) < x.[[Length]] かつ x[i + 1].[[Class]] == "text" の間
        1. x[i].[[Value]] を、x[i].[[Value]] と x[i + 1].[[Value]] とを連結した結果とする
        2. 引数 ToString(i + 1) とともに x の [[DeleteByIndex]] メソッドを呼び出す
      2. もし x[i].[[Value]].length == 0 ならば
        1. 引数 ToString(i) とともに x の [[DeleteByIndex]] メソッドを呼び出す
      3. そうでなければ
        1. i = i + 1 とする
    3. そうでなければ
      1. i = i + 1 とする
  3. x を返す
13.4.4.27 XML.prototype.parent ( )

概要

parent メソッドはこの XML オブジェクトの親を返す。例えば、

// "e" の中の二つ目の name の親要素を取得する。<employee id="1" ... を返す
var firstNameParent = e..name[1].parent()

動作

parent メソッドが XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. x.[[Parent]] を返す
13.4.4.28 XML.prototype.processingInstructions ( [ name ] )

概要

processingInstructions メソッドがひとつのパラメータ name とともに呼び出されたときは、それは与えられた name を持つ処理命令であるこの XML オブジェクトのすべての子を含む XMLList を返す。processingInstructions メソッドがパラメータなしで呼び出されたときは、それはそれらの名前に関係なく処理命令であるこの XML オブジェクトのすべての子を含む XMLList を返す。

動作

processingInstructions メソッドが任意的なパラメータ name とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし name が指定されないならば、name = "*" とする
  2. name = ToXMLName(name) とする
  3. list を、list.[[TargetObject]] = x かつ list.[[TargetProperty]] = null である新しい XMLList とする
  4. i = 0 から x.[[Length]]-1 までに対して
    1. もし x[i].[[Class]] == "processing-instruction" ならば
      1. もし name.localName == "*" または name.localName == x[i].[[Name]].localName ならば
        1. 引数 x[i] とともに list の [[Append]] メソッドを呼び出す
  5. list を返す
13.4.4.29 XML.prototype.prependChild ( value )

概要

prependChild メソッドはこのオブジェクト内のその既存の XML プロパティの前に与えられた child を挿入し、この XML オブジェクトを返す。例えば、

// John の employee 要素の前に新しい子要素を追加する
e.employee.(name == "John").prependChild(<prefix>Mr.</prefix>);

動作

prependChild メソッドがパラメータ value とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. 引数 "0" および value とともにこのオブジェクトの [[Insert]] メソッドを呼び出す
  2. x を返す
13.4.4.30 XML.prototype.propertyIsEnumerable ( P )

概要

propertyIsEnumerable メソッドは、プロパティ P が、この XML オブジェクトが for-in 文の中で使われたときに反復されるプロパティのセットの中に含まれるであろうかどうかを指し示す Boolean 値を返す。ToString(P) が "0" であるときは、このメソッドは true を返し、そうでなければ、それは false を返す。この処置は故意に単独の XML オブジェクトとただひとつの値のみを含む XMLList との間の区別をあいまいにする。

動作

XML オブジェクト x の propertyIsEnumerable メソッドがパラメータ P とともに呼び出されたときは、以下のステップがとられる:

  1. 比較 ToString(P) == "0" の結果が返される
13.4.4.31 XML.prototype.removeNamespace ( namespace )

概要

removeNamespace メソッドは、このオブジェクトおよびそのすべての子孫の範囲内の名前空間から与えられた名前空間を取り除き、この XML オブジェクトのコピーを返す。removeNamespace メソッドは、それがそのオブジェクトの QName またはそのオブジェクトの属性の QName により参照されている場合は、オブジェクトから名前空間を取り除かないだろう。

訳注 コピーではなくその XML オブジェクト自体を返す。

動作

removeNamespace メソッドがパラメータ namespace とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、x を返す
  2. ns を、関数 Namespace( namespace ) を呼び出したかのように作成された Namespace オブジェクトとする
  3. thisNS を、引数 x.[[InScopeNamespaces]] とともに x.[[Name]] 上で [[GetNamespace]] を呼び出した結果とする
  4. もし thisNS == ns ならば、x を返す
  5. x.[[Attributes]] 中のそれぞれの a に対して
    1. aNS を、引数 x.[[InScopeNamespaces]] とともに a.[[Name]] 上で [[GetNamespace]] を呼び出した結果とする
    2. もし aNS == ns ならば、x を返す
  6. もし ns.prefix == undefined ならば
    1. もし n.uri == ns.uri であるような名前空間 nx.[[InScopeNamespaces]] が存在するならば、x.[[InScopeNamespaces]] から名前空間 n を取り除く
  7. そうでなければ
    1. もし n.uri == ns.uri かつ n.prefix == ns.prefix であるような名前空間 nx.[[InScopeNamespaces]] が存在するならば、x から名前空間 n を取り除く
  8. x 中のそれぞれのプロパティ p に対して
    1. もし p.[[Class]] = "element" ならば、引数 ns とともに p の removeNamespace メソッドを呼び出す
  9. x を返す
13.4.4.32 XML.prototype.replace ( propertyName , value )

概要

replace メソッドは propertyName により指定されたこの XML オブジェクトの XML プロパティを value で置き換え、この XML オブジェクトを返す。もしこの XML オブジェクトが propertyName に一致するプロパティを含まないならば、replace メソッドはこの XML オブジェクトを修正することなく返る。propertyName パラメータは数値的なプロパティ名、XML 要素のセットのための非修飾名、XML 要素のセットのための修飾名、またはプロパティワイルドカード "*" であってもよい。propertyName パラメータが非修飾名であるときは、それはデフォルト名前空間内の XML 要素を識別する。value パラメータは XML オブジェクト、XMLList オブジェクト、または ToString() で String に変換されてもよい任意の値であってもよい。例えば、

// 最初の従業員の記録を open なスタッフの requisition で置き換える
employees.replace(0, <requisition status="open"/>);

// order 中のすべての item 要素を単独の空の item で置き換える
order.replace("item", <item/>);

動作

replace メソッドがパラメータ propertyName および value とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction", "attribute"} ならば、x を返す
  2. もし Type(value) ∉ {XML, XMLList} ならば、c = ToString(value) とする
  3. そうでなければ、c を、value の [[DeepCopy]] メソッドを呼び出した結果とする
  4. もし ToString(ToUint32(P)) == P ならば
    1. 引数 P および c とともに x の [[Replace]] メソッドを呼び出し、x を返す
  5. n を、関数 QName(P) を呼び出したかのように作成された QName オブジェクトとする
  6. i = undefined とする
  7. k = x.[[Length]]-1 から 0 までの減少に対して
    1. もし (n.localName == "*" または (x[k].[[Class]] == "element" かつ x[k].[[Name]].localName == n.localName)) かつ (n.uri == null または (x[k].[[Class]] == "element" かつ n.uri == x[k].[[Name]].uri)) ならば
      1. もし i が undefined でないならば、引数 ToString(i) とともに x の [[DeleteByIndex]] メソッドを呼び出す
      2. i = k とする
  8. もし i == undefined ならば、x を返す
  9. 引数 ToString(i) および c とともに x の [[Replace]] メソッドを呼び出す
  10. x を返す
13.4.4.33 XML.prototype.setChildren ( value )

概要

setChildren メソッドはこの XML オブジェクトの XML プロパティを value からの新しい XML プロパティのセットで置き換える。value は単独の XML オブジェクトまたは XMLList であってもよい。setChildren はこの XML オブジェクトを返す。例えば、

// Jim の employee 要素の内容全体を置き換える
e.employee.(name == "Jim").setChildren(<name>John</name> + <age>35</age>);

動作

setChildren メソッドがパラメータ value とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. 引数 "*" および value とともに x の [[Put]] メソッドを呼び出す
  2. x を返す
13.4.4.34 XML.prototype.setLocalName ( name )

概要

setLocalName メソッドはこの XML オブジェクトの局所名を与えられた name から構成される文字列で置き換える。

動作

setLocalName メソッドがパラメータ name とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment"} ならば、返る
  2. もし Type(name) が Object でありかつ name.[[Class]] == QName ならば
    1. name = name.localName とする
  3. そうでなければ
    1. name = ToString(name) とする
  4. x.[[Name]].localName = name とする
13.4.4.35 XML.prototype.setName( name )

概要

setName メソッドはこの XML オブジェクトの名前を与えられた name から構成される QName または AttributeName で置き換える。

動作

setName メソッドがパラメータ name とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment"} ならば、返る
  2. もし Type(name) が Object でありかつ name.[[Class]] == "QName" かつ name.uri == null ならば
    1. name = name.localName とする
  3. n を、コンストラクタ new QName(name) を呼び出したかのように作成された新しい QName とする
  4. もし x.[[Class]] == "processing-instruction" ならば、n.uri を空文字列とする
  5. x.[[Name]] = n とする
  6. ns を、コンストラクタ new Namespace(n.prefix, n.uri) を呼び出したかのように作成された新しい Namespace とする
  7. もし x.[[Class]] == "attribute" ならば
    1. もし x.[[Parent]] == null ならば、返る
    2. x.[[Parent]].[[AddInScopeNamespace]](ns) を呼び出す
  8. もし x.[[Class]] == "element" ならば
    1. x.[[AddInScopeNamespace]](ns) を呼び出す
13.4.4.36 XML.prototype.setNamespace ( ns )

概要

setNamespace メソッドはこの XML オブジェクトの名前に関連付けられた名前空間を与えられた名前空間で置き換える。

動作

setNamespace メソッドがパラメータ ns とともに XML オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Class]] ∈ {"text", "comment", "processing-instruction"} ならば、返る
  2. ns2 を、コンストラクタ new Namespace(ns) を呼び出したかのように作成された新しい Namespace とする
  3. x.[[Name]] を、コンストラクタ new QName(ns2, x.[[Name]]) を呼び出したかのように作成された新しい QName とする
  4. もし x.[[Class]] == "attribute" ならば
    1. もし x.[[Parent]] == null ならば、返る
    2. x.[[Parent]].[[AddInScopeNamespace]](ns2) を呼び出す
  5. もし x.[[Class]] == "element" ならば
    1. x.[[AddInScopeNamespace]](ns2) を呼び出す
13.4.4.37 XML.prototype.text ( )

概要

text メソッドは XML テキストノードを表現するこの XML オブジェクトのすべての XML プロパティを含む XMLList を返す。

動作

XML オブジェクト x の text メソッドが呼び出されたときは、以下のステップがとられる:

  1. list を、list.[[TargetObject]] = x および list.[[TargetProperty]] = null である新しい XMLList とする
  2. i = 0 から x.[[Length]]-1 までに対して
    1. もし x[i].[[Class]] == "text" ならば、引数 x[i] とともに list の [[Append]] メソッドを呼び出す
  3. list を返す
13.4.4.38 XML.prototype.toString ( )

概要

toString メソッドは章 10.1 で記述された ToString 変換演算子によるこの XML オブジェクトの文字列表現を返す。

動作

XML オブジェクト x の toString メソッドが呼び出されたときは、以下のステップがとられる:

  1. ToString(x) を返す
13.4.4.39 XML.prototype.toXMLString ( )

概要

toXMLString() メソッドは章 10.2 で記述された ToXMLString 変換演算子によるこの XML オブジェクトの XML に符号化された文字列表現を返す。toString メソッドとは異なり、toXMLString は XML テキストノード (すなわち、プリミティブ値) のみを含む XML オブジェクトのための特別な処置を提供しない。toXMLString メソッドはその内容に関係なく常に XML オブジェクトの開始タグ、属性、および終了タグを含む。それは規定の XML から文字列への変換規則が望ましくない場合のために提供される。例えば、

var item = <item>
   <description>Laptop Computer</description>
   <price>2799.95</price>
   <quantity>1</quantity>
</item>;

// "Description stored as <description>Laptop Computer</description>" を返す
var logmsg = "Description stored as " + item.description.toXMLString();

// "Thank you for purchasing a Laptop Computer!" を (タグを削除して) 返す
var message = "Thank you for purchasing a " + item.description + "!";

動作

XML オブジェクト x の toXMLString メソッドが呼び出されたときは、以下のステップがとられる:

  1. ToXMLString(x) を返す
13.4.4.40 XML.prototype.valueOf ( )

概要

valueOf メソッドはこの XML オブジェクトを返す。

動作

XML オブジェクト x の valueOf メソッドが呼び出されたときは、以下のステップがとられる:

  1. x を返す

13.4.5 XML インスタンスのプロパティ

XML インスタンスは XML プロトタイプオブジェクトから継承されるものを超える特別なプロパティを持たない。

13.5 XMLList オブジェクト

13.5.1 関数として呼び出される XMLList コンストラクタ

構文

XMLList ( value )

概要

XMLList がコンストラクタとしてよりも関数として呼び出されたときは、それはその引数を XMLList オブジェクトに変換する。その引数が XMLList であるときは、その引数は修正なしで返される。

動作

XMLList がパラメータ value とともに関数として呼び出されたときは、以下のステップがとられる:

  1. もし value が null 、undefined 、または提供されないならば、value を空文字列とする
  2. ToXMLList(value) を返す

13.5.2 XMLList コンストラクタ

構文

new XMLList ( [ value ] )

概要

XMLList が new 式の一部として呼び出されたときは、それはコンストラクタであり新しい XMLList オブジェクトを作成する。XMLList コンストラクタが引数なしで呼び出されたときは、それは空の XMLList を返す。XMLList コンストラクタが XMLList 型の value とともに呼び出されたときは、XMLList コンストラクタは value の浅いコピーを返す。XMLList コンストラクタが XMLList でない値とともに呼び出されたときは、それはその入力引数を XMLList オブジェクトに変換する。

動作

XMLList コンストラクタが任意的なパラメータ value とともに呼び出されたときは、以下のステップがとられる:

  1. もし value が null 、undefined 、または提供されないならば、value を空文字列とする
  2. もし Type(value) が XMLList であるならば
    1. list を、list.[[TargetObject]] = null である新しい XMLList オブジェクトとする
    2. 引数 value とともに list の [[Append]] メソッドを呼び出す
    3. list を返す
  3. そうでなければ
    1. ToXMLList(value) を返す

13.5.3 XMLList コンストラクタのプロパティ

XMLList コンストラクタの内部 [[Prototype]] プロパティの値は Function プロトタイプオブジェクトである。

内部プロパティおよび length プロパティ (その値は 1 である) に加えて、XMLList コンストラクタは以下のプロパティを持つ:

13.5.3.1 XMLList.prototype

XMLList.prototype プロパティの初期値は XMLList プロトタイプオブジェクト (章 13.5.4) である。

このプロパティは属性 { DontEnum, DontDelete, ReadOnly } を持つ。

13.5.4 XMLList プロトタイプオブジェクトのプロパティ (組み込みメソッド)

XMLList 型のそれぞれの値は一般的な操作を実行するために利用可能な組み込みメソッドのセットを持つ。組み込みメソッドは以下の章で記述される。

XMLList プロトタイプオブジェクトは、それ自身その値が空の XMLList である XMLList オブジェクト (その [[Class]] プロパティは "XMLList" である) である。

XMLList プロトタイプオブジェクトの内部 [[Prototype]] プロパティの値は Object プロトタイプオブジェクト (ECMAScript 第 3 版の章 15.2.3.1) である。

注意 プログラマの作業を単純化するため、E4X は故意に単独の XML オブジェクトとただひとつの値のみを含む XMLList との間の区別をあいまいにする。このために、E4X は、XML 型の値のために利用可能なすべてのメソッドが大きさが 1 である XMLList のためにも利用可能であるように、ECMAScript の関数呼び出しの動作を拡張する。より多くの情報のためには章 11.2.2 を見よ。

XMLList.prototype 上で定義される組み込み関数はいずれも汎用的でない。もし this 値が XMLList オブジェクトでないならば、それらは TypeError 例外を投げる。それゆえに、それらはメソッドとしての使用のために他の種類のオブジェクトに転用されることはできない。

13.5.4.1 XMLList.prototype.constructor

XMLList プロトタイプコンストラクタの初期値は組み込み XMLList コンストラクタである。

13.5.4.2 XMLList.prototype.attribute ( attributeName )

概要

attribute メソッドは、パラメータとして attributeName を渡してこの XMLList オブジェクト中のそれぞれの XML オブジェクトの attribute メソッドを呼び出し、その結果を順に含む XMLList を返す。

動作

attribute メソッドがパラメータ attributeName とともに XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. name = ToAttributeName(attributeName) とする
  2. 引数 name とともに list の [[Get]] メソッドを呼び出した結果を返す
13.5.4.3 XMLList.prototype.attributes ( )

概要

attributes メソッドはこの XMLList オブジェクト中のそれぞれの XML オブジェクトの attributes() メソッドを呼び出し、その結果を順に含む XMLList を返す。

動作

attributes メソッドが XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. 引数 ToAttributeName("*") とともに list の [[Get]] メソッドを呼び出した結果を返す
13.5.4.4 XMLList.prototype.child ( propertyName )

概要

child メソッドはこの XMLList オブジェクト中のそれぞれの XML オブジェクトの child() メソッドを呼び出し、その結果を順に含む XMLList を返す。

動作

child メソッドがパラメータ propertyName とともに XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. m を、m.[[TargetObject]] = list である新しい XMLList とする
  2. i = 0 から list.[[Length]]-1 までに対して
    1. r = list[i].child(propertyName) とする
    2. もし r.[[Length]] > 0 ならば、引数 r とともに m の [[Append]] メソッドを呼び出す
  3. m を返す
13.5.4.5 XMLList.prototype.children ( )

概要

children メソッドはこの XMLList オブジェクト中のそれぞれの XML オブジェクトの children メソッドを呼び出し、順に連結されたその結果を含む XMLList を返す。例えば、

// order の中のすべての item のすべての子を取得する
var allitemchildren = order.item.children();

// 名前 price を持つ order のすべての孫を取得する
var grandChildren = order.children().price;

動作

children メソッドが XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. 引数 "*" とともに list の [[Get]] メソッドを呼び出した結果を返す
13.5.4.6 XMLList.prototype.comments ( )

概要

comments メソッドはこの XMLList オブジェクト中のそれぞれの XML オブジェクトの comments メソッドを呼び出し、順に連結されたその結果を含む XMLList を返す。

動作

comments メソッドが XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. m を、m.[[TargetObject]] = list である新しい XMLList とする
  2. i = 0 から list.[[Length]]-1 までに対して
    1. もし list[i].[[Class]] == "element" ならば
      1. r = list[i].comments() とする
      2. もし r.[[Length]] > 0 ならば、引数 r とともに m の [[Append]] メソッドを呼び出す
  3. m を返す
13.5.4.7 XMLList.prototype.constructor

XMLList.prototype.constructor の初期値は組み込み XMLList コンストラクタである。このプロパティは E4X の将来の版のために予約される。

注意 このプロパティの値はアクセスされることはできず、それはこのプロパティを実用上書き込み専用にする。

13.5.4.8 XMLList.prototype.contains ( value )

概要

contains メソッドは、この XMLList オブジェクトが与えられた value と等しく比較される XML オブジェクトを含むかどうかを指し示すブール値を返す。

動作

contains メソッドがパラメータ value とともに XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. i = 0 から list.[[Length]]-1 までに対して
    1. もし比較 list[i] == value の結果が true であるならば、true を返す
  2. false を返す
13.5.4.9 XMLList.prototype.copy ( )

概要

copy メソッドはこの XMLList オブジェクトの深いコピーを返す。

動作

copy メソッドが XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. list の [[DeepCopy]] メソッドを呼び出した結果を返す
13.5.4.10 XMLList.prototype.descendants ( [ name ] )

descendants メソッドは、任意的なパラメータ name (またはもし name が省略されたならば文字列 "*") とともにこの XMLList オブジェクト中のそれぞれの XML オブジェクトの descendants メソッドを呼び出し、順に連結されたその結果を含む XMLList を返す。

動作

descendants メソッドが任意的なパラメータ name とともに XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. もし name が指定されないならば、name = "*"
  2. 引数 name とともに list の [[Descendants]] メソッドを呼び出した結果を返す
13.5.4.11 XMLList.prototype.elements ( [ name ] )

概要

elements メソッドは、任意的なパラメータ name (またはもしそれが省略されたならば "*") を渡してこの XMLList オブジェクト中のそれぞれの XML オブジェクトの elements メソッドを呼び出し、その結果を順に含む XMLList を返す。

動作

elements メソッドが任意的なパラメータ name とともに XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. もし name が指定されないならば、name = "*" とする
  2. name = ToXMLName(name) とする
  3. m を、m.[[TargetObject]] = list および m.[[TaretProperty]] = name である新しい XMLList オブジェクトとする
  4. i = 0 から list.[[Length]]-1 までに対して
    1. もし list[i].[[Class]] == "element" ならば
      1. r = list[i].elements(name) とする
      2. もし r.[[Length]] > 0 ならば、引数 r とともに m の [[Append]] メソッドを呼び出す
  5. m を返す
13.5.4.12 XMLList.prototype.hasOwnProperty ( P )

概要

hasOwnProperty メソッドは、このオブジェクトが P により指定されるプロパティを持つかどうかを指し示す Boolean 値を返す。XMLList プロトタイプオブジェクトを除くすべての XMLList オブジェクトに対して、これは内部メソッド [[HasProperty]] により返されるのと同じ結果である。XMLList プロトタイプオブジェクトに対しては、hasOwnProperty はまた、与えられた名前を持つメソッドプロパティがあるか判定するために局所プロパティのリストをも検査する。

動作

XMLList オブジェクト x の hasOwnProperty メソッドがパラメータ P とともに呼び出されたときは、以下のステップがとられる:

  1. もし引数 P とともにこのオブジェクトの [[HasProperty]] メソッドを呼び出した結果が true であるならば、true を返す
  2. もし x が名前が ToString(P) であるプロパティを持つならば、true を返す
  3. false を返す
13.5.4.13 XMLList.prototype.hasComplexContent( )

概要

hasComplexContent メソッドは、この XMLList オブジェクトが複合内容を含むかどうかを指し示す Boolean 値を返す。XMLList オブジェクトは、もしそれが空でない、複合内容を持つ単独の XML 項目を含む、または複数の要素を含むならば、複合内容を含むと考えられる。

動作

hasComplexContent メソッドが XMLList オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Length]] == 0 ならば、false を返す
  2. もし x.[[Length]] == 1 ならば、x[0].hasComplexContent() を返す
  3. x 中のそれぞれのプロパティ p に対して
    1. もし p.[[Class]] == "element" ならば、true を返す
  4. false を返す
13.5.4.14 XMLList.prototype.hasSimpleContent( )

概要

hasSimpleContent メソッドは、この XMLList が単純内容を含むかどうかを指し示す Boolean 値を返す。XMLList オブジェクトは、もしそれが空である、単純内容を持つ単独の XML 項目を含む、または要素を含まないならば、単純内容を含むと考えられる。

動作

hasSimpleContent メソッドが XMLList オブジェクト x 上で呼び出されたときは、以下のステップがとられる:

  1. もし x.[[Length]] が 0 と等しくないならば
    1. もし x.[[Length]] == 1 ならば、x[0].hasSimpleContent() を返す
    2. x 中のそれぞれのプロパティ p に対して
      1. もし p.[[Class]] == "element" ならば、false を返す
  2. true を返す
13.5.4.15 XMLList.prototype.length ( )

概要

length メソッドはこの XMLList オブジェクト中のプロパティの数を返す。例えば、

for (var i = 0; i < e..name.length(); i++) {
   print("Employee name:" + e..name[i]);
}

動作

XMLList オブジェクト list の length メソッドが呼び出されたときは、以下のステップがとられる:

  1. Return list.[[Length]] を返す
13.5.4.16 XMLList.prototype.normalize ( )

概要

normalize メソッドは、この XMLList 中のすべてのテキストノード、それが含むすべての XML オブジェクト、およびそれが含むすべての XML オブジェクトの子孫を、隣接するテキストノードを併合するおよび空のテキストノードを削除することにより正規形式にする。それはこの XMLList オブジェクトを返す。

動作

normalize メソッドが XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. i = 0 とする
  2. i < list.[[Length]] の間
    1. もし list[i].[[Class]] == "element" ならば
      1. list[i] の normalize メソッドを呼び出す
      2. i = i + 1 とする
    2. そうでなく、もし list[i].[[Class]] == "text" ならば
      1. (i+1) < list.[[Length]] かつ list[i + 1].[[Class]] == "text" の間
        1. list[i].[[Value]] を、list[i].[[Value]] と list[i + 1].[[Value]] とを連結した結果とする
        2. 引数 ToString(i + 1) とともに list の [[Delete]] メソッドを呼び出す
      2. もし list[i].[[Value]].length == 0 ならば
        1. 引数 ToString(i) とともに list の [[Delete]] メソッドを呼び出す
      3. そうでなければ
        1. i = i + 1 とする
    3. そうでなければ
      1. i = i + 1 とする
  3. list を返す
13.5.4.17 XMLList.prototype.parent ( )

概要

もしこの XMLList オブジェクト中のすべての項目が同じ親をもつならば、それが返される。そうでなければ、parent メソッドは undefined を返す。

動作

parent メソッドが XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. もし list.[[Length]] = 0 ならば、undefined を返す
  2. parent = list[0].[[Parent]] とする
  3. i = 0 から list.[[Length]]-1 までに対して、もし list[i].[[Parent]] が parent と等しくないならば、undefined を返す
  4. parent を返す
13.5.4.18 XMLList.prototype.processingInstructions ( [ name ] )

概要

processingInstructions メソッドは、任意的なパラメータ name (またはもしそれが省略されたならば "*") を渡してこの XMLList 中のそれぞれの XML オブジェクトの processingInstructions メソッドを呼び出し、その結果を順に含む XMLList を返す。

動作

processingInstructions メソッドが任意的なパラメータ name とともに XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. もし name が指定されないならば、name = "*" とする
  2. name = ToXMLName(name) とする
  3. m を、m.[[TargetObject]] = list である新しい XMLList とする
  4. i = 0 から list.[[Length]]-1 までに対して
    1. もし list[i].[[Class]] == "element" ならば
      1. r = list[i].processingInstructions(name) とする
      2. もし r.[[Length]] > 0 ならば、引数 r とともに m の [[Append]] メソッドを呼び出す
  5. m を返す
13.5.4.19 XMLList.prototype.propertyIsEnumerable ( P )

概要

propertyIsEnumerable メソッドは、プロパティ P が、この XMLList オブジェクトが for-in 文の中で使われたときに反復されるプロパティのセットの中に含まれるだろうかどうかを指し示す Boolean 値を返す。

動作

XMLList オブジェクト x の propertyIsEnumerable メソッドがパラメータ P とともに呼び出されたときは、以下のステップがとられる:

  1. もし ToNumber(P) が 0 以上でありかつ ToNumber(P) が x.[[Length]] よりも小さいならば、true を返す
  2. false を返す
13.5.4.20 XMLList.prototype.text ( )

概要

text メソッドはこの XMLList オブジェクト中に含まれるそれぞれの XML オブジェクトの text メソッドを呼び出し、順に連結されたその結果を含む XMLList を返す。

動作

text メソッドが XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. m を、m.[[TargetObject]] = list である新しい XMLList とする
  2. i = 0 から list.[[Length]]-1 までに対して
    1. もし list[i].[[Class]] == "element" ならば
      1. r = list[i].text() とする
      2. もし r.[[Length]] > 0 ならば、引数 r とともに m の [[Append]] メソッドを呼び出す
  3. m を返す
13.5.4.21 XMLList.prototype.toString ( )

概要

toString メソッドは章 10.1 で記述される ToString 変換演算子によるこの XMLList オブジェクトの文字列表現を返す。

動作

XMLList オブジェクト list の toString() メソッドが呼び出されたときは、以下のステップがとられる:

  1. ToString(list) を返す
13.5.4.22 XMLList.prototype.toXMLString ( )

概要

toXMLString() メソッドは章 10.2 で記述される ToXMLString 変換演算子によるこの XMLList オブジェクトの XML に符号化された文字列表現を返す。toString メソッドとは異なり、toXMLString は XML テキストノード (すなわち、プリミティブ値) のみを含む XML オブジェクトのための特別な処置を提供しない。toXMLString メソッドは常にこの XMLList オブジェクト内に含まれるそれぞれのプロパティ上で toXMLString を呼び出し、その結果を順に連結し、単独の文字列を返す。

動作

XMLList オブジェクト list の toXMLString() メソッドが呼び出されたときは、以下のステップがとられる:

  1. toXMLString(list) を返す
13.5.4.23 XMLList.prototype.valueOf ( )

概要

valueOf メソッドはこの XMLList オブジェクトを返す。

動作

XMLList オブジェクト list の valueOf メソッドが呼び出されたときは、以下のステップがとられる:

  1. list を返す

14 エラー

E4X はエラーのリストを拡張する。実装は以下のように指定されるように報告することを要求されない:

付録 A (規範的) 任意的な機能

この付録はいくつかの選択肢を記述する。これらの機能を使う E4X の実装は以下の関連付けられた仕様に適合しなければならない。

A.1 XML 組み込みメソッド

E4X 実装は以下のメソッドを XML オブジェクトに追加してもよい。

A.1.1 domNode( )

概要

domNode メソッドはこの XML オブジェクトの W3C DOM Node 表現を返す。

動作

domNode メソッドの動作は実装依存である。

A.1.2 domNodeList( )

概要

domNodeList メソッドはこの XML オブジェクトの単独の W3C DOM Node 表現を含む W3C DOM NodeList を返す。

動作

domNodeList メソッドの動作は実装依存である。

A.1.3 xpath ( XPathExpression )

概要

xpath メソッドは、この XML オブジェクトを文脈ノードとして使い W3C XPath 勧告に従って XPathExpression を評価する。XPathExpression を評価する前に、xpath メソッドは以下のように XPath 文脈を設定する。文脈ノードはこの XML オブジェクトに設定される。文脈位置は 1 に設定される。文脈サイズは 1 に設定される。変数束縛のセットは空のセットに設定される。関数ライブラリは空のセットに設定される。名前空間のセットはこの XML オブジェクト上の範囲内の名前空間のセットに従って設定される。もし XPathExpression がノードリストに評価されるならば、xpath メソッドはその結果を XMLList として返す。そうでなければ、xpath メソッドは TypeError 例外を投げる。例えば、

// John Smith と名のつくすべての従業員を取得するために xpath 式を使う
var jim = e.xpath("//employee[name='John Smith']")

動作

XML オブジェクト x の xpath メソッドがパラメータ XPathExpression とともに呼び出されたときは、以下のステップがとられる:

  1. e を、XPathExpression を評価した結果とする
  2. s = ToString(GetValue(XpathExpression)) とする
  3. XML オブジェクト x を表現する XPath 文脈オブジェクトを作成する。このステップのこの動作は実装依存である
  4. XPath 文脈位置を 1 とする
  5. XPath 文脈サイズを 1 とする
  6. XPath 変数束縛を { } とする
  7. XPath 関数ライブラリを { } とする
  8. XPath 名前空間を x.[[InScopeNamespaces]] とする
  9. r を、W3C XPath 勧告に従って s を評価した結果とする
  10. もし r が XPath ノードセットであるならば、それを実装依存の方法で XMLList に変換し、それを返す
  11. TypeError 例外を投げる

A.2 XMLList 組み込みメソッド

E4X 実装は XMLList オブジェクトに以下のメソッドを追加してもよい。

A.2.1 domNode( )

概要

もしこの XMLList オブジェクトがただひとつの XML 値 x のみを含むならば、domNode メソッドは x の W3C DOM Node 表現を返す。そうでなければ、domNode メソッドは undefined を返す。

動作

domNode メソッドの動作は実装依存である。

A.2.2 domNodeList( )

概要

domNodeList メソッドはこの XMLList オブジェクトの W3C DOM NodeList 表現を返す。

動作

domNodeList メソッドの動作は実装依存である。

A.2.3 xpath ( XPathExpression )

概要

xpath メソッドはこの XMLList オブジェクト中に含まれるそれぞれの XML プロパティに対して XPathExpression を評価し、順に連結されたその結果を含む XMLList の結果を連結する。

動作

xpath メソッドがパラメータ XPathExpression とともに XMLList オブジェクト list 上で呼び出されたときは、以下のステップがとられる:

  1. m を、list.[[TargetObject]] = null である新しい XMLList とする
  2. i = 0 から list.[[Length]]-1 までに対して
    1. もし Type(list[i]) が XML でありかつ list[i].[[Class]] == "element" ならば
      1. r = list[i].xpath(XPathExpression) とする
      2. もし r.[[Length]] > 0 ならば、引数 r とともに m の [[Append]] メソッドを呼び出す
  3. m を返す
Translated by nanto_vi (TOYAMA Nao), Last-modified: 2009-04-30.