DOM4

From HTML5 Chinese Interest Group Wiki
Jump to: navigation, search

目标

本规范用于规范DOM平台。其作用如下:

  1. 强化《DOM Level 3 Core》[DOM3CORE]、《元素遍历》[ELEMENTTRAVERSAL]、《DOM Level 3 事件》[DOM3EVENTS]的“DOM事件架构”和“基本事件接口”章节、以及《DOM Level 2 遍历和排列》[DOM2TR],并操作如下:
    • 如果可能,调整ECMAScript的需求。
    • 调整现有的实现。
    • 尽可能地进行简化。
  2. 从HTML5移动应为DOM平台一部分的特性,以防止依赖HTML5。[HTML]
  3. 定义一个“变化事件”的替代品,为基于DOM的监听器。
    注:我们预计将在适当的时候移除“变化事件”。
  4. 定义用于简化常见DOM操作的新特性。

问题

  • 变化监听器(并更新变化方法)
  • 定义事件处理程序。定义事件处理程序IDL属性列表?定义一个事件处理程序内容属性的概念?
  • 将DOMStringMap移至此处?

一致性

依赖关系

使用者代理必须将本规范里的所有 IDL 片段解释为 Web IDL 所说的必要符合 IDL 片段。[WEBIDL]

本规范部份术语由《Web IDL》、《XML》与《Namespaces in XML》定义。[WEBIDL] [XML] [XMLNS]

可扩展性

术语

术语上下文对象指调用正在讨论的方法或属性的对象。若上下文对象是明确的,则可以忽略该术语。

字符编码的首选MIME名称为IANA字符集注册表中的名称或标为“首选MIME名称”的别名(如果存在),或编码的名称(如果没有如此标记的别名)。[IANACHARSET]

与大多数编程范式相似,Web平台拥有一个有限分层的树形结构,简单的命名为树形结构顺序为先根次序、深度优先遍历。

参与的对象拥有一个父亲(为其他对象或者空),以及一个零或多个孩子对象的有序列表。

如果一个对象没有父亲,其为其自身,否则为其父亲

如果一个对象A是另一个对象B孩子,或者A是作为B后裔的对象C孩子,则A被称为B后裔

包容性后裔是一个对象或其后裔之一。

当且仅当一个对象B是另一个对象A后裔时,A被称为B祖先

包容性祖先是一个对象或其祖先之一。

当且仅当一个对象B和另一个对象A共享同一个非空的父亲时,A被称为B兄弟

如果一个对象A和另一个对象B在同一个内,且按照树形结构顺序AB之前,则AB之前

如果一个对象A和另一个对象B在同一个内,且按照树形结构顺序AB之后,则AB之后

一个对象的第一个孩子是其第一个孩子,或者,如果其没有孩子则为空。

一个对象的最后一个孩子是其最后一个孩子,或者,如果其没有孩子则为空。

一个对象的前一个兄弟是其第一个之前兄弟,或者,如果其没有之前兄弟则为空。

一个对象的后一个兄弟是其第一个之后兄弟,或者,如果其没有之后兄弟则为空。

一个对象的索引是其之前兄弟的数目。

字符串

区分大小写方式比较两个字符串,指逐码点地完全比较它们。

ASCII码下不区分大小写方式比较两个字符串,指逐码点地完全比较它们,除了同样匹配在U+0041至U+005A范围内的字符(拉丁大写字母A至拉丁大写字母Z)及与之对应的U+0061至U+007A范围内的字符(拉丁小些字母A至拉丁小写字母Z)。

将一个字符串转换为ASCII大写形式指将所有U+0061至U+007A(拉丁小写字母A至拉丁小写字母Z)范围内的字符替换为对应的U+0041至U+005A(拉丁大写字母A至拉丁大写字母Z)范围内的字符。

将一个字符串转换为ASCII小些形式指将所有U+0041至U+005A(拉丁大写字母A至拉丁大写字母Z)范围内的字符替换为对应的U+0061至U+007A(拉丁小写字母A至拉丁小写字母Z)范围内的字符。

如果一个字符串模式不长于另一个字符串s,且将s截断为模式的长度会造出两个字符串向匹配,则模式s前缀匹配

按照本规范的目的,空白字符为U+0020空格、U+0009制表符(tab)、U+000A换行(LF)、U+000C换页(FF)以及U+000D回车(CR)。

通用微语法

通用解析器习语

下面描述的一些微解析器遵循以input变量保存正在被解析的字符串、以position变量指出input中下一个被解析的字符的模式。

对于基于此模式的解析器,要求用户代理收集字符序列的步骤指必须执行下列算法,其中characters被设为可以被收集的字符:

  1. inputposition为与调用这些步骤的算法中的同名变量相同。
  2. result为空字符串。
  3. position没有指出input的结尾,且position处的字符为characters中的一个,则将该字符追加到result之后并将position推进至input中的下一个字符。
  4. 返回result

跳过空白步骤指用户代理必须收集一个字符序列,其为空白字符。不使用收集到的字符。

空格分隔的标记

一个空格分隔的标记集是一个包含零或多个单词(被认为是标记)、通过一个或多个空白字符分隔的字符串。其中的单词包括任意的一或多个字符的字符串,且其中没有空白字符

一个包含空格分隔的标记集的字符串可能会拥有前导或尾随的空白字符

一个无序、唯一、空格分隔的标记集是一个没有重复标记的空格分隔的标记集

一个有序、唯一、空格分隔的标记集是一个没有重复标记但标记的顺序有意义的空格分隔的标记集

有时会对空格分隔的标记集定义一个允许的值的集合。若定义了允许值的集合,则所有标记必须来自于该允许值的列表;不允许其他的值。如果没有提供这样的允许值的集合,则允许所有的值。
注:空格分隔的标记集中的标记要如果比较(例如大小写敏感与否)将在在基于预设定义。

如果用户代理需要按照空格分隔字符串,其必须使用下列算法:

  1. input为将要被解析的字符串。
  2. position为一个到input的指针,初始化时指向字符串的起始。
  3. tokens为一个标记列表,初始化为空。
  4. 跳过空白
  5. position没有通过input的结尾:
    1. 收集字符序列,其中不包含空白字符
    2. 将上一步中收集的字符串加入tokens
    3. 跳过空白
  6. 返回tokens

如果用户代理需要从字符串移除一个标记,其必须使用下列算法:

  1. input为将要被修改的字符串。
  2. token为将要被移除的标记。其不能包含任意空白字符
  3. output为输出的字符串,初始化为空。
  4. position为一个到input的指针,初始化时指向字符串的起始。
  5. LOOP:如果position越过input的结尾,则终止这些步骤。
  6. 如果position指向的字符是一个空白字符
    1. position指向的字符追加到output的结尾。
    2. position推进至input中的下一个字符。
    3. 返回标为LOOP的步骤。
  7. 否则,position指向的字符是一个标记的第一个字符。收集字符序列,其中不包含空白字符,并将其设为s
  8. 如果s完全等于token,则:
    1. 跳过空白(在input中)。
    2. 移除目前output结尾处的任意空白字符
    3. 如果position没有超过input的结尾,且output不是空字符串,向output的结尾追加一个单独的U+0020空白字符。
  9. 否则,向output的结尾追加s
  10. 返回标为LOOP的步骤。
注:这将造成每一次出现的将从字符串中删除的标记以及这些标记周围的空格替换为一个单独的空格。但字符串的开始和结尾除外,这种情况下空格将被删除。

命名空间

HTML命名空间为http://www.w3.org/1999/xhtml。

XML命名空间为http://www.w3.org/XML/1998/namespace。

XMLNS命名空间为http://www.w3.org/2000/xmlns/。

错误

DOMException异常

exception DOMException {
  const unsigned short INDEX_SIZE_ERR = 1;
  const unsigned short DOMSTRING_SIZE_ERR = 2; // 历史
  const unsigned short HIERARCHY_REQUEST_ERR = 3;
  const unsigned short WRONG_DOCUMENT_ERR = 4;
  const unsigned short INVALID_CHARACTER_ERR = 5;
  const unsigned short DO_DATA_ALLOWED_ERR = 6; // 历史
  const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7;
  const unsigned short NOT_FOUND_ERR = 8;
  const unsigned short NOT_SUPPORTED_ERR = 9;
  const unsigned short INUSE_ATTRIBUTE_ERR = 10; // 历史
  const unsigned short INVALID_STATE_ERR = 11;
  const unsigned short SYNTAX_ERR = 12;
  const unsigned short INVALID_MODIFICATION_ERR = 13;
  const unsigned short NAMESPACE_ERR = 14;
  const unsigned short INVALID_ACCESS_ERR = 15;
  const unsigned short VALIDATION_ERR = 16; // 历史
  const unsigned short TYPE_MISMATCH_ERR = 17;
  const unsigned short SECURITY_ERR = 18;
  const unsigned short NETWORK_ERR = 19;
  const unsigned short ABORT_ERR = 20;
  const unsigned short URL_MISMATCH_ERR = 21;
  const unsigned short QUOTA_EXCEEDED_ERR = 22;
  const unsigned short TIMEOUT_ERR = 23;
  const unsigned short INVALID_NODE_TYPE_ERR = 24;
  const unsigned short DATA_CLONE_ERR = 25;
  unsigned short code;
};

code异常字段必须返回其初始化的值。在一个异常被创建时,其必须被初始化为零。

为了抛出一个type异常,必须执行下列步骤:

  1. 创建一个新的DOMException异常,其类型type
  2. 设其消息为用户代理定义的值。
  3. 如果其类型在下表的第一列中,且在第三列中拥有一个相应的传统code异常字段值,则设其code异常字段为该值。
  4. 抛出该异常。
为了抛出一个“TimeoutError”异常,用户代理将创建一个类型为“TimeoutError”且code异常字段值为23的DOMException异常,并且在实际上将该对象作为一个异常抛出。
类型 描述 传统code异常字段值(如果存在)
IndexSizeError 索引不再允许的范围内。 INDEX_SIZE_ERR(1)
HierarchyRequestError 操作将产生一个不正确的节点模型。 HIERARCHY_REQUEST_ERR(3)
WrongDocumentError 对象在一个错误的文档中。 WRONG_DOCUMENT_ERR(4)
InvalidCharacterError 字符串包含无效字符。 INVALID_CHARACTER_ERR(5)
NoModificationAllowedError 对象不能被修改。 NO_MODIFICATION_ALLOWED_ERR(7)
NotFoundError 找不到对象。 NOT_FOUND_ERR(8)
NotSupportedError 不支持该操作。 NOT_SUPPORTED_ERR(9)
InvalidStateError 对象处于无效状态。 INVALID_STATE_ERR(11)
SyntaxError 字符串不匹配预计的模式。 SYNTAX_ERR(12)
InvalidModificationError 对象不能通过该方式修改。 INVALID_MODIFICATION_ERR(13)
NamespaceError XML下的命名空间不支持该操作。[XMLNS] NAMESPACE_ERR(14)
InvalidAccessError 对象不支持该操作或参数。 INVALID_ACCESS_ERR(15)
TypeMismatchError 对象的类型不匹配预计的类型。 TYPE_MISMATCH_ERR(17)
SecurityError 操作不安全。 SECURITY_ERR(18)
NetworkError 发生网络错误。 NETWORK_ERR(19)
AbortError 操作被终止。 ABORT_ERR(20)
URLMismatchError 给出的URL不匹配另一个URL。 URL_MISMATCH_ERR(21)
QuotaExceededError 以超出配额。 QUOTA_EXCEEDED_ERR(22)
TimeoutError 操作超时。 TIMEOUT_ERR(23)
InvalidNodeTypeError 该操作提供的节点不正确或存在一个不正确的祖先。 INVALID_NODE_TYPE_ERR(24)
DataCloneError 对象不能被复制。 DATA_CLONE_ERR(25)

DOMError接口

注:此接口的目的是允许其他规范介绍通过异常之外的手段进行的错误处理方法。其为预期的被重用的异常类型。
interface DOMError {
  readonly attribute DOMString name;
};

name属性必须返回其初始化的值。

一个type DOMError指一个name属性被初始化为typeDOMError对象。

一个规范可以声称一个error属性必须返回一个“SyntaxError”DOMError

事件

Event接口

[Constructor(DOMString type, optional EventInit eventInitDict)]
interface Event {
  readonly attribute DOMString type;
  readonly attribute EventTarget? target;
  readonly attribute EventTarget? currentTarget;

  const unsigned short CAPTURING_PHASE = 1;
  const unsigned short AT_TARGET = 2;
  const unsigned short BUBBLING_PHASE = 3;
  readonly attribute unsigned short eventPhase;

  void stopPropagation();
  void stopImmediatePropagation();

  readonly attribute boolean bubbles;
  readonly attribute boolean cancelable;
  void preventDefault();
  readonly attribute boolean defaultPrevented;

  readonly attribute boolean isTrusted;
  readonly attribute DOMTimeStamp timeStamp;

  void initEvent(DOMString type, boolean bubbles, boolean cancelable);
};

dictionary EventInit {
  boolean bubbles;
  boolean cancelable;
};

事件允许发生某事的信号。例如,一个图片下载完成。其通过Event接口或继承自Event接口的其他接口表示。

type属性必须其预置的值。当创建一个事件时,该属性必须被预置为空字符串。

targetcurrentTarget属性必须返回其预置的值。当创建一个事件时,该属性必须被预置为空。
注:在指派事件时,targetcurrentTarget属性将被预置位不同的值。

eventPhase属性必须返回其预置的值,其必须为下列之一:

  • CAPTURING_PHASE(捕获阶段,数值1)
  • AT_TARGET(到达目标,数值2)
  • BUBBLING_PHASE(冒泡阶段,数值3)

该属性必须首先被预置位AT_TARGET

每个事件都拥有下列最初没有设置的相关标记:

  • 停止扩展标记(stop propagation flag)
  • 立即停止扩展标记(stop immediate propagation flag)
  • 撤销标记(canceled flag)
  • 预置标记(initialized flag)
  • 指派标记(dispatch flag)

调用stopPropagation()方法时,必须设置停止扩展标记

调用stopImmediatePropagation()方法时,必须设置停止扩展标记立即停止扩展标记

bubblescancelable属性必须返回它们各自预置的值。当创建一个事件时,这些属性必须被预置为假。

调用preventDefault()方法时,如果cancelable属性为真,则必须设置撤销标记

如果设置了撤销标记,则defaultPrevented属性必须返回真,否则必须返回假。

isTrusted属性必须返回其预置的值。当创建一个事件时,该属性必须被预置为假。

timeStamp属性必须返回其预置的值。当创建一个事件时,该属性必须被预置为从1970年1月1日UTC时区下00:00:00至今所经过的毫秒数。

调用initEvent(type, bubbles, cancelable)方法时,必须执行下列步骤:

  1. 设置initialized标记
  2. 如果设置了dispatch标记,则终止这些步骤。
  3. 删除stop propagation标记stop immediate propagation标记canceled标记
  4. isTrusted属性为false。
  5. target属性为null。
  6. type属性为参数type
  7. bubbles属性为参数bubbles
  8. cancelable属性为参数cancelable
注:由于事件拥有构造器,initEvent()是多余的。但是,其不得不为老式内容而支持该方法。

CustomEvent接口

[Constructor(DOMString type, optional CustomEventInit eventInitDict)]
interface CustomEvent : Event {
  readonly attribute any detail;
};

dictionary CustomEventInit : EventInit {
  any detail;
};

使用CustomEvent接口的事件可以被用于需要携带数据的合成事件。

detail属性必须返回其预置的值。在事件被创建时,该属性必须被预置为空。

构造事件

在调用Event接口或继承自Event接口的其他接口的构造器时,必须执行下列步骤:

  1. 使用调用的构造器所属的接口创建一个事件
  2. 设置其预置标记
  3. type属性预置为type参数。
  4. 如果存在一个eventInitDict参数,对其中定义的每个字典成员,查找事件中其标识符匹配该字典成员的键的属性,并将该属性设为该字典成员的值。
  5. 返回该事件

EventTarget接口

interface EventTarget {
  void addEventListener(DOMString type, EventListener? listener, optional boolean capture);
  void removeEventListener(DOMString type, EventListener? listener, optional boolean capture);
  boolean dispatchEvent(Event event);
};

callback interface EventListener {
  void handleEvent(Event event);
};

EventTarget是用于在发生事情时指派事件的对象。每个EventTarget都有一个与之相关的事件侦听器列表。

事件侦听器是一个特殊事件的处理机。每个事件侦听器由(事件的)类型(type)侦听器(listener)捕获(capture)变量组成。

在调用addEventListener(type, listener, capture)方法时,必须执行下列步骤:

  1. 如果listener为空,则终止这些步骤。
  2. 如果capture被忽略,则设capture为假。
  3. 如果与其相关的事件侦听器列表中没有一个拥有相同类型侦听器捕获事件侦听器,则向其中追加一个事件侦听器,其类型type侦听器listener捕获capture

在调用removeEventListener(type, listener, capture)方法时,必须执行下列步骤:

  1. 如果capture被忽略,则设capture为假。
  2. 移除与其相关的事件侦听器列表中类型type侦听器listener捕获capture事件侦听器

在调用dispatchEvent(event)方法时,必须执行下列步骤:

  1. 如果event设置了指派标记,或者如果没有设置预置标记,则抛出一个“InvalidStateError”异常并终止这些步骤。
  2. eventisTrusted属性预置为假。
  3. 指派event并返回其所返回的值。

指派事件

为了在一个给出的对象上指派一个事件,需要执行下列步骤:

  1. event为将要指派的事件
  2. 设置event指派标记
  3. eventtarget属性预置为指派event的对象。
  4. 移除event指派标记
  5. eventeventPhase属性预置为AT_TARGET
  6. eventcurrentTarget预置为空。
  7. 如果event设置了撤销标记,则返回假,否则返回真。

为了使用一个事件调用一个对象的事件侦听器,需要执行下列步骤:

  1. event为调用事件侦听器事件
  2. listeners为与这些步骤所执行的对象相关的事件侦听器的静态列表。
  3. eventcurrentTarget预置为这些步骤所执行的对象。
  4. 对于listeners中的每一个事件侦听器执行下列子步骤。
    1. 如果event标记了立即停止扩展标记,终止该调用算法。
    2. listener为该事件侦听器
    3. 如果eventtype属性不是listener类型,终止这些子步骤(并且返回下一个事件侦听器)。
    4. 如果eventeventPhase属性为CAPTURING_PHASElistener捕获为假,终止这些子步骤(并且返回下一个事件侦听器)。
    5. 如果eventeventPhase属性为BUBBLING_PHASElistener捕获为真,终止这些子步骤(并且返回下一个事件侦听器)。
    6. 如果listener侦听器为一个Function对象,其回调值eventcurrentTarget属性值。
    7. 请求listener侦听器,并使用本算法传入的事件作为第一个参数。

触发事件

触发名为e的事件指将一个事件指派到给出的对象,该事件使用Event接口、其type属性被预置为e、其isTrusted属性被预置为真。

注:触发较预置和指派一个事件要短。
注:触发一个事件是一个为了使预置和指派一个事件更易被记录的概念。如果事件需要预置其bubbles或cancelable属性,则我们可以记录“触发一个名为submit的事件,其cancelable属性被预置为真”。

节点

节点模型

实现了DocumentDocumentFragmentDocumentTypeElementTextProcessingInstructionComment接口的对象(简单的称之为节点参加一个

节点约束如下,表示节点的类型和起允许的孩子之间的关系:

注:如果预插入替换算法违反了上述约束,将会抛出一个“HierarchyRequestError”。这些算法用于那些修改节点的方法。

改变

问题:本节将为平台定义一个“变化事件”功能的替代。现在其保护了供应商已经实现的接口。
[Constructor(MutationCallback callback)]
interface MutationObserver {
  void observe(Node target, MutationObserverInit options);
  void disconnect();
};

callback MutationCallback = void (MutationRecord[] mutations, MutationObserver observer);

dictionary MutationObserverInit {
  // 变化类型
  boolean childList;     // 如果为真,变化将影响节点的childNodes。
  boolean attributes;    // 如果为真,变化将影响元素的属性。
  boolean characterData; // 如果为真,变化将影响CharacterData节点的值
  // [注意:如果指定了未知的变化类型,则抛出一个错误]

  // 子树探测
  boolean subtree;  // 如果为真,则本登记的节点的探测集应包含MutationTarget的后裔(行为将在之后描述)。

  // 旧值
  boolean attributeOldValue;
  // 如果为真,MutationRecords描述的对属性的修改应该包含修改之前该属性的值。
  // 如果为真但没有属性:标记为真,抛出一个错误。

  boolean characterDataOldValue;
  // 如果为真,MutationRecords描述的对CharacterData节点的修改应该包含修改之前该节点的值。
  // 如果为真但没有characterData:为真,抛出一个错误。

  // 过滤器
  DOMString[] attributeFilter;
  // 如果提供了,则只有对那些localName等于提供的字符串之一的属性的修改才会被执行。
  // 如果提供了但没有属性:为真,抛出一个错误。
};

interface MutationRecord {
  // 变化类型:‘childList’、‘attributes’或‘characterData’之一
  readonly attribute DOMString type;

  // 对于childList和属性,target使其所属的被影响的节点。
  // 对于CharacterData,target为被影响的节点。
  readonly attribute Node target;

  // 对于变化类型为‘childList’的,为在此操作中添加或删除的节点的序列。
  readonly attribute NodeList addedNodes;
  readonly attribute NodeList removedNodes;

  // 对于变化类型为‘childList’的,为childNodes中紧跟着添加和/或删除的第一个和最后一个节点的兄弟。
  // and last nodes added and/or removed.
  readonly attribute Node previousSibling;
  readonly attribute Node nextSibling;

  // 对于变化类型为‘attribute’的,为被影响的属性的名称和namespaceURI
  readonly attribute DOMString attributeName;
  readonly attribute DOMString attributeNamespace;

  // 对于变化类型为‘attribute’或‘characterData’的,如果需要,为变化前的值。
  readonly attribute DOMString oldValue;
};

Node接口

interface Node : EventTarget {
  const unsigned short ELEMENT_NODE = 1;
  const unsigned short ATTRIBUTE_NODE = 2; // 历史遗留
  const unsigned short TEXT_NODE = 3;
  const unsigned short CDATA_SECTION_NODE = 4; // 历史遗留
  const unsigned short ENTITY_REFERENCE_NODE = 5; // 历史遗留
  const unsigned short ENTITY_NODE = 6; // 历史遗留
  const unsigned short PROCESSING_INSTRUCTION_NODE = 7;
  const unsigned short COMMENT_NODE = 8;
  const unsigned short DOCUMENT_NODE = 9;
  const unsigned short DOCUMENT_TYPE_NODE = 10;
  const unsigned short DOCUMENT_FRAGMENT_NODE = 11;
  const unsigned short NOTATION_NODE = 12; // 历史遗留
  readonly attribute unsigned short nodeType;
  readonly attribute DOMString nodeName;

  readonly attribute DOMString? baseURI;

  readonly attribute Document? ownerDocument;
  readonly attribute Node? parentNode;
  readonly attribute Element? parentElement;
  boolean hasChildNodes();
  readonly attribute NodeList childNodes;
  readonly attribute Node? firstChild;
  readonly attribute Node? lastChild;
  readonly attribute Node? previousSibling;
  readonly attribute Node? nextSibling;

  const unsigned short DOCUMENT_POSITION_DISCONNECTED = 0x01;
  const unsigned short DOCUMENT_POSITION_PRECEDING = 0x02;
  const unsigned short DOCUMENT_POSITION_FOLLOWING = 0x04;
  const unsigned short DOCUMENT_POSITION_CONTAINS = 0x08;
  const unsigned short DOCUMENT_POSITION_CONTAINED_BY = 0x10;
  const unsigned short DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20; // 历史遗留
  unsigned short compareDocumentPosition(Node other);
  boolean contains(Node? other);

           attribute DOMString? nodeValue;
           attribute DOMString? textContent;
  Node insertBefore(Node node, Node? child);
  Node appendChild(Node node);
  Node replaceChild(Node node, Node child);
  Node removeChild(Node child);
  void normalize();

  Node cloneNode(optional boolean deep);
  boolean isEqualNode(Node? node);

  DOMString lookupPrefix(DOMString? namespace);
  DOMString lookupNamespaceURI(DOMString? prefix);
  boolean isDefaultNamespace(DOMString? namespace);
};
注:Node是一个抽象接口,不作为节点而存在。它被用于所有的节点DocumentDocumentFragmentDocumentTypeElementTextProcessingInstructionComment)。
每个节点都有一个与其相关的节点文档,在该节点创建时设置,其为一个文档
注:一个节点节点文档可以通过“过继”算法改变。
每个节点都有一个与其相关的基础URL
注:其他规范定义了基础URL的值和其常见行为。本规范只定义这个概念以及baseURI属性。
此区块中不是标准描述,实现要求在下面给出。

node . nodeType

返回node的类型。表示为以下列表中的数字:

node . nodeName

返回一个能恰当地表示node类型的字符串,其值如下:

nodeType属性必须返回节点的类型,其必须为下列值之一:

  • ELEMENT_NODE (1);
  • TEXT_NODE (3);
  • PROCESSING_INSTRUCTION_NODE (7);
  • COMMENT_NODE (8);
  • DOCUMENT_NODE (9);
  • DOCUMENT_TYPE_NODE (10);
  • DOCUMENT_FRAGMENT_NODE (11);

nodeName属性必须根据其上下文对象返回下列值:

此区块中不是标准描述,实现要求在下面给出。

node . baseURI

返回基础URL

baseURI属性必须返回与其相关的基础URL

此区块中不是标准描述,实现要求在下面给出。

doc = node . ownerDocument

返回其节点文档

对于文档来说,则返回空。

parent = node . parentNode

返回其父亲

parent = node . parentElement

返回其父元素

haschildren = node . hasChildNodes

返回node是否拥有孩子

children = node . childNodes

返回其孩子

child = node . firstChild

返回其第一个孩子

child = node . lastChild

返回其最后一个孩子

child = node . previousSibling

返回其前一个兄弟

child = node . nextSibling

返回其后一个兄弟

ownerDocument属性必须执行下列步骤:

  1. 如果其上下文对象是一个文档,则返回空并终止这些步骤。
  2. 返回其节点文档
注:一个文档节点文档是该文档自身。
注:不论何时,所有节点都拥有一个文档

parentNode属性必须返回其父亲

parentElement属性必须返回其父元素

hasChildNodes()方法,如果其上下文对象拥有孩子则必须返回真,否则必须返回假。

childNodes属性必须返回一个植根于其上下文对象、仅匹配其孩子NodeList

firstChild属性必须返回其第一个孩子

lastChild属性必须返回其最后一个孩子

previousSibling属性必须返回其前一个兄弟

nextSibling属性必须返回其后一个兄弟

此区块中不是标准描述,实现要求在下面给出。

node . compareDocumentPosition(other)

返回一个指出othernode之间的位掩码。其可以设置的位包括:

contains = node . contains(other)

如果othernode包容性后裔,则返回真,否则返回假。

以下为compareDocumentPosition()作为掩码返回的常量:

  • DOCUMENT_POSITION_DISCONNECTED (1);
  • DOCUMENT_POSITION_PRECEDING (2);
  • DOCUMENT_POSITION_FOLLOWING (4);
  • DOCUMENT_POSITION_CONTAINS (8);
  • DOCUMENT_POSITION_CONTAINED_BY (16,十六进制中的10)。

compareDocumentPosition(other)方法必须执行下列步骤:

  1. reference为其上下文对象
  2. 如果otherreference是同一个对象,则返回零,并终止这些步骤。
  3. 如果otherreference不在同一个中,则返回DOCUMENT_POSITION_DISCONNECTED,并终止这些步骤。
  4. 如果otherreference祖先,则返回DOCUMENT_POSITION_PRECEDINGDOCUMENT_POSITION_CONTAINS的结果,并终止这些步骤。
  5. 如果otherreference后裔,则返回DOCUMENT_POSITION_FOLLOWINGDOCUMENT_POSITION_CONTAINS_BY的结果,并终止这些步骤。
  6. 如果otherreference之前,则返回DOCUMENT_POSITION_PRECEDING,并终止这些步骤。
  7. 返回DOCUMENT_POSITION_FOLLOWING,并终止这些步骤。

如果other是其上下文对象的一个包容性后裔,则contains(other)方法必须返回真,否则必须返回假。

nodeValue属性必须根据其上下文对象返回如下值:

在设置nodeValue属性时,必须根据其上下文对象按照下列描述进行:

textContent属性必须根据其上下文对象返回如下值:

在设置textContent属性时,如果新值为空,则使用空字符串特带,并且必须根据其上下文对象按照下列描述进行:

此区块中不是标准描述,实现要求在下面给出。

node . normalize()

邻近的Text节点连接为一个单独的Text节点

将一个node预插入到一个parent之中的一个child之前,需要执行这些步骤:

  1. 如果child不为空,且其父亲不是parent,则抛出一个“NotFoundError”异常,并终止这些步骤。
  2. 如果nodeparentparent祖先,则抛出一个“HierarchyRequestError”,并终止这些步骤。
  3. 如果parent不是一个DocumentDocumentFragmentElement节点,则抛出一个“HierarchyRequestError”,并终止这些步骤。
  4. 如果parent是一个文档,则执行这些子步骤:
    1. 如果node不是一个DocumentFragmentDocumentTypeElementProcessingInstructionComment节点,则抛出一个“HierarchyRequestError”,并终止这些步骤。
    2. 如果node是一个DocumentFragment节点,则执行下列内部子步骤:
      1. 如果node拥有超过一个元素作为其孩子或拥有一个Text节点作为其孩子,则抛出一个“HierarchyRequestError”,并终止这些步骤。
      2. 如果node拥有一个元素作为其孩子,并且parent拥有一个元素作为其孩子或者child不为空且有一个DOCTYPEchild之后,则抛出一个“HierarchyRequestError”,并终止这些步骤。
    3. 如果node是一个元素,并且parent拥有一个元素作为其孩子或者child不为空且有一个DOCTYPEchild之后,则抛出一个“HierarchyRequestError”,并终止这些步骤。
    4. 如果node是一个DOCTYPE,并且parent拥有一个DOCTYPE作为其孩子、一个元素child之前、或者child为空且parent拥有一个元素作为其孩子,则抛出一个“HierarchyRequestError”,并终止这些步骤。
  5. 或者,如果parent是一个DocumentFragmentElement节点node不是一个DocumentFragmentElementTextProcessingInstructionComment节点,则抛出一个“HierarchyRequestError”,并终止这些步骤。
  6. node过继parent节点文档
  7. node插入parentchild之前。
  8. 返回child

将一个node插入到一个parent之中的一个child之前,需要执行这些步骤:

  1. 如果node是一个DocumentFragment节点,则设countnode孩子的数目,否则设为一。
  2. 对于每个起始节点parent起始偏移量大于child索引排列,将其起始偏移量增加count
  3. 对于每个结尾节点parent结尾偏移量大于child索引排列,将其结尾偏移量增加count
  4. 如果node是一个DocumentFragment节点,将其孩子(保持树形结构顺序)插入到child之前,或者如果child为空则插入到parent的结尾之前。
  5. 否则,将node插入到child之前,或者如果child为空则插入到parent的结尾之前。

insertBefore(node, child)方法必须将node预插入到其上下文对象之中child之前。

将一个node追加到一个parent之中,即将node预插入parent之中空之前。

appendChild(node)方法必须将node追加到其上下文对象之中。

node替换一个在parent之中的child,需要执行这些步骤:

  1. 如果child父亲不是parent,则抛出一个“NotFoundError”异常,并终止这些步骤。
  2. 如果nodeparentparent祖先,则抛出一个“HierarchyRequestError”,并终止这些步骤。
  3. 如果parent不是一个DocumentDocumentFragmentElement节点,则抛出一个“HierarchyRequestError”,并终止这些步骤。
  4. 如果parent是一个文档,则执行这些子步骤:
    1. 如果node不是一个DocumentFragmentDocumentTypeElementProcessingInstructionComment节点,则抛出一个“HierarchyRequestError”,并终止这些步骤。
    2. 如果node是一个DocumentFragment节点,则执行下列内部子步骤:
      1. 如果node拥有超过一个元素作为其孩子或拥有一个Text节点作为其孩子,则抛出一个“HierarchyRequestError”,并终止这些步骤。
      2. 如果node拥有一个元素作为其孩子,并且parent拥有一个并非child元素作为其孩子或者有一个DOCTYPEchild之后,则抛出一个“HierarchyRequestError”,并终止这些步骤。
    3. 如果node是一个元素,并且parent拥有一个并非child元素作为其孩子或者有一个DOCTYPEchild之后,则抛出一个“HierarchyRequestError”,并终止这些步骤。
    4. 如果node是一个DOCTYPE,并且parent拥有一个并非childDOCTYPE作为其孩子或者有一个元素child之前,则抛出一个“HierarchyRequestError”,并终止这些步骤。
  5. 或者,如果parent是一个DocumentFragmentElement节点node不是一个DocumentFragmentElementTextProcessingInstructionComment节点,则抛出一个“HierarchyRequestError”,并终止这些步骤。
  6. node过继parent节点文档
  7. reference childchild下一个兄弟
  8. parent移除child
  9. node插入parentreference child之前。
  10. 返回child

replaceChild(node, child)方法必须用node替换一个在上下文对象中的child

将一个node从一个parent预移除,需要执行这些步骤:

  1. 如果child父亲不是parent,则抛出一个“NotFoundError”异常,并终止这些步骤。
  2. parent移除child
  3. 返回child

将一个node从一个parent移除,需要执行这些步骤:

  1. indexnode索引
  2. 对于每个起始节点parent后裔排列,将其起始设为(parent, index)。
  3. 对于每个结尾节点parent后裔排列,将其结尾设为(parent, index)。
  4. 对于每个起始节点parent起始偏移量大于index排列,将其起始偏移量减去一。
  5. 对于每个结尾节点parent结尾偏移量大于index排列,将其结尾偏移量减去一。
  6. parent中移除node

removeChild(child)方法必须将child从其上下文对象预移除

normalize()方法必须执行这些步骤:

  1. 对于每个上下文对象Text节点后裔
    1. node为该Text节点后裔
    2. data树形结构顺序node邻近Text节点(除去其自身)的数据的连接。
    3. node为节点、nodelangth属性的值为偏移量、0为计数以及data为数据,来替换数据
    4. 树形结构顺序中,移除node邻近Text节点(除去其自身)。
此区块中不是标准描述,实现要求在下面给出。

clone = node . cloneNode([deep])

返回node的副本。如果deep为真或被忽略,其副本还要包含node孩子

similar = node . isEqualNode([other])

返回nodeother是否拥有相同的属性。

规范可能会为所有或部分节点定义其复制步骤

为了复制一个node,可选地附加一个documentownerDocument和一个clone children flag,需要执行这些步骤:

  1. 如果没有给出document,则设ownerDocumentnode节点文档
  2. copy为一个实现了和node相同的接口的节点
  3. 如果copy是一个对象,则设其节点文档为空,设ownerDocumentcopy

    否则,设copy节点文档ownerDocument

  4. 根据node的类型,复制下列内容:
  5. 执行其他合适的规范中为node定义的任意复制步骤
  6. 如果设置了clone children flag复制所有node孩子,并将其追加到copy之中,其中标记了ownerDocumentclone children flag
  7. 返回copy

cloneNode(deep)方法必须返回一个其上下文对象副本,其中如果deep为真或被忽略则设置clone children flag

如果所有下列约束都为真,则isEqualNode(node)方法必须返回真,否则必须返回假:

使用namespace对一个element查找其命名空间前缀,需要执行这些步骤:

  1. 如果element命名空间namespace,且其命名空间前缀不为空,则返回其命名空间前缀并终止这些步骤。
  2. 如果element拥有一个命名空间前缀为“xmlns”且namespace属性,则返回该属性本地名称并终止这些步骤。
  3. 如果element父元素不为空,则返回在该元素上使用namespace执行查找其命名空间前缀的结果。否则,返回空。

对用prefix对一个node查找其命名空间,由其node决定:

lookupPrefix(namespace)方法必须执行这些步骤:

  1. 如果namespace为空或空字符串,返回空。
  2. 否则,取决于其上下文对象

lookupNamespaceURI(prefix)方法必须执行这些步骤:

  1. 如果prefix为空字符串,设其为空。
  2. 返回使用prefix对其上下文对象执行查找命名空间的结果。

isDefaultNamespace(namespace)方法必须执行这些步骤:

  1. 如果namespace为空字符串,设其为空。
  2. defaultNamespace为使用空对其上下文对象执行查找命名空间的结果。
  3. 如果defaultNamespacenamespace相同,则返回真,否则返回假。

一个节点root本地名称为localName的元素的列表为下列算法返回的NodeList

  1. 如果localName为“*”(U+002A),则返回一个植根于root、过滤器仅匹配元素NodeList
  2. 否则,如果root节点文档是一个HTML文档,则返回一个植根于root、过滤器仅匹配下列节点的NodeList
  3. 否则,返回一个植根于root、过滤器仅匹配本地名称localName元素NodeList

如果使用相同的参数在此调用,则可能会返回与早前调所返回的相同的NodeList对象。

一个节点root命名空间为namespace且本地名称为localName的元素的列表为下列算法返回的NodeList

  1. 如果namespace为空字符串,设其为空。
  2. 如果namespacelocalName均为“*”(U+002A),则返回一个植根于root、过滤器仅匹配元素NodeList
  3. 否则,如果仅namespace为“*”(U+002A),则返回一个植根于root、过滤器仅匹配本地名称localName元素NodeList
  4. 否则,如果仅localName为“*”(U+002A),则返回一个植根于root、过滤器仅匹配命名空间namespace元素NodeList
  5. 否则,返回一个植根于root、过滤器仅匹配本地名称localName命名空间namespace元素NodeList

如果使用相同的参数在此调用,则可能会返回与早前调所返回的相同的NodeList对象。

一个节点root类名称为classNames的元素的列表为下列算法返回的NodeList

  1. classes为用空格分隔classNames所发现的标记集。(忽略重复。)
  2. 如果classes为空集,则返回一个空的NodeList并终止这些步骤。
  3. 返回一个植根于root、过滤器仅匹配拥有所有classes元素NodeList

    如果root节点文档处于怪癖模式,则对的比较必须按照ASCII不区分大小写的方式进行,否则,比较必须按照区分大小写的方式进行。

如果使用相同的参数在此调用,则可能会返回与早前调所返回的相同的NodeList对象。

Document接口

interface Document : Node {
  readonly attribute DOMImplementation implementation;
  readonly attribute DOMString URL;
  readonly attribute DOMString documentURI;
  readonly attribute DOMString compatMode;

           attribute DOMString charset;
  readonly attribute DOMString characterSet;
  readonly attribute DOMString defaultCharset;
  readonly attribute DOMString contentType;

  readonly attribute DocumentType? doctype;
  readonly attribute Element? documentElement;
  NodeList getElementsByTagName(DOMString qualifiedName);
  NodeList getElementsByTagNameNS(DOMString? namespace, DOMString localName);
  NodeList getElementsByClassName(DOMString classNames);
  Element? getElementById(DOMString elementId);

  Element createElement(DOMString localName);
  Element createElementNS(DOMString? namespace, DOMString qualifiedName);
  DocumentFragment createDocumentFragment();
  Text createTextNode(DOMString data);
  Comment createComment(DOMString data);
  ProcessingInstruction createProcessingInstruction(DOMString target, DOMString data);

  Node importNode(Node node, optional boolean deep);
  Node adoptNode(Node node);

  Event createEvent(DOMString eventInterfaceName);

  Range createRange();

  NodeIterator createNodeIterator(Node root, optional unsigned long whatToShow, optional NodeFilter? filter);
  TreeWalker createTreeWalker(Node root, optional unsigned long whatToShow, optional NodeFilter? filter);

  // 新特性
  void prepend(Node | DOMString... nodes);
  void append(Node | DOMString... nodes);
};

interface XMLDocument : Document {};

Document节点简单地被认为是文档

每个文档都有与其相关的字符编码媒体类型URL

如果在创建一个文档时没有显式地给出,其字符编码为“UTF-8”、其媒体类型为“application/xml”、其URL为“about:blank”。

如果没有将一个文档标记为HTML文档,则假定其为XML文档。一个文档HTML文档还是XML文档将会影响某些API的行为。

一个文档总会被设为下列三个模式之一:默认的非怪癖模式;用于标记传统文档的怪癖模式;以及被认为“几近标准”的限定怪癖模式。除非其他适用的规范定义,否则,一个文档必须处于非怪癖模式

注:如果文档是通过HTML解析器创建的,则其模式从默认状态的改变只取决于是否存在DOCTYPE字符串及其值。[HTML]
此区块中不是标准描述,实现要求在下面给出。

document . implementation

返回与其相关的DOMImplementation对象。

document . URL

document . documentURI

返回其URL

document . compatMode

如果document处于非怪癖模式限定怪癖模式,则返回字符串“CSS1Compat”;如果document处于怪癖模式,则返回字符串“BackCompat”。

implementation属性必须返回与该文档相关的DOMImplementation对象。

URLdocumentURI属性必须返回URL

对于compatMode IDL属性,如果其上下文对象并非处于怪癖模式,则必须返回字符串常量“CSS1Compat”,否则必须返回字符串常量“BackCompat”。

此区块中不是标准描述,实现要求在下面给出。

document . charset [ = value ]

返回字符编码

可以被设置,用于修改字符编码

并非用户代理所支持的在IANA注册的别名的新值,将被忽略。

document . characterSet

返回字符编码

document . defaultCharset

返回可能是用户代理默认的字符编码。(用户代理可能会返回其他的字符编码算法,例如为了保护用户隐私或者如果用户代理并非使用一个单一的默认编码。)

document . contentType

返回媒体类型

charset属性必须返回其字符编码首选MIME名称

设置charset属性时,如果新值是一个用户代理所支持的字符编码的IANA注册的别名,必须将字符编码设为该新值。(否则,不进行操作。)

characterSet属性必须返回其字符编码首选MIME名称

defaultCharset属性必须返回其字符编码的首选MIME名称,有可能是用户的默认字符编码、与当前用户地理位置相关的字符编码或者任意字符编码名。

contentType属性必须返回其媒体类型

此区块中不是标准描述,实现要求在下面给出。

document . doctype

返回DOCTYPE,或者如果不存在则返回空。

document . documentElement

返回文档元素

collection = document . getElementsByTagName(localName)

如果localName为“*”,则返回其所有后裔元素NodeList

否则,返回其所有后裔元素本地名称localNameNodeList。(对于HTML文档HTML命名空间下的元素,执行不区分大小写匹配。)

collection = document . getElementsByTagNameNS(namespace, localName)

如果namespacelocalName均为“*”,则返回其所有后裔元素NodeList

如果仅namespace为“*”,则返回其所有后裔元素本地名称localNameNodeList

如果仅localName为“*”,则返回其所有后裔元素命名空间namespaceNodeList

否则,返回其所有后裔元素命名空间namespace本地名称localNameNodeList

collection = document . getElementsByClassName(classes)

collection = element . getElementsByClassName(classes)

返回处于调用该方法的对象(文档元素)中拥有classes中给出的所有类的元素NodeList

classes参数将按照一个空格分隔的类的列表进行解释。

element = document . getElementById(elementId)

返回document中第一个拥有给出的ID元素

doctype属性必须返回文档的一个为DOCTYPE孩子,否则返回空。

documentElement属性必须返回其文档元素

getElementsByTagName(localName)方法必须返回上下文对象本地名称为localName的元素的列表

注:因此,在HTML文档中,document.getElementsByTagName("FOO")将匹配不处于HTML命名空间内的FOO元素,以及处于HTML命名空间内的foo元素,但不匹配处于HTML命名空间内的FOO元素。

getElementsByTagNameNS(namespace, localName)方法必须返回上下文对象命名空间为namespace且本地名称为localName的元素的列表

getElementsByClassName(classNames)方法必须返回上下文对象类名为classNames的元素的列表

给出下列XHTML片段:

<div id="example">
  <p id="p1" class="aaa bbb"/>
  <p id="p2" class="aaa ccc"/>
  <p id="p3" class="bbb ccc"/>
</div>

调用document.getElementById('example').getElementsByClassName('aaa')将返回一个包含两个段落p1和p2的NodeList

调用getElementsByClassName('ccc bbb')将返回一个名为p3的阶段。调用document.getElementById('example').getElementsByClassName('bbb ccc ')将返回同样的内容。

调用getElementsByClassName('aaa,bbb')将不返回阶段;上述片段中没有元素处于aaa,bbb类。

getElementById(elementId)方法必须返回按照树形结构顺序上下文对象中第一个IDelementId元素,或者如果不存在则返回空。

此区块中不是标准描述,实现要求在下面给出。

element = document . createElement(localName)

返回HTML命名空间下的一个元素,其本地名称localName。(在一个HTML文档中,localName是小写的。)

如果localName不匹配产生的Name,将抛出一个“InvalidCharacterError”异常。

element = document . createElementNS(namespace, qualifiedName)

返回一个命名空间namespace元素。其命名空间前缀qualifiedName中所有“:”(U+003E)之前的内容或空。其本地名称qualifiedName中所有“:”(U+003E)之后的内容或qualifiedName

如果localName不匹配产生的Name,将抛出一个“InvalidCharacterError”异常。

如果下列约束之一为真,将抛出一个“NamespaceError”异常:

documentFragment = document . createDocumentFragment()

返回一个DocumentFragment节点

text = document . createTextNode(data)

返回一个数据dataText节点

processingInstruction = document . createProcessingInstruction(target, data)

返回一个目标target数据dataProcessingInstruction节点

如果target不匹配产生的Name,将抛出一个“InvalidCharacterError”异常。

如果data包含“?>”,将抛出一个“InvalidCharacterError”异常。

createElement(localName)方法必须执行这些步骤:

  1. 如果localName不匹配产生的Name,则抛出一个“InvalidCharacterError”异常并终止这些步骤。
  2. 如果其上下文对象是一个HTML文档,设localName为其转换为ASCII小写形式
  3. 返回一个新的元素,其没有属性、命名空间被设为HTML命名空间本地名称被设为localName节点文档被设为上下文对象

createElementNS(namespace, qualifiedName)方法必须执行这些步骤:

  1. 如果namespace为空字符串,设其为空。
  2. 如果qualifiedName不匹配产生的Name,则抛出一个“InvalidCharacterError”异常并终止这些步骤。
  3. 如果qualifiedName不匹配产生的QName,则抛出一个“NamespaceError”异常并终止这些步骤。
  4. 如果qualifiedName包含一个“:”(U+003E),则用其分隔字符串,并设prefix为前一部分、localName为后一部分。否则,设prefix为空、localNamequalifiedName
  5. 如果prefix不为空且namespace为空,则抛出一个“NamespaceError”异常并终止这些步骤。
  6. 如果prefix为“xml”且namespace不为XML命名空间,则抛出一个“NamespaceError”异常并终止这些步骤。
  7. 如果qualifiedNameprefix为“xmlns”且namespace不为XMLNS命名空间,则抛出一个“NamespaceError”异常并终止这些步骤。
  8. 如果namespaceXMLNS命名空间qualifiedNameprefix均不为“xmlns”,则抛出一个“NamespaceError”异常并终止这些步骤。
  9. 返回一个新的元素,其没有属性、命名空间被设为namespace命名空间前缀被设为prefix本地名称被设为localName节点文档被设为上下文对象

createDocumentFragment()方法必须返回一个新的DocumentFragment节点,其节点文档被设为上下文对象

createTextNode(data)方法必须返回一个新的Text节点,其数据被设为data节点文档被设为上下文对象

注:没有执行判断数据包含匹配产生的Char的字符的检查。

createComment(data)方法必须返回一个新的Comment节点,其数据被设为data节点文档被设为上下文对象

注:没有执行判断数据包含匹配产生的Char的字符、包含两个连续的连字符或以连字符结束的检查。

createProcessingInstruction(target, data)方法必须执行这些步骤:

  1. 如果target不匹配产生的Name,则抛出一个“InvalidCharacterError”异常并终止这些步骤。
  2. 如果data包含字符串“?>”,则抛出一个“InvalidCharacterError”异常并终止这些步骤。
  3. 返回一个新的ProcessingInstruction节点,其目标被设为target数据被设为data节点文档被设为上下文对象
注:没有执行判断目标包含“xml”或“:”、数据包含匹配产生的Char的字符的检查。
此区块中不是标准描述,实现要求在下面给出。

clone = document . importNode(node [, deep])

返回一个node的副本。如否deep为真或者被忽略,则该副本还要包含node孩子

如果node是一个文档,则抛出一个“NotSupportedError”异常。

node = document . adoptNode(node)

node从其他文档移来,并返回该节点。

如果node是一个文档,则抛出一个“NotSupportedError”异常。

importNode(node, deep)方法必须执行这些步骤:

  1. 如果node是一个文档,则抛出一个“NotSupportedError”异常并终止这些步骤。
  2. 返回一个node副本,其中document上下文对象且如果deep为真或被忽略则标记clone children flag

过继一个node,附带一个ownerDocument,需要执行这些步骤:

  1. 如果node是一个元素,其受到了基本URL修改的影响
  2. 如果node父亲不为空,则从其父亲处移除node
  3. node以及所有其后裔节点文档ownerDocument

adoptNode(node)方法必须执行这些步骤:

  1. 如果node是一个文档,则抛出一个“NotSupportedError”异常并终止这些步骤。
  2. 过继node,附带上下文对象,并返回其。
此区块中不是标准描述,实现要求在下面给出。

event = document . createEvent(eventInterfaceName)

返回一个事件,其使用的是名字不区分大小写地匹配eventInterfaceName的接口。

当调用createEvent(eventInterfaceName)方法时,必须执行这些步骤:

  1. 如果eventInterfaceName能够ASCII不区分大小写地匹配下表中第一列的任意字符串,设eventInterfaceName为与匹配的字符串同行的第二列内的字符串。
  2. 如果eventInterfaceName'不能ASCII不区分大小写地匹配“event”或者一个继承自Event接口且被用户代理所支持的接口的名称,则抛出一个“NotSupportedError”并终止这些步骤。
  3. 创建一个实现了名称ASCII不区分大小写地匹配eventInterfaceName的接口的事件,并返回该事件
输入的接口 替代的接口
“htmlevents” “event”
“mouseevents” “mouseevent”
“mutationevents” “mutationevent”
“uievents” “uievent”
注:该方法是极端落后的,现在事件拥有其构造器,但是需要向传统内容提供支持。
此区块中不是标准描述,实现要求在下面给出。

event = document . createRange()

返回一个新的排列

createRange()方法必须返回一个新的排列,其中(上下文对象, 0)为其起始结束

当调用createNodeIterator(root, whatToShow, filtre)方法时,必须执行这些步骤:

  1. 创建一个NodeIterator对象。
  2. 设置并预置referenceNode属性为root参数。
  3. 设置要展示的内容whatToShow参数,如果该参数被忽略,则设为SHOW_ALL
  4. 设置过滤器filter参数,如果该参数被忽略,则设为空。
  5. 返回新创建的NodeIterator对象。

当调用createTreeWalker(root, whatToShow, filter)方法时,必须执行这些步骤:

  1. 创建一个TreeWalker对象。
  2. 设置并预置currentNode属性为root参数。
  3. 设置要展示的内容whatToShow参数,如果该参数被忽略,则设为SHOW_ALL
  4. 设置过滤器filter参数,如果该参数被忽略,则设为空。
  5. 返回新创建的TreeWalker对象。

DOMImplementation接口

当用户代理创建一个文档时,必须同时创建一个DOMImplementation对象,并将其与该文档向关联。

interface DOMImplementation {
  boolean hasFeature(DOMString feature, [TreatNullAs=EmptyString] DOMString version);

  DocumentType createDocumentType(DOMString qualifiedName, DOMString publicId, DOMString systemId);
  XMLDocument createDocument(DOMString? namespace, DOMString qualifiedName, DocumentType? doctype);
  Document createHTMLDocument(DOMString title);
};
此区块中不是标准描述,实现要求在下面给出。

hasSupport = document . implementation . hasFeature( feature, version )

返回用户代理是否支持版本为versionfeature。空字符串表示任意版本。

hasFeature(feature, version)方法,如果用户代理支持feature, version)元素,则必须返回真,否则必须返回假。

此区块中不是标准描述,实现要求在下面给出。

doctype = document . implementation . createDocumentType( qualifiedName, publicId, systemId )

返回一个DOCTYPE,其中给出qualifiedNamepublicIdsystemId。如果qualifiedName不匹配产生的Name,将抛出一个“InvalidCharacterError”异常,如果其不匹配产生的QName,将抛出一个“NamespaceError”异常。

doc = document . implementation . createDocument(namespace, qualifiedName, doctype)

返回一个XMLDocument,其中给出本地名称qualifiedName命名空间namespace文档元素(如果qualifiedName不为空字符串)和作为其DOCTYPEdoctype(如果给出)。

该方法将抛出与使用相同参数调用createElementNS方法相同的异常。

doc = document . implementation . createHTMLDocument( title )

返回一个文档,其基本的中已经包含了一个title元素。

createDocumentType(qualifiedName, publicId, systemId)方便必须执行这些步骤:

  1. 如果qualifiedName不匹配产生的Name,将抛出一个“InvalidCharacterError”异常并终止这些步骤。
  2. 如果qualifiedName不匹配产生的QName,将抛出一个“NamespaceError”异常并终止这些步骤。
  3. 返回一个新的DOCTYPE,其名称qualifiedName公开IDpublicId系统IDsystemId,且其节点文档被设为与上下文对象相关联的文档
注:没有执行判断publicId匹配PublicChar或者systemId不包含“"”和“'”的检查。

createDocument(namespace, qualifiedName, doctype)方法必须执行这些步骤:

  1. document为一个新的XMLDocument
    注:该方法创建一个XMLDocument而不是一个普通的文档。它们除了增加了部署内容依赖的load()方法之外是相同的。
  2. element为空。
  3. 如果qualifiedName不是空字符串,则设element为使用参数namespacequalifiedNamedocument上调用createElementNS()方法的结果。如果其抛出一个异常,则重新抛出该异常并终止这些步骤。
  4. 如果doctype不为空,则将doctype追加document中。
  5. 如果element不为空,则将element追加document中。
  6. 返回document

createHTMLDocument(title)方法必须执行这些步骤:

  1. doc为一个新创建的文档
  2. doc标为一个HTML文档
  3. doc媒体类型设为“text/html”。
  4. 创建一个DOCTYPE,其名称为“html”,其节点文档被设为doc。将新创建的节点追加doc中。
  5. HTML命名空间中,创建一个html元素,将其追加doc中。
  6. HTML命名空间中,创建一个head元素,将其追加到上一步中创建的html元素中。
  7. HTML命名空间中,创建一个title元素,将其追加到上一步中创建的head元素中。
  8. 创建一个Text节点,将其数据设为title(可能为空字符串),将其追加到上一步中创建的title元素中。
  9. HTML命名空间中,创建一个body元素,将其追加到更早步骤中创建的html元素中。
  10. 返回doc

DocumentFragment接口

interface DocumentFragment : Node {
  // 新特性
  void prepend(Node | DOMString... nodes);
  void append(Node | DOMString... nodes);
};

DocumentType接口

interface DocumentType : Node {
  readonly attribute DOMString name;
  readonly attribute DOMString publicId;
  readonly attribute DOMString systemId;

  // 新特性
  void before(Node | DOMString... nodes);
  void after(Node | DOMString... nodes);
  void replace(Node | DOMString... nodes);
  void remove();
};

DocumentType节点被认为是DOCTYPE

DOCTYPE拥有与其相关联的名称公开ID系统ID

当创建一个DOCTYPE时,总是需要给出其名称。当创建一个DOCTYPE时,如果没有特别给出,其公开ID系统ID为空字符串。

name属性必须返回名称

publicId属性必须返回公开ID

systemId属性必须返回系统ID

Element接口

interface Element : Node {
  readonly attribute DOMString? namespaceURI;
  readonly attribute DOMString? prefix;
  readonly attribute DOMString localName;
  readonly attribute DOMString tagName;

           attribute DOMString id;
           attribute DOMString className;
  readonly attribute DOMTokenList classList;

  readonly attribute Attr[] attributes;
  DOMString? getAttribute(DOMString name);
  DOMString? getAttributeNS(DOMString? namespace, DOMString localName);
  void setAttribute(DOMString name, DOMString value);
  void setAttributeNS(DOMString? namespace, DOMString name, DOMString value);
  void removeAttribute(DOMString name);
  void removeAttributeNS(DOMString? namespace, DOMString localName);
  boolean hasAttribute(DOMString name);
  boolean hasAttributeNS(DOMString? namespace, DOMString localName);

  NodeList getElementsByTagName(DOMString qualifiedName);
  NodeList getElementsByTagNameNS(DOMString? namespace, DOMString localName);
  NodeList getElementsByClassName(DOMString classNames);

  readonly attribute HTMLCollection children;
  readonly attribute Element? firstElementChild;
  readonly attribute Element? lastElementChild;
  readonly attribute Element? previousElementSibling;
  readonly attribute Element? nextElementSibling;
  readonly attribute unsigned long childElementCount;

  // 新特性
  void prepend(Node | DOMString... nodes);
  void append(Node | DOMString... nodes);
  void before(Node | DOMString... nodes);
  void after(Node | DOMString... nodes);
  void replace(Node | DOMString... nodes);
  void remove();
};

Element节点被认为是元素

元素拥有与其相关的命名空间命名空间前缀本地名称。当创建一个元素时,总是需要给出其本地名称。当创建一个元素时,如果没有特别给出,其命名空间命名空间前缀为空。

元素还拥有一个有序的属性列表。当创建一个元素时,如果没有特别给出,其属性列表为空。如果一个属性A在一个元素属性列表中,则称该元素拥有属性A

元素可以拥有一个与其相关的唯一标识符(ID)

注:在历史上,元素可以拥有多个标识符,例如,通过使用HTML id属性和一个DTD。本标准使ID为DOM的一个概念,且仅允许通过id属性为每个元素给出一个ID

如果一个元素拥有一个其不为空字符串的id属性,则称该元素拥有一个ID。该ID是该属性

如果一个元素拥有一个将其进行分割的结果不是空列表的class属性,则称该元素拥有一个。该是该属性按空格分割

注:对于本规范定义的用户代理处理任意元素的id和class属性的处理需求,我们不对是否使用它们进行强制要求。

一个节点的类型为Element父亲被认为是一个父元素。如果该节点拥有一个不同类型的父亲,则其父元素为空。

一个文档文档元素父亲为该文档元素,如果存在,否则为空。

注:正如节点模型章节中所说的,仅能拥有一个这样的元素

若一个元素或一个其祖先文档元素,则其在文档中

规范可能会定义基本URL更改步骤

若一个元素受基本URL更改的影响,则用户代理必须执行在其他适用的规范中定义的基本URL更改步骤

此区块中不是标准描述,实现要求在下面给出。

namespace = element . namespaceURI

返回其命名空间

prefix = element . prefix

返回其命名空间前缀

localName = element . localName

返回其本地名称

qualifiedName = element . tagName

如果命名空间前缀不为空,则返回由命名空间前缀、“:”和本地名称组成的字符串。反则返回本地名称。(在HTML文档中返回值为大写形式。)

namespaceURI属性必须返回其上下文对象命名空间

prefix属性必须返回其上下文对象命名空间前缀

localName属性必须返回其上下文对象本地名称

tagName属性必须执行这些步骤:

  1. 如果上下文对象命名空间前缀不为空,则设qualified name为其命名空间前缀,其后跟随一个“:”(U+003A)和其本地名称。否则,设qualified name为其本地名称
  2. 如果上下文对象HTML命名空间下,且其节点文档是一个HTML文档,则将qualified name转换为大写形式
  3. 返回qualified name

某些IDL属性被定义为反映特定的内容属性。这意味着,在获取时,必须执行下列步骤:

  1. value为使用内容属性的名字作为参数调用getAttribute()方法所返回的结果。
  2. 如果value为空,返回空字符串并终止这些步骤。
  3. 返回value

在设置时,用户代理必须使用内容属性的名称及新值作为参数调用setAttribute()

id属性必须反映“id”内容属性。

className属性必须反映“class”内容属性。

classList属性必须返回一个基础字符串为其className属性值的DOMTokenList

attributes属性必须返回一个与其上下文对象相关的属性属性只读数组。返回的只读数组必须是实时的。例如,需要反映对与其相关的属性的修改。

getAttribute(name)方法必须执行这些步骤:

  1. 如果上下文对象HTML命名空间下且其节点对象是一个HTML文档,则将name转换为ASCII小写形式
  2. 返回其上下文对象attributes限定名name的第一个属性,否则返回空。

getAttributeNS(namespace, localName)方法必须执行下列步骤:

  1. 如果namespace为空字符,则设其为null。
  2. 返回上下文对象的属性列表中,命名空间为namespace且本地名称为localName的属性的值。如果没有这样的属性则返回null。

setAttribute(qualifiedName, value)方法必须执行这些步骤:

  1. 如果name不匹配XML产生的Name,则抛出一个"INVALID_CHARACTER_ERR"异常,并终止这些步骤。
  2. 如果上下文对象处于HTML命名空间,且其节点文档是一个HTML文档,则将name转换为ASCII小写形式
  3. 上下文对象属性列表中第一个名称name的属性为属性,如果没有这样的属性,则设属性null。
  4. 如果属性为null,则创建一个namevalue属性,并将该属性追加上下文对象上,并终止这些步骤。
  5. 排入一个"attributes"记录,其目标为上下文对象,名称为属性本地名称,命名空间为属性命名空间,旧值为属性
  6. 属性value

setAttributeNS(namespace, qualifiedName, value)方法必须执行这些步骤:

  1. 如果namespace为空字符串,则设其为null。
  2. 如果name不匹配XML中产生的[[1]],则抛出一个"InvalidCharacterError"异常并终止这些步骤。
  3. 如果name不匹配XML中命名空间产生的[[2]],则抛出一个"NamespaceError"异常并终止这些步骤。
  4. 如果name包含一个U+003E冒号(:)字符,则分隔字符串,并设前缀为前一部分,设本地名称为后一部分。否则设前缀为null,设本地名称为name。
  5. 如果前缀不为null,且namespace为null,则抛出一个"NamespaceError"异常并终止这些步骤。
  6. 如果前缀为“xml”,且namespace不是XML命名空间,则抛出一个"NamespaceError"异常并终止这些步骤。
  7. 如果name前缀为“xmlns”,且namespace不是XMLNS命名空间,则抛出一个"NamespaceError"异常并终止这些步骤。
  8. 如果namespaceXMLNS命名空间,且name前缀均不为"xmlns",则抛出一个"NamespaceError"异常并终止这些步骤。
  9. 属性上下文对象属性列表中第一个命名空间namespace本地名称本地名称属性,否则,如果没有这样的属性,则设为null。
  10. 如果属性为null,则创建一个属性,其名称name命名空间namespace命名空间前缀前缀本地名称本地名称value,并将其追加上下文对象属性之中,并终止这些步骤。
  11. 排入一个"attributes"记录,其目标为上下文对象、名称为本地名称、命名空间为namespace、旧值为属性的
  12. 属性value

removeAttribute(qualifiedName)方法必须执行这些步骤:

  1. 如果上下文对象HTML命名空间下,且其节点文档是一个HTML文档,则将qualifiedName转换为ASCII小写形式
  2. 移除上下文对象attributes中第一个限定名qualifiedName属性

removeAttributeNS(namespace, localName)方法必须执行这些步骤:

  1. 如果namespace为空字符串,设其为空。
  2. 移除上下文对象attributes命名空间namespace本地名称localName属性,如果存在。

hasAttribute(qualifiedName)方法必须执行这些步骤:

  1. 如果上下文对象HTML命名空间下,且其节点文档是一个HTML文档,则将qualifiedName转换为ASCII小写形式
  2. 如果上下文对象attributes中包含一个限定名qualifiedName属性则返回真,否则返回假。

hasAttributeNS(namespace, localName)方法必须执行下列步骤:

  1. 如果namespace为空字符串,设其为空。
  2. 如果上下文对象attributes中包含一个命名空间namespace本地名称localName属性则返回真,否则返回假。

当调用getElementsByTagName(qualifiedName)方法时,必须返回一个NodeList,其元素为在上下文对象节点文档上通过传递相同参数调用getElementsByTagName()方法所返回的,除去任意不是调用该方法的上下文对象后裔元素

当使用相同参数效用时,可能会返回与早前的调用所返回的相同的NodeList对象。

当调用getElementsByTagNameNS(namespace, localName)方法时,必须返回一个NodeList,其元素为在上下文对象节点文档上通过传递相同参数调用getElementsByTagNameNS()方法所返回的,除去任意不是调用该方法的上下文对象后裔元素

当使用相同参数效用时,可能会返回与早前的调用所返回的相同的NodeList对象。

当调用getElementsByClassName(classNames)方法时,必须返回一个NodeList,其元素为在上下文对象节点文档上通过传递相同参数调用getElementsByClassName()方法所返回的,除去任意不是调用该方法的上下文对象后裔元素

当使用相同参数效用时,可能会返回与早前的调用所返回的相同的NodeList对象。

此区块中不是标准描述,实现要求在下面给出。

collection = element . children

返回其孩子元素

element = element . firstElementChild

返回第一个是元素孩子,否则返回空。

element = element . lastElementChild

返回最后一个是元素孩子,否则返回空。

element = element . previousElementSibling

返回第一个是元素之前的兄弟,否则返回空。

element = element . nextElementSibling

返回第一个是元素之后的兄弟,否则返回空。

children属性必须返回一个植根于上下文对象仅匹配元素孩子HTMLCollection集合

firstElementChild属性必须返回第一个是元素孩子,否则必须返回空。

lastElementChild属性必须返回最后一个是元素孩子,否则必须返回空。

previousElementSibling属性必须返回第一个是元素之前的兄弟,否则必须返回空。

nextElementSibling属性必须返回第一个是元素之后的兄弟,否则必须返回空。

childElementCount属性必须返回上下文对象中是元素孩子数目。

Attr接口

interface Attr {
  readonly attribute DOMString? namespaceURI;
  readonly attribute DOMString? prefix;
  readonly attribute DOMString localName;
  readonly attribute DOMString name;
           attribute DOMString value;
};

Attr对象被认为是属性

元素类似,属性拥有与其相关的命名空间命名空间前缀本地名称限定名

在一个属性被创建时,总是给出其本地名称。在一个属性被创建时如果没有明确地给出,其命名空间命名空间前缀为空。

如果一个属性命名空间前缀不为空,则其限定名被定义为其命名空间前缀,其后跟随一个“:”(U+003A)和且本地名称

属性还有一个与其相关的,其总是在创建属性时给出。

namespaceURI属性必须返回其命名空间

prefix属性必须返回其命名空间前缀

localName属性必须返回其本地名称

name属性必须返回其限定名

value属性必须返回其

设置value属性必须将其设为新值。

CharacterData接口

interface CharacterData : Node {
  [TreatNullAs=EmptyString] attribute DOMString data;
  readonly attribute unsigned long length;
  DOMString substringData(unsigned long offset, unsigned long count);
  void appendData(DOMString data);
  void insertData(unsigned long offset, DOMString data);
  void deleteData(unsigned long offset, unsigned long count);
  void replacedata(unsigned long offset, unsigned long count, DOMString data);

  // 新特性
  void before(Node | DOMString... nodes);
  void after(Node | DOMString... nodes);
  void replace(Node | DOMString... nodes);
  void remove();
};
注:CharacterData是一个抽象接口,不作为节点而存在。其被TextCommentProcessingInstruction节点使用。

每个实现了CharacterData接口的节点都有一个与其相关联的名为数据的可变字符串。

为了对节点node使用偏移量offset、计数count和数据data替换其数据,需要执行这些步骤:

  1. lengthnodelength属性值。
  2. 如果offset大于length,则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
  3. 如果offset加上count大于length,则设countlength减去offset
  4. data插入到node数据中第offset编码单元之后。
  5. delete offsetoffset加上data中的编码单元数的值。
  6. 从第delete offset编码单元开始,从node数据中移除count编码单元
  7. 对于每个起始节点node起始偏移量大于offset但小于等于offset加上count排列,设其起始偏移量offset
  8. 对于每个结束节点node结束偏移量大于offset但小于等于offset加上count排列,设其结束偏移量offset
  9. 对于每个起始节点node起始偏移量大于offset加上count排列,将其起始偏移量增加data中的编码单元数,之后再减少count
  10. 对于每个结束节点node结束偏移量大于offset加上count排列,将其结束偏移量增加data中的编码单元数,之后再减少count

为了对节点node使用偏移量offset和计数count取其数据的子串,需要执行这些步骤:

  1. lengthnodelength属性值。
  2. 如果offset大于length,则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
  3. 如果offset加上count大于length,则返回一个值为node数据中从第offset编码单元到其结尾的编码单元的字符串,并终止这些步骤。
  4. 返回一个值为node数据中从第offset编码单元到第offset+count编码单元编码单元的字符串。

data属性必须返回数据,在设置时,必须使用节点上下文对象、偏移量0、计数length属性值和数据新值替换数据

length属性必须返回数据中的编码单元数。

substringData(offset, count)方法必须使用节点上下文对象、偏移量offset和计数count取数据的子串

appendData(data)方法必须使用节点上下文对象、偏移量length属性值、计数0和数据data替换数据

insertData(offset, data)方法必须使用节点上下文对象、偏移量offset、计数0和数据data替换数据

deleteData(offset,count)方法必须使用节点上下文对象、偏移量offset、计数count和数据空字符串替换数据

replaceData(offset, count, data)方法必须使用节点上下文对象、偏移量offset、计数count和数据data替换数据

Text接口

interface Text : CharacterData {
  Text splitText(unsigned long offset);
  readonly attribute DOMString wholeText;
};

为了使用偏移量offset分离一个Text节点node,需要执行这些步骤:

  1. length为其length属性值。
  2. 如果offset大于length,则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
  3. countlength减去offset
  4. new data为使用节点node、偏移量offset和计数count取其数据的子串
  5. 使用节点node、偏移量offset、计数count和数据空字符串替换其数据
  6. new node为一个新的Text节点,其节点文档node相同。设new node数据new data
  7. parentnode父亲
  8. 如果parent为空,执行这些子步骤:
    1. 对于每个起始节点node起始偏移量大于等于offset结束偏移量大于offset排列,将其起始节点结束节点设为new node并将其起始偏移量结束偏移量减去offset
    2. 对于每个结束节点node结束偏移量大于offset排列,设其结束偏移量offset
    3. 返回new node并终止这些步骤。
  9. 对于每个起始节点node起始偏移量大于offset排列,设其起始偏移量new node并将其起始偏移量减去offset
  10. 对于每个结束节点node结束偏移量大于offset排列,设其结束节点new node并将其结束偏移量减去offset
  11. new data插入parent nodenode下一个兄弟之前。
  12. 返回new node

splitText(offset)方法必须使用偏移量offset分离上下文对象

一个节点邻近Text节点,在避免重复的情况下,为该节点本身、其前一个兄弟Text节点(如果存在)及邻近Text节点、其后一个兄弟Text节点(如果存在)及邻近Text节点

wholeText属性必须返回按照树形结构顺序连接其上下文对象邻近Text节点数据的结果。

ProcessingInstruction接口

interface ProcessingInstruction : CharacterData {
  readonly attribute DOMString target;
};

ProcessingInstruction节点拥有一个与其相关联的目标

target属性必须返回其目标

Comment接口

interface Comment : CharacterData {
};

排列

一个节点node长度node决定:

Range接口

interface Range {
  readonly attribute Node startContainer;
  readonly attribute unsigned long startOffset;
  readonly attribute Node endContainer;
  readonly attribute unsigned long endOffset;
  readonly attribute boolean collapsed;
  readonly attribute Node commonAncestorContainer;

  void setStart(Node refNode, unsigned long offset);
  void setEnd(Node refNode, unsigned long offset);
  void setStartBefore(Node refNode);
  void setStartAfter(Node refNode);
  void setEndBefore(Node refNode);
  void setEndAfter(Node refNode);
  void collapse(boolean toStart);
  void selectNode(Node refNode);
  void selectNodeContents(Node refNode);

  const unsigned short START_TO_START = 0;
  const unsigned short START_TO_END = 1;
  const unsigned short END_TO_END = 2;
  const unsigned short END_TO_START = 3;
  short compareBoundaryPoints(CompareHow how, Range sourceRange);

  void deleteContents();
  DocumentFragment extractContents();
  DocumentFragment cloneContents();
  void insertNode(Node newNode);
  void surroundContents(Node newParent);

  Range cloneRange();
  void detach();

  boolean isPointInRange(Node parent, unsigned long offset);
  short comparePoint(Node parent, unsigned long offset);

  boolean intersectsNode(Node node);

  stringifier;
};

Range对象被认为是排列

注:排列可以使用createRange()方法创建。

一个边界点是一个(节点偏移量)元组,其偏移量是一个非负整数。

注:通常来说,一个边界点偏移量应当介于零到该边界点节点长度之间(含)。对一个进行修改的算法(特别是插入移除替换数据分离算法)同时也要修改与该相关联的排列

如果边界点节点A偏移量A)及(节点B偏移量B)的两个节点拥有相同的,则前者的位置与后者之间的关系为之前相同之后,其由下列算法得出:

  1. 如果节点A节点B相同,则如果偏移量A偏移量B相同返回相同,如果偏移量A小于偏移量B返回之前,如果偏移量A大于偏移量B返回之后
  2. 如果节点A跟随节点B,则比较(节点B偏移量B)到(节点A偏移量A)的位置关系。如果为之前则返回之后。如果之后则返回之后。不管是哪种情况都要终止这些步骤。
  3. 如果节点A节点B祖先
    1. 孩子等于节点B
    2. 只要孩子不是节点A孩子,则设孩子为其父亲
    3. 如果孩子索引小于偏移量A,则返回之后
  4. 返回之前

每个排列都拥有两个与其相关联的边界点——起始结束——一个与其相关的分离标记,它们初始化时没有设置。

为了简便,起始节点起始节点起始偏移量起始偏移量结束节点结束节点结束偏移量结束偏移量

一个排列是其起始节点,或者如果其设置了分离标记则为空。

如果一个节点node与一个排列range相同,且(node,0)在range起始之后,且(nodenode长度)在range结束之前,则称节点node包含排列range之中。

如果一个节点node是一个排列range起始节点的一个包容性祖先而不是其结束节点的一个包容性祖先,或者相反的情况,则称节点node部分包含排列range之中。

注:

为了更好地理解这些定义,我们例举了下列实例:

此区块中不是标准描述,实现要求在下面给出。

node = range . startContainer

返回range起始节点

offset = range . startOffset

返回range起始偏移量

node = range . endContainer

返回range结束节点

offset = range . endOffset

返回range结束偏移量

collapsed = range . #dom-range-collapsed

如果range起始结束相同,则返回真,否则返回假。

container = range . commonAncestorContainer

返回一个节点,其尽可能的远离文档,且必须同时是range起始节点结束节点祖先

如果没有设置分离标记,则startContainer属性必须返回其起始节点,否则必须抛出一个INVALID_STATE_ERR异常。

如果没有设置分离标记,则startOffset属性必须返回其起始偏移量,否则必须抛出一个INVALID_STATE_ERR异常。

如果没有设置分离标记,则endContainer属性必须返回其结束节点,否则必须抛出一个INVALID_STATE_ERR异常。

如果没有设置分离标记,则endOffset属性必须返回其结束偏移量,否则必须抛出一个INVALID_STATE_ERR异常。

如果没有设置分离标记,如果起始等于结束,则collapsed属性必须返回真,否则必须返回假;否则必须抛出一个INVALID_STATE_ERR异常。

commonAncestorContainer属性必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 容器起始节点
  3. 只要容器不是结束节点的一个包容性祖先,则设容器容器父亲
  4. 返回容器

为了对一个排列设置其起始或结束为一个边界点节点偏移量),需要执行这些步骤:

  1. 如果设置了排列分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果节点是一个DOCTYPE,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  3. 如果偏移量大于节点长度,则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
  4. 边界点边界点节点偏移量)。
    • 如果这些步骤被作为“设置起始”调用
      1. 如果边界点排列结束之后,或者如果排列不等于节点,则设排列结束边界点
      2. 排列起始边界点
    • 如果这些步骤被作为“设置结束”调用
      1. 如果边界点排列起始之前,或者如果排列不等于节点,则设排列起始边界点
      2. 排列结束边界点

setStart(node, offset)方法必须对上下文对象设置其起始边界点(node, offset)。

setEnd(node, offset)方法必须对上下文对象设置其结束边界点(node, offset)。

setStartBefore(node)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 父亲节点父亲
  3. 如果父亲为空,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  4. 上下文对象设置其起始边界点(父亲, 节点索引)。

setStartAfter(node)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 父亲节点父亲
  3. 如果父亲为空,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  4. 上下文对象设置其起始边界点(父亲, 节点索引加上一)。

setEndBefore(node)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 父亲节点父亲
  3. 如果父亲为空,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  4. 上下文对象设置其结束边界点(父亲, 节点索引)。

setEndAfter(node)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 父亲节点父亲
  3. 如果父亲为空,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  4. 上下文对象设置其结束边界点(父亲, 节点索引加上一)。

collapse(toStart)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果toStart为真,则将结束设为起始。否则,将起始设为结束

selectNode(node)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 父亲节点父亲
  3. 如果父亲为空,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  4. 索引节点索引
  5. 起始边界点父亲索引)。
  6. 结束边界点父亲索引加上一)。

selectNodeContents(node)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果节点是一个DOCTYPE,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  3. 长度节点长度
  4. 起始边界点节点,0)。
  5. 结束边界点节点长度)。

compareBoundaryPoints(how, sourceRange)方法必须执行这些步骤:

  1. 如果上下文对象sourceRange设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果上下文对象sourceRange不相同,则抛出一个WRONG_DOCUMENT_ERR异常并终止这些步骤。
  3. 如果how是:
  4. 如果this pointother point位置为:
    • “之前”
      • 返回-1并终止这些算法。
    • “等于”
      • 返回0并终止这些算法。
    • “之后”
      • 返回1并终止这些算法。

deleteContents()方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果起始等于结束,则终止这些步骤。
  3. 原起始节点原起始偏移量原结束节点原结束偏移量分别为上下文对象起始节点起始偏移量结束节点结束偏移量
  4. 如果原起始节点原结束节点'相同,且它们均为TextComment节点,则使用节点原起始节点、偏移量原起始偏移量、计数原结束偏移量减去原起始偏移量及数据空字符串替换其数据,并终止这些步骤。
  5. 将移除的节点树形结构顺序上下文对象中所有被包含节点的列表,其中忽略上下文对象中其父亲被包含节点
  6. 如果原起始节点原结束节点的一个包容性祖先,则将新节点设为原起始节点,将新偏移量设为原起始偏移量
  7. 否则:
    1. 参考节点等于原开始节点
    2. 只要参考节点父亲不为空,且不是原结束节点包容性祖先,则设参考节点为其父亲
    3. 新节点参考节点父亲,设新偏移量为一加上参考节点索引
      注:如果参考节点父亲为空,即其为其上下文对象,所以将为原结束节点的一个包容性祖先,并且我们不可能达到该点。
  8. 如果原起始节点是一个TextComment节点,则使用节点原起始节点、偏移量原起始偏移量、计数原起始节点长度减去原起始偏移量、数据空字符串替换其数据
  9. 对于将移除的节点中的每个节点,按照顺序从其父亲中移除节点
  10. 如果原结束节点是一个TextComment节点,则使用节点原结束节点、偏移量0、计数原结束偏移量、数据空字符串替换其数据
  11. 起始结束设为(新节点新偏移量)。

extractContents()方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 片段为一个新的DocumentFragment,其节点对象上下文对象起始节点节点文档
  3. 如果起始等于结束,返回片段,则终止这些步骤。
  4. 原起始节点原起始偏移量原结束节点原结束偏移量分别为上下文对象起始节点起始偏移量结束节点结束偏移量
  5. 如果原起始节点原结束节点'相同,且它们均为TextComment节点
    1. 副本原起始节点的一个副本
    2. 副本数据为使用节点原起始节点、偏移量原起始偏移量和计数原结束偏移量减去原起始偏移量取其数据的子串的结果。
    3. 副本追加到片段之中。
    4. 使用节点原起始节点、偏移量原起始偏移量、计数原结束偏移量减去原其实偏移量、数据空字符串替换其数据
    5. 返回片段并终止这些步骤。
  6. 普通祖先原起始节点
  7. 只要普通祖先不是原结束节点包容性祖先,则设普通祖先为其父亲
  8. 如果原起始节点原结束节点包容性祖先,则设第一个被部分包含的孩子为空。
  9. 否则,设第一个被部分包含的孩子普通祖先孩子中第一个被部分包含上下文对象之中的。
  10. 如果原结束节点原起始节点的一个包容性祖先,则设最后一个被部分包含的孩子为空。
  11. 否则,设最后一个被部分包含的孩子普通祖先孩子中最后一个被部分包含上下文对象之中的。
  12. 被包含的孩子普通祖先孩子中所有被包含上下文对象之中的,保持树形结构顺序
  13. 如果被包含的孩子中有成员为一个DocumentType的,则抛出一个HIERARCHY_REQUEST_ERR异常并终止这些步骤。
  14. 如果原起始节点原结束节点的一个包容性祖先,则设新节点原起始节点、设新偏移量原起始偏移量
  15. 否则:
    1. 参考节点等于原起始节点
    2. 只要参考节点父亲不为空且不是原结束节点的一个包容性祖先,则设参考节点为其父亲
    3. 新节点参考节点父亲,设新偏移量为一加上参考节点索引
  16. 如果第一个被部分包含的孩子是一个TextComment节点
    1. 副本原起始节点的一个副本
    2. 副本数据为使用节点原起始节点、偏移量原起始偏移量和计数原起始节点长度减去原起始偏移量取其数据的子串
    3. 副本追加到片段之中。
    4. 使用节点原起始节点、偏移量原起始偏移量、计数原起始节点长度减去原起始偏移量和数据空字符串替换其数据
  17. 否则,如果第一个被部分包含的孩子不为空:
    1. 副本第一个被部分包含的孩子的一个副本
    2. 副本追加到片段之中。
    3. 子排列为一个新的排列,其起始为(原起始节点原起始偏移量),其结束为(第一个被部分包含的孩子第一个被部分包含的孩子长度)。
    4. 子片段为在子排列上调用extractContents()的结果。
    5. 对于子片段中的每个孩子,按照顺序,将该孩子追加到片段之中。
  18. 对于被包含的孩子中的每个孩子,将该孩子追加到片段之中。
  19. 如果最后一个被部分包含的孩子是一个TextComment节点
    1. 副本原结束节点的一个副本
    2. 副本数据为使用节点原结束节点、偏移量0和计数原结束偏移量取其数据的子串
    3. 副本追加到片段之中。
    4. 使用节点原结束节点、偏移量0、计数原结束偏移量和数据空字符串替换其数据
  20. 否则,如果最后一个被部分包含的孩子不为空:
    1. 副本最后一个被部分包含的孩子的一个副本
    2. 副本追加到片段之中。
    3. 子排列为一个新的排列,其起始为(最后一个被部分包含的孩子,0),其结束为(原结束节点原结束偏移量)。
    4. 子片段为在子排列上调用extractContents()的结果。
    5. 对于子片段中的每个孩子,按照顺序,将该孩子追加到片段之中。
  21. 起始结束为(新节点新偏移量)。
  22. 返回片段

cloneContents()方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 片段为一个新的DocumentFragment,其节点对象上下文对象起始节点节点文档
  3. 如果起始等于结束,则返回片段,并终止这些步骤。
  4. 原起始节点原起始偏移量原结束节点原结束偏移量分别为上下文对象起始节点起始偏移量结束节点结束偏移量
  5. 如果原起始节点原结束节点'相同,且它们均为TextComment节点
    1. 副本原起始节点的一个副本
    2. 副本数据为使用节点原起始节点、偏移量原起始偏移量和计数原结束偏移量减去原起始偏移量取其数据的子串的结果。
    3. 副本追加到片段之中。
    4. 使用节点原起始节点、偏移量原起始偏移量、计数原结束偏移量减去原其实偏移量、数据空字符串替换其数据
    5. 返回片段并终止这些步骤。
  6. 普通祖先原起始节点
  7. 只要普通祖先不是原结束节点包容性祖先,则设普通祖先为其父亲
  8. 如果原起始节点原结束节点包容性祖先,则设第一个被部分包含的孩子为空。
  9. 否则,设第一个被部分包含的孩子普通祖先孩子中第一个被部分包含上下文对象之中的。
  10. 如果原结束节点原起始节点的一个包容性祖先,则设最后一个被部分包含的孩子为空。
  11. 否则,设最后一个被部分包含的孩子普通祖先孩子中最后一个被部分包含上下文对象之中的。
  12. 被包含的孩子普通祖先孩子中所有被包含上下文对象之中的,保持树形结构顺序
  13. 如果被包含的孩子中有成员为一个DocumentType的,则抛出一个HIERARCHY_REQUEST_ERR异常并终止这些步骤。
  14. 如果第一个被部分包含的孩子是一个TextComment节点
    1. 副本原起始节点的一个副本
    2. 副本数据为使用节点原起始节点、偏移量原起始偏移量和计数原起始节点长度减去原起始偏移量取其数据的子串
    3. 副本追加到片段之中。
  15. 否则,如果第一个被部分包含的孩子不为空:
    1. 副本第一个被部分包含的孩子的一个副本
    2. 副本追加到片段之中。
    3. 子排列为一个新的排列,其起始为(原起始节点原起始偏移量),其结束为(第一个被部分包含的孩子第一个被部分包含的孩子长度)。
    4. 子片段为在子排列上调用cloneContents()的结果。
    5. 对于子片段中的每个孩子,按照顺序,将该孩子追加到片段之中。
  16. 对于被包含的孩子中的每个孩子
    1. 副本孩子的一个副本
    2. 副本追加到片段之中。
  17. 如果最后一个被部分包含的孩子是一个TextComment节点
    1. 副本最后一个被部分包含的孩子的一个副本
    2. 副本数据为使用节点原结束节点、偏移量0和计数原结束节点取其数据的子串
    3. 副本追加到片段之中。
  18. 否则,如果最后一个被部分包含的孩子不为空:
    1. 副本最后一个被部分包含的孩子的一个副本
    2. 副本追加到片段之中。
    3. 子排列为一个新的排列,其起始为(最后一个被部分包含的孩子,0),其结束为(原结束节点原结束偏移量)。
    4. 子片段为在子排列上调用cloneContents()的结果。
    5. 对于子片段中的每个孩子,按照顺序,将该孩子追加到片段之中。
  19. 返回片段

insertNode(newNode)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果起始节点是一个TextComment节点,且其父亲为空,则抛出一个HIERARCHY_REQUEST_ERR异常并终止这些步骤。
  3. 如果起始节点是一个Text节点,则使用偏移量上下文对象起始偏移量分离Text节点,并将参考节点设为返回的结果。
  4. 否则,如果起始节点是一个Comment节点,则将参考节点设为起始节点
  5. 否则,将参考节点设为起始节点索引起始偏移量孩子,或者如果不存在这些的孩子则设为空。
  6. 如果参考节点为空,则设父节点起始节点.
  7. 否则,设父节点参考节点父亲
  8. newNode预插入父节点参考节点之前。

surroundContents(newParent)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果上下文对象部分包含了一个非Text节点,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  3. 如果newParent是一个DocumentDocumentTypeDocumentFragment节点,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  4. 上下文对象上调用extractContents()方法,并将片段设为返回的结果。
  5. 只要newParent拥有孩子,则移除其第一个孩子
  6. 上下文对象上调用insertNode(newParent)方法。
  7. newParent上调用appendChild(片段)方法。
  8. 上下文对象上调用selectNode(newParent)方法。

对于cloneRange()方法,如果设置了分离标记,则必须抛出一个INVALID_STATE_ERR异常。否则,必须返回一个新的排列,其起始结束与其上下文对象中的相同。

detach()方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 设置分离标记
此区块中不是标准描述,实现要求在下面给出。

position = range . comparePoint ( parent, offset )

如果该点在排列之前,则返回-1;如果该点在排列之中,则返回0;如果该点在排列之后,则返回1。

intersects = range . intersectsNode ( node )

返回rangenode是否交叉。

isPointInRange(节点, 偏移量)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果节点不是上下文对象的一个包容性后裔,则抛出一个WRONG_DOCUMENT_ERR异常并终止这些步骤。
  3. 如果节点是一个DOCTYPE,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  4. 如果偏移量大于节点长度,则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
  5. 边界边界点节点偏移量)。
  6. 如果边界起始之前或者在结束之后,则返回假并终止这些步骤。
  7. 返回真。

comparePoint(节点, 偏移量)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果节点不是上下文对象的一个包容性后裔,则抛出一个WRONG_DOCUMENT_ERR异常并终止这些步骤。
  3. 如果节点是一个DOCTYPE,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  4. 如果偏移量大于节点长度,则抛出一个INDEX_SIZE_ERR异常并终止这些步骤。
  5. 边界边界点节点偏移量)。
  6. 如果边界起始之前,则返回-1并终止这些步骤。
  7. 如果边界结束之后,则返回1并终止这些步骤。
  8. 否则,返回0。

intersectsNode(节点)方法必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 如果节点不是一个ElementDocumentTypeDocumentFragmentProcessingInstructionCommentText节点,则抛出一个INVALID_NODE_TYPE_ERR异常并终止这些步骤。
  3. 父亲节点父亲。如果父亲为空,则抛出一个NOT_FOUND_ERR异常并终止这些步骤。
  4. 偏移量节点索引
  5. 前边界边界点父亲偏移量)。
  6. 如果前边界结束之前或者等于结束,则返回假并终止这些步骤。
  7. 后边界边界点父亲偏移量加一)。
  8. 如果上下文对象起始等于后边界或者在后边界之后,则返回假并终止这些步骤。
  9. 否则,返回真。

stringifier必须执行这些步骤:

  1. 如果设置了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. s为空字符串。
  3. 如果起始节点等于结束节点,且其为一个Text节点,则返回该Text节点数据中起始自起始偏移量、结束至结束偏移量的子字符串,并终止这些步骤。
  4. 如果起始节点为一个Text节点,则向s追加一个该节点数据中自起始偏移量、至结尾之前的子字符串。
  5. s追加在上下文对象被包含的所有Text节点数据按照树形结构顺序连接的结果。
  6. 如果结束节点为一个Text节点,则向s追加一个该节点数据中自起始、至结束偏移量之前的子字符串。
  7. 返回s

遍历

NodeIteratorTreeWalker对象可以被用于过滤和遍历节点

每个NodeIteratorTreeWalker对象都拥有一个与其相关的激活标记以避免递归调用。其初始时未设置。

每个NodeIteratorTreeWalker对象还拥有一个与其相关的节点whatToShow掩码和过滤器回调。

为了过滤节点,需要这些这些步骤:

  1. 如果设置了激活标记,则抛出一个INVALID_STATE_ERR异常、终止这些步骤、并终止调用此算法的算法的步骤。
  2. n节点nodeType属性值减去1。
  3. 如果没有设置whatToShow的第n位(其中0为最后一个有意义的位),返回FILTER_SKIP并终止这些步骤。
  4. 如果过滤器为空,则返回FILTER_ACCEPT并终止这些步骤。
  5. 设置激活标记
  6. 结果为调用过滤器的返回值。
  7. 撤销激活标记
  8. 如果抛出了异常,则再次抛出该异常、终止这些步骤、并终止调用此算法的算法的步骤。
  9. 返回结果

NodeIterator接口

interface NodeIterator {
  readonly attribute Node root;
  readonly attribute Node? referenceNode;
  readonly attribute boolean pointerBeforeReferenceNode;
  readonly attribute unsigned long whatToShow;
  readonly attribute NodeFilter? filter;

  Node? nextNode();
  Node? previousNode();

  void detach();
};
注:NodeIterator对象可以通过createNodeIterator()方法创建。

每个NodeIterator对象都有一个与其相关联的迭代器集合,其为一个植根于集合,其过滤器匹配任意节点

在从迭代器集合中移除一个节点之前,必须执行这些步骤:

  1. 如果该节点不是的一个后裔,而且不是referenceNode属性值的一个祖先referenceNode属性值本身,则终止这些步骤。
  2. 如果pointerBeforeReferenceNode属性值为假,则将referenceNode属性设为该节点之前的被删除的第一个节点,并终止这些步骤。
  3. 如果pointerBeforeReferenceNode属性值为真,并且存在在该节点之后的被删除的节点,则将referenceNode属性设为第一个这样的节点,并终止这些步骤。
  4. referenceNode属性设为该节点之前的被删除的第一个节点,并且设pointerBeforeReferenceNode属性值为假。

每个NodeIterator对象还有一个与其相关联的分离标记,其初始化时没有设置。

root属性必须返回

referenceNode属性必须返回其预置的内容。

pointerBeforeReferenceNode属性必须返回其预置的内容。在一个NodeIterator被创建时,必须将其预置为真。

whatToShow属性必须返回shatToShow

filter属性必须返回过滤器

为了在方向方向进行跨越,需要这些这些步骤:

  1. 如果标记了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
  2. 节点为其referenceNode属性的值。
  3. 在节点之前为其pointerBeforeReferenceNode属性的值。
  4. 执行这些子步骤:
      • 如果方向为向后
        • 如果在节点之前为假,则设节点迭代器集合节点之后的第一个节点。如果不存在这样的节点,则返回空并终止这些步骤。
        • 如果在节点之前为真,则将其设为假。
      • 如果方向为向前
        • 如果在节点之前为真,则设节点迭代器集合节点之前的第一个节点。如果不存在这样的节点,则返回空并终止这些步骤。
        • 如果在节点之前为假,则将其设为真。
    1. 过滤节点并将结果设为返回的值。
    2. 如果标记了分离标记,则抛出一个INVALID_STATE_ERR异常并终止这些步骤。
    3. 如果结果FILTER_ACCEPT,在上一层中进入下一步。

      否则,再次执行这些子步骤。

  5. referenceNode属性为节点,设pointerBeforeReferenceNode属性为在节点之前,并返回节点

nextNode()方法必须向后跨越

previousNode()方法必须向前跨越

在调用detach()方法时,将设置分离标记,并设referenceNode属性为空。

TreeWalker接口

interface TreeWalker {
  readonly attribute Node root;
  readonly attribute unsigned long whatToShow;
  readonly attribute NodeFilter? filter;
           attribute Node  currentNode;

  Node? parentNode();
  Node? firstChild();
  Node? lastChild();
  Node? previousSibling();
  Node? nextSibling();
  Node? previousNode();
  Node? nextNode();
};
注:TreeWalker对象可以通过createTreeWalker()方法创建。

root属性必须返回

whatToShow属性必须返回whatToShow

filter属性必须返回过滤器

currentNode属性必须返回其预置的内容。

设置currentNode属性时,必须将其设为新值。

parentNode()方法必须执行这些步骤:

  1. 节点为其currentNode属性的值。
  2. 只要节点不为空且不是,则执行这些子步骤:
    1. 节点节点父亲
    2. 如果节点不为空且过滤节点返回FILTER_ACCEPT,则将currentNode属性设为节点,返回节点,并终止这些步骤。
  3. 返回空。

为了跨越类型为类型的孩子,需要执行这些步骤:

  1. 节点当前为其currentNode属性的值。
  2. 只要节点不为空,则执行这些子步骤:
    1. 过滤节点,并设结果为返回值。
    2. 如果结果FILTER_ACCEPT,则将currentNode属性设为节点,返回节点,并终止这些步骤。
    3. 如果结果FILTER_SKIP节点拥有一个孩子,则按照下面设置节点并在此执行这些子步骤:
    4. 只要节点不为空,则执行这些子子步骤:
      1. 如果兄弟不为空,则设节点兄弟并终止这些步骤。
      2. 如果节点拥有一个父亲,且其不为当前,则设节点为其父亲

        否则,返回空并终止这些步骤。

firstChild()方法必须跨越类型为第一个的孩子

lastChild()方法必须跨越类型为最后一个的孩子

为了跨越类型为类型的兄弟,需要执行这些步骤:

  1. 节点为其currentNode属性的值。
  2. 如果节点,则返回空并终止这些步骤。
  3. 执行这些子步骤:
    1. 只要兄弟不为空,则执行这些子子步骤。
      1. 节点兄弟
      2. 过滤节点并设结果为返回值。
      3. 如果结果FILTER_ACCEPT,则设currentNode属性为节点,返回节点,并终止这些步骤。
      4. 如果结果FILTER_REJECT或者兄弟为空,则设兄弟为下列:
    2. 节点为其父亲
    3. 如果节点为空或,则返回空并终止这些步骤。
    4. 过滤节点,如果返回值为FILTER_ACCEPT则返回空并终止这些步骤。
    5. 再次执行这些子步骤。

nextSibling()方法必须跨越类型为之后的兄弟

previousSibling()方法必须跨越类型为之前的兄弟

previousNode()方法必须执行这些步骤:

  1. 节点为其currentNode属性的值。
  2. 只要节点不为,则执行这些子步骤:
    1. 兄弟节点上一个兄弟
    2. 只要兄弟不为空,则执行这些子子步骤:
      1. 节点兄弟
      2. 过滤节点并设结果为返回值。
      3. 只要结果不是FILTER_REJECT节点拥有一个孩子,则执行这些子子子步骤:
        1. 节点为其最后一个孩子
        2. 过滤节点并设结果为返回值。
      4. 如果结果FILTER_ACCEPT,则设currentNode节点,返回节点,并终止这些步骤。
    3. 如果节点或没有父亲,则返回空并终止这些步骤。
    4. 节点为其父亲
    5. 过滤节点,如果返回值为FILTER_ACCEPT,则设currentNode节点,返回节点,并终止这些步骤。

nextNode()方法必须执行这些步骤:

  1. 节点为其currentNode属性的值。
  2. 结果FILTER_ACCEPT
  3. 执行这些子步骤:
    1. 只要结果不为FILTER_ACCEPT节点拥有一个孩子,则执行这些子子步骤。
      1. 节点为其第一个孩子
      2. 过滤节点并设结果为返回值。
      3. 如果结果FILTER_ACCEPT,则设currentNode节点,返回节点,并终止这些步骤。
    2. 如果一个节点节点之后,且不在之后,则设节点为第一个这样的节点

      否则,再次执行这些子步骤。

    3. 过滤节点,如果返回值为FILTER_ACCEPT,则设currentNode节点,返回节点,并终止这些步骤。

NodeFilter接口

callback interface NodeFilter {
  // acceptNode()常量
 const unsigned short FILTER_ACCEPT = 1;
 const unsigned short FILTER_REJECT = 2;
 const unsigned short FILTER_SKIP = 3;

  // whatToShow常量
  const unsigned long SHOW_ALL = 0xFFFFFFFF;
  const unsigned long SHOW_ELEMENT = 0x1;
  const unsigned long SHOW_ATTRIBUTE = 0x2; // 历史遗留
  const unsigned long SHOW_TEXT = 0x4;
  const unsigned long SHOW_CDATA_SECTION = 0x8; // 历史遗留
  const unsigned long SHOW_ENTITY_REFERENCE = 0x10; // 历史遗留
  const unsigned long SHOW_ENTITY = 0x20; // 历史遗留
  const unsigned long SHOW_PROCESSING_INSTRUCTION = 0x40;
  const unsigned long SHOW_COMMENT = 0x80;
  const unsigned long SHOW_DOCUMENT = 0x100;
  const unsigned long SHOW_DOCUMENT_TYPE = 0x200;
  const unsigned long SHOW_DOCUMENT_FRAGMENT = 0x400;
  const unsigned long SHOW_NOTATION = 0x800; // 历史遗留

  unsigned short acceptNode(Node node);
};

NodeFilter对象可以被用于过滤器的回调并提供whatToShow掩码常量。

这些产量可以被用于回调返回值:

  • FILTER_ACCEPT (1);
  • FILTER_REJECT (2);
  • FILTER_SKIP (3)。

这些常量可以被用于whatToShow掩码:

  • SHOW_ALL (4294967295、十六进制FFFFFFFF);
  • SHOW_ELEMENT (1);
  • SHOW_TEXT (4);
  • SHOW_PROCESSING_INSTRUCTION (64、十六进制40);
  • SHOW_COMMENT (128、十六进制80);
  • SHOW_DOCUMENT (256、十六进制100);
  • SHOW_DOCUMENT_TYPE (512、十六进制200);
  • SHOW_DOCUMENT_FRAGMENT (1024、十六进制400);

集合

一个集合是一个表示一个DOM节点的列表的对象。一个集合可以是动态的或者静态的。除非另作说明,一个集合必须是动态的

如果一个集合动态的,则该对象上的属性和方法必须在其当前的基础数据上执行,而不是该数据的一个快照。

在一个集合被创建时,一个过滤器和一个根与其相关联。

集合表示一个植根于集合的根的子树的试图,仅包含匹配指定过滤器的节点。该视图是线性的。在没有明确的反对要求时,集合中的节点必须按照树形结构顺序排列。

对于返回一个动态的集合的属性,每次获取时都必须返回相同的对象。

NodeList接口

一个NodeList对象是集合的一种。

interface NodeList {
  getter Node? item(unsigned long index);
  readonly attribute unsigned long length;
};
此区块中不是标准描述,实现要求在下面给出。

collection . length

返回集合中元素的数目。

element = collection . item(item)

element = collection[item]

返回集合中索引为index的元素。这些元素按照树形结构顺序排列。

该对象的支持的属性索引为零至集合所表示的节点的数目减去一范围内的数字。如果没有这样的元素,则不存在支持的属性索引

length属性必须返回集合所表示的节点的数目。

item(index)属性必须返回集合中的第index个节点。如果集合中不存在第index个节点,则该方法必须返回空。

HTMLCollection接口

HTMLCollection接口表示一个通用的元素集合

interface HTMLCollection {
  readonly attribute unsigned long length;
  getter Element? item(unsigned long index);
  getter object? namedItem(DOMString name); // 仅返回Element。
};
此区块中不是标准描述,实现要求在下面给出。

collection . length

返回集合中元素的数目。

element = collection . item(index)

element = collection[index]

返回集合中索引为index的元素。这些元素按照树形结构顺序排列。

element = collection . namedItem(name)

element = collection[name]

返回集合中第一个ID或名称为name的元素。

HTML命名空间下仅有a、applet、area、embed、form、frame、frameset、iframe、img和object元素可以拥有支持此方法的名称;它们的名称通过它们的name属性的值给出。

该对象的支持的属性索引为零至集合所表示的节点的数目减去一范围内的数字。如果没有这样的元素,则不存在支持的属性索引

length属性必须返回集合所表示的节点的数目。

item(index)属性必须返回集合中的第index个节点。如果集合中不存在第index个节点,则该方法必须返回空。

支持的属性名称HTML命名空间下每个集合所表示的拥有name属性的a、applet、area、embed、form、frame、frameset、iframe、img和object元素的name属性的值加上集合所表示的元素的ID的列表组成。

namedItem(key)方法必须返回集合中的第一个符合下列类别的元素

  • 其为HTML命名空间下的a、applet、area、embed、form、frame、frameset、iframe、img和object元素,且其name属性等于key。或者
  • 其为一个元素,且其ID等于key

如果没有找到这样的元素,则该方法必须返回空。

列表

DOMStringList接口

interface DOMStringList {
  readonly attribute unsigned long length;
  getter DOMString? item(unsigned long index);
  boolean contains(DOMString string);
};

DOMStringList接口表示一个字符串的有序列表。

此区块中不是标准描述,实现要求在下面给出。

stringlist . length

返回字符串中的标记数目。

string = stringlist . item(index)

stringlist[index]

返回索引为index的字符串。

hasstring = stringlist . contains(string)

如果string存在则返回真,否则返回假。

length属性必须返回列表中字符串的数目。

该对象的支持的属性索引为零至上下文对象length属性值减去一范围内的数字。如果上下文对象length属性值为零,则不存在支持的属性索引

item(index)属性必须返回列表中的第index个字符串。如果index大于等于字符串的数目,则该方法必须返回空。

如果字符串列表中包含string,则contains(string)方法必须返回真,否则必须返回假。

DOMTokenList接口

DOMTokenList接口表示一个基础字符串,其包含一个空格分隔的标记集合

interface DOMTokenList {
  readonly attribute unsigned long length;
  getter DOMString? item(unsigned long index);
  boolean contains(DOMString token);
  void add(DOMString token);
  void remove(DOMString token);
  boolean toggle(DOMString token);
  stringifier DOMString ();
};
此区块中不是标准描述,实现要求在下面给出。

tokenlist . length

返回字符串中的标记数目。

element = tokenlist . item(index)

tokenlist[index]

返回索引为index的标记。标记按照其在基础字符串中被发现的顺序返回。

hastoken = tokenlist . contains(token)

如果token存在则返回真,否则返回假。

如果token为空则抛出一个SYNTAX_ERR异常。

如果token包含空格则抛出一个INVALID_CHARACTER_ERR异常。

tokenlist . add(token)

如果token尚未存在,添加token

如果token为空则抛出一个SYNTAX_ERR异常。

如果token包含空格则抛出一个INVALID_CHARACTER_ERR异常。

tokenlist . remove(token)

如果token存在,移除token

如果token为空则抛出一个SYNTAX_ERR异常。

如果token包含空格则抛出一个INVALID_CHARACTER_ERR异常。

hastoken = tokenlist . toggle(token)

如果token不存在,添加token,如果token存在,移除token。如果当前token存在(被添加)则返回真;如果当前token不存在(被移除)则返回假。

如果token为空则抛出一个SYNTAX_ERR异常。

如果token包含空格则抛出一个INVALID_CHARACTER_ERR异常。

length属性必须返回使用空格分隔上下文对象基础字符串所返回的标记的数目。

该对象的支持的属性索引为零至上下文对象length属性值减去一范围内的数字。如果上下文对象length属性值为零,则不存在支持的属性索引

item(index)属性必须执行这些步骤:

  1. 如果index大于等于上下文对象length属性,则返回空并终止这些步骤。
  2. 使用空格分隔上下文对象基础字符串,保留在基础字符串中被发现的顺序,以获得标记的列表。
  3. 返回该列表中的第index个元素。

举例说明,如果字符串为“a b a c”,则会发现四个标记:索引为0的标记“a”、索引为1的标记“b”、索引为2的标记“a”及索引为3的“c”。

contains(token)方法必须执行这些步骤:

  1. 如果token为空字符串,则抛出一个SYNTAX_ERR异常并终止这些步骤。
  2. 如果token包含任意空白字符,则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
  3. 使用空格分隔上下文对象基础字符串,以获得标记的列表。
  4. 如果token能够区分大小写地匹配上一步中所得到的列表中的一个标记,则返回真,否则返回假。

add(token)方法必须执行这些步骤:

  1. 如果token为空字符串,则抛出一个SYNTAX_ERR异常并终止这些步骤。
  2. 如果token包含任意空白字符,则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
  3. 使用空格分隔上下文对象基础字符串,以获得标记的列表。
  4. 如果token能够区分大小写地匹配上一步中所得到的列表中的一个标记,则终止这些步骤。
  5. 如果上下文对象基础字符串不是空字符串且该字符串的最后一个字符不是一个空白字符,则向该字符串中追加一个U+0020空白字符。
  6. 上下文对象基础字符串中追加token

remove(token)方法必须执行这些步骤:

  1. 如果token为空字符串,则抛出一个SYNTAX_ERR异常并终止这些步骤。
  2. 如果token包含任意空白字符,则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
  3. 上下文对象基础字符串中移除token

toggle(token)方法必须执行这些步骤:

  1. 如果token为空字符串,则抛出一个SYNTAX_ERR异常并终止这些步骤。
  2. 如果token包含任意空白字符,则抛出一个INVALID_CHARACTER_ERR异常并终止这些步骤。
  3. 使用空格分隔上下文对象基础字符串,以获得标记的列表。
  4. 如果token能够区分大小写地匹配上一步中所得到的列表中的一个标记,则从上下文对象基础字符串中移除token、返回假并终止这些步骤。
  5. 如果上下文对象基础字符串不是空字符串且该字符串的最后一个字符不是一个空白字符,则向该字符串中追加一个U+0020空白字符。
  6. 上下文对象基础字符串中追加token
  7. 返回真。

DOMTokenList对象必须字符串化上下文对象基础字符串

DOMSettableTokenList接口

DOMSettableTokenList接口与DOMTokenList接口相同,除了允许直接修改基础字符串。

interface DOMSettableTokenList : DOMTokenList {
           attribute DOMString value;
};
此区块中不是标准描述,实现要求在下面给出。

tokenlist . value

返回基础字符串。

可以被设置,以改变基础字符串。

一个实现DOMSettableTokenList接口的对象的行为必须按照DOMTokenList接口的定义执行,除了这里定义的value

value属性必须返回基础字符串,在设置时必须使用新值替换基础字符串。

DOM特性

历史

DOM事件

DOM核心

DOM排列

DOM遍历