Riferimento XmL DOM
Introduzione a XML DOM

Il DOM (Document Object Model) è una interfaccia indipendente dal linguaggio e dalla piattaforma che permette ai programmi
e agli script di accedere e di modificare dinamicamente i contenuti, la struttura e lo stile dei documenti.
Modelli a Oggetti
Un modello a oggetti definisce: - Gli oggetti usati per rappresentare e manipolare un particolare tipo di informazione. - Le interfacce usate per interagire con gli oggetti definiti. - La semantica richiesta dagli oggetti e dalle interfacce definite. - Le relazioni e interazioni tra le interfacce e gli oggetti definiti. Nel nostro caso, il modello a oggetti è applicato alla struttura dei documenti XML. Il Document Object Model (DOM) XML è un modello a oggetti generico applicabile a tutti i documenti XML. Fornisce una rappresentazione dei documenti XML compatibile con i più noti linguaggi di programmazione. Incapsula ogni elemento caratteristico di XML (elementi, attributi, commenti...) in un oggetto specifico, che ne fornisce una interfaccia per la manipolazione. Permette di manipolare la struttura del documento in maniera object-oriented (orientata all'oggetto). Esistono varie versioni del DOM, strutturate in livelli: "DOM Level 0" o BOM Il termine " DOM Level 0 " o BOM, si riferisce ad un misto di funzionalità per documenti HTML (non formalmente specificate) e già esistenti, offerti da Netscape Navigator versione 3.0 e Microsoft Internet Explorer versione 3.0 prima dell'anno 1998, anno in in cui in ottobre, il W3C pubblicò il primo standard, chiamandolo: Document Object Model Level 1. "DOM Level 0" o BOM (Modello a Oggetti del Browser) [già trattato nella guida JavaScript] Come loggetto globale, Window definisce un assortimento di proprietà e metodi per la programmazione lato client. Il Browser Object Model è un modello a oggetti, privo di una specifica, esposto da un browser che consente di interagire e interfacciarsi con esso e con lo schermo del computer. Esso espone le funzionalità di un browser attraverso la definizione di una gerarchia di oggetti: quali window: location, screen, document, history, navigator, con proprietà e metodi per manipolare l'ambiente di esecuzione della pagina web.


immagine BOM

L'oggetto window racchiude tutto l'ambiente del browser, compresi i bordi della finestra, la pagina web e le azioni effettuate dagli utenti. L'oggetto window è l'oggetto di primo livello. Tramite window si possono impostare manualmente la visualizzazione delle barre del browser, aprire una nuova finestra, ridimensionarne una già aperta, chiuderla e così via. "Anche il DOM applicato al documento Html é stato già trattato nella guida JavaScript.


immagine BOM


Il DOM è stato progettato a più livelli

"DOM Liv.1" definisce l’infrastruttura generale e base su cui poggiare anche le versioni successive: Contiene funzionalità per la navigazione del documento e la manipolazione XmL e HtmL. "DOM Liv.2" Modifica alcuni metodi del livello 1, introduce supporto ai namespaces e alla clonazione dei nodi, ha espanso la versione precedente con supporto ai CSS e agli Eventi. "DOM Liv.3" Affronta caricamento e salvataggio del documento Xml e la sua convalida, introduce nuovi metodi e interfacce per una navigazione più rapida nel documento, per il supporto dei tipi di nodo e per la serializzazione.
Il DOM come sistema "modulare"
A partire dal livello 2, lo standard DOM è stato progettato con un sistema "modulare". L'obiettivo del gruppo W3C-DOM è di definire una interfaccia standard di programmazione per Xhtml suddiviso in tre parti: - Core: L'interfaccia di base "CORE" contiene le "INTERFACCIE FONDAMENTALI" di oggetti minimali a basso livello, che possono rappresentare qualsiasi documento strutturato HTML o XML, ma l'interfaccia del nucleo DOM, potrebbe non essere adeguata o conveniente per tutti gli utenti di documenti Xhtml, e per questo sono state fatte delle "INTERFACCIE SPECIFICHE". - HTML: Le specifiche "HTML" e "XML" forniscono "INTERFACCE SPECIALIZZATE" aggiuntive di livello superiore che vengono utilizzate con la specifica di base per fornire una visione più comoda e appropriata nel documento. Queste specifiche consistono di oggetti e metodi che consentono l'accesso più diretto e facile nei tipi specifici dei documenti per i quali sono state ideate. - XML: Nella specifica del Nucleo DOM sono comprese anche le "INTERFACCIE ESTESE" che ovviamente sono obbligatorie solo se si ha che fare con documenti XML in quanto sono interfaccie classificate a parte proprio perché si riferiscono ad elementi e attributi che esistono solo nei documenti XML. Segue un GRAFICO di riepilogo

ARCHITETTURA COMPLETA DEL W3C-Standard-DOM

immagine

Conformità

Una implementazione del Browser, è conforme al Livello-DOM(x) se supporta il modulo principale "CORE" con tutte le sue Interfacce fondamentali. Oppure è conforme a un modulo-DOM Levello(x) se supporta tutte le interfacce per quel modulo e la semantica associata. Ecco la lista completa dei moduli per i vari Livelli; i nomi delle funzioni sono case-insensitive. DOM Level 1 - Ultima versione pubblicata nel mese di ottobre 1998: Una API di 2 moduli: Core, HTML. DOM Level 2 - Pubblicato nel Novembre 2000: Una API di 14 moduli: Core, XML, HTML, Views, StyleSheets, CSS, CSS2, Events, User interface Events, Mouse Events, Mutation Events, HTML Events, Range, and Traversal. DOM Level 3 - Pubblicato in Aprile 2004: Una API di 16 moduli: Core, (X)HTML, XPath, Range, Validation, Load and Save, Asynchronous Load, Events, HTML Events, Mutation Events, Mutation Name Events, UI Events, Mouse Events, Text Events, Keyboard Events. La rappresentazione seguente contiene tutti i moduli DOM definiti come: Insieme delle SPECIFICHE DOM: Una API di 21 moduli: Core, XML, HTML, XPath, Travesal, Range, Validation, Load and Save, Asynchronous Load, Views, Stylesheets, CSS, CSS2, Events, HTML Events, Mutation Events, Mutation Name Events, UI Events, Mouse Events, Text Events, Keyboard Events. Comunque se si è interessati a una interfaccia particolore, il modo più sicuro rimane quello di chiederla direttamente al Browser con questa funzione: <html> <head> <title>prova Conformità DOM</title> </head> <body> <script type="text/javascript"> var supportato = document.implementation.hasFeature('Events', '2.0') document.writeln (supportato); </script> </body> </html> Se la risposta è true, l'interfaccia richiesta è supportata, se false no.

Rappresentazione di documenti come alberi

I documenti XML (e HTML) hanno una struttura gerarchica che è esemplificata nel DOM come "Struttura ad Albero". I nodi dell'albero rappresentano i vari tipi di contenuti in un documento. L'albero di un documento contiene principalmente: "Nodi Elemento"<elemento>e "Nodi Stringhe Testo" <elemento>Stringa di testo</elemento>. Un documento può contenere anche "Nodi Commento" <!-- commento della riga 48 --> vediamo un esempio:

Rappresentazione ad albero di un documento "XML" immagine


la Base del DOM: Interfacce DOM "CORE"

Dal punto di vista del modello a oggetti del DOM: - L'intero documento XML è formato da nodi; - Ogni elemento XML è un nodo elemento; - Il testo negli elementi XML è un nodo di testo; - Ogni attributo è un nodo attributo; - I commenti sono nodi di commenti; L'interfaccia Node include le operazioni di base eseguibili su ogni nodo (indipendentemente dal suo tipo specifico). Le varie classi derivate implementano poi delle interfacce più specifiche, che comprendono le operazioni proprie ciascun tipo. Prenderemo ora in esame Interfaccie, Metodi e Proprietà del Modulo Base: DOM "CORE" Livello 2 MODIFICHE E CAMBIAMENTI tra: DOM Level Core 1 e DOM Level Core 2 Tipo DOMString DOMString é ora definito come un Valuetype. Interfaccia Attr Attr ha un nuovo attributo: ownerElement. Interfaccia Document Document ha cinque nuovi metodi: ImportNode, createElementNS, createAttributeNS, getElementsByTagNameNS e GetElementById. Interfaccia NamedNodeMap NamedNodeMap dispone di tre nuovi metodi: getNamedItemNS, setNamedItemNS, removeNamedItemNS. Interface Node Node dispone di due nuovi metodi: isSupported e HasAttributes. E tre nuovi attributi: namespaceURI, prefix e localName. Interfaccia DocumentType DocumentType ha tre attributi: publicId, systemid e internalSubset. Interfaccia DOMImplementation DOMImplementation presenta due nuovi metodi: CreateDocumentType e createDocument. Interfaccia Element è stata spostata nell'interfaccia Node da cui ora eredita i suoi Metodi. Eccezione DOMException DOMException ha cinque nuovi codici di eccezione: INVALID_STATE_ERR, SYNTAX_ERR, INVALID_MODIFICATION_ERR, NAMESPACE_ERR e INVALID_ACCESS_ERR. NUOVI TIPI: DOMTimeStamp Il tipo DOMTimeStamp è stato aggiunto al modulo Nucleo. Interfacce fondamentali modulo Base: DOM Level Core 2 DOMException, ExceptionCode, DOMImplementation, DocumentFragment, Document, Node, NodeList, NamedNodeMap, CharacterData, Attr, Element, Text, Comment Interfacce estese: per XML CDATASection, DocumentType, notation, Entity, EntityReference, ProcessingInstruction.

Gerarchia del DOM Interfaccie di BASE
immagine

Come abbiamo visto, i nodi dell’albero DOM sono rappresentati da oggetti derivati dalla classe Node. In generale, le funzionalità presenti nelle interfacce DOM di base accettano e restituiscono solo oggetti di tipo Node, anche se in realtà tali oggetti appartengono sempre a una classe più specifica derivata da Node.

Nelle tabelle seguenti sono elencati i diversi tipi di nodi stabiliti dal W3C Ed a ogni tipo di NODO è associato un numero identificatore che vanno da 1 a 12:
proprietà
NodeTypeNome della costanteDescrizione
1 ELEMENT NODE Elemento
2 ATTRIBUTE NODE Attributo
3 TEXT NODE Contenuto Testuale
4 CDATA SECTION NODE Sezione CData
5 ENTITY REFERENCE NODE Riferimento a Entità
6 ENTITY NODE Entità
7 PROCESSING INSTRUCTION NODE Istruzione di Elaborazione
8 COMMENT NODE Commento
9 DOCUMENT NODE Intero Documento
10DOCUMENT TYPE NODE Interfaccia per Entità del Documento
11DOCUMENT FRAGMENT NODE Parte di un Documento
12NOTATION NODE Nota della Dichiarazione
Ci sono 12 tipi di nodi diversi, che possono avere vari tipi di nodi figli:
NodeTypeTipo di nodoFigli
1Elemento Elemento, testo, commento, Processing Instruction, CDATASection, Entity Reference
2Attributo Testo, EntityReference
3Testo Nessuno
4CDATASection Nessuno
5Entity Reference Elemento, Processing Instruction, Comment, Testo, CDATASection, Entity Reference
6Entità Elemento, Processing Instruction, Comment, Testo, CDATASection, Entity Reference
7Processing InstructionNessuno
8Commento Nessuno
9Documento Elemento(max uno), Processing Instruction, Comment, Documen tType (max uno)
10 DocumentType Nessuno
11 Document Fragment Elemento, Processing Instruction, Comment, Testo, CDATASection, Entity Reference
12 Notazione Nessuno
Ritorno valore proprietà node Name e node Value per ogni tipo di nodo:
Node TypeTipo di nodonode Name: restituiscenode Value: restituisce
1 Elemento nome elemento null
2 Attributo nome attributo valore dell'attributo
3 Testo #Text contenuto del nodo
4 CDATA Section #Cdata section contenuto del nodo
5 Entity Reference soggetto riferimento nomenull
6 Entità nome entità null
7 Processing Instruction obiettivo contenuto del nodo
8 Commento #Comment testo di commento
9 Documento #Documento null
10 DocumentType nome DOCTYPE null
11 Document Fragment #Documento frammento null
12 Notazione nome notazione null


Interfaccia dell'oggetto Node

L'interfaccia dell'oggetto Node è il tipo di dati principale per l'intero Document Object Model e rappresenta un singolo nodo nell'albero del documento, Mentre tutti gli oggetti che implementano la sua interfaccia espongono i metodi per trattare con gli elementi figli, (sempre che ne abbiano). interface Node { // NodeType const unsigned short ELEMENT_NODE = 1; const unsigned short ATTRIBUTE_NODE = 2; const unsigned short TEXT_NODE = 3; const unsigned short CDATA_SECTION_NODE = 4; const unsigned short ENTITY_REFERENCE_NODE = 5; const unsigned short ENTITY_NODE = 6; const unsigned short PROCESSING_INSTRUCTION_NODE = 7; const unsigned short COMMENT_NODE = 8; const unsigned short DOCUMENT_NODE = 9; const unsigned short DOCUMENT_TYPE_NODE = 10; const unsigned short DOCUMENT_FRAGMENT_NODE = 11; const unsigned short NOTATION_NODE = 12; readonly attribute DOMString nodeName; attribute DOMString nodeValue; // raises(DOMException) on setting // raises(DOMException) on retrieval readonly attribute unsigned short nodeType; readonly attribute Node parentNode; readonly attribute NodeList childNodes; readonly attribute Node firstChild; readonly attribute Node lastChild; readonly attribute Node previousSibling; readonly attribute Node nextSibling; readonly attribute NamedNodeMap attributes; // Modified in DOM Level 2: readonly attribute Document ownerDocument; Node insertBefore(in Node newChild, in Node refChild) raises(DOMException); Node replaceChild(in Node newChild, in Node oldChild) raises(DOMException); Node removeChild(in Node oldChild) raises(DOMException); Node appendChild(in Node newChild) raises(DOMException); boolean hasChildNodes(); Node cloneNode(in boolean deep); // Modified in DOM Level 2: void normalize(); // Introduced in DOM Level 2: boolean isSupported(in DOMString feature, in DOMString version); // Introduced in DOM Level 2: readonly attribute DOMString namespaceURI; // Introduced in DOM Level 2: attribute DOMString prefix; // raises(DOMException) on setting // Introduced in DOM Level 2: readonly attribute DOMString localName; // Introduced in DOM Level 2: boolean hasAttributes(); };

Proprietà e Metodi: Oggetto Node

Per la struttura ad oggetti dell'interfaccia DOM verrà usata la notazione standard per i linguaggi ad oggetti: nomeoggetto.metodo(parametri del metodo) nomeoggetto.proprieta nomeoggetto.attributo ecc... Proprietà e metodi definiscono l'interfaccia di programmazione per il modello DOM XML. L'interfaccia di programmazione per il DOM è definita da proprietà e metodi standard-stabiliti dal W3C come già detto. Le proprietà sono indicate come qualcosa che è (cioè: nomeNodo è "libro"). I metodi sono indicati come qualcosa che viene fatto (cioè: creare, modificare, cancellare... "libro").
Proprietà dell'Oggeto Node
Proprietà Descrizione
baseUri Restituisce l'URI assoluto di base di un nodo
childNodes Restituisce un NodeList di nodi figlio per un nodo
firstChild Restituisce il primo figlio di un nodo
lastChild Restituisce l'ultimo figlio di un nodo
localName Restituisce la parte locale del nome di un nodo
namespaceURI Restituisce l'URI dello spazio dei nomi di un nodo
nextSibling Restituisce il nodo successivo allo stesso livello albero dei nodi
nodeName Restituisce il nome di un nodo, a seconda del tipo
nodeType Restituisce il tipo di un nodo
nodeValue Imposta o restituisce il valore di un nodo, a seconda del tipo
OwnerDocument Restituisce l'elemento radice (oggetto del documento) per un nodo
parentNode Restituisce il nodo padre di un nodo
prefix Imposta o restituisce il prefisso dello spazio dei nomi di un nodo
previousSibling Restituisce il nodo precedente allo stesso livello albero dei nodi
textContent Imposta o restituisce il contenuto testuale di un nodo ed i suoi discendenti
Metodi dell'Oggetto Node
Metodo Descrizione
appendChild() Aggiunge un nuovo nodo figlio, al nodo specificato, come il nodo ultimo figlio
cloneNode() Clona un nodo
compareDocumentPosition() Confronta la posizione del documento di due nodi
getFeature(funzione, vers.)Restituisce un oggetto DOM di un'API della funzione specificata e la versione
getUserData(tasto) Restituisce l'oggetto associato ad un tasto su un nodo
HasAttributes() Restituisce true se un nodo possiede attributi, altrimenti restituisce false
hasChildNodes() Restituisce true se un nodo dispone di nodi figlio, altrimenti restituisce false
insertBefore() Inserisce un nuovo nodo figlio prima di un determinato, esistente, nodo figlio
isDefaultNamespace() True se il namespaceURI è l'impostazione predefinita, altrimenti false
isEqualNode() Verifica se due nodi sono uguali
isSameNode() Verifica se due nodi sono lo stesso nodo
isSupported() True l'elemento specificato è supportato su un nodo, altrimenti false
lookupNamespaceURI() Restituisce l'URI dello spazio dei nomi corrispondente a un prefisso specificato
LookupPrefix() Restituisce il prefisso corrisponde a un URI dello spazio dei nomi specificato
normalize() Unisce i nodi di testo adiacenti ed elimina i nodi di testo vuoti
removeChild() Rimuove un nodo figlio
replaceChild() Sostituisce un nodo figlio

Interfaccia, Proprietà e Metodi: Oggetto NodeLista

interface NodeList { Node item(in unsigned long index); readonly attribute unsigned long length; }; L'oggetto NodeList rappresenta un insieme ordinato di nodi. Ai nodi di NodeList si può accedere attraverso il loro numero di indice (partendo da 0). Un oggetto NodeList potrebbe essere la raccolta di un nodo di nodi figlio.
Proprietà dell'oggetto NodeList
Proprietà Descrizione
length Restituisce il numero di nodi nella collezione
Metodi dell'oggetto NodeList
MetodoDescrizione
item()Restituisce il nodo in corrispondenza dell'indice specificato in un elenco di nodi


Interfaccia, Proprietà e Metodi: Oggetto NamedNodeMap

interface NamedNodeMap { Node getNamedItem(in DOMString name); Node setNamedItem(in Node arg) raises(DOMException); Node removeNamedItem(in DOMString name) raises(DOMException); Node item(in unsigned long index); readonly attribute unsigned long length; // Introduced in DOM Level 2: Node getNamedItemNS(in DOMString namespaceURI, in DOMString localName); // Introduced in DOM Level 2: Node setNamedItemNS(in Node arg) raises(DOMException); // Introduced in DOM Level 2: Node removeNamedItemNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException); }; L'oggetto NamedNodeMap rappresenta una raccolta non ordinata di nodi. I nodi del NamedNodeMap si può accedere attraverso il loro nome. Un oggetto NamedNodeMap potrebbe essere la raccolta di un nodo di attributi.
Proprietà dell'oggetto NamedNodeMap
ProprietàDescrizione
lengthRestituisce il numero di nodi nella collezione
La colonna "DOM" indica in quale Livello del DOM il metodo è stato introdotto.
Metodi dell'Oggetto NamedNodeMap
MetodoDescrizione
getNamedItem()Restituisce il nodo specificato (per nome)
getNamedItemNS()Restituisce il nodo specificato (in base al nome e lo spazio dei nomi)
item()Restituisce il nodo in corrispondenza dell'indice specificato nel NamedNodeMap
removeNamedItem()Rimuove il nodo specificato (per nome)
removeNamedItemNS()Rimuove il nodo specificato (in base al nome e lo spazio dei nomi)
setNamedItem()Imposta il nodo specificato (per nome)
setNamedItemNS()Imposta il nodo specificato (in base al nome e lo spazio dei nomi)

Interfaccia, Proprietà e Metodi: Oggetto Documento

interface Document : Node { readonly attribute DocumentType doctype; readonly attribute DOMImplementation implementation; readonly attribute Element documentElement; Element createElement(in DOMString tagName) raises(DOMException); DocumentFragment createDocumentFragment(); Text createTextNode(in DOMString data); Comment createComment(in DOMString data); CDATASection createCDATASection(in DOMString data) raises(DOMException); ProcessingInstruction createProcessingInstruction(in DOMString target, in DOMString data) raises(DOMException); Attr createAttribute(in DOMString name) raises(DOMException); EntityReference createEntityReference(in DOMString name) raises(DOMException); NodeList getElementsByTagName(in DOMString tagname); // Introduced in DOM Level 2: Node importNode(in Node importedNode, in boolean deep) raises(DOMException); // Introduced in DOM Level 2: Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException); // Introduced in DOM Level 2: Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException); // Introduced in DOM Level 2: NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName); // Introduced in DOM Level 2: Element getElementById(in DOMString elementId); }; L'oggetto documento è la radice di un albero del documento e ci permette di accedere ai dati del documento. Dal momento che i nodi elemento, nodi di testo, attributi, commenti, ecc non può esistere al di fuori del documento, l'oggetto Document contiene metodi per creare questi oggetti. Tutti gli oggetti Node hanno una proprietà OwnerDocument che li associa con il documento in cui sono stati creati. Nota: L'oggetto Document può anche utilizzare le proprietà e i metodi dell'oggetto Node.
Proprietà dell'Oggetto Documento
La colonna "DOM" indica in quale DOM Level la proprietà è stata introdotta.
Proprietà Descrizione
doctypeRestituisce la dichiarazione di tipo di documento associato al documento
documentElementRestituisce l'elemento del documento(elemento HTML)
implementationRestituisce l'oggetto DOMImplementation che gestisce il presente documento
Metodi dell'Oggetto Documento
MetodoDescrizione
Create Attribute (nome)Crea un nodo attributo
create AttributeNS (URI, nome)Crea un attributo con il nome specificato e namspaceURI
create CDATA Section()Crea un nodo CDATA con il testo specificato. Per XML DOM solo
create Comment()Crea un nodo commento con il testo specificato
create Document Fragment()Crea un nodo vuoto DocumentFragment
create Element (tagName)Crea un nodo elemento
create ElementNS()Crea un elemento con lo spazio dei nomi specificato
create Entity Reference(nome)Crea un nodo EntityReference. solo Per XML DOM
create Processing Instruction (target, dati)Crea un nodo EntityReference. Per XML DOM solo
createTextNode()Crea un nodo di testo
getElement ById (IDelemento)Restituisce l'elemento che ha l'attributo ID con il valore specificato
getElementsBy TagName (tagName)Restituisce un NodeList con tutti gli elementi con tagname specificato
getElementsBy TagNameNS (URI, nome) Restituisce NodeList con tutti gli elementi specificati
ImportNode()Importa un nodo da un altro documento


Interfaccia, Proprietà e Metodi: Oggetto Elemento

interface Element : Node { readonly attribute DOMString tagName; DOMString getAttribute(in DOMString name); void setAttribute(in DOMString name, in DOMString value) raises(DOMException); void removeAttribute(in DOMString name) raises(DOMException); Attr getAttributeNode(in DOMString name); Attr setAttributeNode(in Attr newAttr) raises(DOMException); Attr removeAttributeNode(in Attr oldAttr) raises(DOMException); NodeList getElementsByTagName(in DOMString name); // Introduced in DOM Level 2: DOMString getAttributeNS(in DOMString namespaceURI, in DOMString localName); // Introduced in DOM Level 2: void setAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName, in DOMString value) raises(DOMException); // Introduced in DOM Level 2: void removeAttributeNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException); // Introduced in DOM Level 2: Attr getAttributeNodeNS(in DOMString namespaceURI, in DOMString localName); // Introduced in DOM Level 2: Attr setAttributeNodeNS(in Attr newAttr) raises(DOMException); // Introduced in DOM Level 2: NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName); // Introduced in DOM Level 2: boolean hasAttribute(in DOMString name); // Introduced in DOM Level 2: boolean hasAttributeNS(in DOMString namespaceURI, in DOMString localName); }; L'oggetto Element rappresenta un elemento del documento HTML. L'oggetto elemento può avere nodi figlio di tipo Element, testo, commento, CDATASection, ProcessingInstruction e EntityReference. L'oggetto elemento può avere degli attributi, che hanno il nodo di tipo Attr. Nota: L'oggetto Element inoltre possibile utilizzare le proprietà ei metodi di oggetto Node.
Proprietà dell'oggetto Element
ProprietàDescrizione
attributes Ritorna un NamedNodeMap di attributi per l'elemento
baseURI Ritorna l'Uri vile ed incondizionato dell'elemento
childNodes Ritorna un NodeList di nodi di bambino per l'elemento
firstChild Ritorna il primo bambino dell'elemento
lastChild Ritorna l'ultimo bambino dell'elemento
localName Ritorna la parte locale del nome dell'elemento
namespaceURI Ritorna Uri dell'elemento il namespace
nextSibling Ritorna il nodo che immediatamente segue l'elemento
nodeName Ritorna il nome del nodo, dipendendo dal suo tipo
nodeType Ritorna il tipo del nodo
ownerDocument Ritorna l'elemento di radice (oggetto di documento) per un elemento
parentNode Ritorna il nodo di genitore dell'elemento
prefix Set o ritorna il prefisso di namespace dell'elemento
previousSibling Immediatamente ritorna il nodo di fronte all'elemento
schemaTypeInfo Ritorna le informazioni di tipo associate con l'elemento
tagName Ritorna il nome dell'elemento
Metodi dell'Oggetto Element
MetodoDescrizione
appendChild()Aggiunge un nodo di bambino nuovo alla fine dell'elenco di bambini del nodo
cloneNode()Clona un nodo
compareDocumentPosition()Compara la posizione di documento di due nodi
getAttribute()Restituisce il valore dell'attributo specificato
getAttributeNS()Restituisce il valore dell'attributo con lo spazio dei nomi specificato
getAttributeNode()Restituisce il nodo attributo specificato
getElementsByTagName()Restituisce un insieme di tutti gli elementi figlio con il tagname specificato
getElementsByTagNameNS()Restituisce tutti gli elementi figlio con il tagname specificato e spazio nomi
hasAttribute()Restituisce true se l'elemento ha l'attributo specificato, altrimenti false
hasAttributeNS()Restituisce true se l'elemento ha l'attributo e spazio dei nomi specificato
normalize()Cerca di normalizzare tutti i parametri (incluso attributi e testi vuoti)
removeAttribute()Rimuove l'attributo specificato
removeAttributeNS()Rimuove l'attributo con il nome specificato e spazio dei nomi
removeAttributeNode()Rimuove il nodo specificato attributi, e restituisce il nodo rimosso
setAttribute()Imposta o modifica l'attributo specificato, al valore specificato
setAttributeNS()Imposta o modifica l'attributo specificato, con lo spazio nomi specificato
setAttributeNode()Imposta o modifica il nodo attributo specificato
setAttributeNodeNS()Imposta o modifica il nodo attributo specificato


Interfaccia e Proprietà: Oggetto Attributo

interface Attr : Node { readonly attribute DOMString name; readonly attribute boolean specified; attribute DOMString value; // raises(DOMException) on setting // Introduced in DOM Level 2: readonly attribute Element ownerElement; }; L'oggetto Attr rappresenta un attributo di un oggetto Element. I valori consentiti per gli attributi sono in genere definiti in una DTD. Poiché l'oggetto Attr è anche un nodo, eredita le proprietà dei metodi dell'oggetto Node. Nota: Tuttavia, un attributo non ha un nodo padre e non è considerato un nodo figlio di un elemento, e tornerà null per molte delle proprietà Node.
Proprietà dell'Oggetto Attr (Attributo)
ProprietàDescrizione
localName Ritorna la parte locale del nome dell'attributo
name Ritorna il nome dell'attributo
nodeName Ritorna il nome del nodo, dipendendo dal suo tipo
nodeType Ritorna il tipo del nodo
nodeValue Setta o ritorna il valore del nodo, dipendendo dal suo tipo
ownerDocument Ritorna l'elemento radice (oggetto documento) per un attributo
ownerElement Ritorna il nodo elemento al quale l'attributo è legato
prefix Setta o ritorna il prefisso del namespace dell'attributo
specified Ritorna true se il valore dell'attributo è messo nel documento
textContent Set o ritorna il contenuto testuale di un attributo
value Set o ritorna il valore dell'attributo


Interfaccia, Proprietà e Metodi: Oggetto Testo

interface Text : CharacterData { Text splitText(in unsigned long offset) raises(DOMException); }; L'oggetto di testo rappresenta il contenuto testuale di un elemento o attributo.
Proprietà dell'Oggetto Text (Testo)
ProprietàDescrizione
data Setta o ritorna il testo dell'elemento o attributo
length Ritorna la lunghezza del testo dell'elemento o attributo
Metodi dell'Oggetto Text (Testo)
MetodoDescrizione
appendData() Aggiunge dati al nodo
deleteData() Cancella dati dal nodo
insertData() Inserisce i dati nel nodo
replaceData() Sostituisce dati nel nodo
splitText() Divide il nodo come specificato, e ritorna il nuovo nodo rielaborato
substringData() Dati estratti dal nodo


Interfaccia, Proprietà e Metodi: Oggetto CDATASection

interface CDATASection : Text { }; L'oggetto CDATASection rappresenta una sezione CDATA in un documento. Una sezione CDATA contiene del testo che non sarà analizzato da un parser. Tag all'interno di una sezione CDATA non saranno trattati come markup e di entità non sarà ampliato. Lo scopo primario è per l'inclusione di materiale come frammenti XML, senza la necessità di sfuggire a tutti i delimitatori. L'unico delimitatore che è riconosciuto in una sezione CDATA è "]]>" - che indica la fine della sezione CDATA. Le sezioni CDATA non possono essere nidificate.
Proprietà dell'Oggetto CDATASection (Sezione CDati)
ProprietàDescrizione
data Setta o ritorna il testo di questo nodo
length Ritorna la lunghezza della sezione di CDATA
Metodi dell'Oggetto CDATASection (Sezione CDati)
MetodoDescrizione
appendData() Aggiunge dati al nodo
deleteData() Cancella dati dal nodo
insertData() Inserisce i dati nel nodo
replaceData() Sostituisce dati nel nodo
splitText() Divide il nodo di CDATA in due nodi e ritorna il nuovo nodo rielaborato
substringData() Dati estratti dal nodo


Interfaccia, Proprietà e Metodi: Oggetto Comment

interface Comment : CharacterData { }; L'oggetto Comment rappresenta il contenuto del commento nodi in un documento.
Proprietà dell'Oggetto Comment (Commenti)
ProprietàDescrizione
data Setta o ritorna il testo di questo nodo
length Ritorna la lunghezza del testo in questo nodo
Metodi dell'Oggetto Comment (Commenti)
MetodoDescrizione
appendData() Aggiunge dati al nodo
deleteData() Cancella dati dal nodo
insertData() Inserisce i dati nel nodo
replaceData() Sostituisce dati nel nodo
substringData() Dati estratti dal nodo


Interfaccia CharacterData

interface CharacterData : Node { attribute DOMString data; // raises(DOMException) on setting // raises(DOMException) on retrieval readonly attribute unsigned long length; DOMString substringData(in unsigned long offset, in unsigned long count) raises(DOMException); void appendData(in DOMString arg) raises(DOMException); void insertData(in unsigned long offset, in DOMString arg) raises(DOMException); void deleteData(in unsigned long offset, in unsigned long count) raises(DOMException); void replaceData(in unsigned long offset, in unsigned long count, in DOMString arg) raises(DOMException); }; L'interfaccia CharacterData estende Node con una serie di attributi e metodi per l'accesso ai dati carattere nel DOM. Per chiarezza questa serie viene definita qui, piuttosto che su ogni oggetto che utilizza questi attributi e metodi. Nessun oggetto DOM corrispondono direttamente a CharacterData, anche se il testo ed altri fanno ereditare l'interfaccia da esso. Tutte le compensazioni in questa interfaccia partono da 0 .

Interfaccia DocumentType

interface DocumentType : Node { readonly attribute DOMString name; readonly attribute NamedNodeMap entities; readonly attribute NamedNodeMap notations; // Introduced in DOM Level 2: readonly attribute DOMString publicId; // Introduced in DOM Level 2: readonly attribute DOMString systemId; // Introduced in DOM Level 2: readonly attribute DOMString internalSubset; }; Ogni documento ha un attributo doctype il cui valore è nullo o un oggetto DocumentType. Nel Nucleo DOM DocumentType fornisce un'interfaccia per l'elenco di enti definiti nel documento.

Interfaccia ProcessingInstruction

interface ProcessingInstruction : Node { readonly attribute DOMString target; attribute DOMString data; // raises(DOMException) on setting }; L'interfaccia ProcessingInstruction rappresenta un "istruzione di elaborazione", é usata per mantenere le informazioni specifiche del testo nel documento.

Interfaccia EntityReference

interface EntityReference : Node { };

Interfaccia Entity

interface Entity : Node { readonly attribute DOMString publicId; readonly attribute DOMString systemId; readonly attribute DOMString notationName; }; In un documento XML rappresenta un'entità (analizzata o non ancora analizzata).

Interfaccia Notation

interface Notation : Node { readonly attribute DOMString publicId; readonly attribute DOMString systemId; }; Questa interfaccia rappresenta una nota dichiarata nella DTD.

DOMException e ExceptionCode

exception DOMException { unsigned short code; }; // ExceptionCode const unsigned short INDEX_SIZE_ERR = 1; const unsigned short DOMSTRING_SIZE_ERR = 2; const unsigned short HIERARCHY_REQUEST_ERR = 3; const unsigned short WRONG_DOCUMENT_ERR = 4; const unsigned short INVALID_CHARACTER_ERR = 5; const unsigned short NO_DATA_ALLOWED_ERR = 6; const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7; const unsigned short NOT_FOUND_ERR = 8; const unsigned short NOT_SUPPORTED_ERR = 9; const unsigned short INUSE_ATTRIBUTE_ERR = 10; // Introduced in DOM Level 2: const unsigned short INVALID_STATE_ERR = 11; // Introduced in DOM Level 2: const unsigned short SYNTAX_ERR = 12; // Introduced in DOM Level 2: const unsigned short INVALID_MODIFICATION_ERR = 13; // Introduced in DOM Level 2: const unsigned short NAMESPACE_ERR = 14; // Introduced in DOM Level 2: const unsigned short INVALID_ACCESS_ERR = 15; Operazioni DOM sollevano eccezioni solo in circostanze "eccezionali", cioè quando l'operazione è impossibile da eseguire (sia per ragioni logiche, in quanto i dati vengono persi, o perché l'applicazione è diventata instabile). Oggetto DOMException DOMException ha le seguenti proprietà: code Questa proprietà è di tipo Number.
Definizione di gruppo ExceptionCode
Un numero intero che indica il tipo di errore generato. Nota: Altri codici numerici sono riservati a W3C per eventuale uso futuro. Costanti definite DOMSTRING_SIZE_ERR Se l'intervallo di testo specificato non rientra in una DOMString HIERARCHY_REQUEST_ERR Se un nodo viene inserito in qualche luogo che non appartiene INDEX_SIZE_ERR Se l'indice o il formato è negativo, o maggiore del valore consentito INUSE_ATTRIBUTE_ERR Se si tenta di aggiungere un attributo che è già in uso altrove INVALID_ACCESS_ERR , introdotto nel DOM Level 2. Se un parametro o un operazione non è supportata dall'oggetto sottostante. INVALID_CHARACTER_ERR Se un carattere non valido o illegale è specificato, come ad esempio in un nome. INVALID_MODIFICATION_ERR , introdotto nel DOM Level 2. Se viene fatto un tentativo di modificare il tipo dell'oggetto sottostante. INVALID_STATE_ERR , introdotto nel DOM Level 2. Se si tenta di utilizzare un oggetto che non è, o non è più, utilizzabile. NAMESPACE_ERR , introdotto nel DOM Level 2. Se viene effettuato un tentativo di creare o modificare un oggetto in un modo che non è corretto per quanto riguarda gli spazi dei nomi. NOT_FOUND_ERR Se si tenta di fare riferimento a un nodo in un contesto dove non esiste NOT_SUPPORTED_ERR Se l'applicazione non supporta il tipo richiesto di oggetto o di funzionamento. NO_DATA_ALLOWED_ERR Se i dati non viene specificato per un nodo che non supporta i dati NO_MODIFICATION_ALLOWED_ERR Se si tenta di modificare un oggetto in cui non sono ammessi modifiche SYNTAX_ERR , introdotto nel DOM Level 2. Se viene specificata una stringa non valida o illegale. WRONG_DOCUMENT_ERR Se un nodo viene usato in un documento diverso da quello che ha creato (che non lo supporta).

Interfaccia DOMImplementation

interface DOMImplementation { boolean hasFeature(in DOMString feature, in DOMString version); // Introduced in DOM Level 2: DocumentType createDocumentType(in DOMString qualifiedName, in DOMString publicId, in DOMString systemId) raises(DOMException); // Introduced in DOM Level 2: Document createDocument(in DOMString namespaceURI, in DOMString qualifiedName, in DocumentType doctype) raises(DOMException); }; l'interfaccia DOMImplementation fornisce una serie di metodi per le operazioni che sono indipendenti da qualsiasi particolare istanza del modello a oggetti del documento. Oggetto DOMImplementation DOMImplementation ha i seguenti metodi: hasFeature (caratteristica, versione) Questo metodo restituisce un valore booleano; i parametri (caratteristica e versione) sono di tipo String; CreateDocumentType (qualifiedName, publicId, systemId) Questo metodo restituisce un oggetto DocumentType; i parametri (qualifiedName, publicId, systemId) sono di tipo String. createDocument (namespaceURI, qualifiedName, doctype) Questo metodo restituisce un oggetto documento; i parametri (namespaceURI e qualifiedName) sono di tipo String; Il parametro DOCTYPE è un oggetto DocumentType. Questi metodi possono sollevare un'eccezzione di tipo DOMException.

Interfaccia DocumentFragment

interface DocumentFragment : Node { }; Permette di estrarre o creare un nuovo frammento da un documento. Oggetto DocumentFragment DocumentFragment ha le tutte le proprietà e i metodi dell'oggetto Node e dell'oggetto Document.