1.소개

이 섹션은 참고용입니다.

이 표준은 웹 브라우저에 구현될 인터페이스를 기술하는 데 사용할 수 있는 인터페이스 정의 언어, 웹 IDL을 정의합니다. 웹 IDL은 웹 플랫폼의 일반적인 스크립트 객체의 동작을 보다 쉽게 명세할 수 있도록 하는 다양한 기능을 가진 IDL 변형입니다. 웹 IDL로 기술된 인터페이스가 자바스크립트 실행 환경 내의 구조와 어떻게 대응되는지도 이곳에서 자세히 설명합니다.

구체적으로, 웹 IDL은 웹 플랫폼 객체의 표면 API를 명세하는 구문과, 그 API가 자바스크립트 구조로 어떻게 나타나는지 상세히 기술하는 자바스크립트 바인딩을 제공합니다. 이로 인해 글로벌 속성 설치, 숫자 입력 처리, 반복 동작 노출과 같은 일반적인 작업들이 웹 플랫폼 명세서 전체에서 일관성을 유지할 수 있습니다. 이러한 명세서들은 웹 IDL로 인터페이스를 기술하고, 프로즈로 API 고유의 세부사항을 명세합니다.

"자바스크립트"라는 용어는 공식 용어 ECMAScript가 아닌 ECMA-262를 의미하며, 자바스크립트라는 명칭이 더 널리 알려져 있기 때문에 사용합니다.

2.인터페이스 정의 언어

이 섹션에서는웹 IDL이라는 언어를 설명합니다. 이는 웹 플랫폼의 API를 정의하는 인터페이스를 명세하는 데 사용할 수 있습니다. 웹 API를 정의하는 명세서는 하나 이상의IDL 프래그먼트를 포함하여, 해당 명세서에서 정의된 API의 인터페이스(객체가 가질 수 있는 상태와 동작)를 기술합니다.IDL 프래그먼트는Definitions 문법 기호에 일치하는 일련의 정의입니다. 구현체가 지원하는IDL 프래그먼트 집합은 순서가 없습니다. 전체 문법과 표기법 설명은IDL 문법을 참고하세요.

IDL 프래그먼트에 등장할 수 있는 다양한정의의 종류는 다음과 같습니다:인터페이스,부분 인터페이스 정의,인터페이스 믹스인,부분 믹스인 정의,콜백 함수,콜백 인터페이스,네임스페이스,부분 네임스페이스 정의,딕셔너리,부분 딕셔너리 정의,타입 정의(typedef) 및includes 문입니다. 모든 종류는 아래 섹션에서 정의됩니다.

각정의 (Definition에 일치) 앞에는확장 속성 목록(ExtendedAttributeList에 일치)이 올 수 있으며, 이는 해당 정의가 언어 바인딩에서 어떻게 처리될지 제어합니다. 이 명세서에서 정의된 언어 바인딩에 독립적인 확장 속성은§ 2.14 확장 속성에서, 자바스크립트 언어 바인딩에 특화된 것은§ 3.3 확장 속성에서 설명합니다.

[extended_attributes]interfaceidentifier {  /* interface_members... */};

Definitions ::ExtendedAttributeListDefinitionDefinitions    ε

Definition ::CallbackOrInterfaceOrMixinNamespacePartialDictionaryEnumTypedefIncludesStatement

[Exposed=Window]interfacePaint { };[Exposed=Window]interfaceSolidColor :Paint {attributedoublered;attributedoublegreen;attributedoubleblue;};[Exposed=Window]interfacePattern :Paint {attributeDOMStringimageURL;};[Exposed=Window]interfaceGraphicalWindow {constructor();readonlyattributeunsignedlongwidth;readonlyattributeunsignedlongheight;attributePaintcurrentPaint;undefineddrawRectangle(doublex,doubley,doublewidth,doubleheight);undefineddrawText(doublex,doubley,DOMStringtext);};

2.1.이름

모든인터페이스,부분 인터페이스 정의,네임스페이스,부분 네임스페이스 정의,딕셔너리,부분 딕셔너리 정의,열거형,콜백 함수,콜백 인터페이스 및타입 정의(typedef) (이들을 통틀어이름이 있는 정의이라 함) 그리고 모든상수,속성,딕셔너리 멤버는식별자를 가지며, 일부연산도 마찬가지입니다. 식별자는 선언 내 어딘가에 등장하는identifier 토큰에 의해 결정됩니다:

• 이름이 있는 정의의 경우,identifier 토큰이interface,namespace,dictionary,enum 또는callback 키워드 바로 뒤에 나오며, 이 토큰이 해당 정의의 식별자를 결정합니다.

  interfaceinterface_identifier { /* interface_members... */ };partialinterfaceinterface_identifier { /* interface_members... */ };namespacenamespace_identifier { /* namespace_members... */ };partialnamespacenamespace_identifier { /* namespace_members... */ };dictionarydictionary_identifier { /* dictionary_members... */ };partialdictionarydictionary_identifier { /* dictionary_members... */ };enumenumeration_identifier {"enum","values" /* , ... */ };callbackcallback_identifier =return_type (/* arguments... */);callbackinterfacecallback_interface_identifier { /* interface_members... */ };

• 속성,타입 정의,딕셔너리 멤버의 경우, 선언 마지막에 세미콜론 앞에 위치한identifier 토큰이 식별자를 결정합니다.

  [extended_attributes]interfaceidentifier {attributetypeattribute_identifier;};typedeftypetypedef_identifier;dictionaryidentifier {typedictionary_member_identifier;};

• 상수의 경우, 등호 앞에 위치한identifier 토큰이 식별자를 결정합니다.

  consttypeconstant_identifier = 42;

• 연산의 경우, 반환 타입 뒤, 여는 괄호 앞에 위치한identifier 토큰(즉,OptionalOperationName 문법 기호의 일부로 매칭되는 토큰)이 연산의 식별자를 결정합니다. 만약 해당identifier 토큰이 없다면, 연산은 식별자를 가지지 않습니다.

  interfaceinterface_identifier {return_typeoperation_identifier(/* arguments... */);};

참고: 연산은 getter, setter와 같은특수 연산을 선언할 때 식별자가 없을 수 있습니다.

이러한 모든 구조에서,식별자는identifier 토큰 값에서 앞에 오는 U+005F (_)를 제거한 값입니다.

참고: 앞에 오는 U+005F (_)는 식별자가 예약어처럼 보이지 않게 하기 위해 사용되며, 예를 들어 "interface"라는 이름의 인터페이스를 정의할 수 있습니다. 식별자를 해제할 때는 앞의 U+005F (_)를 삭제합니다.

연산의 인자(argument)는 더 넓은 범위의 식별자 집합을 가질 수 있습니다. 연산 선언에서 인자의 식별자는 타입 뒤에 바로 명시되며,identifier 토큰 또는ArgumentNameKeyword 심볼에 매칭되는 키워드 중 하나로 지정됩니다. 이런 키워드가 사용될 경우, 앞에 밑줄로 이스케이프할 필요가 없습니다.

interfaceinterface_identifier {return_typeoperation_identifier(argument_typeargument_identifier /* , ... */);};

ArgumentNameKeyword ::attributecallbackconstconstructordeleterdictionaryenumgetterincludesinheritinterfaceiterablemaplikemixinnamespacepartialreadonlyrequiredsetlikesetterstaticstringifiertypedefunrestricted

identifier 토큰이 사용된 경우, 연산 인자의식별자는 해당 토큰 값에서 앞의 U+005F (_)를 제거한 값입니다. 만약ArgumentNameKeyword 키워드 토큰이 사용된다면, 연산 인자의식별자는 그 토큰 자체입니다.

위에 언급된 IDL 구조(연산 인자 제외)의식별자는 "constructor", "toString"이거나 U+005F (_)로 시작해서는 안 됩니다. 이런 것들은예약 식별자라 부릅니다.

"toJSON"식별자는예약 식별자는 아니지만,정상 연산에서만 객체를JSON 타입으로 변환하는 목적으로 사용해야 하며,§ 2.5.3.1 toJSON에서 설명합니다.

참고: 특정 구조에 대한 식별자 명명 제한은 이후 섹션에서 추가될 수 있습니다.

주어진 구현체가 지원하는IDL 프래그먼트 집합 내에서, 모든인터페이스,네임스페이스,딕셔너리,열거형,콜백 함수,콜백 인터페이스,타입 정의의식별자는 서로 같아서는 안 됩니다.

하나의IDL 프래그먼트 내에서는,정의에 대한 참조가 참조된 정의의 선언 뒤에 등장하지 않아도 됩니다. 또한IDL 프래그먼트 간에도 참조할 수 있습니다.

[Exposed=Window]interfaceB :A {undefinedf(SequenceOfLongsx);};[Exposed=Window]interfaceA {};typedefsequence<long>SequenceOfLongs;

// 타입 정의 식별자: "number"typedefdoublenumber;// 인터페이스 식별자: "System"[Exposed=Window]interfaceSystem {  // 연산 식별자:          "createObject"  // 연산 인자 식별자: "interface"objectcreateObject(DOMString_interface);  // 연산 인자 식별자: "interface"sequence<object>getObjects(DOMStringinterface);  // 연산에는 식별자가 없음; getter 선언임.getterDOMString (DOMStringkeyName);};// 인터페이스 식별자: "TextField"[Exposed=Window]interfaceTextField {  // 속성 식별자: "const"attributeboolean_const;  // 속성 식별자: "value"attributeDOMString?_value;};

2.2.인터페이스

IDL 프래그먼트는 객체 지향 시스템을 기술하는 데 사용됩니다. 이러한 시스템에서 객체란 정체성을 가지고 있으며, 상태와 행동을 캡슐화한 엔티티입니다.인터페이스는 (interfaceInterfaceRest에 일치) 해당 인터페이스를 구현하는 객체가 노출하는 상태와 행동을 선언하는 정의입니다.

[extended_attributes]interfaceidentifier {  /* interface_members... */};

인터페이스는인터페이스 멤버 (InterfaceMembers에 일치)의 집합을 명세합니다. 인터페이스 선언 중괄호 사이에 등장하는멤버들이 이에 해당합니다.

웹 IDL의 인터페이스는 해당 인터페이스를 구현하는 객체가 어떻게 동작하는지 기술합니다. 객체 지향 언어 바인딩에서는, 특정 IDL 인터페이스를 구현하는 객체가 객체의 상태를 검사하고 수정하며, 인터페이스가 기술하는 동작을 호출할 수 있도록 제공하는 것이 기대됩니다.

인터페이스는 다른 인터페이스를상속하도록 정의할 수 있습니다. 만약 인터페이스 식별자 뒤에 U+003A (:)와식별자가 오면, 해당 식별자가 상속받는 인터페이스를 나타냅니다. 어떤 객체가 다른 인터페이스를 상속한 인터페이스를 구현하면, 그 객체는 상속받은 인터페이스도 구현하게 됩니다. 즉, 객체는 상속된 인터페이스의 멤버도 가지게 됩니다.

interfaceidentifier :identifier_of_inherited_interface {  /* interface_members... */};

멤버의 등장 순서는자바스크립트 바인딩에서 프로퍼티 열거에 영향을 미칩니다.

인터페이스는 상속받은 인터페이스의 멤버와 같은 이름의 인터페이스 멤버를 명시할 수도 있습니다. 파생 인터페이스를 구현하는 객체는 파생 인터페이스의 멤버를 노출합니다. 오버라이드된 멤버를 객체에서 접근할 수 있는지는 언어 바인딩에 따라 다릅니다.

[Exposed=Window]interfaceA {undefinedf();undefinedg();};[Exposed=Window]interfaceB :A {undefinedf();undefinedg(DOMStringx);};

[Object.prototype: Object 프로토타입 객체]     ↑[A.prototype: A의 인터페이스 프로토타입 객체]     ↑[B.prototype: B의 인터페이스 프로토타입 객체]     ↑[instanceOfB]

주어진 인터페이스A의상속 인터페이스들은A가 직접 또는 간접적으로 상속하는 모든 인터페이스의 집합입니다.A가 다른 인터페이스를상속하지 않으면 집합은 비어 있습니다. 그렇지 않으면, 집합에는A가상속하는 인터페이스B와B의상속 인터페이스들이 포함됩니다.

인터페이스의 상속 계층에 순환(cycle)이 있어서는 안 됩니다. 즉, 인터페이스A가 자기 자신을 상속하거나,B에서A를 상속하는 등 반복적으로 상속할 수 없습니다.

일반적인 인터페이스의 다중 상속은 지원하지 않으며, 객체도 임의의 인터페이스 집합을 구현할 수 없습니다. 객체는 하나의 주어진 인터페이스A를 구현하도록 정의되며, 이는A의상속 인터페이스들도 구현함을 의미합니다. 추가로,includes 문을 사용하여인터페이스A를 구현하는 객체가인터페이스 믹스인 멤버도 항상 포함하도록 정의할 수 있습니다.A가include하는인터페이스 믹스인의 멤버를 포함합니다.

각 인터페이스 멤버는확장 속성 리스트(ExtendedAttributeList에 일치)가 앞에 올 수 있으며, 이는 해당 멤버가 언어 바인딩에서 어떻게 처리될지 제어합니다.

[extended_attributes]interfaceidentifier {  [extended_attributes]consttypeconstant_identifier = 42;  [extended_attributes]attributetypeidentifier;  [extended_attributes]return_typeidentifier(/* arguments... */);};

인터페이스에 대한 IDL은부분 인터페이스 정의(partialinterfacePartialInterfaceRest에 일치)를 사용하여 여러 부분으로 나눌 수 있습니다. 부분 인터페이스 정의의식별자는 반드시 인터페이스 정의의 식별자와 같아야 합니다. 각 부분 인터페이스에 등장하는 모든 멤버는 실제 인터페이스의 멤버로 간주합니다.

interfaceSomeInterface {  /* interface_members... */};partialinterfaceSomeInterface {  /* interface_members... */};

참고: 부분 인터페이스 정의는 명세 편집 시, 하나의 인터페이스 정의를 여러 문서 또는 여러 섹션에 나눠서 기술하는 데 도움을 주기 위한 것입니다.

인터페이스 정의와 그 부분 인터페이스 정의의 등장 순서는 중요하지 않습니다.

참고: 부분 인터페이스 정의는 인터페이스가 다른 인터페이스를상속하도록 지정할 수 없습니다. 상속은 원래의인터페이스 정의에서 지정해야 합니다.

적용되는 언어 바인딩이 인터페이스가 해당 언어의 구조와 어떻게 대응되는지 결정합니다.

다음 확장 속성들이 인터페이스에 적용될 수 있습니다: [CrossOriginIsolated], [Exposed], [Global], [LegacyFactoryFunction], [LegacyNoInterfaceObject], [LegacyOverrideBuiltIns], [LegacyWindowAlias], [SecureContext].

다음 확장 속성들은부분 인터페이스에 적용될 수 있습니다: [CrossOriginIsolated], [Exposed], [LegacyOverrideBuiltIns], [SecureContext].

인터페이스는 반드시 [Exposed]확장 속성으로 주석 처리해야 합니다.

CallbackOrInterfaceOrMixin ::callbackCallbackRestOrInterfaceinterfaceInterfaceOrMixin

InterfaceOrMixin ::InterfaceRestMixinRest

InterfaceRest ::identifierInheritance{InterfaceMembers};

Partial ::partialPartialDefinition

PartialDefinition ::interfacePartialInterfaceOrPartialMixinPartialDictionaryNamespace

PartialInterfaceOrPartialMixin ::PartialInterfaceRestMixinRest

PartialInterfaceRest ::identifier{PartialInterfaceMembers};

InterfaceMembers ::ExtendedAttributeListInterfaceMemberInterfaceMembers    ε

InterfaceMember ::PartialInterfaceMemberConstructor

PartialInterfaceMembers ::ExtendedAttributeListPartialInterfaceMemberPartialInterfaceMembers    ε

PartialInterfaceMember ::ConstOperationStringifierStaticMemberIterableAsyncIterableReadOnlyMemberReadWriteAttributeReadWriteMaplikeReadWriteSetlikeInheritAttribute

Inheritance :::identifier    ε

[Exposed=Window]interfaceAnimal {attributeDOMStringname;};[Exposed=Window]interfaceHuman :Animal {attributeDog?pet;};[Exposed=Window]interfaceDog :Animal {attributeHuman?owner;};

[Exposed=Window]interfaceNode {readonlyattributeDOMStringnodeName;readonlyattributeNode?parentNode;NodeappendChild(NodenewChild);undefinedaddEventListener(DOMStringtype,EventListenerlistener);};callbackinterfaceEventListener {undefinedhandleEvent(Eventevent);};

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.인터페이스 믹스인

인터페이스 믹스인은 (interfaceMixinRest에 일치) 하나 이상의인터페이스에서include하여 객체가 노출할 수 있는 상태와 행동을 선언합니다.인터페이스에서include한인터페이스 믹스인을 구현하는 객체에 의해 노출됩니다.

interfacemixinidentifier {  /* mixin_members... */};

참고:인터페이스 믹스인은부분 인터페이스와 마찬가지로, 명세 편집의 편의를 위해 사용되어 일관된 기능 집합을 묶고, 여러 인터페이스(문서 간 포함 가능)에 포함할 수 있게 합니다. 언어 바인딩을 통해 직접 노출되도록 의도된 것이 아닙니다.§ 2.3.1 믹스인 및 부분 사용에서부분 인터페이스,인터페이스 믹스인,부분 인터페이스 믹스인 중 어느 것을 선택할지 설명합니다.

인터페이스 믹스인은인터페이스 믹스인 멤버 (MixinMembers에 일치) 집합을 명세합니다. 즉,상수,일반 연산,일반 속성,문자열 변환자들이 중괄호 사이에 선언됩니다.

이러한상수,일반 연산,일반 속성,문자열 변환자는 해당 객체가 구현할 수 있는 동작을 기술하며, 마치 이를인터페이스에 직접 명세한 것처럼 동작합니다.

정적 속성,정적 연산,특수 연산,이터러블,비동기 이터러블,maplike,setlike 선언은인터페이스 믹스인 선언에 포함될 수 없습니다.

인터페이스와 마찬가지로,인터페이스 믹스인의 IDL도부분 인터페이스 믹스인 정의(partialinterfaceMixinRest에 일치)를 이용해 여러 부분으로 나눌 수 있습니다. 부분 인터페이스 믹스인정의의식별자는 해당인터페이스 믹스인정의의 식별자와 같아야 합니다. 각 부분 인터페이스 믹스인에 등장하는 모든멤버는 실제인터페이스 믹스인의 멤버로 간주되고,인터페이스가include할 때도 포함됩니다.

interfacemixinSomeMixin {  /* mixin_members... */};partialinterfacemixinSomeMixin {  /* mixin_members... */};

멤버의 등장 순서는자바스크립트 바인딩에서 프로퍼티 열거에 영향을 줍니다.

인터페이스나딕셔너리와 달리,인터페이스 믹스인은 타입을 생성하지 않습니다.

이 명세에서 정의된 확장 속성 중, [CrossOriginIsolated], [Exposed], [SecureContext] 만인터페이스 믹스인에 적용됩니다.

includes 문은 (IncludesStatement에 일치) 모든인터페이스I (첫 번째식별자로 식별됨)를 구현하는 객체가멤버를인터페이스 믹스인M (두 번째 식별자로 식별됨)의 멤버를 추가로 포함해야 함을 선언하는 정의입니다.인터페이스I는include인터페이스 믹스인M을 포함한다고 합니다.

interface_identifierincludesmixin_identifier;

첫 번째식별자는인터페이스I를 참조해야 하며, 두 번째 식별자는인터페이스 믹스인M을 참조해야 합니다.

M의 각멤버는인터페이스I,J,K 등include하는 모든 인터페이스의멤버로 간주됩니다. 즉,M의 멤버m에 대해I는멤버m_I,J는멤버m_J,K는멤버m_K를 갖게 됩니다.호스트 인터페이스란m_I,m_J,m_K의 각각의I,J,K를 말합니다.

참고: 자바스크립트에서는,인터페이스 믹스인 멤버로 선언된일반 연산이내장 함수 객체 값의 데이터 속성으로 노출될 때, 각인터페이스 프로토타입 객체마다 별도내장 함수 객체가 생성됩니다.속성도 마찬가지로 접근자 속성의 getter와 setter가 각각 별도내장 함수 객체가 됩니다.

includes 문의 등장 순서는호스트 인터페이스에서인터페이스 믹스인이 포함되는 순서에 영향을 줍니다.

멤버 순서는 명확히 규정되어 있지 않으며, 특히인터페이스 믹스인이 별도 문서에 정의될 때 더욱 그렇습니다.issue #432에서 논의되고 있습니다.

이 명세에서 정의된 확장 속성 중includes 문에 적용 가능한 것은 없습니다.

interfaceEntry {readonlyattributeunsignedshortentryType;  // ...};interfacemixinObservable {undefinedaddEventListener(DOMStringtype,EventListenerlistener,booleanuseCapture);  // ...};EntryincludesObservable;

var e= getEntry();// Entry 인스턴스 얻기typeof e.addEventListener;// "function"으로 평가됨

CallbackOrInterfaceOrMixin ::callbackCallbackRestOrInterfaceinterfaceInterfaceOrMixin

InterfaceOrMixin ::InterfaceRestMixinRest

Partial ::partialPartialDefinition

PartialDefinition ::interfacePartialInterfaceOrPartialMixinPartialDictionaryNamespace

MixinRest ::mixinidentifier{MixinMembers};

MixinMembers ::ExtendedAttributeListMixinMemberMixinMembers    ε

MixinMember ::ConstRegularOperationStringifierOptionalReadOnlyAttributeRest

IncludesStatement ::identifierincludesidentifier;

2.3.1.믹스인 및 부분 사용

이 섹션은 참고용입니다.

인터페이스 믹스인은속성,상수,연산을여러인터페이스에 공유할 수 있게 해줍니다. 만약 하나의 인터페이스만 확장하려는 경우라면부분 인터페이스 사용을 고려할 수 있습니다.

예를 들면, 다음과 같이 하지 말고:

interfacemixinWindowSessionStorage {readonlyattributeStoragesessionStorage;};WindowincludesWindowSessionStorage;

이렇게 하세요:

partialinterfaceWindow {readonlyattributeStoragesessionStorage;};

또한, 다른 명세에서 노출하는인터페이스 믹스인을 확장하여 window와 worker 등 여러 컨텍스트에속성,상수,연산을 노출하는 등 공통적인 활용 사례를 타겟할 수도 있습니다.

예를 들어, 흔하지만 장황한 방식 대신:

interfacemixinGlobalCrypto {readonlyattributeCryptocrypto;};WindowincludesGlobalCrypto;WorkerGlobalScopeincludesGlobalCrypto;

WindowOrWorkerGlobalScope인터페이스 믹스인을부분 인터페이스 믹스인으로 확장할 수 있습니다:

partialinterfacemixinWindowOrWorkerGlobalScope {readonlyattributeCryptocrypto;};

2.4.콜백 인터페이스

콜백 인터페이스는정의로,callbackinterfaceidentifier{CallbackInterfaceMembers};에 일치합니다.§ 2.12 인터페이스를 구현하는 객체에서 설명한 대로, 어떤 객체든 구현할 수 있습니다.

참고:콜백 인터페이스는인터페이스가 아닙니다. 명칭과 문법은 표준의 이전 버전에서 유래된 것으로, 당시에는 개념적으로 더 많은 공통점이 있었습니다.

콜백 인터페이스는콜백 인터페이스 멤버 (CallbackInterfaceMembers에 일치)의 집합을 명세합니다. 이들은 인터페이스 선언의 중괄호 사이에 등장하는멤버입니다.

callbackinterfaceidentifier {  /* interface_members... */};

참고: 유사한 명칭의콜백 함수 정의도 참고하세요.

콜백 인터페이스는 정확히 하나의일반 연산을 정의해야 합니다.

콜백 인터페이스가상수를 선언하는 경우 반드시 [Exposed]확장 속성으로 주석 처리해야 합니다.

CallbackRestOrInterface ::CallbackRestinterfaceidentifier{CallbackInterfaceMembers};

CallbackInterfaceMembers ::ExtendedAttributeListCallbackInterfaceMemberCallbackInterfaceMembers    ε

CallbackInterfaceMember ::ConstRegularOperation

2.5.멤버

인터페이스,인터페이스 믹스인,네임스페이스는 중괄호 안에 등장하는멤버(각각InterfaceMembers,MixinMembers,NamespaceMembers에 일치)을 명세합니다. 멤버에는상수,속성,연산, 기타 선언이 있습니다.속성은 해당인터페이스,인터페이스 믹스인,네임스페이스를 구현하는 객체가 노출하는 상태를 설명하며,연산은 객체에서 호출할 수 있는 동작을 설명합니다.상수는 시스템 내 객체 사용자에게 편의를 제공하기 위한 이름 있는 상수 값을 선언합니다.

여러멤버에 대해 정의되는생성자 단계,getter 단계,setter 단계,메서드 단계는 해당인터페이스 또는인터페이스 믹스인 위에 정의된 멤버에서this 값을 사용할 수 있습니다. 이는 멤버가 선언된 인터페이스 타입, 혹은 멤버가 선언된 인터페이스 믹스인을include한 타입의 IDL 값입니다.

setter 단계에서는지정된 값도 사용할 수 있는데, 이는 해당속성이 선언된 타입의 IDL 값입니다.

인터페이스,인터페이스 믹스인,콜백 인터페이스,네임스페이스는 각각 지원하는멤버의 종류가 다르며,§ 2.2 인터페이스,§ 2.3 인터페이스 믹스인,§ 2.4 콜백 인터페이스,§ 2.6 네임스페이스에서 설명합니다. 아래 표는 이를 요약한 참고용 표입니다:

2.5.1.상수

상수는 (Const에 일치) 이름에 상수값을 바인딩하는 선언입니다. 상수는인터페이스와콜백 인터페이스에 등장할 수 있습니다.

상수는 과거에 주로 열거형 스타일로 명명된 정수 코드를 정의하는 데 사용되었습니다. 웹 플랫폼은 문자열 사용으로 이 패턴에서 벗어나고 있습니다. 이 기능을 사용하려는 편집자는 진행하기 전에이슈를 등록하여 논의할 것을 강력히 권고합니다.

consttypeconstant_identifier = 42;

상수의식별자는 동일한인터페이스 멤버 또는콜백 인터페이스 멤버의 식별자와 같아서는 안 됩니다(동일한인터페이스나콜백 인터페이스에 정의된). 또한 "length", "name", "prototype"이어서는 안 됩니다.

참고: 이 세 이름은 자바스크립트 바인딩에서인터페이스 객체에 정의된 프로퍼티 이름입니다.

상수의 타입(ConstType에 일치)은원시 타입이어야 하며, 그 외 타입은 허용되지 않습니다.식별자가 사용되는 경우, 해당 식별자는 원시 타입인타입 정의를 참조해야 합니다.

상수 선언의ConstValue 부분은 상수의 값을 나타내며, 두 개의 불리언 리터럴 토큰(true,false),integer 토큰,decimal 토큰, 또는 세 가지 특수 부동소수점 상수값(-Infinity,Infinity,NaN) 중 하나일 수 있습니다.

참고: 이 값들은(문자열, 빈 시퀀스 포함) 딕셔너리 멤버의기본값이나옵션 인자 기본값으로도 사용할 수 있습니다. 단, 문자열, 빈 시퀀스[], 기본 딕셔너리{}는상수의 값으로 사용할 수 없습니다.

불리언 리터럴 토큰true와false의 값은 IDLboolean 타입의true와false입니다.

integer 토큰의 타입은 사용되는 상수, 딕셔너리 멤버, 옵션 인자의 타입과 동일합니다. 해당 토큰의 값은§ 2.13 타입에서 주어진 타입의 유효 범위를 벗어나면 안 됩니다.

상수값이Infinity,-Infinity,NaN로 지정된 경우, 상수, 딕셔너리 멤버, 옵션 인자의 타입에 따라 IEEE 754 단정밀도 또는 배정밀도 부동소수점 숫자가 됩니다:

타입unrestricted float, 상수값Infinity

값은 IEEE 754 단정밀도 양의 무한대입니다.

타입unrestricted double, 상수값Infinity

값은 IEEE 754 배정밀도 양의 무한대입니다.

타입unrestricted float, 상수값-Infinity

값은 IEEE 754 단정밀도 음의 무한대입니다.

타입unrestricted double, 상수값-Infinity

값은 IEEE 754 배정밀도 음의 무한대입니다.

타입unrestricted float, 상수값NaN

값은 비트 패턴 0x7fc00000의 IEEE 754 단정밀도 NaN입니다.

타입unrestricted double, 상수값NaN

값은 비트 패턴 0x7ff8000000000000의 IEEE 754 배정밀도 NaN입니다.

decimal 토큰의 타입은 사용되는 상수, 딕셔너리 멤버, 옵션 인자의 타입과 동일합니다. 해당 토큰의 값은§ 2.13 타입에서 주어진 타입의 유효 범위를 벗어나면 안 됩니다. 또한,Infinity,-Infinity,NaN은float나double 타입의 값으로 사용할 수 없습니다.

null 토큰의 값은null 값이며,널 허용 타입의 멤버입니다.null 토큰의 타입은 해당 상수, 딕셔너리 멤버, 옵션 인자의 타입과 동일합니다.

상수에 할당된 값의 타입VT와 상수, 딕셔너리 멤버, 옵션 인자 자체의 타입DT는 호환되어야 하며,DT와VT가 동일하거나,DT가널 허용 타입이고내부 타입이VT인 경우에 해당합니다.

상수는 해당인터페이스 또는콜백 인터페이스의 특정 인스턴스와 연결되지 않습니다. 인스턴스에서상수가 노출되는지 여부는 언어 바인딩에 따라 다릅니다.

[Exposed=Window]interfaceA {constshortrambaldi = 47;};

상수에 적용 가능한 확장 속성은 다음과 같습니다: [CrossOriginIsolated], [Exposed], [SecureContext].

Const ::constConstTypeidentifier=ConstValue;

ConstValue ::BooleanLiteralFloatLiteralinteger

BooleanLiteral ::truefalse

FloatLiteral ::decimal-InfinityInfinityNaN

ConstType ::PrimitiveTypeidentifier

[Exposed=Window]interfaceUtil {constbooleanDEBUG =false;constoctetLF = 10;constunsignedlongBIT_MASK = 0x0000fc00;constdoubleAVOGADRO = 6.022e23;};

2.5.2.속성

속성은인터페이스 멤버 또는네임스페이스 멤버로, (inheritAttributeRest,staticOptionalReadOnlyAttributeRest,stringifierOptionalReadOnlyAttributeRest,OptionalReadOnlyAttributeRest, 또는AttributeRest에 일치) 주어진 타입과식별자를 가진 데이터 필드를 선언하며, 해당 값은 조회되거나(일부 경우) 변경될 수 있습니다. 속성에는 두 가지 종류가 있습니다:

1. 일반 속성은 해당인터페이스를 구현하는 객체가 지정된식별자의 데이터 필드 멤버를 갖도록 선언합니다.

   interfaceinterface_identifier {attributetypeidentifier;};

2. 정적 속성은 인터페이스를 구현하는 특정 객체와 관련되지 않은 속성을 선언할 때 사용합니다.

   interfaceinterface_identifier {staticattributetypeidentifier;};

속성에static 키워드가 없으면일반 속성을 선언한 것이고, 있으면정적 속성을 선언한 것입니다. 참고로인터페이스 멤버 외에도,읽기 전용일반 속성은네임스페이스 멤버가 될 수도 있습니다.

속성attr의getter 단계는 “attr getter 단계는 다음과 같다:”(목록) 또는 “attr getter 단계는 다음을 수행한다”(인라인 설명)와 같은 텍스트로 소개해야 합니다.

속성attr의setter 단계는 “attr setter 단계는 다음과 같다:”(목록) 또는 “attr setter 단계는 다음을 수행한다”(인라인 설명)와 같은 텍스트로 소개해야 합니다.

참고:getter 단계를 정의할 때는this에 암묵적으로 접근할 수 있습니다.setter 단계를 정의할 때는this와지정된 값에 암묵적으로 접근할 수 있습니다.

속성의식별자는 동일한인터페이스에 정의된 다른인터페이스 멤버의 식별자와 같아서는 안 됩니다. 정적 속성의 식별자는 "prototype"이면 안 됩니다.

속성의 타입은attribute 키워드 뒤에 등장하는 타입(Type에 일치)으로 정해집니다. 만약Type이식별자거나 식별자 다음에?가 붙은 경우, 해당 식별자는인터페이스,열거형,콜백 함수,콜백 인터페이스,타입 정의를 식별해야 합니다.

타입 정의를 해석한 후, 속성의 타입은 다음 타입의 널 허용 또는 비허용 버전이 되어서는 안 됩니다:

• 시퀀스 타입

• 비동기 시퀀스 타입

• 딕셔너리 타입

• 레코드 타입

• 유니온 타입에 널 허용 또는 비허용 시퀀스 타입, 딕셔너리, 레코드가평탄화된 멤버 타입 중 하나로 포함된 경우

속성은읽기 전용이며,readonly 키워드가attribute 키워드 앞에 있으면 그렇게 됩니다. 읽기 전용 속성이 정의된 인터페이스를 구현하는 객체는 해당 속성에 값을 할당할 수 없습니다. 언어 바인딩마다 할당이 단순히 금지되는지, 무시되는지, 예외가 발생하는지 다를 수 있습니다.

interfaceinterface_identifier {readonlyattributetypeidentifier;};

타입이프라미스 타입인 속성은 반드시읽기 전용이어야 하며, 또한 [LegacyLenientSetter], [PutForwards], [Replaceable], [SameObject] 확장 속성을 가질 수 없습니다.

읽기 전용이 아닌일반 속성은 상위 인터페이스에서 getter를상속받도록 선언할 수 있습니다. 이를 통해 상위 인터페이스의 읽기 전용 속성을 파생 인터페이스에서 쓰기 가능하게 만들 수 있습니다. 속성이 getter를상속하려면 선언에inherit이 포함되어야 합니다. getter를 상속받는 속성은 가장 가까운 상위 인터페이스에서 동일한 식별자를 가진 속성입니다. getter를 상속받는 속성과 상속하는 속성의 타입은 같아야 합니다.

참고: 문법상inherit는읽기 전용 속성이나정적 속성에 사용할 수 없습니다.

[Exposed=Window]interfaceAncestor {readonlyattributeTheTypetheIdentifier;};[Exposed=Window]interfaceDerived :Ancestor {inheritattributeTheTypetheIdentifier;};

stringifier 키워드가일반 속성 선언에 사용되면, 해당 인터페이스를 구현하는 객체가 해당 속성 값으로 문자열 변환됨을 의미합니다. 자세한 내용은§ 2.5.5 문자열 변환자를 참조하세요.

interfaceinterface_identifier {stringifierattributeDOMStringidentifier;};

다음확장 속성은 일반 및 정적 속성에 적용 가능합니다: [CrossOriginIsolated], [Exposed], [SameObject], [SecureContext].

다음확장 속성은 일반 속성에만 적용됩니다: [LegacyLenientSetter], [LegacyLenientThis], [PutForwards], [Replaceable], [LegacyUnforgeable].

ReadOnlyMember ::readonlyReadOnlyMemberRest

ReadOnlyMemberRest ::AttributeRestMaplikeRestSetlikeRest

ReadWriteAttribute ::AttributeRest

InheritAttribute ::inheritAttributeRest

AttributeRest ::attributeTypeWithExtendedAttributesAttributeName;

AttributeName ::AttributeNameKeywordidentifier

AttributeNameKeyword ::required

OptionalReadOnly ::readonly    ε

[Exposed=Window]interfaceAnimal {  // 임의의 문자열 값으로 설정 가능한 단순 속성.readonlyattributeDOMStringname;  // 값을 할당할 수 있는 속성.attributeunsignedshortage;};[Exposed=Window]interfacePerson :Animal {  // Animal에서 getter 동작을 상속받으며, Person 설명에서 별도 명시 필요 없음.inheritattributeDOMStringname;};

2.5.3.연산

연산은인터페이스 멤버,콜백 인터페이스 멤버,네임스페이스 멤버 (staticRegularOperation,stringifier,RegularOperation 또는SpecialOperation에 일치) 해당 인터페이스를 구현하는 객체에서 호출할 수 있는 동작을 정의합니다. 연산에는 세 가지 종류가 있습니다:

1. 일반 연산은 해당인터페이스를 구현하는 객체가 지정된식별자의 메서드를 갖도록 선언합니다.

   interfaceinterface_identifier {return_typeidentifier(/* arguments... */);};

2. 특수 연산은 객체 인덱싱, 문자열 변환 등 특별한 동작을 구현하는 객체에 선언할 때 사용합니다.

   interfaceinterface_identifier {  /* special_keyword */return_typeidentifier(/* arguments... */);  /* special_keyword */return_type (/* arguments... */);};

3. 정적 연산은 인터페이스를 구현하는 특정 객체와 관련되지 않은 연산을 선언할 때 사용합니다.

   interfaceinterface_identifier {staticreturn_typeidentifier(/* arguments... */);};

연산에 식별자가 있고static 키워드가 없으면일반 연산을 선언한 것입니다. 연산에 선언에특수 키워드(Special에 일치하는 키워드 또는stringifier 키워드)가 있으면 특수 연산을 선언합니다. 하나의 연산이 일반 연산과 특수 연산을 동시에 선언할 수도 있습니다. 자세한 내용은§ 2.5.6 특수 연산을 참조하세요. 참고로, 일반 연산은인터페이스 멤버 외에도,콜백 인터페이스 멤버 및네임스페이스 멤버가 될 수 있습니다.

연산에 식별자가 없으면 반드시 특수 키워드를 사용하여 특수 연산으로 선언해야 합니다.

일반 연산 또는정적 연산의 식별자는 동일한인터페이스,콜백 인터페이스,네임스페이스에 정의된상수나속성의 식별자와 같아서는 안 됩니다. 정적 연산의 식별자는 "prototype"이면 안 됩니다.

참고: 연산의 식별자는 동일 인터페이스의 다른 연산과 같을 수 있습니다. 이는 연산 오버로딩을 명세하는 방식입니다.

참고:정적 연산의 식별자는 동일 인터페이스에 정의된일반 연산의 식별자와 같을 수 있습니다.

연산의반환 타입은 연산 선언에서 식별자 앞에 등장하는 타입(Type에 일치)으로 정해집니다. 반환 타입이?가 붙은 식별자인 경우, 해당 식별자는인터페이스,딕셔너리,열거형,콜백 함수,콜백 인터페이스,타입 정의를 식별해야 합니다.

연산의 인자(ArgumentList에 일치)는 선언의 괄호 사이에 명시됩니다. 각 인자는 타입(Type에 일치) 뒤에식별자(ArgumentName에 일치)로 지정합니다.

참고: 표현력을 위해, 연산 인자의 식별자는ArgumentNameKeyword 심볼에 일치하는 키워드 중 하나로 지정할 수 있으며, 이 경우 이스케이프할 필요가 없습니다.

연산 인자의Type이?가 붙은 식별자인 경우, 해당 식별자는인터페이스,열거형,콜백 함수,콜백 인터페이스,타입 정의를 식별해야 합니다.?가 없는 식별자 타입인 경우, 해당 식별자는 위의 정의들 중 하나 또는딕셔너리를 식별해야 합니다.

인자 타입을 타입 정의 해석 후, 널 허용 타입(nullable type)이면, 그내부 타입은딕셔너리 타입일 수 없습니다.

interfaceinterface_identifier {return_typeidentifier(typeidentifier,typeidentifier /* , ... */);};

각 인자의 식별자는 동일 연산 선언 내의 다른 인자 식별자와 같아서는 안 됩니다.

각 인자는확장 속성 리스트(ExtendedAttributeList에 일치)가 앞에 올 수 있으며, 이는 해당 인자 값이 언어 바인딩에서 어떻게 처리되는지 제어합니다.

interfaceinterface_identifier {return_typeidentifier([extended_attributes]typeidentifier, [extended_attributes]typeidentifier /* , ... */);};

[Exposed=Window]interfaceDimensions {attributeunsignedlongwidth;attributeunsignedlongheight;};[Exposed=Window]interfaceButton {  // 인자를 받지 않고 불리언을 반환하는 연산.booleanisMouseOver();  // 오버로딩된 연산들.undefinedsetDimensions(Dimensionssize);undefinedsetDimensions(unsignedlongwidth,unsignedlongheight);};

연산 또는생성자 연산은 마지막 인자가... 토큰으로 선언된 경우가변 인자로 간주됩니다. 가변 인자 연산은 마지막 인자 이후 임의 개수의 인자를 받아 호출할 수 있음을 의미합니다. 추가 암시적 형식 인자들은 연산 선언의 마지막 명시적 인자와 동일한 타입입니다. 마지막 인자는 연산 호출 시 생략할 수도 있습니다.... 토큰은 반드시 연산 인자 리스트의 마지막 인자에만 사용할 수 있습니다.

interfaceinterface_identifier {return_typeidentifier(type...identifier);return_typeidentifier(typeidentifier,type...identifier);};

확장 속성 중인자 리스트를 받는 ([LegacyFactoryFunction]) 및콜백 함수도... 토큰이 인자 리스트에 사용되면가변 인자로 간주합니다.

[Exposed=Window]interfaceIntegerSet {readonlyattributeunsignedlongcardinality;undefinedunion(long...ints);undefinedintersection(long...ints);};

var s= getIntegerSet();// IntegerSet 인스턴스 얻기s.union();// 'ints'에 해당하는 인자를 안 넘김s.union(1,4,7);// 'ints'에 해당하는 인자를 세 개 넘김

인자에optional 키워드가 있으면옵션 인자로 간주합니다. 가변 인자(variadic) 연산의 마지막 인자도 옵션 인자로 간주됩니다. 인자를 옵션으로 선언하면 연산 호출 시 해당 인자를 생략할 수 있습니다. 연산이 가변 인자일 때 마지막 인자는 명시적으로 옵션 인자로 선언할 수 없습니다.

interfaceinterface_identifier {return_typeidentifier(typeidentifier,optionaltypeidentifier);};

옵션 인자는기본값도 가질 수 있습니다. 인자 식별자 뒤에 U+003D(=)와 값(DefaultValue에 일치)이 오면, 그 값이 옵션 인자의기본값이 됩니다. 가변 인자 연산의 마지막(암시적 옵션) 인자에는 기본값을 지정할 수 없습니다. 기본값은 해당 인자가 생략되어 호출될 때 적용됩니다.

interfaceinterface_identifier {return_typeidentifier(typeidentifier,optionaltypeidentifier = "value");};

boolean 타입의 옵션 인자에true를 기본값으로 사용하는 것은 권장하지 않습니다. 저자는 기본 변환(즉undefined →false)을 예상할 수 있으므로 혼동을 줄 수 있습니다.[API-DESIGN-PRINCIPLES]

인자 타입이딕셔너리 타입 또는유니온 타입이며, 해당 딕셔너리 타입 및 조상에필수 멤버가 없고, 인자가 마지막이거나 뒤따르는 인자들이 모두옵션 인자라면, 해당 인자는 옵션으로 선언되고 기본값을 지정해야 합니다.

불리언 리터럴 토큰(true,false),null 토큰,integer 토큰,decimal 토큰,Infinity,-Infinity,NaN 중 하나가 옵션 인자 기본값으로 사용되면,상수에 대해와 동일하게 해석합니다.

undefined 토큰이 옵션 인자 기본값으로 사용된 경우, 값은 IDLundefined입니다.

옵션 인자의 타입이열거형이면, 지정된기본값은 반드시 해당열거형 값 중 하나여야 합니다.

옵션 인자 기본값으로 두 토큰 값[]를 사용할 수 있으며, 이는 빈 시퀀스 값을 나타냅니다. 타입은 해당 옵션 인자의 타입과 동일해야 하며, 반드시시퀀스 타입,널 허용 타입 중 내부 타입이 시퀀스 타입인 것,유니온 타입,널 허용 유니온 타입은시퀀스 타입을평탄화된 멤버 타입 중 하나로 가져야 합니다.

옵션 인자 기본값으로 두 토큰 값{}도 사용할 수 있으며, 이는 기본 초기화된(ESnull 또는 속성이 없는 객체와 같이) 딕셔너리 값을 의미합니다. 타입은 해당 옵션 인자의 타입과 동일해야 하며, 반드시딕셔너리 타입이거나유니온 타입 중딕셔너리 타입을평탄화된 멤버 타입 중 하나로 가져야 합니다.

[Exposed=Window]interfaceColorCreator {objectcreateColor(doublev1,doublev2,doublev3,optionaldoublealpha);};

[Exposed=Window]interfaceColorCreator {objectcreateColor(doublev1,doublev2,doublev3);objectcreateColor(doublev1,doublev2,doublev3,doublealpha);};

dictionaryLookupOptions {booleancaseSensitive =false;};[Exposed=Window]interfaceAddressBook {booleanhasAddressForName(USVStringname,optionalLookupOptionsoptions = {});};

연산에 적용 가능한 확장 속성은 다음과 같습니다: [CrossOriginIsolated], [Default], [Exposed], [LegacyUnforgeable], [NewObject], [SecureContext].

연산operation의메서드 단계는 “operation(arg1,arg2, ...) 메서드 단계는 다음과 같다:”(목록) 또는 “operation(arg1,arg2, ...) 메서드 단계는 다음을 수행한다”(인라인 설명)와 같은 텍스트로 소개해야 합니다.

참고:메서드 단계를 정의할 때는this에 암묵적으로 접근할 수 있습니다.

DefaultValue ::ConstValuestring[]{}nullundefined

Operation ::RegularOperationSpecialOperation

RegularOperation ::TypeOperationRest

SpecialOperation ::SpecialRegularOperation

Special ::gettersetterdeleter

OperationRest ::OptionalOperationName(ArgumentList);

OptionalOperationName ::OperationName    ε

OperationName ::OperationNameKeywordidentifier

OperationNameKeyword ::includes

ArgumentList ::ArgumentArguments    ε

Arguments ::,ArgumentArguments    ε

Argument ::ExtendedAttributeListArgumentRest

ArgumentRest ::optionalTypeWithExtendedAttributesArgumentNameDefaultTypeEllipsisArgumentName

ArgumentName ::ArgumentNameKeywordidentifier

Ellipsis ::...    ε

ArgumentNameKeyword ::attributecallbackconstconstructordeleterdictionaryenumgetterincludesinheritinterfaceiterablemaplikemixinnamespacepartialreadonlyrequiredsetlikesetterstaticstringifiertypedefunrestricted

2.5.3.1.toJSON

toJSON일반 연산을 선언함으로써,인터페이스는 해당 인터페이스를 구현하는 객체를JSON 타입으로 변환하는 방법을 명세합니다.

toJSON일반 연산은 이러한 용도를 위해 예약되어 있습니다. 반드시 인자를 받지 않아야 하며,JSON 타입을 반환해야 합니다.

JSON 타입은 다음과 같습니다:

• 숫자 타입,

• boolean,

• 문자열 타입,

• 널 허용 타입 (내부 타입이JSON 타입인 경우),

• 주석 타입 (내부 타입이JSON 타입인 경우),

• 유니온 타입 (멤버 타입이 모두JSON 타입인 경우),

• 타입 정의 (새 이름이 부여되는 타입이JSON 타입인 경우),

• 시퀀스 타입 (파라미터 타입이JSON 타입인 경우),

• 불변 배열 타입 (파라미터 타입이JSON 타입인 경우),

• 딕셔너리 타입 (딕셔너리와 상속받은 모든 멤버 타입이JSON 타입인 경우),

• 레코드 (모든 값이JSON 타입인 경우),

• object,

• 인터페이스 타입 (자신이나 상속받은 인터페이스에toJSON 연산이 선언된 경우),

toJSON일반 연산 이 객체에서 어떻게 노출되는지, 그리고JSON 타입이 JSON 문자열로 변환되는 방식은 언어 바인딩에 따라 다릅니다.

참고: 자바스크립트 바인딩에서는,toJSON 메서드를 노출하여JSON 타입을 자바스크립트 값으로 반환하고,JSON.stringify() 함수로 JSON 문자열로 변환할 수 있도록 합니다. 또한, 자바스크립트 바인딩에서toJSON 연산에 [Default]확장 속성을 사용할 수 있으며, 이 경우기본 toJSON 단계가 대신 노출됩니다.

[Exposed=Window]interfaceTransaction {readonlyattributeDOMStringfrom;readonlyattributeDOMStringto;readonlyattributedoubleamount;readonlyattributeDOMStringdescription;readonlyattributeunsignedlongnumber;TransactionJSONtoJSON();};dictionaryTransactionJSON {Accountfrom;Accountto;doubleamount;DOMStringdescription;};

// 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의 멤버일 때생성자 단계는 “Thenewinterface(arg1,arg2, ...) 생성자 단계는 다음과 같다:”(목록) 또는 “Thenewinterface(arg1,arg2, ...) 생성자 단계는 다음을 수행한다”(인라인 설명)와 같은 텍스트로 소개해야 합니다.

생성자 단계는 아무 것도 하지 않거나,this에 전달된 값을 초기화하거나, 예외를 던질 수 있습니다.

생성자가this를 초기화하지 않는 경우, “Thenew Example(init) 생성자 단계는 아무 것도 하지 않는다.”라고 쓸 수 있습니다.

§ 3.7.1 인터페이스 객체에서생성자 연산이 어떻게 구현되는지 자세히 설명합니다.

[Exposed=Window]interfaceNodeList {Nodeitem(unsignedlongindex);readonlyattributeunsignedlonglength;};[Exposed=Window]interfaceCircle {constructor();constructor(doubleradius);attributedoubler;attributedoublecx;attributedoublecy;readonlyattributedoublecircumference;};

var x=new Circle();// 0개 인자 생성자로 Circle 인터페이스 구현 객체 생성// 플랫폼 객체 참조 반환var y=new Circle(1.25);// 1개 인자 생성자로 Circle 객체 생성var z=new NodeList();// 생성자 선언이 없으므로 TypeError 발생

Constructor ::constructor(ArgumentList);

ArgumentList ::ArgumentArguments    ε

Arguments ::,ArgumentArguments    ε

Argument ::ExtendedAttributeListArgumentRest

ArgumentRest ::optionalTypeWithExtendedAttributesArgumentNameDefaultTypeEllipsisArgumentName

ArgumentName ::ArgumentNameKeywordidentifier

Ellipsis ::...    ε

ArgumentNameKeyword ::attributecallbackconstconstructordeleterdictionaryenumgetterincludesinheritinterfaceiterablemaplikemixinnamespacepartialreadonlyrequiredsetlikesetterstaticstringifiertypedefunrestricted

2.5.5.문자열 변환자

인터페이스에문자열 변환자가 있으면, 해당 인터페이스를 구현하는 객체가 기본값이 아닌 문자열 변환(conversion)을 갖는다는 의미입니다. 문자열 변환자는stringifier 키워드로 지정할 수 있으며, 단독으로 사용될 경우 문자열 변환 연산을 만듭니다.

interfaceinterface_identifier {stringifier;};

인터페이스와 함께 설명되는 프로즈(prose)에서는 해당 인터페이스의문자열 변환 동작을 정의해야 합니다.

stringifier 키워드는속성에도 사용할 수 있습니다. 이 경우, 객체를 문자열로 변환할 때 사용할 값은 해당 속성의 값입니다.stringifier 키워드는 반드시DOMString 또는USVString 타입의 속성에만 사용할 수 있습니다. 또한정적 속성에는 사용할 수 없습니다.

interfaceinterface_identifier {stringifierattributeDOMStringidentifier;};

특정인터페이스에는 문자열 변환자가 최대 하나만 존재해야 합니다.

Stringifier ::stringifierStringifierRest

StringifierRest ::OptionalReadOnlyAttributeRest;

[Exposed=Window]interfaceStudent {constructor();attributeunsignedlongid;stringifierattributeDOMStringname;};

var s=new Student();s.id=12345678;s.name='周杰倫';var greeting='Hello, '+ s+'!';// greeting == 'Hello, 周杰倫!'

[Exposed=Window]interfaceStudent {constructor();attributeunsignedlongid;attributeDOMString?familyName;attributeDOMStringgivenName;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]interfaceDictionary {readonlyattributeunsignedlongpropertyCount;getterdouble (DOMStringpropertyName);setterundefined (DOMStringpropertyName,doublepropertyValue);};

특수 연산을 식별자를 사용해 정의하는 것은, 해당 특수 연산을 식별자 없이 별도의 선언으로 분리하는 것과 동등합니다. 이 방식은 인터페이스 연산의메서드 단계를 단순화하기 위해 허용됩니다.

[Exposed=Window]interfaceDictionary {readonlyattributeunsignedlongpropertyCount;getterdoublegetProperty(DOMStringpropertyName);setterundefinedsetProperty(DOMStringpropertyName,doublepropertyValue);};

[Exposed=Window]interfaceDictionary {readonlyattributeunsignedlongpropertyCount;doublegetProperty(DOMStringpropertyName);undefinedsetProperty(DOMStringpropertyName,doublepropertyValue);getterdouble (DOMStringpropertyName);setterundefined (DOMStringpropertyName,doublepropertyValue);};

특정특수 키워드는 연산에서 두 번 이상 등장해서는 안 됩니다.

Getter와 setter에는 두 가지 종류가 있습니다:DOMString을 프로퍼티 이름으로 받는이름 있는 프로퍼티 getter와이름 있는 프로퍼티 setter가 있고,unsigned long을 프로퍼티 인덱스로 받는인덱스 프로퍼티 getter 및인덱스 프로퍼티 setter가 있습니다. deleter는 한 종류만 있습니다:이름 있는 프로퍼티 deleter. 자세한 내용은§ 2.5.6.1 인덱스 프로퍼티와§ 2.5.6.2 이름 프로퍼티를 참조하세요.

특정인터페이스에는이름 있는 프로퍼티 deleter가 최대 하나, getter와 setter의 각 종류도 최대 하나만 존재해야 합니다.

인터페이스에 특정 종류의 setter가 있으면 반드시 같은 종류의 getter도 있어야 합니다.이름 있는 프로퍼티 deleter가 있으면, 반드시이름 있는 프로퍼티 getter도 있어야 합니다.

연산으로 선언된 특수 연산은가변 인자(variadic)가 아니어야 하며,옵션 인자를 가질 수 없습니다.

객체가 두 개 이상의인터페이스를 구현하며, 동일한 특수 연산을 정의한다면, 실제 어떤 특수 연산이 호출되는지는 정의되지 않습니다.

2.5.6.1.인덱스 프로퍼티

인덱스 프로퍼티 getter를 정의한인터페이스는인덱스 프로퍼티를 지원한다고 한다. 확장해서,플랫폼 객체가 인덱스 프로퍼티를 지원한다고 하려면 해당 객체가 인덱스 프로퍼티를 지원하는인터페이스를 구현하면 된다.

인터페이스가인덱스 프로퍼티를 지원하면, 인터페이스 정의에는 객체가 언제든지 어떤 인덱스로 인덱싱될 수 있는지 기술이 포함되어야 한다. 이 인덱스들을지원되는 프로퍼티 인덱스라고 한다.

인덱스 프로퍼티를 지원하는 인터페이스는 "length"라는정수형속성을 정의해야 한다.

인덱스 프로퍼티 getter는 반드시unsigned long 하나의 인자를 받아야 한다. 인덱스 프로퍼티 setter는 반드시 두 개의 인자를 받아야 하며, 첫 번째 인자는unsigned long이어야 한다.

interfaceinterface_identifier {gettertypeidentifier(unsignedlongidentifier);settertypeidentifier(unsignedlongidentifier,typeidentifier);gettertype (unsignedlongidentifier);settertype (unsignedlongidentifier,typeidentifier);};

인덱스 프로퍼티 getter와 setter 정의에는 다음 요구 사항이 적용된다:

• 인덱스 프로퍼티 getter가연산에식별자를 써서 지정된 경우, 객체를 지원되는 프로퍼티 인덱스로 인덱싱하면 해당 인덱스를 유일 인자로 넘겨 연산을 호출한 결과값이 반환된다. 만약 인덱스 프로퍼티 getter 선언에 식별자가 없다면, 인터페이스 정의에 주어진 인덱스에 대해인덱스 프로퍼티 값 결정 방법을 기술해야 한다.

• 인덱스 프로퍼티 setter가 연산에 식별자를 써서 지정된 경우, 객체를 지원되는 프로퍼티 인덱스와 값으로 프로퍼티 할당/생성을 위해 인덱싱하면, 인덱스를 첫 번째 인자, 값을 두 번째 인자로 넘겨 연산을 호출한 것과 동일하게 동작한다. 만약 인덱스 프로퍼티 setter 선언에 식별자가 없다면, 인터페이스 정의에 기존 인덱스 프로퍼티 값 설정(기존 인덱스 프로퍼티 값 설정)과 새 인덱스 프로퍼티 값 설정(새 인덱스 프로퍼티 값 설정) 방법을 기술해야 한다.

[Exposed=Window]interfaceA {getterDOMStringtoWord(unsignedlongindex);};

var a= getA();a.toWord(0);// "zero" 반환a[0];// 역시 "zero" 반환a.toWord(5);// "five" 반환a[5];// "5"라는 프로퍼티가 없으므로 undefined 반환

[Exposed=Window]interfaceOrderedMap {readonlyattributeunsignedlongsize;getteranygetByIndex(unsignedlongindex);setterundefinedsetByIndex(unsignedlongindex,anyvalue);getteranyget(DOMStringname);setterundefinedset(DOMStringname,anyvalue);};

// map은 OrderedMap 인터페이스를 구현하는 레거시 플랫폼 객체라고 가정var map= getOrderedMap();var x, y;x= map[0];// map.length > 0이면 아래와 동등:// x = map.getByIndex(0)// 즉, map에 "0"이라는 프로퍼티가 있으므로// 그렇지 않으면 x는 undefinedmap[1]=false;// 아래와 동등:// map.setByIndex(1, false)y= map.apple;// apple이라는 이름 프로퍼티가 있으면 아래와 동등:// y = map.get('apple')// 없으면 y는 undefinedmap.berry=123;// 아래와 동등:// map.set('berry', 123)delete map.cake;// cake라는 이름 프로퍼티가 있으면 해당 프로퍼티 삭제 후 아래 동등:// map.remove("cake")

2.5.6.2.이름 프로퍼티

이름 프로퍼티 getter를 정의한인터페이스는이름 프로퍼티를 지원한다고 한다. 확장해서,플랫폼 객체가 이름 프로퍼티를 지원한다고 하려면 해당 객체가 이름 프로퍼티를 지원하는인터페이스를 구현하면 된다.

인터페이스가이름 프로퍼티를 지원하면, 인터페이스 정의에는 객체를 언제든지 어떤 이름으로 인덱싱할 수 있는지(순서가 있는 이름 집합) 기술이 포함되어야 한다. 이 이름들을지원되는 프로퍼티 이름이라고 한다.

이름 프로퍼티 getter와 deleter는 반드시DOMString 하나의 인자를 받아야 한다. 이름 프로퍼티 setter는 반드시 두 개의 인자를 받아야 하며, 첫 번째 인자는DOMString이어야 한다.

interfaceinterface_identifier {gettertypeidentifier(DOMStringidentifier);settertypeidentifier(DOMStringidentifier,typeidentifier);deletertypeidentifier(DOMStringidentifier);gettertype (DOMStringidentifier);settertype (DOMStringidentifier,typeidentifier);deletertype (DOMStringidentifier);};

이름 프로퍼티 getter, setter, deleter 정의에는 다음 요구 사항이 적용된다:

• 이름 프로퍼티 getter가연산에식별자를 써서 지정된 경우, 객체를 지원되는 프로퍼티 이름으로 인덱싱하면 해당 이름을 유일 인자로 넘겨 연산을 호출한 결과값이 반환된다. 만약 이름 프로퍼티 getter 선언에 식별자가 없다면, 인터페이스 정의에 주어진 이름에 대해이름 프로퍼티 값 결정 방법을 기술해야 한다.

• 이름 프로퍼티 setter가 연산에 식별자를 써서 지정된 경우, 객체를 지원되는 프로퍼티 이름과 값으로 프로퍼티 할당/생성을 위해 인덱싱하면, 이름을 첫 번째 인자, 값을 두 번째 인자로 넘겨 연산을 호출한 것과 동일하게 동작한다. 만약 이름 프로퍼티 setter 선언에 식별자가 없다면, 인터페이스 정의에 기존 이름 프로퍼티 값 설정(기존 이름 프로퍼티 값 설정)과 새 이름 프로퍼티 값 설정(새 이름 프로퍼티 값 설정) 방법을 기술해야 한다.

• 이름 프로퍼티 deleter가 연산에 식별자를 써서 지정된 경우, 객체를 지원되는 프로퍼티 이름으로 삭제 인덱싱하면, 이름을 유일 인자로 넘겨 연산을 호출한 것과 동일하게 동작한다. 만약 이름 프로퍼티 deleter 선언에 식별자가 없다면, 인터페이스 정의에 주어진 이름에 대해기존 이름 프로퍼티 삭제 방법을 기술해야 한다.

참고:인덱스 프로퍼티와 마찬가지로,이름 프로퍼티 getter,setter 또는deleter 가 연산에 식별자를 써서 지정된 경우, 객체를 지원되지 않는 이름으로 인덱싱할 때 해당 연산을 해당 이름으로 호출하는 것과 반드시 같은 동작을 하는 것은 아니며, 실제 동작은 언어 바인딩마다 다릅니다.

2.5.7.정적 속성 및 연산

정적 속성 및정적 연산 은 해당 인터페이스의 특정 인스턴스가 아니라 인터페이스 자체에 연결되는 속성/연산입니다. 정적 속성과 연산은 선언에static 키워드를 사용해 지정합니다.

정적 연산을 호출하거나 정적 속성을 참조하는 것이 인터페이스 인스턴스에서 가능한지는 언어 바인딩마다 다릅니다.

StaticMember ::staticStaticMemberRest

StaticMemberRest ::OptionalReadOnlyAttributeRestRegularOperation

[Exposed=Window]interfacePoint { /* ... */ };[Exposed=Window]interfaceCircle {attributedoublecx;attributedoublecy;attributedoubleradius;staticreadonlyattributelongtriangulationCount;staticPointtriangulate(Circlec1,Circlec2,Circlec3);};

var circles= getCircles();// Circle 객체 배열typeof Circle.triangulate;// "function" 반환typeof Circle.triangulationCount;// "number" 반환Circle.prototype.triangulate;// undefined 반환Circle.prototype.triangulationCount;// 역시 undefined 반환circles[0].triangulate;// 이 역시 undefinedcircles[0].triangulationCount;// 이것도 undefined// 정적 연산 호출var triangulationPoint= Circle.triangulate(circles[0], circles[1], circles[2]);// 수행한 삼각분할 개수 확인window.alert(Circle.triangulationCount);

2.5.8.오버로딩

인터페이스에 정의된일반 연산 또는정적 연산이 동일한 종류(일반 또는 정적)의 다른 연산과 동일한식별자를 가지면, 해당 연산은오버로딩된 연산이라 한다. 오버로딩된 연산의 식별자가 인터페이스를 구현하는 객체에서 호출될 때, 전달된 인자의 개수와 타입에 따라 실제로 어떤 오버로딩된 연산이 호출되는지가 결정된다.생성자 연산도 오버로딩될 수 있다. 오버로딩된 연산과 생성자가 받을 수 있는 인자에는 몇 가지 제한이 있으며, 이를 설명하기 위해유효 오버로드 집합이라는 개념을 사용한다.

오버로딩된연산 집합은 다음 중 하나를 만족해야 한다:

• 연산 중반환 타입이프라미스 타입인 것이 없어야 한다;

• 모든연산의반환 타입이프라미스 타입이어야 한다.

연산은인터페이스,부분 인터페이스,인터페이스 믹스인,부분 인터페이스 믹스인 정의를 넘나들어 오버로딩될 수 없다.

[Exposed=Window]interfaceA {undefinedf();};partialinterfaceA {undefinedf(doublex);undefinedg();};partialinterfaceA {undefinedg(DOMStringx);};

유효 오버로드 집합은 특정연산, 생성자(생성자 연산 또는 [LegacyFactoryFunction]), 또는콜백 함수에 대해 허용되는 호출을 나타낸다.유효 오버로드 집합 계산 알고리즘은 다음 네 가지 IDL 구조에 대해 동작하며, 각 구조마다 필요한 입력이 있다:

일반 연산의 경우

정적 연산의 경우

• 연산이 정의된인터페이스

• 연산의식별자

• 전달할 인자의 개수

생성자의 경우

• 생성자 연산이 정의된인터페이스

• 전달할 인자의 개수

레거시 팩토리 함수의 경우

• [LegacyFactoryFunction] 확장 속성이 정의된인터페이스

• 레거시 팩토리 함수의식별자

• 전달할 인자의 개수

유효 오버로드 집합은 인터페이스에 지정된 오버로딩 연산과 생성자에 모호함이 있는지 판별하는 데 사용된다.

아이템들은유효 오버로드 집합의튜플로, (호출 객체,타입 리스트,옵셔널리티 리스트) 형태를 가진다. 아래에 각 아이템 설명:

• 호출 객체는유효 오버로드 집합이일반 연산,정적 연산 또는생성자 연산일 때 연산이고,유효 오버로드 집합이레거시 팩토리 함수일 때는 확장 속성이다.

• 타입 리스트는 IDL 타입들의리스트이다.

• 옵셔널리티 리스트는 "required", "optional", "variadic" 중 하나의옵셔널리티 값을 인덱스별로 가지는리스트이다. 해당 인자가옵션 인자인지,가변 인자인지를 표시한다.

각튜플은 해당 타입의 인자값 리스트로 연산, 생성자, 콜백 함수를 호출할 수 있음을 의미한다.옵션 인자 및가변 인자 연산/생성자 덕분에, 동일한 연산이나 생성자로 식별되는유효 오버로드 집합 아이템이 여러 개 있을 수 있다.

[Exposed=Window]interfaceA {  /* f1 */undefinedf(DOMStringa);  /* f2 */undefinedf(Nodea,DOMStringb,double...c);  /* f3 */undefinedf();  /* f4 */undefinedf(Eventa,DOMStringb,optionalDOMStringc,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 orlong)? 와(Interface2 orDOMString)?
   • (Interface1 orlong?) 와(Interface2 orDOMString)?
   • (Interface1 orlong?) 와(Interface2 orDOMString?)
   • (Dictionary1 orlong) 와(Interface2 orDOMString)?
   • (Dictionary1 orlong) 와(Interface2 orDOMString?)

2. 두 타입 모두유니온 타입 또는널 허용 유니온 타입이면, 각 멤버 타입이 서로 구별 가능하면true, 아니면false를 반환한다.

3. 한 타입이유니온 타입 또는 널 허용 유니온 타입이면, 유니온 타입의 각멤버 타입이 비유니온 타입과 구별 가능하면true, 아니면false를 반환한다.

4. 각 타입의내부 타입(주석 타입이면)과내부 타입(그 결과가 널 허용 타입이면)을 취한 "가장 안쪽" 타입을 고려한다. 이 두 타입이 아래 표의 카테고리에 속하고, 해당 교차점에 ● 또는 지정된 조건(a, b, c, d)이 만족되면true, 아니면false를 반환한다.

   카테고리:

   interface-like

   • 인터페이스 타입

   • 버퍼 소스 타입

   dictionary-like

   • 딕셔너리 타입

   • 레코드 타입

   • 콜백 인터페이스 타입

   sequence-like

   • 시퀀스 타입

   • 불변 배열 타입

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

   1. 식별된 두 interface-like 타입이 서로 다르고, 어떤플랫폼 객체도 두 타입을 모두 구현하지 않는다.

   2. 타입이 구별 가능하지만, 오버로딩에서 사용에 별도의 제한이 있다. 또한 이 타입의 유니온 사용에 관한 조언도 참고할 것.

   3. [LegacyTreatNonObjectAsNull] 확장 속성이 없는콜백 함수는 dictionary-like 카테고리 타입과 구별 가능하다.

      예를 들어, ECMAScript 값을콜백 함수와 딕셔너리-like 타입을 포함하는 유니온 타입으로 변환할 때, 값이호출 가능이면 콜백 함수로, 아니면 딕셔너리-like 타입으로 변환된다.

   4. 타입이 구별 가능하지만, ECMAScript 값 변환 시문자열 객체는비동기 시퀀스 타입으로 변환되지 않는다(해당 타입의 오버로드나 유니온이 있으면).

   double 과DOMString 은숫자 타입과문자열 타입 교차점에 ●이 있으므로 구별 가능하다.
   double 과long은 모두숫자 타입이므로, 숫자 타입 교차점에 ●이나 문자가 없으므로 구별 불가능하다.
   다음과 같을 때:

   callbackinterfaceCBIface {undefinedhandle();};[Exposed=Window]interfaceIface {attributeDOMStringattr2;};dictionaryDict {DOMStringfield1;};

   CBIface는Iface와는 구별 가능하다(딕셔너리-like와 인터페이스-like 교차점에 ●이 있음). 하지만Dict와는 구별 불가능하다(딕셔너리-like 교차점에 ● 없음).

   프라미스 타입은 위 표에 없으므로, 어떤 다른 타입과도 구별 불가능하다.

하나의항목 이상이 주어진효과적 오버로드 집합에 있고, 해당 항목들이 같은타입 리스트크기를 가진 경우, 그러한 항목들에 대해 어떤 인덱스i가 존재해야 하며, 각 항목 쌍에 대해 인덱스i의 타입들이구별 가능해야 합니다. 이러한 최소 인덱스를 해당 타입 리스트 크기를 가진효과적 오버로드 집합의 항목에 대한구별 인자 인덱스라고 합니다.

하나의효과적 오버로드 집합에는 같은항목이 동일한타입 리스트크기를 가질 때,하나의 항목이bigint 인자를구별 인자 인덱스에서 가지며, 다른 항목이숫자 타입 인자를 동일한구별 인자 인덱스에서 갖는 경우가 둘 이상 존재해서는 안 됩니다.

[Exposed=Window]interfaceB {undefinedf(DOMStringx);undefinedf(USVStringx);};

또한, 어떤 type list 크기의구별 인자 인덱스보다 작은 인덱스j에 대해, 모든 아이템의 type list에서j번째 타입이 같아야 하며, 모든 아이템의 optionality list에서j번째 optionality 값도 같아야 한다.

[Exposed=Window]interfaceB {  /* f1 */undefinedf(DOMStringw);  /* f2 */undefinedf(longw,doublex,Nodey,Nodez);  /* f3 */undefinedf(doublew,doublex,DOMStringy,Nodez);};

«  (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.오버로딩 vs. 유니온 타입

이 섹션은 참고용입니다.

interfaceCanvasDrawPathExcerpt {undefinedstroke();undefinedstroke(Path2Dpath);};

interfaceCanvasDrawPathExcerptOptional {undefinedstroke(optionalPath2Dpath);};

2.5.9.이터러블 선언

인터페이스는이터러블로 선언될 수 있으며, 이는 인터페이스 본문에이터러블 선언(Iterable에 일치)을 사용하여 지정한다.

interfaceinterface_identifier {iterable<value_type>;iterable<key_type,value_type>;};

인터페이스를 이터러블로 구현한 객체는 값을 시퀀스로 얻을 수 있도록 반복(iterate)할 수 있다.

참고: 자바스크립트 바인딩에서는 이터러블 인터페이스의인터페이스 프로토타입 객체에entries,forEach,keys,values,%Symbol.iterator% 프로퍼티가 있다.

타입 파라미터가 하나면값 이터레이터이며, 해당 타입의 값을 제공한다. 타입 파라미터가 둘이면쌍 이터레이터이며,값 쌍을 제공한다.

값 쌍은 키 타입과 값 타입이 주어졌을 때 두 개의구조체 아이템으로 이루어진다:

1. 아이템의이름이 "key"이고,값 쌍의키라 하며, 값은 키 타입의 IDL 값이다;

2. 아이템의이름이 "value"이고,값 쌍의값이라 하며, 값은 값 타입의 IDL 값이다.

값 이터레이터는 반드시인덱스 프로퍼티를 지원하는 인터페이스에만 선언될 수 있다. 값 이터레이터의 value-type은인덱스 프로퍼티 getter가 반환하는 타입과 같아야 한다. 값 이터레이터는 해당 객체의 인덱스 프로퍼티를 반복(iterate)하는 것으로 암묵적으로 정의된다.

쌍 이터레이터는인덱스 프로퍼티를 지원하는 인터페이스에 선언될 수 없다.

페어 반복자가 있는인터페이스에 대한 설명은 각인터페이스 인스턴스마다리스트를값 쌍의 형태로 정의해야 하며, 이 리스트는반복할 값 쌍입니다.

참고: 이는array 이터레이터 객체 동작 방식이다. 인덱스 프로퍼티를 지원하는 인터페이스의 경우,entries,keys,values,%Symbol.iterator% 가 반환하는 이터레이터 객체는 실제 array 이터레이터 객체이다.

이터러블 선언이 있는인터페이스에는 "entries", "forEach", "keys", "values"라는 이름의속성,상수,일반 연산이 존재해서는 안 되며, 상속받은 인터페이스에도 이 이름의속성,상수,일반 연산이 존재해서는 안 된다.

[Exposed=Window]interfaceSessionManager {SessiongetSessionForUser(DOMStringusername);iterable<DOMString,Session>;};[Exposed=Window]interfaceSession {readonlyattributeDOMStringusername;  // ...};

// 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 usernameof sm.keys()){  console.log(username);}// 아래도 동일하다.for(let[username, session]of sm){  console.log(username);}

인터페이스에는 하나의이터러블 선언만 존재해야 한다. 상속받은 인터페이스에도이터러블 선언이 있으면 안 된다.이터러블 선언이 있는 인터페이스와 그 상속 인터페이스에는maplike 선언,setlike 선언,비동기 이터러블 선언이 있어서는 안 된다.

이터러블 선언에 적용 가능한 확장 속성: [CrossOriginIsolated], [Exposed], [SecureContext].

Iterable ::iterable<TypeWithExtendedAttributesOptionalType>;

OptionalType ::,TypeWithExtendedAttributes    ε

2.5.10.비동기 이터러블 선언

인터페이스는비동기 반복 선언 (AsyncIterable과 일치) 을인터페이스의 본문에 사용함으로써 비동기적으로 반복 가능하도록 선언할 수 있습니다.

interfaceinterface_identifier {async_iterable<value_type>;async_iterable<value_type>(/* arguments... */);async_iterable<key_type,value_type>;async_iterable<key_type,value_type>(/* arguments... */);};

비동기 이터러블로 선언된인터페이스를구현하는 객체는 값을 비동기로 반복(iterate)해서 얻을 수 있다.

타입 파라미터가 하나면값 비동기 이터러블 선언이며, 해당 타입의 값을 비동기로 제공한다. 두 개면쌍 비동기 이터러블 선언이며,값 쌍을 비동기로 제공한다.

인자가 있다면,비동기 이터러블 선언의 인자(ArgumentList에 일치)는 모두옵션 인자여야 한다.

비동기 이터러블 선언이 있는인터페이스의 프로즈에는다음 반복 결과 얻기 알고리즘을 정의해야 한다. 이 알고리즘은 반복 중인인터페이스 인스턴스와 비동기 이터레이터 객체를 받으며(상태 저장에 유용),Promise를 반환해야 한다. 이 Promise는 reject되거나, 반복 종료 신호를 나타내는반복 종료 값을 resolve하거나, 아래 중 하나를 resolve한다:

값 비동기 이터러블 선언의 경우:

선언된 타입의 값

쌍 비동기 이터러블 선언의 경우:

선언된 두 타입의 값을 포함하는튜플

또한 프로즈에서비동기 이터레이터 반환 알고리즘을 정의할 수 있다. 이 알고리즘은 반복 중인인터페이스 인스턴스, 비동기 이터레이터 객체,any 타입의 인자 하나를 받는다. 이는 이터레이터가 중단될 때 호출되며,Promise를 반환해야 하며, fulfill되면 값은 무시되고, reject되면 에러가 사용자에게 전달된다.

자바스크립트 바인딩에서는 이 알고리즘을 통해 async iterator의return()이 호출될 때 동작을 커스터마이즈할 수 있다. 이는break나return으로for-await-of 루프를 빠져나갈 때 가장 흔히 발생한다.

throw()에 대한 유사한 hook도 추가할 수 있다. 현재까지 필요가 없었지만, 그런 API가 필요하다면이슈를 등록해 주세요.

또한 프로즈에서비동기 이터레이터 초기화 단계도 정의할 수 있다. 이는 반복 중인인터페이스 인스턴스, 새로 생성된 이터레이터 객체, 전달된 인자를 나타내는 IDL 값리스트를 받는다.

비동기 이터러블 선언이 있는인터페이스에는 "entries", "keys", "values"라는 이름의속성,상수,일반 연산이 존재해서는 안 되며, 상속받은 인터페이스에도 이 이름의속성,상수,일반 연산이 존재해서는 안 된다.

[Exposed=Window]interfaceSessionManager {SessiongetSessionForUser(DOMStringusername);async_iterable<DOMString,Session>;};[Exposed=Window]interfaceSession {readonlyattributeDOMStringusername;  // ...};

// SessionManager 인스턴스를 얻는다.// 예를 들어 "anna", "brian" 유저 세션이 있다고 가정.var sm= getSessionManager();typeof SessionManager.prototype.values;// "function" 반환var it= sm.values();// values()는 이터레이터 객체 반환typeof it.next;// "function" 반환// 아래 루프는 "anna", "brian"을 로그한다.forawait(let usernameof sm.keys()){  console.log(username);}// 이것도 동일하다.forawait(let[username, session]of sm){  console.log(username);}

인터페이스에는 하나의비동기 이터러블 선언만 존재해야 한다. 비동기 이터러블 선언이 있는 인터페이스의 상속 인터페이스에도 비동기 이터러블 선언이 있으면 안 된다. 비동기 이터러블 선언이 있는 인터페이스와 그 상속 인터페이스에는maplike 선언,setlike 선언,이터러블 선언이 있어서는 안 된다.

비동기 이터러블 선언에 적용 가능한 확장 속성: [CrossOriginIsolated], [Exposed], [SecureContext].

이확장 속성들은 현재는 적용되지 않으며, 추후 적용되면 예상대로 동작할 것이다.

AsyncIterable ::async_iterable<TypeWithExtendedAttributesOptionalType>OptionalArgumentList;

OptionalArgumentList ::(ArgumentList)    ε

2.5.11.Maplike 선언

인터페이스는maplike로 선언될 수 있으며, 이는 인터페이스 본문에maplike 선언 (ReadWriteMaplike 또는readonlyMaplikeRest에 일치)을 사용해 지정한다.

interfaceinterface_identifier {readonlymaplike<key_type,value_type>;maplike<key_type,value_type>;};

maplike로 선언된 인터페이스를 구현하는 객체는, 처음에는 비어 있고, 키–값 쌍의순서 있는 map을 나타내며, 이를 해당 객체의map 엔트리라고 한다. 키와 값의 타입은 maplike 선언의 꺾쇠 괄호에 지정된다. 키는 반드시 고유해야 한다.

명세 작성자는map 엔트리의 내용을 수정할 수 있으며, 이는 자바스크립트 코드에서 객체의 내용에 자동으로 반영된다.

maplike 인터페이스는 언어 바인딩에 적절한 map 엔트리 질의 API를 지원한다.readonly 키워드가 없으면, map 엔트리 수정 API도 지원한다.

참고: 자바스크립트 바인딩에서는 map 엔트리와 상호작용하는 API는 자바스크립트Map 객체와 유사하다.readonly 키워드가 있을 때는entries,forEach,get,has,keys,values,%Symbol.iterator% 메서드, 그리고size getter를 포함한다. 읽기–쓰기 maplike일 경우,clear,delete,set 메서드도 포함한다.

maplike 인터페이스에는 "entries", "forEach", "get", "has", "keys", "size", "values" 이름의속성,상수,일반 연산이 존재해서는 안 되며, 상속받은 인터페이스에도 이 이름의속성,상수,일반 연산이 존재해서는 안 된다.

읽기–쓰기 maplike 인터페이스에는 "clear", "delete", "set" 이름의속성 또는상수가 존재해서는 안 되며, 상속받은 인터페이스에도 해당 이름의속성이나상수가 있어서는 안 된다.

참고: 읽기–쓰기 maplike 인터페이스는일반 연산으로 "clear", "delete", "set" 이름을 가질 수 있으며, 이는 해당 메서드의 기본 구현을 덮어쓴다(§ 3.7.11 Maplike 선언 참조). 이런 연산이 정의되면, 각 메서드의 기본 구현에 명시된 입력/출력 기대치와 일치해야 한다.

인터페이스에는 하나의maplike 선언만 존재해야 한다. maplike 인터페이스의 상속 인터페이스에도 maplike 선언이 있으면 안 된다. maplike 인터페이스와 상속 인터페이스에는이터러블 선언,비동기 이터러블 선언,setlike 선언,인덱스 프로퍼티 getter가 있어서는 안 된다.

ReadOnlyMember ::readonlyReadOnlyMemberRest

ReadOnlyMemberRest ::AttributeRestMaplikeRestSetlikeRest

ReadWriteMaplike ::MaplikeRest

MaplikeRest ::maplike<TypeWithExtendedAttributes,TypeWithExtendedAttributes>;

이 명세에서 정의된확장 속성은maplike 선언에 적용되지 않는다.

예시 추가 필요.

2.5.12.Setlike 선언

인터페이스는setlike로 선언될 수 있으며, 이는 인터페이스 본문에setlike 선언 (ReadWriteSetlike 또는readonlySetlikeRest에 일치)을 사용해 지정한다.

interfaceinterface_identifier {readonlysetlike<type>;setlike<type>;};

setlike로 선언된 인터페이스를 구현하는 객체는, 처음에는 비어 있고, 값의순서 있는 집합을 나타내며, 이를 해당 객체의set 엔트리라고 한다. 값의 타입은 setlike 선언의 꺾쇠 괄호에 지정된다. 값은 반드시 고유해야 한다.

명세 작성자는set 엔트리의 내용을 수정할 수 있으며, 이는 자바스크립트 코드에서 객체의 내용에 자동으로 반영된다.

setlike 인터페이스는 언어 바인딩에 적절한 set 엔트리 질의 API를 지원한다.readonly 키워드가 없으면, set 엔트리 수정 API도 지원한다.

참고: 자바스크립트 바인딩에서는 set 엔트리와 상호작용하는 API는 자바스크립트Set 객체와 유사하다.readonly 키워드가 있을 때는entries,forEach,has,keys,values,%Symbol.iterator% 메서드, 그리고size getter를 포함한다. 읽기–쓰기 setlike일 경우,add,clear,delete 메서드도 포함한다.

setlike 인터페이스에는 "entries", "forEach", "has", "keys", "size", "values" 이름의속성,상수,일반 연산이 존재해서는 안 되며, 상속받은 인터페이스에도 이 이름의속성,상수,일반 연산이 존재해서는 안 된다.

읽기–쓰기 setlike 인터페이스에는 "add", "clear", "delete" 이름의속성 또는상수가 존재해서는 안 되며, 상속받은 인터페이스에도 해당 이름의속성이나상수가 있어서는 안 된다.

참고: 읽기–쓰기 setlike 인터페이스는일반 연산으로 "add", "clear", "delete" 이름을 가질 수 있으며, 이는 해당 메서드의 기본 구현을 덮어쓴다(§ 3.7.12 Setlike 선언 참조). 이런 연산이 정의되면, 각 메서드의 기본 구현에 명시된 입력/출력 기대치와 일치해야 한다.

인터페이스에는 하나의setlike 선언만 존재해야 한다. setlike 인터페이스의 상속 인터페이스에도 setlike 선언이 있으면 안 된다. setlike 인터페이스와 상속 인터페이스에는이터러블 선언,비동기 이터러블 선언,maplike 선언,인덱스 프로퍼티 getter가 있어서는 안 된다.

ReadOnlyMember ::readonlyReadOnlyMemberRest

ReadOnlyMemberRest ::AttributeRestMaplikeRestSetlikeRest

ReadWriteSetlike ::SetlikeRest

SetlikeRest ::setlike<TypeWithExtendedAttributes>;

이 명세에서 정의된확장 속성은setlike 선언에 적용되지 않는다.

예시 추가 필요.

2.6.네임스페이스

네임스페이스란, 전역 싱글턴과 관련 동작을 선언하는 정의(Namespace에 일치)입니다.

namespaceidentifier {  /* namespace_members... */};

네임스페이스는네임스페이스 멤버들의 명세(NamespaceMembers에 일치)입니다. 네임스페이스 멤버란, 네임스페이스 선언의 중괄호 사이에 등장하는일반 연산,읽기 전용일반 속성,상수입니다. 이 연산과 속성들은 네임스페이스에 패키징되는 동작을 설명합니다.

인터페이스와 마찬가지로, 네임스페이스의 IDL도부분 네임스페이스 정의(partialNamespace에 일치)를 사용해 여러 부분으로 나눌 수 있습니다. 부분 네임스페이스 정의의식별자는 네임스페이스 정의의 식별자와 동일해야 합니다. 각 부분 네임스페이스 정의에 등장하는 모든 멤버는 네임스페이스 자체의 멤버로 간주됩니다.

namespaceSomeNamespace {  /* namespace_members... */};partialnamespaceSomeNamespace {  /* namespace_members... */};

참고: 부분 인터페이스 정의처럼, 부분 네임스페이스 정의는 명세 편집을 돕기 위한 것으로, 네임스페이스 정의를 문서의 여러 섹션 또는 여러 문서에 걸쳐 분리해 기술할 수 있게 해줍니다.

멤버가 등장하는 순서는JavaScript 바인딩에서 프로퍼티 열거에 영향을 미칩니다.

인터페이스나 딕셔너리와 다르게, 네임스페이스는 타입을 생성하지 않습니다.

이 명세에서 정의된 확장 속성 중, [CrossOriginIsolated], [Exposed], [SecureContext]만 네임스페이스에 적용할 수 있습니다.

네임스페이스는 반드시 [Exposed]확장 속성으로 어노테이트해야 합니다.

Partial ::partialPartialDefinition

PartialDefinition ::interfacePartialInterfaceOrPartialMixinPartialDictionaryNamespace

Namespace ::namespaceidentifier{NamespaceMembers};

NamespaceMembers ::ExtendedAttributeListNamespaceMemberNamespaceMembers    ε

NamespaceMember ::RegularOperationreadonlyAttributeRestConst

namespaceVectorUtils {readonlyattributeVectorunit;doubledotProduct(Vectorx,Vectory);VectorcrossProduct(Vectorx,Vectory);};

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에 일치하는 정의로, 고정된 순서의순서 있는 map 데이터 타입을 정의하는 데 사용된다. 이 map의엔트리들은딕셔너리 멤버라 하며,키는 문자열이고값은 정의에서 지정한 특정 타입이다.

dictionaryidentifier {  /* dictionary_members... */};

딕셔너리 인스턴스는 언어별 표현(예: 해당하는 자바스크립트 객체)에 대한 참조를 유지하지 않는다. 예를 들어, 딕셔너리를연산에서 반환하면, 현재 딕셔너리 값으로부터 새로운 자바스크립트 객체가 생성된다. 반대로 연산에서 딕셔너리를 인자로 받을 경우, 전달된 자바스크립트 값으로부터 딕셔너리로 한 번만 변환이 수행된다. 딕셔너리를 수정해도 해당 자바스크립트 객체에는 반영되지 않고, 그 반대도 마찬가지다.

딕셔너리는속성이나상수의 타입으로 사용될 수 없다.

딕셔너리는 다른 딕셔너리를상속하도록 정의할 수 있다. 딕셔너리의 식별자 뒤에 콜론과식별자가 오면, 해당 식별자는 상속받는 딕셔너리를 식별한다. 반드시 딕셔너리를 식별해야 한다.

딕셔너리의 상속 계층에 순환 구조가 있으면 안 된다. 즉, 딕셔너리A가 자기 자신을 상속하거나,B를 상속하면서B가 다시A를 상속하는 방식은 금지된다.

dictionaryBase {  /* dictionary_members... */};dictionaryDerived :Base {  /* dictionary_members... */};

딕셔너리D의상속된 딕셔너리들은D가 직접 또는 간접적으로 상속받는 모든 딕셔너리 집합을 의미한다.D가 다른 딕셔너리를상속하지 않으면 집합은 비어 있다. 그렇지 않으면,D가 상속한 딕셔너리E와E의상속된 딕셔너리들이 모두 포함된다.

딕셔너리 멤버는필수로 지정될 수 있다. 이 경우, 해당 멤버에 값을 제공하지 않으면 언어별 값에서 딕셔너리로 변환할 때 오류가 발생한다. 필수가 아닌 멤버는옵션이다.

딕셔너리 멤버를필수로 지정하는 것은, 언어별 딕셔너리 표현(예: 연산 인자로 자바스크립트 값을 전달할 때)에서만 효과가 있다. 이외의 경우, 즉 딕셔너리를반환 타입으로만 사용하는 경우 등에는 멤버를옵션으로 남겨두는 것이 좋다.

타입D의 딕셔너리 값에는,D와D의상속된 딕셔너리들에 정의된 모든 딕셔너리 멤버에 대한엔트리가 있을 수 있다.필수 또는기본값이 지정된 멤버는 반드시 엔트리가 존재한다. 그 외 멤버의 엔트리는 존재할 수도 있고, 아닐 수도 있다.

자바스크립트 바인딩에서는, 딕셔너리 멤버에 해당하는 프로퍼티 값이undefined면, 해당 프로퍼티가 생략된 것과 동일하게 처리된다. 즉, 필수라면 오류가 발생하고, 기본값이 있으면 그 값이 사용되며, 그 외에는 딕셔너리 값에 해당엔트리가 존재하지 않는다.

연산 인자 기본값과 마찬가지로,boolean 타입 딕셔너리 멤버의기본값으로true를 사용하지 말 것을 강력히 권장한다. 이는undefined의 기본 변환이false가 되기를 기대하는 저자에게 혼란을 줄 수 있기 때문이다.[API-DESIGN-PRINCIPLES]

문자열키를 가진순서 있는 map은, 모든엔트리가 딕셔너리D의딕셔너리 멤버에 대응하고, 타입이 맞고, 필수 또는 기본값 멤버에 대한엔트리가 모두 존재하면 암묵적으로D 타입의 딕셔너리 값으로 간주될 수 있다.

dictionaryDescriptor {DOMStringname;sequence<unsignedlong>serviceIdentifiers;};

각딕셔너리 멤버(DictionaryMember에 일치)는Type에 일치하는 타입 뒤에식별자가 따라온다(타입 뒤에identifier 토큰). 이 식별자가 키–값 쌍의 키 이름이다.Type이식별자 뒤에?가 붙으면, 해당 식별자는인터페이스,열거형,콜백 함수,콜백 인터페이스,타입 정의 중 하나를 식별해야 한다.?가 없으면, 위 타입들 중 하나 또는딕셔너리여야 한다.

딕셔너리 멤버의 타입이 typedef 해석 후널 허용 타입이면,내부 타입이딕셔너리 타입이면 안 된다.

dictionaryidentifier {typeidentifier;};

옵션딕셔너리 멤버의 식별자 뒤에 U+003D(=)와 값(DefaultValue에 일치)이 오면, 해당 멤버의기본값이 된다. 이 값은 코드나 명세에서 값을 지정하지 않을 경우 기본으로 사용된다.

dictionaryidentifier {typeidentifier = "value";};

불리언 리터럴 토큰(true 또는false),null 토큰,integer 토큰,decimal 토큰, 세 가지 특수 부동소수점 리터럴(Infinity,-Infinity,NaN),string 토큰,[] 또는{} 토큰 시퀀스가기본값으로 사용되면,연산의옵션 인자 기본값과 같은 방식으로 해석된다.

딕셔너리 멤버 타입이열거형이면,기본값은 반드시열거형의 값 중 하나여야 한다.

딕셔너리 멤버 타입 앞에required 키워드가 있으면, 해당 멤버는필수딕셔너리 멤버로 간주된다.

dictionaryidentifier {requiredtypeidentifier;};

딕셔너리 멤버의 타입에는 해당 딕셔너리가 포함되면 안 된다. 타입이 딕셔너리D를 포함한다는 것은 다음 중 하나라도 참이면 성립한다:

• 타입이D이다.

• 타입이D를 상속하는 딕셔너리이다.

• 타입이널 허용 타입이면서,내부 타입이D를 포함한다.

• 타입이시퀀스 타입 또는불변 배열이면서, 요소 타입이D를 포함한다.

• 타입이유니온 타입이며, 멤버 타입 중 하나가D를 포함한다.

• 타입이 딕셔너리이고, 그 멤버 또는 상속 멤버의 타입 중D를 포함하는 것이 있다.

• 타입이record<K,V>이고,V가D를 포함한다.

인터페이스와 마찬가지로, 딕셔너리의 IDL도부분 딕셔너리 정의(partialDictionary에 일치)를 사용해 여러 부분으로 나눌 수 있다. 부분 딕셔너리 정의의식별자는 딕셔너리 정의의 식별자와 같아야 한다. 각 부분 딕셔너리 정의에 등장하는 모든 멤버는 딕셔너리 자체의 멤버로 간주된다.

dictionarySomeDictionary {  /* dictionary_members... */};partialdictionarySomeDictionary {  /* dictionary_members... */};

참고: 부분 인터페이스 정의와 같이, 부분 딕셔너리 정의는 명세 편집을 돕기 위한 것으로, 딕셔너리 정의를 문서의 여러 섹션이나 여러 문서에 걸쳐 분리할 수 있게 해준다.

딕셔너리의딕셔너리 멤버 순서는, 상속된 멤버가 비상속 멤버보다 앞에 오고, 한 딕셔너리 정의(부분 딕셔너리 포함) 내 멤버들은 식별자의 유니코드 코드포인트 기준으로 사전순 정렬된다.

dictionaryB :A {longb;longa;};dictionaryA {longc;longg;};dictionaryC :B {longe;longf;};partialdictionaryA {longh;longd;};

[Exposed=Window]interfaceSomething {undefinedf(Aa);};

var something= getSomething();// 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 ::partialPartialDefinition

PartialDefinition ::interfacePartialInterfaceOrPartialMixinPartialDictionaryNamespace

Dictionary ::dictionaryidentifierInheritance{DictionaryMembers};

DictionaryMembers ::DictionaryMemberDictionaryMembers    ε

DictionaryMember ::ExtendedAttributeListDictionaryMemberRest

DictionaryMemberRest ::requiredTypeWithExtendedAttributesidentifier;TypeidentifierDefault;

PartialDictionary ::dictionaryidentifier{DictionaryMembers};

Default ::=DefaultValue    ε

DefaultValue ::ConstValuestring[]{}nullundefined

Inheritance :::identifier    ε

[Exposed=Window]interfacePoint {constructor();attributedoublex;attributedoubley;};dictionaryPaintOptions {DOMStringfillPattern = "black";DOMStringstrokePattern;Pointposition;};[Exposed=Window]interfaceGraphicsContext {undefineddrawRectangle(doublewidth,doubleheight,optionalPaintOptionsoptions);};

// GraphicsContext 인스턴스 얻기var ctx= getGraphicsContext();// 사각형 그리기ctx.drawRectangle(300,200,{ fillPattern:"red", position:new Point(10,10)});

2.8.예외

예외란 오류를 나타내는 객체 타입으로, 구현체에서 throw 하거나 값처럼 다룰 수 있다. Web IDL에는 명세에서 연산, 속성 등에 참조 또는 throw할 수 있는 여러 기본 예외가 정의되어 있다.인터페이스에서DOMException을상속하여 커스텀 예외 타입도 정의할 수 있다.

단순 예외는 다음 타입 중 하나로 식별된다:

• EvalError

• RangeError

• ReferenceError

• TypeError

• URIError

이들은 JavaScript의에러 객체와 대응한다 (단,SyntaxError 와Error는 제외됨; 각각 JS 파서와 저자 용도로 예약되어 있음). 각단순 예외의 의미는 JavaScript 명세의 대응 에러 객체와 같다.

두 번째 예외 종류는DOMException으로, 발생한 오류에 대해name으로 프로그래밍적으로 상세 정보를 제공한다.name 값은 아래DOMException 이름 테이블에서 선정된다.

DOMException은인터페이스 타입이므로 IDL에서 타입으로 사용할 수 있다. 예를 들어연산의DOMException반환 타입으로 선언할 수 있지만, 예외는 반환이 아니라 throw하는 것이므로 이런 패턴은 바람직하지 않다.

세 번째 예외 종류는DOMException을 상속한 인터페이스이다. 이들은 더 복잡하므로§ 2.8.2 DOMException 파생 인터페이스에서 따로 설명한다.

단순 예외는 타입 이름을 제공해생성할 수 있다.DOMException은name과 함께 제공하여 생성한다. 예외는throw할 수도 있는데, 이때도 생성할 때와 동일한 정보가 필요하다. 두 경우 모두 예외가 무엇을 의미하는지에 대한 추가 정보를 제공할 수 있으며, 예외 메시지 작성에 유용하다.

예외 생성 및 throw의 실제 동작은 언어 바인딩마다 다르다.

§ 3.14.3 예외 생성 및 throw에서 자바스크립트 바인딩에서 예외 생성 및 throw의 상세 동작을 볼 수 있다.

2.8.1.기본DOMException 오류 이름

아래DOMException 이름 테이블은 기본DOMException 인터페이스 인스턴스에 허용되는 모든이름과, 각 이름의 의미 및 레거시 숫자 오류 코드 값을 설명합니다.

DOMException을상속한 인터페이스(아래§ 2.8.2 DOMException 파생 인터페이스 참고)는 자체 이름을 가지며, 이 테이블에는 포함되지 않습니다.

DOMException을생성하거나throw할 때, 명세서는 반드시 이 이름 중 하나를 사용해야 합니다. 만약 명세자가 어떤 이름도 적합하지 않다고 생각되면,이슈를 등록해 새로운 이름 추가를 논의해야 하며, 커뮤니티가 이런 작업을 조율할 수 있습니다. 새로운 케이스별 이름은, 웹 개발자가 단일 API에서 여러 오류 조건을 구분할 필요가 있을 때만 중요합니다.

DOMException 이름 중 "deprecated"로 표시된 것은 레거시를 위해 남아 있지만, 사용은 권장하지 않습니다.

참고: 여기 정의된 "SyntaxError"DOMException과 JavaScript의SyntaxError를 혼동하지 마세요. "SyntaxError"DOMException은 웹 API에서 파싱 오류(예: 셀렉터 파싱 등)를 보고하는 데 사용되며, JavaScriptSyntaxError는 JS 파서 용도로 예약되어 있습니다. 혼동을 피하기 위해, 항상 "SyntaxError"DOMException 표기를 사용하세요.[DOM]

2.8.2.DOMException 파생 인터페이스

예외가DOMException의name으로 제공되는 정보 외에, 추가로 프로그래밍적으로 조회 가능한 정보를 담아야 할 때, 명세 작성자는DOMException를상속하는인터페이스를 만들 수 있다. 이런 인터페이스는 개발자가 예측 가능한 형태로 다룰 수 있도록 다음 규칙을 따라야 한다:

• 인터페이스의식별자는 반드시Error로 끝나야 하며,DOMException 이름 테이블에 있는 이름이면 안 된다.

• 인터페이스에는, 인스턴스의name을 인터페이스의식별자로 설정하는생성자 연산이 있어야 한다.

• 생성자 연산의 첫 번째 인자는옵션DOMString 타입의message이며, 기본값은 빈 문자열이어야 하고, 인스턴스의message를message로 설정해야 한다.

• 생성자 연산의 두 번째 인자는 노출할 추가 정보를 담는딕셔너리여야 한다.

• 생성자 딕셔너리의 멤버와 동일한 이름을 가진읽기 전용속성을 가지며, 생성자 연산에서 받은 값을 반환해야 한다.

• 직렬화 가능한 객체여야 하며,직렬화 단계와역직렬화 단계에서 추가 정보가 보존되어야 한다.

이 요구로 인해, 이런 인터페이스의 상속된code 프로퍼티는 항상 0을 반환한다.

DOMException 파생 인터페이스를생성하거나throw하려면, 해당인터페이스식별자와 추가 정보가 필요하다.

2.8.3.미리 정의된DOMException 파생 인터페이스

이 표준에서는 현재 미리 정의된DOMException 파생 인터페이스가 하나 있다:

[Exposed=*,Serializable]interfaceQuotaExceededError :DOMException {constructor(optionalDOMStringmessage = "",optionalQuotaExceededErrorOptionsoptions = {});readonlyattributedouble?quota;readonlyattributedouble?requested;};dictionaryQuotaExceededErrorOptions {doublequota;doublerequested;};

QuotaExceededError 예외는 할당량을 초과했을 때 throw할 수 있다. 두 개의 속성(quota, requested)을 가지고 있으며, 웹 개발자가 자신의 요청과 할당량 값을 비교할 수 있도록 추가 정보를 제공한다.

이전 버전의 표준에서는 "QuotaExceededError"가기본DOMException 오류 이름 중 하나였으나, 이런 정보를 제공할 수 있도록 풀 인터페이스로 승격되었다.

모든QuotaExceededError 인스턴스는requested와quota라는 두 개의 숫자 또는 null 값을 가지며, 최초 값은 모두 null이다.

quota getter는this의quota를 반환한다.

requested getter는this의requested를 반환한다.

QuotaExceededError 인터페이스는DOMException의code getter를 상속받으며, 항상 22를 반환한다. 하지만 이 값에 의존하는 것은 권장되지 않는다(QuotaExceededError와DOMException 모두에서). 대신name getter를 사용하는 것이 더 낫다.

QuotaExceededError 객체는직렬화 가능한 객체이다.

QuotaExceededError를생성하거나throw할 때,requested와quota가 모두 null이 아니면서requested가quota보다 작으면 안 된다.

2.9.열거형

열거형이란,Enum에 일치하는 정의로, 타입의 유효 값이 미리 정해진 문자열 집합인 것을 선언한다. 열거형은DOMString 값이속성에 할당되거나연산에 인자로 전달될 때, 가능한 값을 제한하는 데 사용할 수 있다.

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

열거형 값은 쉼표로 구분된string 리터럴 목록으로 지정한다.열거형 값 목록에는 중복이 있으면 안 된다.

열거형 값은 모두 소문자로 하고, 여러 단어는 대시(-)로 구분하거나 아예 구분하지 않는 것이 강력히 권장된다. 특별한 이유가 없으면 다른 명명 규칙을 사용하지 말 것. 예를 들어, 객체 생성 의미의 값은 "createobject" 또는 "create-object"로 할 수 있다. 관련 API에서 일관성을 위해 단어 구분 방식도 신중히 결정할 것.

열거형 타입 속성에 유효하지 않은 문자열 값을 할당하거나,연산 인자로 전달하는 경우의 동작은 언어 바인딩에 따라 다르다.

참고: 자바스크립트 바인딩에서는 속성에 잘못된 문자열 값을 할당하면 무시되지만, 다른 맥락(예: 연산 인자)에서는 예외가 throw된다.

이 명세에서 정의된확장 속성은열거형에 적용되지 않는다.

Enum ::enumidentifier{EnumValueList};

EnumValueList ::stringEnumValueListComma

EnumValueListComma ::,EnumValueListString    ε

EnumValueListString ::stringEnumValueListComma    ε

enumMealType {"rice","noodles","other" };[Exposed=Window]interfaceMeal {attributeMealTypetype;attributedoublesize;     // g 단위undefinedinitialize(MealTypetype,doublesize);};

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" 명세에서는 플랫폼 객체 제공 함수에도 콜백 함수 타입을 사용하고 싶어합니다. 콜백 함수 대신 그냥 "함수"로 이름을 바꿔서 두 가지 용도 모두 명확히 할 수 있을까요?

콜백 함수란,callbackCallbackRest에 일치하는 정의로, 함수 타입을 선언하는 데 사용됩니다.

callbackidentifier =return_type (/* arguments... */);

참고: 유사 이름의콜백 인터페이스도 참고하세요.

등호 왼쪽의식별자가 콜백 함수 이름이며, 오른쪽의 반환 타입과 인자 목록(Type 및ArgumentList)이 함수 시그니처를 정의합니다.

콜백 함수는상수의 타입으로 사용될 수 없습니다.

콜백 함수에 적용 가능한 확장 속성: [LegacyTreatNonObjectAsNull].

CallbackOrInterfaceOrMixin ::callbackCallbackRestOrInterfaceinterfaceInterfaceOrMixin

CallbackRest ::identifier=Type(ArgumentList);

callbackAsyncOperationCallback =undefined (DOMStringstatus);[Exposed=Window]interfaceAsyncOperations {undefinedperformOperation(AsyncOperationCallbackwhenFinished);};

var ops= getAsyncOperations();// AsyncOperations 인스턴스 얻기ops.performOperation(function(status){  window.alert("Operation finished, status is "+ status+".");});

2.11.타입 정의(typedef)

타입 정의(typedef)란,Typedef에 일치하는 정의로, 타입에 새 이름을 선언하는 데 사용됩니다. 이 새 이름은 언어 바인딩에 노출되지 않으며, IDL 내에서 타입을 참조할 때만 약칭으로 쓰입니다.

typedeftypeidentifier;

새 이름을 부여받는 타입은typedef 키워드 뒤에 지정되며(TypeWithExtendedAttributes에 일치), 그 뒤의identifier 토큰이 이름이 됩니다.

Type은 동일하거나 다른typedef의 식별자가 되어서는 안 됩니다.

이 명세에서 정의된확장 속성은타입 정의에 적용되지 않습니다.

Typedef ::typedefTypeWithExtendedAttributesidentifier;

[Exposed=Window]interfacePoint {attributedoublex;attributedoubley;};typedefsequence<Point>Points;[Exposed=Window]interfaceWidget {booleanpointWithinBounds(Pointp);booleanallPointsWithinBounds(Pointsps);};

2.12.인터페이스를 구현하는 객체

하나의IDL 프래그먼트 집합에 대한 구현에서는, 객체가플랫폼 객체라고 할 수 있습니다.

플랫폼 객체란인터페이스를 구현하는 객체입니다.

레거시 플랫폼 객체란 [Global]확장 속성이 없는 인터페이스를 구현하고,인덱스 프로퍼티 또는이름 프로퍼티 또는 둘 다를 지원하는플랫폼 객체입니다.

예를 들어 브라우저에서는, 브라우저가 구현한 DOM 객체들(Node,Document 등 인터페이스 구현)은 페이지 내 자바스크립트에서 웹 페이지 내용을 접근할 수 있게 해주는플랫폼 객체입니다. 이런 객체들은 C++ 등으로 구현된 특수 객체일 수도 있고, 네이티브 자바스크립트 객체일 수도 있습니다. 어쨌든, 하나의 IDL 프래그먼트 집합에 대한 구현에서는, 모든플랫폼 객체를 인식할 수 있어야 합니다. 이것은 내부적으로 객체가 플랫폼 객체임을 기록하거나, 객체가 특정 C++ 클래스에서 구현된 것을 감지하는 방식 등으로 이뤄질 수 있습니다. 어떤 방식으로 인식할지는 구현체마다 다릅니다.

시스템 내 다른 객체들은 플랫폼 객체로 취급되지 않습니다. 예를 들어, 브라우저에서 웹 페이지가 자바스크립트 라이브러리를 불러와 DOM Core를 구현한다고 해도, 이 라이브러리에서Node 인터페이스를 구현해 만든 객체는 브라우저 구현체가Node를 구현한 플랫폼 객체로 취급되지 않습니다.

반면콜백 인터페이스는 어떤 자바스크립트 객체로도 구현할 수 있습니다. 이를 통해 웹 API가 저자(사용자) 정의 연산을 호출할 수 있습니다. 예를 들어, DOM Events 구현에서는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 ::SingleTypeUnionTypeNull

TypeWithExtendedAttributes ::ExtendedAttributeListType

SingleType ::DistinguishableTypeanyPromiseType

UnionType ::(UnionMemberTypeorUnionMemberTypeUnionMemberTypes)

UnionMemberType ::ExtendedAttributeListDistinguishableTypeUnionTypeNull

UnionMemberTypes ::orUnionMemberTypeUnionMemberTypes    ε

DistinguishableType ::PrimitiveTypeNullStringTypeNullidentifierNullsequence<TypeWithExtendedAttributes>Nullasync_sequence<TypeWithExtendedAttributes>NullobjectNullsymbolNullBufferRelatedTypeNullFrozenArray<TypeWithExtendedAttributes>NullObservableArray<TypeWithExtendedAttributes>NullRecordTypeNullundefinedNull

ConstType ::PrimitiveTypeidentifier

PrimitiveType ::UnsignedIntegerTypeUnrestrictedFloatTypebooleanbyteoctetbigint

UnrestrictedFloatType ::unrestrictedFloatTypeFloatType

FloatType ::floatdouble

UnsignedIntegerType ::unsignedIntegerTypeIntegerType

IntegerType ::shortlongOptionalLong

OptionalLong ::long    ε

StringType ::ByteStringDOMStringUSVString

PromiseType ::Promise<Type>

RecordType ::record<StringType,TypeWithExtendedAttributes>

Null ::?    ε

2.13.1.any

any 타입은 모든 다른 non-union 타입의 합집합입니다.

any 타입은 각 값이 특정 non-any 타입과 연결되어 있다는 점에서 discriminated union 타입과 유사합니다. 예를 들어,any 타입의 한 값은unsigned long 150이고, 또 다른 값은long 150입니다. 이 둘은 서로 다른 값입니다.

any 값의 특정 타입은특정 타입이라고 합니다. (union 타입의 값도특정 타입을 가집니다.)

2.13.2.undefined

undefined 타입은 고유한 값을 하나만 가집니다.

undefined 상수 값은 IDL에서undefined 토큰으로 표현됩니다.

undefined 타입은 어떤 경우에도(연산,콜백 함수,생성자 연산 등) 인자 타입이나,딕셔너리 멤버 타입(직접 또는 union 내)으로 사용해서는 안 됩니다. 대신옵션 인자나, non-필수딕셔너리 멤버를 사용하세요.

참고: 이 값은 이전에는void로 표기되었으며, 사용 방식이 더 제한적이었습니다.

2.13.3.boolean

boolean 타입은불리언과 대응됩니다.

boolean 상수 값은 IDL에서true와false 토큰으로 표현됩니다.

2.13.4.byte

byte 타입은8비트 부호 있는 정수와 대응됩니다.

byte 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.5.octet

octet 타입은8비트 부호 없는 정수와 대응됩니다.

octet 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.6.short

short 타입은16비트 부호 있는 정수와 대응됩니다.

short 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.7.unsigned short

unsigned short 타입은16비트 부호 없는 정수와 대응됩니다.

unsigned short 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.8.long

long 타입은32비트 부호 있는 정수와 대응됩니다.

long 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.9.unsigned long

unsigned long 타입은32비트 부호 없는 정수와 대응됩니다.

unsigned long 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.10.long long

long long 타입은64비트 부호 있는 정수와 대응됩니다.

long long 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.11.unsigned long long

unsigned long long 타입은64비트 부호 없는 정수와 대응됩니다.

unsigned long long 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.12.float

float 타입은 부동소수점 숫자 타입으로, 유한한 단정밀도 32비트 IEEE 754 부동소수점 숫자 집합에 대응합니다.[IEEE-754]

float 상수 값은 IDL에서decimal 토큰으로 표현됩니다.

32비트 부동소수점 타입을 특별히 써야 할 이유가 없다면,double을float 대신 사용하는 것이 좋습니다.double이 표현할 수 있는 값 집합이 JavaScript Number와 더 유사하기 때문입니다.

2.13.13.unrestricted float

unrestricted float 타입은 부동소수점 숫자 타입으로, 모든 가능한 단정밀도 32비트 IEEE 754 부동소수점 값(유한, 무한 및 NaN)을 포함합니다.[IEEE-754]

unrestricted float 상수 값은 IDL에서decimal 토큰으로 표현됩니다.

2.13.14.double

double 타입은 부동소수점 숫자 타입으로, 유한한 배정밀도 64비트 IEEE 754 부동소수점 숫자 집합에 대응합니다.[IEEE-754]

double 상수 값은 IDL에서decimal 토큰으로 표현됩니다.

2.13.15.unrestricted double

unrestricted double 타입은 부동소수점 숫자 타입으로, 모든 가능한 배정밀도 64비트 IEEE 754 부동소수점 값(유한, 무한 및 NaN)을 포함합니다.[IEEE-754]

unrestricted double 상수 값은 IDL에서decimal 토큰으로 표현됩니다.

2.13.16.bigint

bigint 타입은 범위가 제한되지 않은 임의의 정수 타입입니다.

bigint 상수 값은 IDL에서integer 토큰으로 표현됩니다.

2.13.17.DOMString

DOMString 타입은문자열과 대응됩니다.

참고:null은DOMString 타입의 값이 아닙니다.null을 허용하려면널 허용DOMString, 즉 IDL에서DOMString?을 사용해야 합니다.

참고:DOMString 값에는 매치되지 않는서로게이트코드 포인트가 포함될 수 있습니다. 이를 원하지 않는 경우USVString을 사용하세요.

IDL에서는DOMString 상수 값을 표현할 방법이 없습니다. 다만DOMString딕셔너리 멤버기본값이나연산 옵션 인자기본값에는문자열 리터럴 토큰의 값을 사용할 수 있습니다.

2.13.18.ByteString

ByteString 타입은바이트 시퀀스와 대응됩니다.