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.
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.
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
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"
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
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à
| NodeType | Nome della costante | Descrizione |
|---|
| 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 |
| 10 | DOCUMENT TYPE NODE | Interfaccia per Entità del Documento |
| 11 | DOCUMENT FRAGMENT NODE | Parte di un Documento |
| 12 | NOTATION NODE | Nota della Dichiarazione |
Ci sono 12 tipi di nodi diversi, che possono avere vari tipi di nodi figli:
| NodeType | Tipo di nodo | Figli |
|---|
| 1 | Elemento | Elemento, testo, commento, Processing Instruction, CDATASection, Entity Reference |
| 2 | Attributo | Testo, EntityReference |
| 3 | Testo | Nessuno |
| 4 | CDATASection | Nessuno |
| 5 | Entity Reference | Elemento, Processing Instruction, Comment, Testo, CDATASection, Entity Reference |
| 6 | Entità | Elemento, Processing Instruction, Comment, Testo, CDATASection, Entity Reference |
| 7 | Processing Instruction | Nessuno |
| 8 | Commento | Nessuno |
| 9 | Documento | 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 Type | Tipo di nodo | node Name: restituisce | node 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 nome | null |
| 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
| Metodo | Descrizione |
|---|
| 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 |
|---|
| length | Restituisce il numero di nodi nella collezione |
La colonna "DOM" indica in quale Livello del DOM il metodo è stato introdotto.
Metodi dell'Oggetto NamedNodeMap
| Metodo | Descrizione |
|---|
| 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 |
|---|
| doctype | Restituisce la dichiarazione di tipo di documento associato al documento |
| documentElement | Restituisce l'elemento del documento(elemento HTML) |
| implementation | Restituisce l'oggetto DOMImplementation che gestisce il presente documento |
Metodi dell'Oggetto Documento
| Metodo | Descrizione |
|---|
| 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
| Metodo | Descrizione |
|---|
| 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)
| Metodo | Descrizione |
|---|
| 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)
| Metodo | Descrizione |
|---|
| 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)
| Metodo | Descrizione |
|---|
| 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.
