Web IDL

1. 简介

本节为资料性内容。

本标准定义了一种接口定义语言 Web IDL，可用于描述拟在 Web 浏览器中实现的接口。Web IDL 是一种 IDL 变体，具有许多特性，能够更容易地指定 Web 平台中常见脚本对象的行为。还详细说明了使用 Web IDL 描述的接口如何与 JavaScript 执行环境中的构造相对应。

具体而言，Web IDL 提供了一种语法，用于指定 Web 平台对象的表面 API 以及 JavaScript 绑定，详细说明了这些 API 如何以 JavaScript 构造的形式体现。这确保了常见任务（例如安装全局属性、处理数值输入或暴露迭代行为）在各个 Web 平台规范中保持统一：这些规范使用 Web IDL 描述其接口，然后使用文章来指定 API 特定的细节。

术语“JavaScript”用于指代 ECMA-262，而不是官方术语 ECMAScript，因为 JavaScript 这一术语更为人所熟知。

2. 接口定义语言

本节描述了一种语言，Web IDL，可以用于为 Web 平台中的 API 定义接口。定义 Web API 的规范可以包含一个或多个 IDL 片段， 描述该规范所定义的 API 的接口（对象可以展示的状态和行为）。 一个 IDL 片段 是一系列与 Definitions 语法符号相匹配的定义。 一个实现支持的 IDL 片段 集合没有顺序。 请参见 IDL 语法 获取完整的语法以及符号使用说明。

可以出现在 IDL 片段 中的各种 定义 包括：接口，部分接口定义，接口混入，部分混入定义，回调函数，回调接口，命名空间，部分命名空间定义，字典，部分字典定义，类型定义 以及 包含声明。 这些定义将在以下部分中进行详细定义。

每个 定义（与 Definition 相匹配） 可以由一系列 扩展属性（与 ExtendedAttributeList 相匹配）开头， 用于控制定义将在语言绑定中如何处理。 本规范定义的与语言绑定无关的扩展属性将在 § 2.14 扩展属性 中讨论， 而与 JavaScript 语言绑定相关的扩展属性则在 § 3.3 扩展属性 中讨论。

[扩展属性]
  接口 标识符 {
    /* 接口成员... */
  };
  

Definitions ::
      ExtendedAttributeList Definition Definitions
      ε
  

Definition ::
      CallbackOrInterfaceOrMixin
      Namespace
      Partial
      Dictionary
      Enum
      Typedef
      IncludesStatement
  

[暴露=Window]
  接口 Paint { };
  
  [暴露=Window]
  接口 SolidColor : Paint {
    属性 双精度浮点数 red;
    属性 双精度浮点数 green;
    属性 双精度浮点数 blue;
  };
  
  [暴露=Window]
  接口 Pattern : Paint {
    属性 DOMString imageURL;
  };
  
  [暴露=Window]
  接口 GraphicalWindow {
    构造函数();
    只读 属性 无符号 长整数 width;
    只读 属性 无符号 长整数 height;
  
    属性 Paint currentPaint;
  
    未定义 drawRectangle(双精度浮点数 x, 双精度浮点数 y, 双精度浮点数 width, 双精度浮点数 height);
  
    未定义 drawText(双精度浮点数 x, 双精度浮点数 y, DOMString text);
  };
  

2.1. 名称

每个 接口，部分接口定义，命名空间，部分命名空间定义，字典，部分字典定义，枚举，回调函数，回调接口 和 类型定义 （统称为 命名定义） 以及每个 常量，属性， 和 字典成员 都有一个 标识符，某些 操作 也有。 该标识符通过声明中的 identifier 令牌确定：

• 对于 命名定义， 在 identifier 令牌紧接 interface、namespace、dictionary、enum 或 callback 关键字出现时确定该定义的标识符。

  interface interface_identifier { /* interface_members... */ };
    partial interface interface_identifier { /* interface_members... */ };
    namespace namespace_identifier { /* namespace_members... */ };
    partial namespace namespace_identifier { /* namespace_members... */ };
    dictionary dictionary_identifier { /* dictionary_members... */ };
    partial dictionary dictionary_identifier { /* dictionary_members... */ };
    enum enumeration_identifier { "enum", "values" /* , ... */ };
    callback callback_identifier = return_type (/* arguments... */);
    callback interface callback_interface_identifier { /* interface_members... */ };
    

• 对于 属性，类型定义 和 字典成员， 在声明末尾分号前的最终 identifier 令牌确定标识符。

  [extended_attributes]
    interface identifier {
      attribute type attribute_identifier;
    };
    
    typedef type typedef_identifier;
    
    dictionary identifier {
      type dictionary_member_identifier;
    };
    

• 对于 常量， 在等号之前的 identifier 令牌确定标识符。

  const type constant_identifier = 42;

• 对于 操作，在返回类型之后但在左括号之前出现的 identifier 令牌（即，与 OptionalOperationName 语法符号中的一部分匹配）决定该操作的标识符。如果没有这样的 identifier 令牌，则该操作没有标识符。

  interface interface_identifier {
      return_type operation_identifier(/* arguments... */);
    };
    

注意： 当用于声明 特殊类型的操作（如 getter 或 setter）时，操作可以没有标识符。

对于所有这些构造，标识符 是删除任何前导 U+005F (_) 后的 identifier 令牌的值。

注意： 前导 U+005F (_) 用于防止标识符看起来像保留字，例如，可以定义一个名为“interface”的接口。前导 U+005F (_) 会被删除以取消转义标识符。

操作参数可以采用稍微宽泛的标识符集。在操作声明中，参数的标识符在其类型之后立即指定，由 identifier 令牌或与 ArgumentNameKeyword 符号匹配的关键字之一表示。如果使用这些关键字之一，则无需使用前导下划线进行转义。

interface interface_identifier {
    return_type operation_identifier(argument_type argument_identifier /* , ... */);
  };
  

ArgumentNameKeyword ::
      async
      attribute
      callback
      const
      constructor
      deleter
      dictionary
      enum
      getter
      includes
      inherit
      interface
      iterable
      maplike
      mixin
      namespace
      partial
      readonly
      required
      setlike
      setter
      static
      stringifier
      typedef
      unrestricted
  

如果使用了 identifier 令牌，则操作参数的 标识符 是删除任何前导 U+005F (_) 后的该令牌的值。 如果使用的是 ArgumentNameKeyword 关键字令牌，则操作参数的 标识符 就是该令牌本身。

上述 IDL 构造的任何一个的 标识符（操作参数除外）不得为 "constructor"、 "toString" 或以 U+005F (_) 开头。这些被称为 保留标识符。

尽管 "toJSON" 标识符 不是 保留标识符， 但它必须仅用于将对象转换为 JSON 类型 的 常规操作，如 § 2.5.3.1 toJSON 所述。

注意： 某些构造的标识符名称可能在后续部分中有进一步限制。

在给定实现支持的 IDL 片段 集合中，每个 接口、命名空间、字典、枚举、回调函数、回调接口 和 类型定义 的 标识符 不得与任何其他 接口、命名空间、字典、枚举、回调函数、回调接口 或 类型定义 的标识符相同。

在 IDL 片段 中，对 定义 的引用无需出现在所引用定义的声明之后。引用也可以跨 IDL 片段 进行。

[Exposed=Window]
  interface B : A {
    undefined f(SequenceOfLongs x);
  };
  
  [Exposed=Window]
  interface A {
  };
  
  typedef sequence<long> SequenceOfLongs;
  

// Typedef identifier: "number"
  typedef double number;
  
  // Interface identifier: "System"
  [Exposed=Window]
  interface System {
  
    // Operation identifier:          "createObject"
    // Operation argument identifier: "interface"
    object createObject(DOMString _interface);
  
    // Operation argument identifier: "interface"
    sequence<object> getObjects(DOMString interface);
  
    // Operation has no identifier; it declares a getter.
    getter DOMString (DOMString keyName);
  };
  
  // Interface identifier: "TextField"
  [Exposed=Window]
  interface TextField {
  
    // Attribute identifier: "const"
    attribute boolean _const;
  
    // Attribute identifier: "value"
    attribute DOMString? _value;
  };
  

2.2. 接口

IDL 片段用于描述面向对象的系统。在这些系统中，对象是具有标识性并封装状态和行为的实体。接口是一个定义（匹配interface InterfaceRest），声明了一个实现该接口的对象将公开的某些状态和行为。

[extended_attributes]
  interface identifier {
    /* interface_members... */
  };
  

接口是 接口成员（匹配InterfaceMembers）的规范。这些成员是在接口声明的大括号之间出现的成员。

Web IDL 中的接口描述了实现该接口的对象的行为。在面向对象语言的绑定中，预计实现特定 IDL 接口的对象提供检查和修改对象状态以及调用接口描述的行为的方式。

接口可以定义为从另一个接口继承。如果接口的标识符后跟 U+003A (:) 和一个标识符，那么该标识符标识继承的接口。实现继承接口的对象也将实现该继承接口。因此，对象还将拥有与继承接口的接口成员相对应的成员。

interface identifier : identifier_of_inherited_interface {
    /* interface_members... */
  };
  

成员出现的顺序对JavaScript 绑定中的属性枚举具有重要意义。

接口可以指定一个与继承接口中的同名接口成员。实现派生接口的对象将在派生接口上公开该成员。是否可以在对象上访问被覆盖的成员取决于语言绑定的具体情况。

[Exposed=Window]
  interface A {
    undefined f();
    undefined g();
  };
  
  [Exposed=Window]
  interface B : A {
    undefined f();
    undefined g(DOMString x);
  };
  

[Object.prototype: the Object prototype object]
       ↑
  [A.prototype: interface prototype object for A]
       ↑
  [B.prototype: interface prototype object for B]
       ↑
  [instanceOfB]
  

给定接口A的继承接口是A直接或间接继承的所有接口的集合。如果A不从另一个接口继承，则集合为空。否则，集合包括A继承的接口B以及B的所有继承接口。

接口声明不得使其继承层次结构形成循环。即，接口A不能继承自它自身，也不能继承自继承自A的另一个接口B，等等。

请注意，一般的接口多重继承不被支持，且对象也不能实现任意集合的接口。可以定义对象来实现给定的单个接口A，这意味着它也实现了A的所有继承接口。此外，可以使用includes 语句来定义实现接口A的对象将始终包含A 接口混入的成员。

每个接口成员前可以有一个扩展属性列表（匹配ExtendedAttributeList），该属性可以控制接口成员在语言绑定中的处理方式。

[extended_attributes]
  interface identifier {
  
    [extended_attributes]
    const type constant_identifier = 42;
  
    [extended_attributes]
    attribute type identifier;
  
    [extended_attributes]
    return_type identifier(/* arguments... */);
  };
  

接口的 IDL 可以通过使用部分接口定义（匹配partial interface PartialInterfaceRest）拆分为多个部分。部分接口定义的标识符必须与接口定义的标识符相同。每个部分接口中出现的成员都被视为接口本身的成员。

interface SomeInterface {
    /* interface_members... */
  };
  
  partial interface SomeInterface {
    /* interface_members... */
  };
  

注意：部分接口定义旨在作为规范编辑辅助工具，允许将接口定义分散在文档的多个部分，有时甚至是多个文档中。

接口定义及其任何部分接口定义的出现顺序没有关系。

注意：部分接口定义不能指定接口继承自另一个接口。继承必须在原始接口定义中指定。

相关语言绑定决定接口如何对应于该语言中的结构。

以下扩展属性适用于接口：[CrossOriginIsolated]，[Exposed]，[Global]，[LegacyFactoryFunction]，[LegacyNoInterfaceObject]，[LegacyOverrideBuiltIns]，[LegacyWindowAlias]，以及[SecureContext]。

以下扩展属性适用于部分接口：[CrossOriginIsolated]，[Exposed]，[LegacyOverrideBuiltIns]，以及[SecureContext]。

接口必须使用[Exposed] 扩展属性进行注解。

CallbackOrInterfaceOrMixin ::
      callback CallbackRestOrInterface
      interface InterfaceOrMixin
  

InterfaceOrMixin ::
      InterfaceRest
      MixinRest
  

InterfaceRest ::
      identifier Inheritance { InterfaceMembers } ;
  

Partial ::
      partial PartialDefinition
  

PartialDefinition ::
      interface PartialInterfaceOrPartialMixin
      PartialDictionary
      Namespace
  

PartialInterfaceOrPartialMixin ::
      PartialInterfaceRest
      MixinRest
  

PartialInterfaceRest ::
      identifier { PartialInterfaceMembers } ;
  

InterfaceMembers ::
      ExtendedAttributeList InterfaceMember InterfaceMembers
      ε
  

InterfaceMember ::
      PartialInterfaceMember
      Constructor
  

PartialInterfaceMembers ::
      ExtendedAttributeList PartialInterfaceMember PartialInterfaceMembers
      ε
  

PartialInterfaceMember ::
      Const
      Operation
      Stringifier
      StaticMember
      Iterable
      AsyncIterable
      ReadOnlyMember
      ReadWriteAttribute
      ReadWriteMaplike
      ReadWriteSetlike
      InheritAttribute
  

Inheritance ::
      : identifier
      ε
  

[Exposed=Window]
  interface Animal {
    attribute DOMString name;
  };
  
  [Exposed=Window]
  interface Human : Animal {
    attribute Dog? pet;
  };
  
  [Exposed=Window]
  interface Dog : Animal {
    attribute Human? owner;
  };
  

[Exposed=Window]
  interface Node {
    readonly attribute DOMString nodeName;
    readonly attribute Node? parentNode;
    Node appendChild(Node newChild);
    undefined addEventListener(DOMString type, EventListener listener);
  };
  
  callback interface EventListener {
    undefined handleEvent(Event event);
  };
  

var node = getNode();                                // 获取 Node 实例。

  var listener = {
    handleEvent: function(event) {
      // ...
    }
  };
  node.addEventListener("click", listener);            // 这可以正常工作。

  node.addEventListener("click", function() { ... });  // 这也是可以的。
  

var node = getNode();  // 获取 Node 实例。

  var newNode = {
    nodeName: "span",
    parentNode: null,
    appendChild: function(newchild) {
      // ...
    },
    addEventListener: function(type, listener) {
      // ...
    }
  };
  node.appendChild(newNode);  // 这将抛出一个 TypeError 异常。
  

2.3. 接口混入

接口混入 是一个定义（匹配 interface 和 MixinRest），它声明了可以由一个或多个接口 包含的状态和行为，这些行为会通过实现接口并包含此接口混入的对象来公开。

interface mixin identifier {
    /* mixin_members... */
  };
  

注意：接口混入与部分接口类似，旨在作为规范编辑的工具，允许将一组功能归为一组，并在多个接口中包含，可能跨多个文档。它们不打算通过语言绑定暴露。有关何时选择部分接口、接口混入或部分接口混入的指导可以在§ 2.3.1 使用混入和部分接口中找到。

接口混入是常量、常规操作、常规属性和字符串化器的集合描述，它们是定义在接口混入声明中的。

这些常量、常规操作、常规属性和字符串化器描述了可以由对象实现的行为，就好像它们是由接口指定的一样，这些接口包含了这些混入。

与接口一样，接口混入的IDL可以通过使用部分接口混入定义分成多个部分（匹配 partial interface 和 MixinRest）。部分接口混入的标识符必须与其相应的接口混入相同。

interface mixin SomeMixin {
    /* mixin_members... */
  };
  
  partial interface mixin SomeMixin {
    /* mixin_members... */
  };
  

接口成员的出现顺序在JavaScript绑定中的属性枚举具有意义。

需要注意的是，与接口或字典不同，接口混入并不创建类型。

在本规范中定义的扩展属性中，只有[CrossOriginIsolated]、[Exposed]和[SecureContext]适用于接口混入。

包含语句 是一个定义（匹配 IncludesStatement），用于声明实现某个接口的所有对象必须额外包含指定的成员。

interface_identifier includes mixin_identifier;
  

第一个标识符必须引用一个接口I。第二个标识符必须引用一个接口混入M。

M的每个成员都被视为每个接口 I、J、K 等的成员，这些接口包含M，就好像每个成员都被复制了一样。因此，对于M的某个成员m，接口I被认为有一个成员m_I，接口J被认为有一个成员m_J，接口K被认为有一个成员m_K，以此类推。m_I、m_J 和 m_K 的宿主接口分别是I、J 和 K。

注意：在 JavaScript 中，这意味着每个作为成员声明的接口混入M的常规操作，并作为具有内置函数对象值的数据属性公开的，在每个包含混入M的接口的接口原型对象中都是一个独立的内置函数对象。同样，对于属性，每个访问器属性的副本都有独立的内置函数对象用于其获取器和设置器。

includes 声明的出现顺序会影响接口混入被其宿主接口 包含的顺序。

成员的顺序并没有明确规定，特别是当接口混入在不同文档中定义时。这在问题 #432中有所讨论。

本规范中定义的扩展属性不适用于includes 声明。

interface Entry {
    readonly attribute unsigned short entryType;
    // ...
  };
  
  interface mixin Observable {
    undefined addEventListener(DOMString type,
                          EventListener listener,
                          boolean useCapture);
    // ...
  };
  
  Entry includes Observable;
  

var e = getEntry();          // 获取一个 Entry 的实例。
  typeof e.addEventListener;   // 结果为 "function"。
  

CallbackOrInterfaceOrMixin ::
      callback CallbackRestOrInterface
      interface InterfaceOrMixin
  

InterfaceOrMixin ::
      InterfaceRest
      MixinRest
  

Partial ::
      partial PartialDefinition
  

PartialDefinition ::
      interface PartialInterfaceOrPartialMixin
      PartialDictionary
      Namespace
  

MixinRest ::
      mixin identifier { MixinMembers } ;
  

MixinMembers ::
      ExtendedAttributeList MixinMember MixinMembers
      ε
  

MixinMember ::
      Const
      RegularOperation
      Stringifier
      OptionalReadOnly AttributeRest
  

IncludesStatement ::
      identifier includes identifier ;
  

2.3.1. 使用 mixins 和 partials

本节是说明性的。

接口混入允许在多个 接口之间共享属性、常量和操作。如果你只打算扩展一个接口，可以考虑使用部分接口。

例如，不要这样做：

interface mixin WindowSessionStorage {
    readonly attribute Storage sessionStorage;
  };
  Window includes WindowSessionStorage;
  

可以这样做：

partial interface Window {
    readonly attribute Storage sessionStorage;
  };
  

此外，你还可以依赖其他规范中暴露的接口混入，以针对常见用例，如在窗口和工作线程上下文中暴露一组属性、常量或操作。

例如，与其使用常见但冗长的方式：

interface mixin GlobalCrypto {
    readonly attribute Crypto crypto;
  };
  
  Window includes GlobalCrypto;
  WorkerGlobalScope includes GlobalCrypto;
  

你可以使用部分接口混入扩展WindowOrWorkerGlobalScope 接口混入：

partial interface mixin WindowOrWorkerGlobalScope {
    readonly attribute Crypto crypto;
  };
  

2.4. 回调接口

回调接口是一个符合callback interface identifier { CallbackInterfaceMembers } ; 的定义。它可以由任何对象实现，如§ 2.12 实现接口的对象中描述的那样。

注意： 回调接口不是一个接口。其名称和语法来源于本标准的早期版本，当时这些概念有更多的共通点。

回调接口是对一组回调接口成员（符合CallbackInterfaceMembers）的规范。这些成员是在接口声明中的大括号之间出现的成员。

callback interface identifier {
    /* interface_members... */
  };

注意： 另请参阅类似名称的回调函数定义。

回调接口必须定义一个常规操作。

回调接口如果声明了常量，必须使用 [Exposed] 扩展属性进行注释。

CallbackRestOrInterface ::
      CallbackRest
      interface identifier { CallbackInterfaceMembers } ;
  

CallbackInterfaceMembers ::
      ExtendedAttributeList CallbackInterfaceMember CallbackInterfaceMembers
      ε
  

CallbackInterfaceMember ::
      Const
      RegularOperation
  

2.5. 成员

接口, 接口混入, 和 命名空间 是一组 成员 的规范（分别对应 InterfaceMembers, MixinMembers, 和 NamespaceMembers），这些成员是 常量, 属性, 操作, 以及声明之间的大括号内出现的其他声明。 属性 描述了实现 接口、 接口混入 或 命名空间 的对象将暴露的状态，操作 则描述了可以在该对象上调用的行为。常量 声明了命名的常量值，方便系统中的对象用户使用。

对于在 接口 或 接口混入 上定义的各种 成员，其 构造函数步骤、 getter 步骤、setter 步骤 和 方法步骤 可以访问 this 值，该值是 接口 类型的 IDL 值，其成员是在其声明中或 包含 接口混入 中声明的成员。

Setter 步骤 还可以访问 给定值， 该值是 属性 声明的类型的 IDL 值。

接口、接口混入、回调接口 和 命名空间 各自支持不同的 成员 集合， 其分别在 § 2.2 接口、§ 2.3 接口混入、§ 2.4 回调接口 和 § 2.6 命名空间 中规定，并在以下信息表中总结：

2.5.1. 常量

常量 是一个声明（对应 Const），用于将常量值绑定到名称。 常量可以出现在 接口 和 回调接口 上。

过去常量主要用于以枚举方式定义命名的整数代码。Web 平台正在逐步远离这种设计模式，转而使用字符串。 编辑希望使用此功能时，强烈建议在继续之前通过 提交问题 进行讨论。

const type constant_identifier = 42;

标识符不能与另一个定义在相同 接口 或 回调接口 上的 接口成员 或 回调接口成员 的标识符相同。 此外，标识符不能为 "length", "name" 或 "prototype"。

注意： 这三个名称是 JavaScript 语言绑定中定义在 接口对象 上的属性名称。

常量的类型（对应 ConstType）不能是除 原始类型 以外的任何类型。 如果使用了 标识符，它必须引用一个其类型为原始类型的 typedef。

常量声明的 ConstValue 部分给出了常量的值，可以是两个布尔字面量标记之一（true 和 false），一个 整数 标记， 一个 小数 标记， 或三个特殊的浮点常量值之一（-Infinity, Infinity 和 NaN）。

注意： 除了字符串和空序列之外，这些值还可用于指定 字典成员的默认值 或 可选参数的默认值。 请注意，字符串、空序列 [] 和默认字典 {} 不能用作 常量 的值。

布尔字面量标记 true 和 false 的值是 IDL 中的 boolean 值 true 和 false。

常量值为 Infinity, -Infinity 或 NaN 时，该值为 IEEE 754 单精度或双精度浮点数，具体取决于常量、字典成员或可选参数的类型：

类型 无限制浮点数，常量值 Infinity

值为 IEEE 754 单精度正无穷大值。

类型 无限制双精度浮点数，常量值 Infinity

值为 IEEE 754 双精度正无穷大值。

类型 无限制浮点数，常量值 -Infinity

值为 IEEE 754 单精度负无穷大值。

类型 无限制双精度浮点数，常量值 -Infinity

值为 IEEE 754 双精度负无穷大值。

类型 无限制浮点数，常量值 NaN

值为 IEEE 754 单精度 NaN 值，位模式为 0x7fc00000。

类型 无限制双精度浮点数，常量值 NaN

值为 IEEE 754 双精度 NaN 值，位模式为 0x7ff8000000000000。

小数 标记的类型与其作为常量、字典成员或可选参数值的类型相同。 小数 标记的值不得超出其类型的有效值范围，如 § 2.13 类型 中所述。 同时，Infinity、-Infinity 和 NaN 不得 用作 float 或 double 的值。

null 标记的值是 null 的特殊值，它是 可为空类型 的成员。 null 标记的类型与其作为常量、字典成员或可选参数值的类型相同。

如果 VT 是分配给常量的值的类型，DT 是常量、字典成员或可选参数本身的类型，那么这些类型必须 兼容，兼容的情况是 DT 和 VT 相同， 或者 DT 是其 内部类型 为 VT 的 可为空类型。

常量 与出现在它们上的特定 接口 或 回调接口 的实例无关。是否在实例上暴露 常量 取决于语言绑定。

[Exposed=Window]
  interface A {
    const short rambaldi = 47;
  };
  

以下扩展属性适用于常量： [CrossOriginIsolated], [Exposed] 和 [SecureContext]。

Const ::
      const ConstType identifier = ConstValue ;
  

ConstValue ::
      布尔字面量
      浮点字面量
      整数
  

布尔字面量 ::
      true
      false
  

浮点字面量 ::
      小数
      -Infinity
      Infinity
      NaN
  

ConstType ::
      原始类型
      标识符
  

[Exposed=Window]
  interface Util {
    const boolean DEBUG = false;
    const octet LF = 10;
    const unsigned long BIT_MASK = 0x0000fc00;
    const double AVOGADRO = 6.022e23;
  };
  

2.5.2. 属性

属性 是一个 接口成员 或 命名空间成员（对应 inherit AttributeRest，static OptionalReadOnly AttributeRest，stringifier OptionalReadOnly AttributeRest， 或 AttributeRest）， 用于声明具有给定类型和 标识符 的数据字段，其值可以被检索，并且（在某些情况下）可以更改。属性有两种类型：

1. 常规属性，用于声明实现 接口 的对象将拥有带有给定 标识符 的数据字段成员。

   interface interface_identifier {
       attribute type identifier;
     };
     

2. 静态属性，用于声明与实现接口的特定对象无关的属性。

   interface interface_identifier {
       static attribute type identifier;
     };
     

如果属性没有 static 关键字，则声明一个 常规属性。否则，它声明为 静态属性。请注意，除了作为 接口成员 外，只读 的 常规属性 也可以是 命名空间成员。

属性 attr 的 getter 步骤 应以类似“attr getter 步骤如下：”的文字介绍，后跟列表，或以“attr getter 步骤是”开头，后跟内联描述。

属性 attr 的 setter 步骤 应以类似“attr setter 步骤如下：”的文字介绍，后跟列表，或以“attr setter 步骤是”开头，后跟内联描述。

注意： 定义 getter 步骤 时，隐式访问 this。 定义 setter 步骤 时，隐式访问 this 和 给定值。

属性的 标识符不得与相同 接口 上定义的另一个 接口成员 的标识符相同。 静态属性的标识符不得为 "prototype"。

属性的类型由出现在 attribute 关键字之后的类型（对应 Type）给出。 如果 Type 是 标识符 或后接 ? 的标识符， 则标识符必须标识一个 接口、枚举、回调函数、回调接口 或 typedef。

在解析 typedef 后，属性的类型不能是以下任何类型的 可为空 或不可为空的版本：

• 序列类型

• 一个异步可迭代类型

• 字典类型

• 记录类型

• 包含可为空或不可为空序列类型、字典或记录作为其 扁平成员类型 之一的 联合类型

如果在 attribute 关键字之前使用 readonly 关键字，则属性是 只读 的。 实现了定义了只读属性的接口的对象不允许对该属性赋值。 是否仅由语言禁止赋值，忽略赋值还是抛出异常，取决于语言绑定。

interface interface_identifier {
    readonly attribute type identifier;
  };
  

类型为 Promise 类型 的属性必须是 只读 的。此外，它们不能拥有 以下任何 扩展属性：[LegacyLenientSetter]， [PutForwards]， [Replaceable]， 或 [SameObject]。

非 只读 的 常规属性 可以声明为从祖先接口继承其 getter。 这可以用于使祖先接口中的只读属性在派生接口上可写。 如果声明中包含 inherit，则属性 继承其 getter。 继承其 getter 的属性是与定义继承属性的接口最接近的祖先接口上具有相同标识符的属性。 被继承 getter 的属性必须与继承属性的类型相同。

注意： 语法确保 inherit 不会出现在 只读 属性或 静态属性 上。

[Exposed=Window]
  interface Ancestor {
    readonly attribute TheType theIdentifier;
  };
  
  [Exposed=Window]
  interface Derived : Ancestor {
    inherit attribute TheType theIdentifier;
  };
  

当在 常规属性 声明中使用 stringifier 关键字时，它表明实现接口的对象将被转换为该属性的值。 详情见 § 2.5.5 Stringifiers。

interface interface_identifier {
    stringifier attribute DOMString identifier;
  };
  

以下 扩展属性 适用于常规和静态属性： [CrossOriginIsolated]， [Exposed]， [SameObject]， 和 [SecureContext]。

以下 扩展属性 仅适用于常规属性： [LegacyLenientSetter]， [LegacyLenientThis]， [PutForwards]， [Replaceable]， [LegacyUnforgeable]。

ReadOnlyMember ::
      readonly ReadOnlyMemberRest
  

ReadOnlyMemberRest ::
      AttributeRest
      MaplikeRest
      SetlikeRest
  

ReadWriteAttribute ::
      AttributeRest
  

InheritAttribute ::
      inherit AttributeRest
  

AttributeRest ::
      attribute TypeWithExtendedAttributes AttributeName ;
  

AttributeName ::
      AttributeNameKeyword
      identifier
  

AttributeNameKeyword ::
      async
      required
  

OptionalReadOnly ::
      readonly
      ε
  

[Exposed=Window]
  interface Animal {
  
    // 一个可以设置为任何字符串值的简单属性。
    readonly attribute DOMString name;
  
    // 一个属性，其值可以被分配。
    attribute unsigned short age;
  };
  
  [Exposed=Window]
  interface Person : Animal {
  
    // 一个从 Animal 继承 getter 行为的属性，不需要在 Person 的描述中指定。
    inherit attribute DOMString name;
  };
  

2.5.3. 操作

一个操作是一个接口成员、回调接口成员或命名空间成员（匹配 static RegularOperation、 stringifier、RegularOperation 或 SpecialOperation）， 它定义了一种可以在实现该接口的对象上调用的行为。 操作有三种类型：

1. 常规操作， 用于声明实现 接口 的对象将拥有具有给定 标识符 的方法。

   interface interface_identifier {
       return_type identifier(/* arguments... */);
     };
     

2. 特殊操作， 用于在实现接口的对象上声明特殊行为，例如对象索引和字符串化

   interface interface_identifier {
       /* special_keyword */ return_type identifier(/* arguments... */);
       /* special_keyword */ return_type (/* arguments... */);
     };
     

3. 静态操作， 用于声明与实现接口的特定对象无关的操作。

   interface interface_identifier {
       static return_type identifier(/* arguments... */);
     };
     

如果一个操作有标识符但没有 static 关键字，则声明一个 常规操作。 如果操作的声明中使用了 特殊关键字（即，任何匹配 Special 的关键字，或 stringifier 关键字）， 则声明为特殊操作。一个操作可以同时声明为常规操作和特殊操作； 详情见 § 2.5.6 特殊操作。 请注意，除了作为 接口成员 外， 常规操作也可以是 回调接口成员 和 命名空间成员。

如果操作没有标识符， 则必须使用其中一个特殊关键字将其声明为特殊操作。

常规操作 或 静态操作 的标识符不得与在相同 接口、回调接口 或 命名空间 上定义的 常量 或 属性 的标识符相同。 静态操作的标识符不得为 "prototype"。

注意： 然而，标识符可以与接口上其他操作的标识符相同。 这是指定操作重载的方式。

注意： 静态操作 的标识符可以与在相同 接口 上定义的 常规操作 的标识符相同。

操作的 返回类型 由 出现在操作的可选 标识符 之前的类型（对应 Type）给出。 如果返回类型是后接 ? 的 标识符， 则该标识符必须标识 接口、字典、枚举、回调函数、回调接口 或 typedef。

操作的参数（对应 ArgumentList） 在声明中的括号内给出。每个参数都由一个类型（对应 Type）后跟一个 标识符（对应 ArgumentName）指定。

注意： 为了表达的灵活性，操作参数的标识符还可以指定为 匹配 ArgumentNameKeyword 符号的关键字之一，无需转义。

如果操作参数的 Type 是后接 ? 的标识符， 则该标识符必须标识 接口、枚举、回调函数、回调接口， 或 typedef。 如果操作参数的类型是未后接 ? 的 标识符，则该标识符必须标识其中任何一个定义，或 字典。

如果操作参数的类型在解析 typedef 后， 是 可为空类型， 则其 内部类型 不能是 字典类型。

interface interface_identifier {
    return_type identifier(type identifier, type identifier /* , ... */);
  };
  

每个参数的标识符不得与相同操作声明中的其他参数标识符相同。

每个参数可以有一个前置的 扩展属性 列表（对应 ExtendedAttributeList）， 用于控制传递给语言绑定的参数值的处理方式。

interface interface_identifier {
    return_type identifier([extended_attributes] type identifier, [extended_attributes] type identifier /* , ... */);
  };
  

[Exposed=Window]
  interface Dimensions {
    attribute unsigned long width;
    attribute unsigned long height;
  };
  
  [Exposed=Window]
  interface Button {
  
    // 一个不带参数并返回布尔值的操作。
    boolean isMouseOver();
  
    // 重载的操作。
    undefined setDimensions(Dimensions size);
    undefined setDimensions(unsigned long width, unsigned long height);
  };
  

操作或 构造器操作 被视为 可变参数，如果最后一个参数使用 ... 标记紧跟在参数类型之后。声明操作为可变参数表示在调用该操作时可以在最后一个参数之后传递任意数量的参数。那些额外的隐含形式参数与操作声明中的最后一个显式参数类型相同。在调用操作时，最后一个参数也可以省略。操作的参数声明中，除非是最后一个参数，否则不得使用 ... 标记。

interface interface_identifier {
    return_type identifier(type... identifier);
    return_type identifier(type identifier, type... identifier);
  };

扩展属性 使用参数列表的情况（例如 [LegacyFactoryFunction]）和 回调函数，当其参数列表中使用 ... 标记时，也视为 可变参数。

[Exposed=Window]
  interface IntegerSet {
    readonly attribute unsigned long cardinality;
  
    undefined union(long... ints);
    undefined intersection(long... ints);
  };
  

var s = getIntegerSet();  // 获取 IntegerSet 的实例。
  
  s.union();                // 不传递与 'ints' 对应的参数。
  s.union(1, 4, 7);         // 传递三个与 'ints' 对应的参数。
  

如果参数使用了 optional 关键字，则被认为是 可选参数。可变参数操作的最后一个参数也被视为可选参数。声明一个参数为可选表示在调用操作时可以省略该参数的值。可变参数操作的最后一个参数不能明确声明为可选。

interface interface_identifier {
    return_type identifier(type identifier, optional type identifier);
  };

可选参数还可以有 默认值。如果参数的标识符后跟 U+003D (=) 和一个值（对应 DefaultValue），则该值为该可选参数的 默认值。可变参数操作的隐式可选最后一个参数不能指定默认值。当调用操作时，如果省略了相应的参数，则将假定使用默认值。

interface interface_identifier {
    return_type identifier(type identifier, optional type identifier = "value");
  };

强烈建议不要为 boolean 类型的参数使用默认值 true，因为这可能会让作者感到困惑，他们可能期望默认转换 undefined 被使用（即 false）。[API-DESIGN-PRINCIPLES]

如果参数的类型是 字典类型 或 联合类型，且其具有 字典类型 作为其 展平的成员类型之一，并且该字典类型及其祖先没有 必需 成员，并且该参数是最后一个参数或后面仅跟有 可选参数，则该参数必须指定为可选并提供默认值。

当布尔文字标记（true 或 false），null 标记，一个 整数 标记，一个 小数 标记或三个特殊浮点文字值之一（Infinity、-Infinity 或 NaN）用作 默认值 时，其解释方式与 常量 的解释方式相同。

当 undefined 标记被用作 默认值 时，其值为 IDL undefined 值。

如果 可选参数 的类型是 枚举类型，则其 默认值，如果指定，必须是 枚举的值之一。

可选参数的默认值还可以使用两个标记值 [] 指定，表示空序列值。该值的类型与用作其默认值的可选参数的类型相同。该类型必须是 序列类型，一个 可空类型，其 内部类型 是 序列类型，或是 联合类型 或具有 可空联合类型，且其中一个展平成员类型是 序列类型。

可选参数默认值也可以使用双标记值 {} 来指定，它表示一个默认初始化的（如同来自 ES null 或没有属性的对象）字典值。此值的类型与其用作默认值的可选参数的类型相同。该类型必须是一个字典类型，或一个在其扁平化成员类型中具有字典类型的联合类型。

[Exposed=Window]
  interface ColorCreator {
    object createColor(double v1, double v2, double v3, optional double alpha);
  };
  

[Exposed=Window]
  interface ColorCreator {
    object createColor(double v1, double v2, double v3);
    object createColor(double v1, double v2, double v3, double alpha);
  };
  

dictionary LookupOptions {
    boolean caseSensitive = false;
  };
  
  [Exposed=Window]
  interface AddressBook {
    boolean hasAddressForName(USVString name, optional LookupOptions options = {});
  };
  

以下扩展属性适用于操作：[CrossOriginIsolated]，[Default]，[Exposed]，[LegacyUnforgeable]，[NewObject]，和 [SecureContext]。

一个操作 operation 的 方法步骤 应使用如下格式的文本引入：“operation(arg1, arg2, ...) 方法步骤如下：”后跟一个列表，或者“operation(arg1, arg2, ...) 方法步骤是为了”后跟一个内联描述。

注意：在定义 方法步骤 时，隐式地可以访问 this。

DefaultValue ::
      ConstValue
      string
      [ ]
      { }
      null
      undefined
  

Operation ::
      RegularOperation
      SpecialOperation
  

RegularOperation ::
      Type OperationRest
  

SpecialOperation ::
      Special RegularOperation
  

Special ::
      getter
      setter
      deleter
  

OperationRest ::
      OptionalOperationName ( ArgumentList ) ;
  

OptionalOperationName ::
      OperationName
      ε
  

OperationName ::
      OperationNameKeyword
      identifier
  

OperationNameKeyword ::
      includes
  

ArgumentList ::
      Argument Arguments
      ε
  

Arguments ::
      , Argument Arguments
      ε
  

Argument ::
      ExtendedAttributeList ArgumentRest
  

ArgumentRest ::
      optional TypeWithExtendedAttributes ArgumentName Default
      Type Ellipsis ArgumentName
  

ArgumentName ::
      ArgumentNameKeyword
      identifier
  

Ellipsis ::
      ...
      ε
  

ArgumentNameKeyword ::
      async
      attribute
      callback
      const
      constructor
      deleter
      dictionary
      enum
      getter
      includes
      inherit
      interface
      iterable
      maplike
      mixin
      namespace
      partial
      readonly
      required
      setlike
      setter
      static
      stringifier
      typedef
      unrestricted
  

2.5.3.1. toJSON

通过声明一个 toJSON 常规操作， 一个 接口 指定了如何将实现它的对象转换为 JSON 类型。

toJSON 常规操作 保留用于此用途。 它必须不带参数并返回 JSON 类型。

JSON 类型包括：

• 数值类型,

• 布尔类型,

• 字符串类型,

• 可为空类型，其内部类型是 JSON 类型,

• 带注释的类型，其 内部类型 是 JSON 类型,

• 联合类型，其 成员类型 是 JSON 类型,

• 类型定义，其 被命名的新类型 是 JSON 类型,

• 序列类型，其参数化类型是 JSON 类型,

• 冻结数组类型，其参数化类型是 JSON 类型,

• 字典类型，其中字典和所有 继承的字典 中声明的所有成员的类型都是 JSON 类型,

• 记录类型，其中所有的 值 都是 JSON 类型,

• 对象,

• 接口类型，这些接口类型声明了 toJSON 操作，或在它们的 继承的接口 上声明了。

toJSON 常规操作 在语言绑定中如何在对象上可用，以及 JSON 类型 如何精确地转换为 JSON 字符串，取决于具体的语言绑定。

注意：在 JavaScript 语言绑定中，这通过暴露一个 toJSON 方法来实现， 该方法返回转换为 JavaScript 值的 JSON 类型， 该值可以通过 JSON.stringify() 函数转化为 JSON 字符串。 此外，在 JavaScript 语言绑定中， toJSON 操作可以带有 [Default] 扩展属性， 在这种情况下，默认的 toJSON 步骤 将被暴露。

[Exposed=Window]
  interface Transaction {
    readonly attribute DOMString from;
    readonly attribute DOMString to;
    readonly attribute double amount;
    readonly attribute DOMString description;
    readonly attribute unsigned long number;
    TransactionJSON toJSON();
  };
  
  dictionary TransactionJSON {
    Account from;
    Account to;
    double amount;
    DOMString description;
  };
  

// 获取一个 Transaction 实例。
  var txn = getTransaction();

  // 结果评估为类似这样的对象：
  // {
  //   from: "Bob",
  //   to: "Alice",
  //   amount: 50,
  //   description: "books"
  // }
  txn.toJSON();

  // 结果评估为类似这样的字符串：
  // '{"from":"Bob","to":"Alice","amount":50,"description":"books"}'
  JSON.stringify(txn);
  

2.5.4. 构造操作

如果一个 接口 具有 构造操作 成员（匹配 Constructor），这表明可以使用 构造函数 创建实现该 接口 的对象。

在一个 接口 上可以出现多个 构造操作。 对于该 接口 上的每个 构造操作，将有一种方式通过传递指定的参数来尝试构造实例。

名为 interface 的接口的构造操作的 构造步骤应使用如下形式的文本引入：“new interface(arg1, arg2, ...) 构造步骤如下：”，然后跟一个列表，或者“new interface(arg1, arg2, ...) 构造步骤是”后跟内联描述。

构造步骤必须不做任何操作，初始化作为 this 传递的值，或者抛出异常。

如果构造函数没有初始化 this，可以写作：“new Example(init) 构造步骤是不做任何操作。”

有关如何实现 构造操作 的详细信息，请参见 § 3.7.1 接口对象。

[Exposed=Window]
  interface NodeList {
    Node item(unsigned long index);
    readonly attribute unsigned long length;
  };
  
  [Exposed=Window]
  interface Circle {
    constructor();
    constructor(double radius);
    attribute double r;
    attribute double cx;
    attribute double cy;
    readonly attribute double circumference;
  };
  

var x = new Circle();      // 这使用零参数构造函数创建了
                             // 一个实现 Circle 接口的平台对象的引用。

  var y = new Circle(1.25);  // 这次使用一个参数构造函数创建了一个 Circle 对象。

  var z = new NodeList();    // 这会抛出一个 TypeError，因为没有
                             // 声明构造函数。
  

Constructor ::
      constructor ( ArgumentList ) ;
  

ArgumentList ::
      Argument Arguments
      ε
  

Arguments ::
      , Argument Arguments
      ε
  

Argument ::
      ExtendedAttributeList ArgumentRest
  

ArgumentRest ::
      optional TypeWithExtendedAttributes ArgumentName Default
      Type Ellipsis ArgumentName
  

ArgumentName ::
      ArgumentNameKeyword
      identifier
  

Ellipsis ::
      ...
      ε
  

ArgumentNameKeyword ::
      async
      attribute
      callback
      const
      constructor
      deleter
      dictionary
      enum
      getter
      includes
      inherit
      interface
      iterable
      maplike
      mixin
      namespace
      partial
      readonly
      required
      setlike
      setter
      static
      stringifier
      typedef
      unrestricted
  

2.5.5. 字符串化

当一个 接口 具有 stringifier 时， 这表示实现该接口的对象具有非默认的字符串转换。Stringifier 可以通过使用 stringifier 关键字来指定，当单独使用时，会创建一个字符串化操作。

interface interface_identifier {
    stringifier;
  };
  

与接口相关的文本必须定义接口的 字符串化行为。

stringifier 关键字也可以放置在 属性 上。 在这种情况下，将对象转换为字符串的值是该属性的值。stringifier 关键字不得放置在属性上，除非 它被声明为类型 DOMString 或 USVString。 它也不得放置在 静态属性 上。

interface interface_identifier {
    stringifier attribute DOMString identifier;
  };
  

在给定的 接口 上，最多只能存在一个 stringifier。

Stringifier ::
      stringifier StringifierRest
  

StringifierRest ::
      OptionalReadOnly AttributeRest
      ;
  

[Exposed=Window]
  interface Student {
    constructor();
    attribute unsigned long id;
    stringifier attribute DOMString name;
  };
  

var s = new Student();
  s.id = 12345678;
  s.name = '周杰倫';

  var greeting = 'Hello, ' + s + '!';  // 现在 greeting == 'Hello, 周杰倫!'。
  

[Exposed=Window]
  interface Student {
    constructor();
    attribute unsigned long id;
    attribute DOMString? familyName;
    attribute DOMString givenName;

    stringifier;
  };
  

var s = new Student();
  s.id = 12345679;
  s.familyName = 'Smithee';
  s.givenName = 'Alan';

  var greeting = 'Hi ' + s;  // 现在 greeting == 'Hi Alan Smithee'。
  

2.5.6. 特殊操作

特殊操作 是在实现接口的对象上声明某种特殊行为的声明，这些特殊操作声明出现在该接口上。通过在操作声明中使用 特殊关键字 来声明特殊操作。

特殊操作有三种类型。下表列出了给定的特殊操作类型所使用的特殊关键字以及该特殊操作的目的：

并非所有语言绑定都支持所有这四种特殊对象行为。当使用没有标识符的操作声明特殊操作时，在不支持这些特殊操作的语言绑定中，此类功能将不会被实现。

[Exposed=Window]
  interface Dictionary {
    readonly attribute unsigned long propertyCount;
  
    getter double (DOMString propertyName);
    setter undefined (DOMString propertyName, double propertyValue);
  };
  

定义一个带有 标识符 的特殊操作等同于将该特殊操作分离为独立的、没有标识符的声明。这种方法被允许简化接口操作的 方法步骤。

[Exposed=Window]
  interface Dictionary {
    readonly attribute unsigned long propertyCount;
  
    getter double getProperty(DOMString propertyName);
    setter undefined setProperty(DOMString propertyName, double propertyValue);
  };
  

[Exposed=Window]
  interface Dictionary {
    readonly attribute unsigned long propertyCount;
  
    double getProperty(DOMString propertyName);
    undefined setProperty(DOMString propertyName, double propertyValue);
  
    getter double (DOMString propertyName);
    setter undefined (DOMString propertyName, double propertyValue);
  };
  

一个给定的 特殊关键字不能在一个操作上出现两次。

取值器和赋值器有两种类型：一种是使用 DOMString 作为属性名，称为 命名属性取值器 和 命名属性赋值器，另一种是使用 unsigned long 作为属性索引，称为 索引属性取值器 和 索引属性赋值器。删除器只有一种类型：命名属性删除器。详情请参阅 § 2.5.6.1 索引属性 和 § 2.5.6.2 命名属性。

在给定的 接口 上，最多只能有一个 命名属性删除器，以及每种类型的取值器和赋值器各一个。

如果一个接口具有某种类型的赋值器，则它必须也具有该类型的取值器。如果它具有 命名属性删除器，则它必须也具有 命名属性取值器。

使用操作声明的特殊操作不得是 可变参数，也不得有任何 可选参数。

如果一个对象实现了多个定义相同特殊操作的 接口，则无法确定将调用哪个（如果有的话）特殊操作。

2.5.6.1. 索引属性

定义了 索引属性取值器 的 接口 被认为 支持索引属性。 由此扩展，如果 平台对象 实现了 接口，则该对象被认为 支持索引属性。

如果一个接口 支持索引属性，那么该接口定义必须附带描述对象在任何给定时间可以使用哪些索引来进行索引操作的描述。这些索引称为 支持的属性索引。

支持索引属性的接口必须定义一个名为 "length" 的 整数类型 属性。

索引属性取值器必须声明为接受一个 unsigned long 参数。 索引属性赋值器必须声明为接受两个参数，其中第一个参数是 unsigned long。

interface interface_identifier {
    getter type identifier(unsigned long identifier);
    setter type identifier(unsigned long identifier, type identifier);
  
    getter type (unsigned long identifier);
    setter type (unsigned long identifier, type identifier);
  };
  

以下要求适用于索引属性取值器和赋值器的定义：

• 如果通过带有 标识符 的 操作 指定了 索引属性取值器，则使用给定 支持的属性索引 对对象进行索引时返回的值应是调用该操作并传递该索引作为唯一参数的结果。如果用于声明索引属性取值器的操作没有标识符，则接口定义必须附带如何为给定索引 确定索引属性的值 的描述。

• 如果通过带有标识符的操作指定了 索引属性赋值器，则对对象进行属性赋值时的行为与调用该操作并传递索引作为第一个参数、值作为第二个参数时的行为相同。如果用于声明索引属性赋值器的操作没有标识符，则接口定义必须附带如何为给定属性索引和值 设置现有索引属性的值 以及如何 设置新索引属性的值 的描述。

[Exposed=Window]
  interface A {
    getter DOMString toWord(unsigned long index);
  };
  

var a = getA();
  
  a.toWord(0);  // 返回 "zero".
  a[0];         // 也返回 "zero".
  
  a.toWord(5);  // 返回 "five".
  a[5];         // 返回 undefined，因为没有名为 "5" 的属性。
  

[Exposed=Window]
  interface OrderedMap {
    readonly attribute unsigned long size;
  
    getter any getByIndex(unsigned long index);
    setter undefined setByIndex(unsigned long index, any value);
  
    getter any get(DOMString name);
    setter undefined set(DOMString name, any value);
  };
  

// 假设 map 是一个实现了 OrderedMap 接口的传统平台对象。
  var map = getOrderedMap();
  var x, y;

  x = map[0];       // 如果 map.length > 0，则等效于：
                    //
                    //   x = map.getByIndex(0)
                    //
                    // 因为一个名为 "0" 的属性将被添加到 map 上。
                    // 否则，x 将被设置为 undefined，因为 map 上没有名为 "0" 的属性。

  map[1] = false;   // 这将等效于：
                    //
                    //   map.setByIndex(1, false)

  y = map.apple;    // 如果存在名为 "apple" 的属性，则这将等效于：
                    //
                    //   y = map.get('apple')
                    //
                    // 因为一个名为 "apple" 的属性将被添加到 map 上。否则，y 将被设置为 undefined，因为 map 上没有名为 "apple" 的属性。

  map.berry = 123;  // 这将等效于：
                    //
                    //   map.set('berry', 123)

  delete map.cake;  // 如果存在名为 "cake" 的属性，则将删除 "cake" 属性，然后执行以下操作的等效操作：
                    //
                    //   map.remove("cake")
  

2.5.6.2. 命名属性

定义了 命名属性 getter 的 接口 称为 支持命名属性。 拓展来说，实现了 接口 的 平台对象 也称为 支持命名属性。

如果一个接口 支持命名属性， 那么该接口的定义必须附带描述该对象在任何给定时间可用于索引的名称的有序集合。 这些名称称为 受支持的属性名称。

命名属性 getter 和 deleter 必须声明只接受一个 DOMString 参数。 命名属性 setter 必须声明接受两个参数，其中第一个是 DOMString。

interface interface_identifier {
    getter type identifier(DOMString identifier);
    setter type identifier(DOMString identifier, type identifier);
    deleter type identifier(DOMString identifier);
  
    getter type (DOMString identifier);
    setter type (DOMString identifier, type identifier);
    deleter type (DOMString identifier);
  };
  

以下要求适用于命名属性 getter、setter 和 deleter 的定义：

• 如果 命名属性 getter 是使用带有 标识符 的 操作 指定的， 那么当使用给定的 受支持的属性名称 对象进行索引时返回的值与调用操作返回的值相同，将名称作为其唯一参数传递。 如果用于声明命名属性 getter 的操作没有标识符，则接口定义必须附带描述如何为给定的属性名称 确定命名属性的值 的描述。

• 如果 命名属性 setter 是使用带有标识符的操作指定的， 那么当使用给定的受支持属性名称和值对对象进行索引以进行属性赋值时发生的行为与调用操作时相同，将名称作为第一个参数，将值作为第二个参数传递。 如果用于声明命名属性 setter 的操作没有标识符，则接口定义必须附带描述如何 设置现有命名属性的值 以及如何 为给定的属性名称和值 设置新命名属性的值。

• 如果 命名属性 deleter 是使用带有标识符的操作指定的， 那么当使用给定的受支持属性名称对对象进行索引以删除属性时发生的行为与调用操作时相同，将名称作为唯一参数传递。 如果用于声明命名属性 deleter 的操作没有标识符，则接口定义必须附带描述如何为给定的属性名称 删除现有命名属性。

注意：与 索引属性 类似， 如果 命名属性 getter、setter 或 deleter 是使用带有 标识符 的 操作 指定的， 那么使用不属于 受支持的属性名称 的名称对对象进行索引的行为不一定与调用该名称的操作时的行为相同；此行为是语言绑定特定的。

2.5.7. 静态属性和操作

静态属性 和 静态操作 是那些 不与声明其上的 接口 的特定实例相关联的，而是与接口本身相关联的属性和操作。静态属性和操作通过在声明中使用 static 关键字来声明。

是否可以通过接口实例的引用调用静态操作或获取或设置静态属性取决于语言绑定的具体实现。

StaticMember ::
  static StaticMemberRest

StaticMemberRest ::
  OptionalReadOnly AttributeRest
  RegularOperation

[Exposed=Window]
  interface Point { /* ... */ };
  
  [Exposed=Window]
  interface Circle {
    attribute double cx;
    attribute double cy;
    attribute double radius;
  
    static readonly attribute long triangulationCount;
    static Point triangulate(Circle c1, Circle c2, Circle c3);
  };
  

var circles = getCircles();           // Circle 对象的数组
  
  typeof Circle.triangulate;            // 计算结果为 "function"
  typeof Circle.triangulationCount;     // 计算结果为 "number"
  Circle.prototype.triangulate;         // 计算结果为 undefined
  Circle.prototype.triangulationCount;  // 计算结果同样为 undefined
  circles[0].triangulate;               // 也是 undefined
  circles[0].triangulationCount;        // 也是 undefined
  
  // 调用静态操作
  var triangulationPoint = Circle.triangulate(circles[0], circles[1], circles[2]);
  
  // 查找我们已经完成了多少次三角剖分
  window.alert(Circle.triangulationCount);
  

2.5.8. 重载

如果一个定义在 接口 上的 常规操作 或 静态操作 的 标识符 与该接口上的其他同类操作（常规或静态）的标识符相同， 则该操作被称为 重载。 当使用重载操作的标识符调用实现该接口的对象上的操作时，传递给操作的参数数量和类型决定了实际调用的重载操作。 构造函数操作 也可以被重载。 对于重载操作和构造函数可以指定的参数有一些限制，为了描述这些限制，使用了“有效重载集”的概念。

一组重载的 操作 必须满足以下条件之一：

• 不包含任何返回类型为 promise 类型 的操作；

• 仅包含返回类型为 promise 类型 的操作。

操作 不能在 接口、部分接口、接口混入 和 部分接口混入 定义之间被重载。

[Exposed=Window]
  interface A {
    undefined f();
  };
  
  partial interface A {
    undefined f(double x);
    undefined g();
  };
  
  partial interface A {
    undefined g(DOMString x);
  };
  

一个 有效重载集 表示特定 操作、构造函数（由 构造函数操作 或 [LegacyFactoryFunction] 指定）或 回调函数 的允许调用。 用于 计算有效重载集 的算法 针对以下四种 IDL 构造之一进行操作，下面列出的是计算集时需要的输入：

对于常规操作

对于静态操作

• 要查找 操作 的 接口

• 操作的 标识符

• 要传递的参数数量

对于构造函数

• 要查找 构造函数操作 的 接口

• 要传递的参数数量

对于遗留工厂函数

• 要查找 [LegacyFactoryFunction] 扩展属性的 接口

• 遗留工厂函数的 标识符

• 要传递的参数数量

一个有效的重载集用于确定在接口上指定的重载操作和构造函数是否存在歧义等。

有效重载集的项目是形式为 (可调用, 类型列表, 可选性列表) 的元组，其项目描述如下：

• 可调用项 是一个 操作，如果 有效重载集 是针对 常规操作、 静态操作，或 构造函数操作；如果是针对 遗留工厂函数 的 有效重载集，则为 扩展属性。

• 类型列表 是一个 IDL 类型的 列表。

• 可选性列表 是一个 列表，其包含三种可能的 可选性值 ——“必需的”、“可选的”或“可变参数的”， 指示在给定索引处的参数是被声明为 可选的，还是 对应于 可变参数。

每个 元组 代表操作、构造函数或回调函数的一个允许调用， 其参数值列表为给定类型。由于使用了 可选参数 和 可变参数 操作和构造函数，有效重载集 中可能有多个项标识相同的操作或构造函数。

[Exposed=Window]
  interface A {
    /* f1 */ undefined f(DOMString a);
    /* f2 */ undefined f(Node a, DOMString b, double... c);
    /* f3 */ undefined f();
    /* f4 */ undefined f(Event a, DOMString b, optional DOMString c, double... d);
  };
  

«
    (f1, « DOMString »,                           « required »),
    (f2, « Node, DOMString »,                     « required, required »),
    (f2, « Node, DOMString, double »,             « required, required, variadic »),
    (f2, « Node, DOMString, double, double »,     « required, required, variadic, variadic »),
    (f3, « »,                                     « »),
    (f4, « Event, DOMString »,                    « required, required »),
    (f4, « Event, DOMString, DOMString »,         « required, required, optional »),
    (f4, « Event, DOMString, DOMString, double », « required, required, optional, variadic »)
  »
  

两个类型在以下算法返回 true 时被认为是可区分的。

1. 如果一个类型包含一个可空类型，另一个类型也包含一个可空类型，是一个联合类型，且展平后的成员类型包含字典类型，或者是字典类型，则返回false。

   以下类型对不可区分：

   • double? 和 Dictionary1
   • (Interface1 或 long)? 和 (Interface2 或 DOMString)?
   • (Interface1 或 long?) 和 (Interface2 或 DOMString)?
   • (Interface1 或 long?) 和 (Interface2 或 DOMString?)
   • (Dictionary1 或 long) 和 (Interface2 或 DOMString?)
   • (Dictionary1 或 long) 和 (Interface2 或 DOMString?)

2. 如果两个类型都是联合类型或可空联合类型，则每个成员类型相互可区分时返回 true，否则返回 false。

3. 如果一个类型是联合类型或可空联合类型，返回 true，如果联合类型的每个成员类型与非联合类型相互可区分，否则返回 false。

4. 考虑两个类型的“最内层”类型，通过获取每个类型的内部类型，如果它是注释类型，然后获取它的内部类型，如果结果是可空类型。如果这两个最内层类型出现在下表中，且在相应条目中有“●”标记，或者有字母且满足下表的附加要求，则返回true，否则返回false。

   类别：

   interface-like

   • 接口类型

   • 缓冲区源类型

   dictionary-like

   • 字典类型

   • 记录类型

   • 回调接口类型

   sequence-like

   • 序列类型

   • 冻结数组类型

   	undefined	boolean	numeric types	bigint	string types	object	symbol	interface-like	callback function	dictionary-like	async iterable	sequence-like
   undefined		●	●	●	●	●	●	●	●		●	●
   boolean			●	●	●	●	●	●	●	●	●	●
   numeric types				(b)	●	●	●	●	●	●	●	●
   bigint					●	●	●	●	●	●	●	●
   string types						●	●	●	●	●	(d)	●
   object							●
   symbol								●	●	●	●	●
   interface-like								(a)	●	●	●	●
   callback function										(c)	●	●
   dictionary-like											●	●
   async iterable
   sequence-like

   1. 两个标识的接口类型不同，且没有单一平台对象同时实现这两种接口类型。

   2. 这些类型是可区分的，但对其在重载中的使用有额外限制。另请注意关于使用这些类型联合的建议。

   3. 不具有 [LegacyTreatNonObjectAsNull] 扩展属性的回调函数可与字典类类别中的类型区分开。

      例如，当将 ECMAScript 值转换为包含回调函数和字典类类型的联合类型时，如果该值是可调用的， 则将其转换为回调函数。否则，将其转换为字典类类型。

   4. 这些类型是可区分的，但是在从 ECMAScript 值转换时，如果字符串类型也在重载集或联合中，则字符串对象永远不会转换成异步可迭代类型（即使它具有 %Symbol.iterator% 方法）。

   double 和 DOMString 是可区分的，因为在数值类型和字符串类型的交叉处有一个●。
   double 和 long 不可区分，因为它们都是数值类型，且在数值类型之间的交叉处没有●或字母。
   给定：

   callback interface CBIface {
     undefined handle();
   };
   
   [Exposed=Window]
   interface Iface {
     attribute DOMString attr2;
   };
   
   dictionary Dict {
     DOMString field1;
   };
   

   CBIface 可与 Iface 区分开，因为字典类型和接口类型的交叉处有 ●，但不能与 Dict 区分，因为字典类型与自身的交叉处没有 ●。

   Promise 类型没有出现在上表中，因此它不能与任何其他类型区分。

如果在一个有效重载集中有多个具有相同类型列表 大小的项目，那么对于这些项目，必须存在一个索引i，使得每对项目在索引i处的类型是可区分的。该最小索引被称为区分参数索引，用于具有给定类型列表大小的有效重载集中的项目。

一个有效重载集中不得包含多个具有相同类型列表 大小的项目，其中一个项目在区分参数索引处有一个bigint参数，而另一个项目在该索引处有一个数字类型参数。

[Exposed=Window]
  interface B {
    undefined f(DOMString x);
    undefined f(USVString x);
  };
  

此外，对于每个索引j，如果j小于给定类型列表大小的区分参数索引，那么所有项的类型列表中索引j处的类型必须相同，且所有项的可选性列表中索引j处的可选性值也必须相同。

[Exposed=Window]
  interface B {
    /* f1 */ undefined f(DOMString w);
    /* f2 */ undefined f(long w, double x, Node y, Node z);
    /* f3 */ undefined f(double w, double x, DOMString y, Node z);
  };
  

«
    (f1, « DOMString »,                       « required »),
    (f2, « long, double, Node, Node »,        « required, required, required, required »),
    (f3, « double, double, DOMString, Node », « required, required, required, required »)
  »

2.5.8.1. 重载与联合类型

本节是说明性的。

interface CanvasDrawPathExcerpt {
    undefined stroke();
    undefined stroke(Path2D path);
  };
  

interface CanvasDrawPathExcerptOptional {
    undefined stroke(optional Path2D path);
  };
  

2.5.9. 可迭代声明

一个接口可以通过在接口主体中使用一个可迭代声明（匹配Iterable）来声明为可迭代。

interface interface_identifier {
    iterable<value_type>;
    iterable<key_type, value_type>;
  };
  

实现了声明为可迭代接口的对象支持通过迭代获取一系列值。

注意：在JavaScript语言绑定中，一个可迭代的接口将在其接口原型对象上拥有entries、forEach、keys、values，以及%Symbol.iterator%属性。

如果给出了一个类型参数，则该接口将拥有一个值迭代器并提供指定类型的值。如果给出了两个类型参数，则该接口将拥有一个对迭代器并提供具有给定类型的值对。

给定一个键类型和一个值类型，一个值对是一个包含两个项的结构：

1. 一个项，其名称为 "key"， 被称为值对的键，其值为键类型的 IDL 值；

2. 一个项，其名称为 "value"， 被称为值对的值，其值为值类型的 IDL 值。

一个值迭代器只能在支持索引属性的接口上声明。值迭代器的值类型必须与索引属性获取器返回的类型相同。值迭代器被隐式定义为迭代对象的索引属性。

一个键值对迭代器不能在支持索引属性的接口上声明。

具有键值对迭代器的接口的相关文本必须为每个接口实例定义一个列表，该列表是该实例的值对，即迭代的值对列表。

注意：这是数组迭代器对象的工作方式。对于支持索引属性的接口，entries、keys、values和%Symbol.iterator%返回的迭代器对象是真正的数组迭代器对象。

带有可迭代声明的接口必须不能有名为entries、forEach、keys或values的属性、常量或常规操作，也不能从拥有这些名称的属性、常量或常规操作的继承接口继承这些名称。

[Exposed=Window]
  interface SessionManager {
    Session getSessionForUser(DOMString username);
  
    iterable<DOMString, Session>;
  };
  
  [Exposed=Window]
  interface Session {
    readonly attribute DOMString username;
    // ...
  };
  

// 获取一个SessionManager实例。
  // 假设它有两个用户的会话，"anna"和"brian"。
  var sm = getSessionManager();

  typeof SessionManager.prototype.values;            // 计算结果为 "function"
  var it = sm.values();                              // values() 返回一个迭代器对象
  String(it);                                        // 计算结果为 "[object SessionManager Iterator]"
  typeof it.next;                                    // 计算结果为 "function"

  // 该循环将首先记录"anna"，然后是"brian"。
  for (;;) {
    let result = it.next();
    if (result.done) {
      break;
    }
    let session = result.value;
    console.log(session.username);
  }

  // 该循环也将记录"anna"和"brian"。
  for (let username of sm.keys()) {
    console.log(username);
  }

  // 另一种实现相同目标的方式。
  for (let [username, session] of sm) {
    console.log(username);
  }
  

一个接口不能有多个可迭代声明。一个具有可迭代声明的接口及其继承的接口不能有maplike声明、setlike声明或异步可迭代声明。

以下扩展属性适用于可迭代声明： [CrossOriginIsolated]、 [Exposed] 和 [SecureContext]。

Iterable ::
      iterable < TypeWithExtendedAttributes OptionalType > ;
  

OptionalType ::
      , TypeWithExtendedAttributes
      ε
  

2.5.10. 异步可迭代声明

一个接口可以通过在接口的主体中使用异步可迭代声明（匹配AsyncIterable）来声明为异步可迭代。

interface interface_identifier {
    async iterable<value_type>;
    async iterable<value_type>(/* 参数... */);
    async iterable<key_type, value_type>;
    async iterable<key_type, value_type>(/* 参数... */);
  };
  

实现了声明为异步可迭代的接口的对象支持通过异步迭代来获取值序列。

如果只给出一个类型参数，则该接口具有值异步可迭代声明，并异步提供指定类型的值。如果给出了两个类型参数，则该接口具有键值对异步可迭代声明，并异步提供具有给定类型的键值对。

如果给定，异步可迭代声明的参数 （匹配 ArgumentList）必须全部是可选参数。

与具有接口和异步可迭代声明相关的描述性文字必须定义一个获取下一个迭代结果的算法。 该算法接收正在被迭代的接口的实例，以及异步迭代器本身（这有助于存储状态）。 它必须返回一个Promise，该Promise要么被拒绝，要么解决为一个特殊的迭代结束值，以表示迭代的结束，或者解决为以下之一：

对于值异步可迭代声明：

一个声明中给定类型的值；

对于键值对异步可迭代声明：

一个包含声明中第一个给定类型的值和第二个给定类型的值的元组。

描述性文字还可以定义一个异步迭代器返回算法。该算法接收被迭代的接口的实例、异步迭代器本身，以及一个类型为any的单一参数值。在异步迭代器的提前终止情况下，调用该算法。该算法必须返回一个Promise；如果Promise兑现，兑现值将被忽略，但如果被拒绝，该失败将传递给异步迭代器API的使用者。

在JavaScript绑定中，该算法允许自定义当异步迭代器的return()方法被调用时的行为。这通常发生在break或return语句导致退出for-await-of循环时。

我们可以为throw()添加一个类似的钩子。目前还没有这样的需求，但如果您在创建需要此类功能的API，请提交一个问题。

描述性文字还可以定义异步迭代器初始化步骤。这些步骤接收被迭代的接口的实例、新创建的迭代器对象，以及一个包含传递的参数（如果有的话）的IDL值列表。

具有 异步可迭代声明的接口不应具有任何名为entries、keys或values的属性，常量，或常规操作，也不能具有任何继承了这些名称的继承接口。

[Exposed=Window]
  interface SessionManager {
    Session getSessionForUser(DOMString username);
  
    async iterable<DOMString, Session>;
  };
  
  [Exposed=Window]
  interface Session {
    readonly attribute DOMString username;
    // ...
  };
  

// 获取SessionManager的实例。
  // 假设它有两个用户的会话："anna"和"brian"。
  var sm = getSessionManager();
  
  typeof SessionManager.prototype.values;            // 计算结果为 "function"
  var it = sm.values();                              // values() 返回一个迭代器对象
  typeof it.next;                                    // 计算结果为 "function"
  
  // 此循环将打印 "anna" 和 "brian"。
  for await (let username of sm.keys()) {
    console.log(username);
  }
  
  // 另一种实现相同功能的方式。
  for await (let [username, session] of sm) {
    console.log(username);
  }
  

接口不能有多个异步可迭代声明。带有继承接口的接口不能同时具有异步可迭代声明。具有异步可迭代声明的接口及其继承接口不得具有类映射声明、类集合声明或可迭代声明。

以下扩展属性适用于异步可迭代声明：[CrossOriginIsolated]、[Exposed]和[SecureContext]。

这些扩展属性目前尚未生效。当它们生效时，其效果将符合预期。

AsyncIterable ::
      async iterable < TypeWithExtendedAttributes OptionalType > OptionalArgumentList ;
  

OptionalArgumentList ::
      ( ArgumentList )
      ε
  

2.5.11. Maplike 声明

一个 接口 可以通过在接口主体中使用 maplike 声明 （匹配 ReadWriteMaplike 或 readonly MaplikeRest）声明为 maplike 声明。

interface interface_identifier {
    readonly maplike<key_type, value_type>;
    maplike<key_type, value_type>;
  };
  

实现了类映射声明的接口的对象表示有序映射的键值对，初始为空，称为该对象的映射条目。 键和值的类型在类映射声明的尖括号中给出。键必须是唯一的。

规范作者可以修改映射条目的内容，这将在JavaScript代码中自动反映对象的内容。

类映射接口支持适用于语言绑定的查询映射条目的API。如果未使用readonly关键字，则还支持修改映射条目的API。

注意：在JavaScript语言绑定中，用于操作映射条目的API类似于JavaScript Map对象的API。如果使用了readonly关键字，这包括entries、forEach、get、has、keys、values、%Symbol.iterator%方法以及size属性获取器。对于可读写的类映射，还包括clear、delete和set方法。

类映射接口不能有名为entries、forEach、get、has、keys、size或values的属性、常量或常规操作，也不能具有任何具有这些名称的继承接口。

可读写的类映射接口不能有名为clear、delete或set的属性或常量，也不能有任何具有这些名称的继承接口。

注意：可读写的类映射接口可以有名为clear、delete或set的常规操作，这些操作将覆盖这些方法的默认实现（定义在§ 3.7.11 类映射声明中）。如果定义了这样的常规操作，它们必须匹配各方法的输入和输出期望，定义在各自的默认实现部分中。

接口不能有多个类映射声明。 类映射接口的继承接口不能也有类映射声明。 类映射接口及其继承接口不得具有可迭代声明、异步可迭代声明、类集合声明或索引属性获取器。

ReadOnlyMember ::
      readonly ReadOnlyMemberRest
  

ReadOnlyMemberRest ::
      AttributeRest
      MaplikeRest
      SetlikeRest
  

ReadWriteMaplike ::
      MaplikeRest
  

MaplikeRest ::
      maplike < TypeWithExtendedAttributes , TypeWithExtendedAttributes > ;
  

本规范中未定义任何适用于类映射声明的扩展属性。

添加示例。

2.5.12. Setlike 声明

一个 接口 可以通过在接口主体中使用 setlike 声明 （匹配 ReadWriteSetlike 或 readonly SetlikeRest）声明为 setlike 声明。

interface interface_identifier {
    readonly setlike<type>;
    setlike<type>;
  };
  

实现了类集合声明的接口的对象表示有序集合的值，初始为空，称为该对象的集合条目。 类集合声明的尖括号中给出了值的类型。值必须是唯一的。

规范作者可以修改集合条目的内容，这将在JavaScript代码中自动反映对象的内容。

类集合接口支持适用于语言绑定的查询集合条目的API。如果未使用readonly关键字，则还支持修改集合条目的API。

注意：在JavaScript语言绑定中，用于操作集合条目的API类似于JavaScript Set对象的API。如果使用了readonly关键字，这包括entries、forEach、has、keys、values、%Symbol.iterator%方法以及size属性获取器。对于可读写的类集合，还包括add、clear和delete方法。

类集合接口不能有名为entries、forEach、has、keys、size或values的属性、常量或常规操作，也不能具有任何具有这些名称的继承接口。

可读写的类集合接口不能有名为add、clear或delete的属性或常量，也不能有任何具有这些名称的继承接口。

注意：可读写的类集合接口可以有名为add、clear或delete的常规操作，这些操作将覆盖这些方法的默认实现（定义在§ 3.7.12 类集合声明中）。如果定义了这样的常规操作，它们必须匹配各方法的输入和输出期望，定义在各自的默认实现部分中。

接口不能有多个类集合声明。 类集合接口的继承接口不能也有类集合声明。 类集合接口及其继承接口不得具有可迭代声明、异步可迭代声明、类映射声明或索引属性获取器。

ReadOnlyMember ::
      readonly ReadOnlyMemberRest
  

ReadOnlyMemberRest ::
      AttributeRest
      MaplikeRest
      SetlikeRest
  

ReadWriteSetlike ::
      SetlikeRest
  

SetlikeRest ::
      setlike < TypeWithExtendedAttributes > ;
  

本规范中未定义任何适用于类集合声明的扩展属性。

添加示例。

2.6. 命名空间

命名空间是一个声明全局单例及其相关行为的定义（匹配Namespace）。

namespace identifier {
    /* namespace_members... */
  };
  

命名空间是常规操作、只读 常规属性和常量的集合规范（匹配NamespaceMembers），这些操作和属性描述了打包到命名空间中的行为。

与接口一样，命名空间的IDL可以通过使用部分命名空间定义（匹配partial Namespace）拆分为多个部分。部分命名空间定义的标识符必须与命名空间定义的标识符相同。每个部分命名空间定义中出现的成员都被视为命名空间本身的成员。

namespace SomeNamespace {
    /* namespace_members... */
  };
  
  partial namespace SomeNamespace {
    /* namespace_members... */
  };
  

注意：与部分接口定义一样，部分命名空间定义旨在作为规范编辑的辅助工具，允许命名空间定义分散在文档的多个部分，有时甚至是多个文档。

成员出现的顺序对于JavaScript绑定中的属性枚举具有重要意义。

注意，与接口或字典不同，命名空间不会创建类型。

在本规范中定义的扩展属性中，只有[CrossOriginIsolated]、[Exposed]和[SecureContext]扩展属性适用于命名空间。

命名空间必须带有[Exposed] 扩展属性。

Partial ::
      partial PartialDefinition
  

PartialDefinition ::
      interface PartialInterfaceOrPartialMixin
      PartialDictionary
      Namespace
  

Namespace ::
      namespace identifier { NamespaceMembers } ;
  

NamespaceMembers ::
      ExtendedAttributeList NamespaceMember NamespaceMembers
      ε
  

NamespaceMember ::
      RegularOperation
      readonly AttributeRest
      Const
  

namespace VectorUtils {
    readonly attribute Vector unit;
    double dotProduct(Vector x, Vector y);
    Vector crossProduct(Vector x, Vector y);
  };
  

Object.getPrototypeOf(VectorUtils);                         // 计算结果为Object.prototype。
  Object.keys(VectorUtils);                                   // 计算结果为["dotProduct", "crossProduct"]。
  Object.getOwnPropertyDescriptor(VectorUtils, "dotProduct"); // 计算结果为{ value: <a function>, enumerable: true, configurable: true, writable: true }。
  Object.getOwnPropertyDescriptor(VectorUtils, "unit");       // 计算结果为{ get: <a function>, enumerable: true, configurable: true }。
  

2.7. 字典

字典是一种定义（匹配Dictionary），用于定义具有固定、有序有序映射的条目集合的数据类型，这些条目称为字典成员，其中键是字符串，值具有在定义中指定的特定类型。

dictionary identifier {
    /* dictionary_members... */
  };
  

字典实例不会保留对其语言特定表示（例如，对应的JavaScript对象）的引用。因此，例如，从操作返回字典将从字典的当前值创建一个新的JavaScript对象，并且，接受字典作为参数的操作将基于当前的JavaScript对象属性进行一次性转换。对字典的修改不会反映在对应的JavaScript对象中，反之亦然。

字典不能用作属性或常量的类型。

字典可以定义为从另一个字典继承。如果字典的标识符后面跟着冒号和标识符，则该标识符标识继承的字典。标识符必须标识一个字典。

字典不能声明为使其继承层次结构产生循环。也就是说，字典A不能继承自自身，也不能继承自另一个继承自A的字典B，等等。

dictionary Base {
    /* dictionary_members... */
  };
  
  dictionary Derived : Base {
    /* dictionary_members... */
  };
  

给定字典D的继承字典是所有直接或间接从D继承的字典的集合。如果D没有从另一个字典继承，则该集合为空。否则，集合包括D继承自的字典E及其所有的继承字典。

字典成员可以指定为必需，这意味着将语言特定的值转换为字典时，必须为该成员提供值。任何未被指定为必需的字典成员都是可选的。

请注意，将字典成员指定为必需仅在将其他表示形式的字典（如作为操作参数提供的JavaScript值）转换为IDL字典时具有可观察的效果。在所有其他情况下，包括字典类型仅作为操作的返回类型时，规范作者应将成员保留为可选。

类型为D的字典值可以具有D定义的每个字典成员和D的任何继承字典中的字典成员的条目。指定为必需的字典成员，或指定为具有默认值的字典成员，将始终具有相应的条目。其他成员的条目可能存在，也可能不存在于字典值中。

在JavaScript绑定中，属性对应的字典成员的值为undefined时，等同于省略该属性。因此，如果该成员是必需的，将会导致错误；如果存在默认值，将触发该默认值；否则，字典值中将不会存在该条目。

与操作参数默认值一样，强烈建议不要使用true作为boolean类型字典成员的默认值，因为这可能会让作者感到困惑，他们可能期望使用默认的undefined转换（即false）。[API-DESIGN-PRINCIPLES]

具有字符串键的有序映射可以隐式视为特定字典D的字典值，如果其所有条目都对应于字典成员，并且这些条目具有正确的类型，并且存在针对任何必需或默认的字典成员的条目。

dictionary Descriptor {
    DOMString name;
    sequence<unsigned long> serviceIdentifiers;
  };
  

每个字典成员（匹配DictionaryMember）被指定为一个类型（匹配Type），后跟一个标识符（由类型后面的identifier标记给出）。标识符是键值对的键名。如果Type是一个后跟?的标识符，那么该标识符必须标识一个接口、枚举、回调函数、回调接口或类型定义。如果字典成员类型是一个未后跟?的标识符，则该标识符必须标识这些定义之一或一个字典。

如果字典成员的类型在解析类型定义后是可空类型，则其内部类型不得是字典类型。

dictionary identifier {
    type identifier;
  };
  

如果可选字典成员的标识符后面跟着U+003D (=)和一个值（匹配DefaultValue），则该值为字典成员的默认值，当作者代码或规范文本未为该成员提供值时，默认使用此值。

dictionary identifier {
    type identifier = "value";
  };
  

当布尔文字标记（true或false）、null标记、整数标记、小数标记、三个特殊的浮点文字值之一（Infinity、-Infinity或NaN）、字符串标记、[]标记或{}标记作为默认值使用时，它的解释与操作的可选参数默认值相同。

如果字典成员的类型是枚举，那么它的默认值（如果指定）必须是该枚举值之一。

如果字典成员的类型前有required关键字，则该成员被视为必需的字典成员。

dictionary identifier {
    required type identifier;
  };
  

字典成员的类型不能包含它所在的字典。如果类型包含字典D，则至少满足以下条件之一：

• 类型是D

• 类型是从D继承的字典

• 类型是D的可空类型，其内部类型包含D

• 类型是序列类型或冻结数组，其元素类型包含D

• 类型是联合类型，其中的成员类型包含D

• 类型是字典，其成员或继承成员的类型包含D

• 类型是record<K, V>，其中V包含D

与接口类似，字典的IDL可以通过使用部分字典定义（匹配partialDictionary）拆分为多个部分。

dictionary SomeDictionary {
    /* dictionary_members... */
  };
  
  partial dictionary SomeDictionary {
    /* dictionary_members... */
  };
  

注意：与部分接口定义类似，部分字典定义用于作为规范编辑的辅助工具，允许将字典的定义分散在文档的多个部分，有时甚至是多个文档中。

在给定字典中的字典成员的顺序是继承的字典成员排在非继承成员之前，并且字典定义（包括任何部分字典定义）中的字典成员按组成其标识符的Unicode代码点的字典顺序排列。

dictionary B : A {
    long b;
    long a;
  };
  
  dictionary A {
    long c;
    long g;
  };
  
  dictionary C : B {
    long e;
    long f;
  };
  
  partial dictionary A {
    long h;
    long d;
  };
  

[Exposed=Window]
  interface Something {
    undefined f(A a);
  };
  

var something = getSomething();  // Get an instance of Something.
  var x = 0;
  
  var dict = { };
  Object.defineProperty(dict, "d", { get: function() { return ++x; } });
  Object.defineProperty(dict, "c", { get: function() { return ++x; } });
  
  something.f(dict);
  

字典成员的标识符不能与字典中定义的另一个字典成员或该字典的继承字典中的字典成员相同。

没有扩展属性适用于字典。

Partial ::
      partial PartialDefinition
  

PartialDefinition ::
      interface PartialInterfaceOrPartialMixin
      PartialDictionary
      Namespace
  

Dictionary ::
      dictionary identifier Inheritance { DictionaryMembers } ;
  

DictionaryMembers ::
      DictionaryMember DictionaryMembers
      ε
  

DictionaryMember ::
      ExtendedAttributeList DictionaryMemberRest
  

DictionaryMemberRest ::
      required TypeWithExtendedAttributes identifier ;
      Type identifier Default ;
  

PartialDictionary ::
      dictionary identifier { DictionaryMembers } ;
  

Default ::
      = DefaultValue
      ε
  

DefaultValue ::
      ConstValue
      string
      [ ]
      { }
      null
      undefined
  

Inheritance ::
      : identifier
      ε
  

[Exposed=Window]
interface Point {
  constructor();
  attribute double x;
  attribute double y;
};

dictionary PaintOptions {
  DOMString fillPattern = "black";
  DOMString strokePattern;
  Point position;
};

[Exposed=Window]
interface GraphicsContext {
  undefined drawRectangle(double width, double height, optional PaintOptions options);
};

// 获取GraphicsContext的实例。
var ctx = getGraphicsContext();

// 画一个矩形。
ctx.drawRectangle(300, 200, { fillPattern: "red", position: new Point(10, 10) });

2.8. 异常

异常是一种表示错误的对象类型，能够被抛出或作为一等值处理。Web IDL 预定义了一些异常类型，这些异常类型可以在规范定义的操作、属性等中引用并抛出。也可以自定义异常类型，作为继承自DOMException的接口来定义。

简单异常可以通过以下类型之一标识：

• EvalError

• RangeError

• ReferenceError

• TypeError

• URIError

这些对应于所有 JavaScript 错误对象 （除了 SyntaxError 和 Error，它们被故意省略， 因为它们分别被保留给 JavaScript 解析器和作者使用）。每个 简单异常 的含义与其在 JavaScript 规范中的相应错误对象匹配。

第二种类型的异常是 DOMException， 它通过提供一个 名称 来提供有关发生错误的进一步编程可检查的详细信息。 此类 名称 来自下方的 DOMException 名称表。

由于 DOMException 是一个 接口类型， 它可以在 IDL 中用作类型。这允许，例如，可以声明一个 操作 具有 DOMException 的 返回类型。然而，这通常是一个不好的模式，因为异常应当被抛出而不是返回。

最后一种类型的异常是 DOMException 的派生接口。 它们更复杂，因此在专门章节 § 2.8.2 DOMException 派生接口 中进行了描述。

简单异常 可以通过提供其类型名称进行 创建。 可以通过提供其 名称 后接 DOMException 来创建一个 DOMException。 异常也可以通过提供创建所需的相同详细信息进行 抛出。 在这两种情况下，调用方可以提供关于异常指示内容的额外信息，这在构造异常的消息时非常有用。

创建和抛出异常的结果行为取决于语言绑定。

有关在JavaScript语言绑定中创建和抛出异常的详细信息，请参阅§ 3.14.3 创建和抛出异常。

2.8.1. 基础DOMException 错误名称

下面的DOMException名称表列出了基础DOMException 接口实例的所有允许的名称，以及这些名称的含义和遗留的数字错误代码值。

继承自DOMException的接口（如§ 2.8.2 DOMException派生接口中所述），将拥有自己的名称，未列入此表。

在创建或抛出一个DOMException时，规范必须使用这些名称之一。如果规范作者认为这些名称都不适合其案例，他们必须提交问题，以讨论将新名称添加到共享命名空间，方便社区协调这些工作。请注意，只有当您认为Web开发人员会区分同一API产生的多个错误情况时，添加新的特定用途的名称才显得重要。

DOMException名称标记为过时是为了兼容遗留问题，但不推荐使用这些名称。

注意：不要混淆这里定义的"SyntaxError"DOMException与JavaScript中的SyntaxError。"SyntaxError"DOMException用于报告Web API中的解析错误，例如解析选择器时，而JavaScript的SyntaxError是为JavaScript解析器保留的。为了进一步避免混淆，请始终优先使用"SyntaxError"DOMException符号，而不是仅使用SyntaxError来指代DOMException。[DOM]

2.8.2. DOMException 派生接口

当异常需要携带可供程序检测的额外信息，而这些信息超出了 DOMException 的名称范围时，规范作者可以创建一个接口，该接口继承自 DOMException。这些接口必须遵循特定的规则，以确保开发者可以预测其行为。具体规则如下：

• 接口的标识符必须以Error结尾，并且不得与DOMException 名称表中的名称重复。

• 该接口必须具有一个构造函数，该构造函数会将实例的名称设置为接口的标识符。

• 构造函数的第一个参数必须是可选的 DOMString，命名为message，默认为空字符串，并且必须将实例的消息设置为message。

• 构造函数的第二个参数应为包含额外信息的字典。

• 该接口应具有与构造函数字典成员同名的只读 属性，这些属性返回构造函数接收的值。

• 这些接口应是可序列化对象，其序列化步骤和反序列化步骤能够保留这些额外信息。

这些要求意味着这些接口的继承 代码 属性将始终返回 0。

[Exposed=Window, Serializable]
  interface ProtocolXError : DOMException {
    constructor(optional DOMString message = "", ProtocolXErrorOptions options);
  
    readonly attribute unsigned long long errorCode;
  };
  
  dictionary ProtocolXErrorOptions {
      required [EnforceRange] unsigned long long errorCode;
  };
  

要创建或抛出一个 DOMException 派生接口，提供其 接口 标识符以及构造它所需的额外信息。

2.9. 枚举

枚举是一种用于声明类型的定义（匹配Enum），其有效值为一组预定义的字符串。枚举可以用来限制DOMString值，该值可以分配给属性或传递给操作。

enum identifier { "enum", "values" /* , ... */ };

枚举值通过以逗号分隔的string字面量列表指定。枚举值列表不得包含重复项。

强烈建议枚举值全为小写，并且多个单词使用连字符分隔或不分隔，除非有特定原因使用其他命名方案。例如，指示应创建对象的枚举值可以命名为 "createobject" 或 "create-object"。在决定是否连字符分隔或不分隔枚举值单词时，请考虑相关 API 的一致性。

当字符串值不是有效的枚举值并赋值给属性或传递给枚举类型的操作参数时，行为是语言绑定特定的。

注意：在 JavaScript 绑定中，将无效的字符串值赋给属性时会被忽略，而在其他上下文（例如作为操作参数）中传递此类值时会抛出异常。

此规范中定义的没有适用于枚举的扩展属性。

Enum ::
      enum identifier { EnumValueList } ;
  

EnumValueList ::
      string EnumValueListComma
  

EnumValueListComma ::
      , EnumValueListString
      ε
  

EnumValueListString ::
      string EnumValueListComma
      ε
  

enum MealType { "rice", "noodles", "other" };
  
  [Exposed=Window]
  interface Meal {
      attribute MealType type;
      attribute double size;     // 以克为单位
  
    undefined initialize(MealType type, double size);
  };
  

var meal = getMeal();                // 获取一个 Meal 实例。
  
  meal.initialize("rice", 200);        // 正常调用操作。
  
  try {
    meal.initialize("sandwich", 100);  // 抛出 TypeError。
  } catch (e) {
  }

  meal.type = "noodles";               // 属性正常分配。
  meal.type = "dumplings";             // 属性分配被忽略。
  meal.type == "noodles";              // 计算结果为 true。

2.10. 回调函数

“Custom DOM Elements” 规范希望使用回调函数类型来提供平台对象函数。我们是否应该将“回调函数”重命名为仅“函数”，以明确它们可以用于两种目的？

回调函数 是一种定义（匹配 callback CallbackRest），用于声明函数类型。

callback identifier = return_type (/* 参数... */);

注意：另请参见类似命名的 回调接口。

等号左边的 标识符 给出了 回调函数 的名称，等号右边的返回类型和参数列表（匹配 Type 和 ArgumentList）则给出了回调函数类型的签名。

回调函数 不能用作 常量 的类型。

以下扩展属性适用于回调函数： [LegacyTreatNonObjectAsNull]。

CallbackOrInterfaceOrMixin ::
      callback CallbackRestOrInterface
      interface InterfaceOrMixin
  

CallbackRest ::
      identifier = Type ( ArgumentList ) ;
  

callback AsyncOperationCallback = undefined (DOMString status);
  
  [Exposed=Window]
  interface AsyncOperations {
    undefined performOperation(AsyncOperationCallback whenFinished);
  };
  

var ops = getAsyncOperations();  // 获取 AsyncOperations 的实例。
  
  ops.performOperation(function(status) {
    window.alert("操作完成，状态为 " + status + ".");
  });
  

2.11. 类型定义

类型定义 是一种定义 （匹配 Typedef） 用于声明一个类型的新名称。这个新名称不会通过语言绑定暴露出来；它纯粹作为在 IDL 中引用该类型的简写使用。

typedef type identifier;

被赋予新名称的类型 在 typedef 关键字之后指定（匹配 TypeWithExtendedAttributes），后面的 标识符 token 提供了新名称。

类型 不得是相同或其他 类型定义 的标识符。

本规范中没有任何定义的 扩展属性 适用于 类型定义。

Typedef ::
      typedef TypeWithExtendedAttributes identifier ;
  

[Exposed=Window]
  interface Point {
    attribute double x;
    attribute double y;
  };
  
  typedef sequence<Point> Points;
  
  [Exposed=Window]
  interface Widget {
    boolean pointWithinBounds(Point p);
    boolean allPointsWithinBounds(Points ps);
  };
  

2.12. 实现接口的对象

在一组 IDL 片段 的给定实现中， 一个对象可以被描述为 平台对象。

平台对象 是实现了 接口 的对象。

遗留平台对象 是 平台对象，它实现了没有 [Global] 扩展属性 的接口，并且支持 索引属性、命名属性，或者两者兼有。

例如，在浏览器中， 浏览器实现的 DOM 对象（实现了如 Node 和 Document 这样的接口）为页面中运行的 JavaScript 提供对网页内容的访问权限，这些对象将被视为 平台对象。这些对象可能是异质对象，使用 C++ 语言实现，或者它们可能是原生的 JavaScript 对象。不管怎样， 一个给定的 IDL 片段集合的实现需要能够识别所有由该实现创建的 平台对象。这可以通过某种内部状态记录一个给定对象是否确实是该实现的一个平台对象，或者可能通过观察 该对象是由某个给定的内部 C++ 类实现的。具体来说，平台对象如何由一组 IDL 片段的给定实现识别是实现相关的。

系统中的所有其他对象不会被视为平台对象。例如，假设 一个在浏览器中打开的网页加载了一个 JavaScript 库，该库实现了 DOM Core。这个库 将被视为与浏览器提供的实现不同的实现。 由该 JavaScript 库创建的实现 Node 接口的对象 不会被浏览器实现视为实现 Node 的平台对象。

另一方面，回调接口 可以由任何 JavaScript 对象实现。这 允许 Web API 调用作者定义的操作。例如，DOM 事件的实现 允许作者通过提供实现了 EventListener 接口的对象来注册回调。

2.13. 类型

本节列出了 Web IDL 支持的类型、 每个类型对应的值集合或 Infra 类型， 以及该类型的常量的表示方式。

以下类型被称为整数类型：byte、octet、short、unsigned short、 long、unsigned long、 long long 和 unsigned long long。

以下类型被称为数值类型： 整数类型、float、unrestricted float、 double 和 unrestricted double。

原始类型 包括 bigint、 boolean， 以及数值类型。

字符串类型 包括 DOMString、 所有枚举类型、 ByteString 和 USVString。

缓冲区类型 包括 ArrayBuffer 和 SharedArrayBuffer。

类型化数组类型 包括 Int8Array、 Int16Array、 Int32Array、 Uint8Array、 Uint16Array、 Uint32Array、 Uint8ClampedArray、 BigInt64Array、 BigUint64Array、 Float16Array、 Float32Array、 和 Float64Array。

缓冲区视图类型 包括 DataView 和类型化数组类型。

缓冲区源类型 包括 缓冲区类型 和 缓冲区视图类型。

object 类型、 所有 接口类型 和 所有 回调接口类型 被称为对象类型。

当从语言绑定的特定类型到 IDL 类型进行转换以调用操作或为属性分配值时， 在执行操作或属性分配的指定功能之前，将执行所有必要的转换。如果无法执行转换，则操作不会运行或 属性不会更新。在某些语言绑定中， 类型转换可能会导致抛出异常。 在这种情况下，这些异常将传播到尝试调用操作或 为属性赋值的代码中。

Type ::
      SingleType
      UnionType Null
  

TypeWithExtendedAttributes ::
      ExtendedAttributeList Type
  

SingleType ::
      DistinguishableType
      any
      PromiseType
  

UnionType ::
      ( UnionMemberType or UnionMemberType UnionMemberTypes )
  

UnionMemberType ::
      ExtendedAttributeList DistinguishableType
      UnionType Null
  

UnionMemberTypes ::
      or UnionMemberType UnionMemberTypes
      ε
  

DistinguishableType ::
    PrimitiveType Null
    StringType Null
    identifier Null
    sequence < TypeWithExtendedAttributes > Null
    async_iterable < TypeWithExtendedAttributes > Null
    object Null
    symbol Null
    BufferRelatedType Null
    FrozenArray < TypeWithExtendedAttributes > Null
    ObservableArray < TypeWithExtendedAttributes > Null
    RecordType Null
    undefined Null

ConstType ::
      PrimitiveType
      identifier
  

PrimitiveType ::
      UnsignedIntegerType
      UnrestrictedFloatType
      boolean
      byte
      octet
      bigint
  

UnrestrictedFloatType ::
      unrestricted FloatType
      FloatType
  

FloatType ::
      float
      double
  

UnsignedIntegerType ::
      unsigned IntegerType
      IntegerType
  

IntegerType ::
      short
      long OptionalLong
  

OptionalLong ::
      long
      ε
  

StringType ::
      ByteString
      DOMString
      USVString
  

PromiseType ::
      Promise < Type >
  

RecordType ::
      record < StringType , TypeWithExtendedAttributes >
  

Null ::
      ?
      ε
  

2.13.1. 任意类型

any 类型是所有其他可能的非联合类型的并集。

any 类型类似于区分联合类型，因为它的每个值都有一个特定的非any类型与之关联。例如，any 类型的一个值是 unsigned long 150，而另一个是 long 150。这些是不同的值。

any 值的特定类型称为其特定类型。（联合类型的值也有特定类型。）

2.13.2. undefined 类型

undefined 类型有一个唯一的值。

undefined 常量值在 IDL 中用 undefined token 表示。

undefined 不能在任何情况下作为参数类型（在 操作、回调函数、构造函数操作等中），也不能作为 字典成员的类型，无论是直接使用还是在联合类型中使用。相反，应该使用可选参数或非必需的 字典成员。

注意： 此值以前拼写为 void，并且在使用上受到更多限制。

2.13.3. 布尔类型

boolean 类型对应于布尔值。

IDL 中的 boolean 常量值用 true 和 false 标记表示。

2.13.4. 字节类型

byte 类型对应于8 位有符号整数。

IDL 中的 byte 常量值用 整数 标记表示。

2.13.5. 八位字节类型

octet 类型对应于8 位无符号整数。

IDL 中的 octet 常量值用 整数 标记表示。

2.13.6. 短整型

short 类型对应于16 位有符号整数。

IDL 中的 short 常量值用 整数 标记表示。

2.13.7. 无符号短整型

unsigned short 类型对应于16 位无符号整数。

IDL 中的 unsigned short 常量值用 整数 标记表示。

2.13.8. 长整型

long 类型对应于32 位有符号整数。

IDL 中的 long 常量值用 整数 标记表示。

2.13.9. 无符号长整型

unsigned long 类型对应于32 位无符号整数。

IDL 中的 unsigned long 常量值用 整数 标记表示。

2.13.10. 长长整型

long long 类型对应于64 位有符号整数。

IDL 中的 long long 常量值用 整数 标记表示。

2.13.11. 无符号长长整型

unsigned long long 类型对应于64 位无符号整数。

IDL 中的 unsigned long long 常量值用 整数 标记表示。

2.13.12. 单精度浮点型

float 类型是一种浮点数值类型，对应于有限单精度 32 位 IEEE 754 浮点数的集合。[IEEE-754]

IDL 中的 float 常量值用 十进制 标记表示。

除非有特定原因需要使用 32 位浮点类型，否则规范应使用 double 而不是 float，因为 double 可以表示的值集更接近 JavaScript Number。

2.13.13. 无限制单精度浮点型

unrestricted float 类型是一种浮点数值类型，对应于所有可能的单精度 32 位 IEEE 754 浮点数的集合，包括有限值、非有限值和特殊的“非数字”值 (NaN)。[IEEE-754]

IDL 中的 unrestricted float 常量值用 十进制 标记表示。

2.13.14. 双精度浮点型

double 类型是一种浮点数值类型，对应于有限双精度 64 位 IEEE 754 浮点数的集合。[IEEE-754]

IDL 中的 double 常量值用 十进制 标记表示。

2.13.15. 无限制双精度浮点型

unrestricted double 类型是一种浮点数值类型，对应于所有可能的双精度 64 位 IEEE 754 浮点数的集合，包括有限值、非有限值和特殊的“非数字”值 (NaN)。[IEEE-754]

IDL 中的 unrestricted double 常量值用 十进制 标记表示。

2.13.16. 大整数类型

bigint 类型是一种任意整数类型，范围不受限制。

IDL 中的 bigint 常量值用 整数 标记表示。

2.13.17. DOM字符串类型

DOMString 类型对应于字符串。

注意： null 不是 DOMString 类型的值。要允许 null，需要使用可为空的 DOMString，在 IDL 中写作 DOMString?。

注意： DOMString 值可能包含未配对的代理码点。如果不希望如此，请使用 USVString。

IDL 中没有办法表示常量 DOMString 值，尽管 DOMString 字典成员默认值和操作可选参数默认值可以设置为字符串字面量的值。

2.13.18. 字节字符串类型

ByteString 类型对应于字节序列。

在 IDL 中没有办法表示 ByteString 的常量值，但可以将 ByteString 的字典成员 默认值 和 操作的可选参数 默认值 设置为 字符串字面量的值。

规范应仅在与同时使用字节和字符串的协议（如 HTTP）进行交互时使用 ByteString。一般来说，字符串应使用 DOMString 值表示，即使预期字符串的值总是 ASCII 或某些 8 位字符编码。应使用带有 octet 或 byte 元素的序列或冻结数组，或者使用 Uint8Array 或 Int8Array 来保存 8 位数据，而不是使用 ByteString。

2.13.19. USV字符串类型