dom library Null safety
- The interface represents a controller object that allows you to abort one or more Web requests as and when desired. [...]
- The interface represents a signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object.
- The abstract interface is the base class upon which all DOM range types are defined. A range is an object that indicates the start and end points of a section of content within the document. [...]
- The Attr interface represents one of a DOM element's attributes as an object. In most DOM methods, you will directly retrieve the attribute as a string (e.g., Element.getAttribute()), but certain functions (e.g., Element.getAttributeNode()) or means of iterating return types. [...]
The CDATASection interface represents a CDATA section
that can be used within XML to include extended portions of
unescaped text. The symbols
&don’t need escaping as they normally do when inside a CDATA section. [...]
- The CharacterData abstract interface represents a Node object that contains characters. This is an abstract interface, meaning there aren't any objects of type : it is implemented by other interfaces like Text, Comment, or ProcessingInstruction, which aren't abstract.
The Comment interface represents textual notations within
markup; although it is generally not visually shown, such
comments are available to be read in the source view. Comments
are represented in HTML and XML as content between '
<!--' and '
-->'. In XML, the character sequence '
--' cannot be used within a comment.
- The interface represents events initialized by an application for any purpose. Note: This feature is available in Web Workers
The interface represents any web page loaded in the browser and
serves as an entry point into the web page's content, which is
the DOM tree. The DOM tree includes elements such as
<table>, among many others. It provides functionality globally to the document, like how to obtain the page's URL and create new elements in the document. [...]
- The interface represents a minimal document object that has no parent. It is used as a lightweight version of Document that stores a segment of a document structure comprised of nodes just like a standard document. The key difference is due to the fact that the document fragment isn't part of the active document tree structure. Changes made to the fragment don't affect the document (even on reflow) or incur any performance impact when changes are made.
- The interface represents a Node containing a doctype.
- The DOMImplementation interface represents an object providing methods which are not dependent on any particular document. Such an object is returned by the Document.implementation property.
The DOMTokenList interface represents a set of space-separated
tokens. Such a set is returned by Element.classList,
HTMLIframeElement.sandbox, or HTMLOutputElement.htmlFor. It is indexed beginning with
- is the most general base class from which all element objects (i.e. objects that represent elements) in a Document inherit. It only has methods and properties common to all kinds of elements. More specific classes inherit from . For example, the HTMLElement interface is the base interface for HTML elements, while the SVGElement interface is the basis for all SVG elements. Most functionality is specified further down the class hierarchy. [...]
- The Event interface represents an event which takes place in the DOM. [...]
- The interface represents an object that can handle an event dispatched by an EventTarget object. Note: Due to the need for compatibility with legacy content, accepts both a function and an object with a handleEvent() property function. This is shown in the example below.
- is a DOM interface implemented by objects that can receive events and may have listeners for them. [...]
The interface represents a generic collection (array-like object
arguments) of elements (in document order) and offers methods and properties for selecting from the list. [...]
- The interface provides the ability to watch for changes being made to the DOM tree. It is designed as a replacement for the older Mutation Events feature, which was part of the DOM3 Events specification.
The dictionary describes the configuration of a mutation
observer. As such, it's primarily used as the type of the
optionsparameter on the MutationObserver.observe() method.
- A represents an individual DOM mutation. It is the object that is passed to MutationObserver's callback.
- The NamedNodeMap interface represents a collection of Attr objects. Objects inside a are not in any particular order, unlike NodeList, although they may be accessed by an index as in an array. [...]
DOM interface is an abstract base
class upon which many other DOM API objects are based, thus
letting those object types
to be used similarly and often interchangeably. As an abstract
class, there is
no such thing as a plain object. All objects that implement
functionality are based on one of its subclasses. Most notable
Document, Element, and DocumentFragment.
In addition, every kind of DOM node is represented by an
interface based on
. These include Attr, CharacterData
(which Text, Comment, CDATASection and
ProcessingInstruction are all based on), DocumentType,
- A interface represents an object used to filter the nodes in a NodeIterator or TreeWalker. A knows nothing about the document or traversing nodes; it only knows how to evaluate a single node against the provided filter. Note: The browser doesn't provide any object implementing this interface. It is the user who is expected to write one, tailoring the acceptNode() method to its needs, and using it with some TreeWalker or NodeIterator objects.
- The interface represents an iterator over the members of a list of the nodes in a subtree of the DOM. The nodes will be returned in document order.
objects are collections of nodes, usually returned by
properties such as Node.childNodes and methods such as
document.querySelectorAll(). Although is not an Array, it is possible to iterate over it with
forEach(). It can also be converted to a real Array using
- The ProcessingInstruction interface represents a processing instruction; that is, a Node which embeds an instruction targeting a specific application but that can be ignored by any other applications which don't recognize the instruction. [...]
- The interface represents a fragment of a document that can contain nodes and parts of text nodes. [...]
- The ShadowRoot interface of the Shadow DOM API is the root node of a DOM subtree that is rendered separately from a document's main DOM tree. [...]
- The DOM interface extends AbstractRange to provide a method to specify a range of content in the DOM whose contents don't update to reflect changes which occur within the DOM tree. It offers the same set of properties and methods as AbstractRange. [...]
- The interface represents the textual content of Element or Attr. [...]
- The object represents the nodes of a document subtree and a position within them. [...]
- The XMLDocument interface represents an XML document. It inherits from the generic Document and does not add any specific methods or properties to it: nevertheless, several algorithms behave differently with the two types of documents.
- The interface allows to compile and evaluate XPath expressions. [...]
- This interface is a compiled XPath expression that can be evaluated on a document or specific node to return information from its DOM tree. This is useful when an expression will be reused in an application, because it is just compiled once and all namespace prefixes which occur within the expression are preresolved. [...]
- The interface permits prefix strings in an XPath expression to be properly bound to namespace URI strings. [...]
- The interface represents the results generated by evaluating an XPath expression within the context of a given node. Since XPath expressions can result in a variety of result types, this interface makes it possible to determine and handle the type and value of the result.
- Non-standard This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future. [...]
- The ChildNode mixin contains methods and properties that are common to all types of Node objects that can have a parent. It's implemented by Element, DocumentType, and CharacterData objects.