XML Tutorial/it: what changed

Revision 0 to 1. Removed lines have a minus sign; added lines have a plus sign.

Title: XML Tutorial/it

New		Line
1	+	## Introduzione
2	+
3	+	L'Extensible Markup Language è un linguaggio raccomandato dal [W3C](http://www.w3.org/) creato per l'interscambio di informazioni tra sistemi differenti. Si tratta di un sistema di memorizzazione di informazioni basato su file di testo. Linguaggi moderni di interscambio di dati come XHTML, così come la maggior parte delle tecnologie WebService, sono basati su XML.
4	+
5	+	Al momento esistono una serie di unit che forniscono supporto per XML su Free Pascal. Queste unit sono chiamate "XMLRead", "XMLWrite" e "DOM" e sono parte della Free Component Library (FCL) del Free Pascal Compiler. La FCL si trova già nei percorsi di ricerca di default per il compilatore in Lazarus, così bisogna soltanto aggiungere queste unit alla clausola uses per avere il supporto di XML. La FCL al momento (Ottobre / 2005) non è documentata, quindi questo breve tutorial introdurrà XML tramite l'utilizzo di queste unit.
6	+
7	+	XML DOM (Document Object Model) sono una serie di oggetti standardizzati che forniscono un'interfaccia simile per l'utilizzo di XML con differenti linguaggi e su differenti sistemi. Lo standard specifica soltanto i metodi, le proprietà e altre parti dell'interfaccia dell'oggetto, lasciando l'implementazione libera per i diversi linguaggi. La FCL al momento offre pieno supporto per [XML DOM 1.0](http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/).
8	+
9	+	## Esempi
10	+
11	+	Di seguito c'è una lista di esempi di manipolazione dati tramite XML di complessità crescente. Le unit necessarie per compilare le funzioni di esempio (e in generale per lavorare con l'XML) sono: DOM, XMLRead, XMLWrite, XMLCfg, XMLUtils, XMLStreaming. Nella maggior parte degli esempi sono necessarie solo alcune di queste, comunque.
12	+
13	+	### Leggere un nodo di testo
14	+
15	+	Per Programmatori Delphi: Notare che quando si lavora con TXMLDocument, il testo all'interno di un Node viene considerato come un TEXT Node separato. Quindi si deve accedere al valore del testo del nodo come se si trattasse di un nodo separato. In alternativa, è possibile utilizzare la proprietà TextContent per ottenere il contenuto di tutti i nodi di testo al di sotto del nodo specificato, concatenati assieme.
16	+
17	+	La procedure ReadXMLFile crea sempre un nuovo TXMLDocument, quindi non c'è bisogno di crearlo prima. In ogni caso, assicuratevi di distruggere il documento tramite una chiamata a Free quando avete terminato.
18	+
19	+	Per esempio, consideriamo il seguente XML:
20	+
21	+	``` xml
22	+	<?xml version="1.0"?>
23	+	<request>
24	+	<request_type>PUT_FILE</request_type>
25	+	<username>123</username>
26	+	<password>abc</password>
27	+	</request>
28	+	```
29	+
30	+	Il seguente codice di esempio mostra sia il modo corretto che quello non corretto di ottenere il valore del testo del nodo:
31	+
32	+	``` pascal
33	+	var
34	+	PassNode: TDOMNode;
35	+	Doc: TXMLDocument;
36	+	begin
37	+	// Read in xml file from disk
38	+	ReadXMLFile(Doc, 'c:\xmlfiles\test.xml');
39	+	// Retrieve the "password" node
40	+	PassNode := Doc.DocumentElement.FindNode('password');
41	+	// Write out value of the selected node
42	+	WriteLn(PassNode.NodeValue); // will be blank
43	+	// The text of the node is actually a separate child node
44	+	WriteLn(PassNode.FirstChild.NodeValue); // correctly prints "abc"
45	+	// alternatively
46	+	WriteLn(PassNode.TextContent);
47	+	// finally, free the document
48	+	Doc.Free;
49	+	end;
50	+	```
51	+
52	+	### Stampare i nomi dei nodi
53	+
54	+	Una nota veloce sulla navigazione di un albero DOM: quando c'è bisogno di accedere i nodi in sequenza, è preferibile utilizzare le proprietà FirstChild e NextSibling (per scorrerlo in avanti), o LastChild e PreviousSibling (per scorrerlo indietro). Per un accesso random è possibile utilizzare i metodi ChildNodes o GetElementsByTagName, ma questi creeranno un oggetto TDOMNodeList che alla fine deve essere rilasciato. Questo comportamento differisce da altre implementazioni di DOM come MSXML, perché l'implementazione di FCL è basata sugli oggetti, non sulle interfacce.
55	+
56	+	Il seguente esempio mostra come stampare i nomi dei nodi in un TMemo posizionato su un form.
57	+
58	+	Qui sotto c'è il file XML chiamato 'C:\Programas\teste.xml':
59	+
60	+	``` xml
61	+	<?xml version="1.0"?>
62	+	<images directory="mydir">
63	+	<imageNode URL="graphic.jpg" title="">
64	+	<Peca DestinoX="0" DestinoY="0">Pecacastelo.jpg1.swf</Peca>
65	+	<Peca DestinoX="0" DestinoY="86">Pecacastelo.jpg2.swf</Peca>
66	+	</imageNode>
67	+	</images>
68	+	```
69	+
70	+	E qui il codice Pascal per eseguire il compito:
71	+
72	+	``` pascal
73	+	var
74	+	Documento: TXMLDocument;
75	+	Child: TDOMNode;
76	+	j: Integer;
77	+	begin
78	+	ReadXMLFile(Documento, 'C:\Programas\teste.xml');
79	+	Memo.Lines.Clear;
80	+	// using FirstChild and NextSibling properties
81	+	Child := Documento.DocumentElement.FirstChild;
82	+	while Assigned(Child) do
83	+	begin
84	+	Memo.Lines.Add(Child.NodeName + ' ' + Child.Attributes.Item[0].NodeValue);
85	+	// using ChildNodes method
86	+	with Child.ChildNodes do
87	+	try
88	+	for j := 0 to (Count - 1) do
89	+	Memo.Lines.Add(Item[j].NodeName + ' ' + Item[j].FirstChild.NodeValue);
90	+	finally
91	+	Free;
92	+	end;
93	+	Child := Child.NextSibling;
94	+	end;
95	+	Documento.Free;
96	+	end;
97	+	```
98	+
99	+	Questo stamperà:
100	+
101	+	imageNode graphic.jpg
102	+	Peca Pecacastelo.jpg1.swf
103	+	Peca Pecacastelo.jpg1.swf
104	+
105	+	### Popolare un TreeView tramite XML
106	+
107	+	Un utilizzo comune dei files XML è quello di eseguire un parsing su di essi e mostrare il loro contenuto in una struttura ad albero. E' possibile trovare il componente TTreeView nella linguetta "Common Controls" in Lazarus.
108	+
109	+	La funzione qui in basso prenderà un documento XML precedentemente caricato da file o generato via codice e popolerà un TreeView con il suo contenuto. La caption di ogni nodo sarà il contenuto del primo attributo di ogni nodo.
110	+
111	+	``` pascal
112	+	procedure TForm1.XML2Tree(tree: TTreeView; XMLDoc: TXMLDocument);
113	+	var
114	+	iNode: TDOMNode;
115	+
116	+	procedure ProcessNode(Node: TDOMNode; TreeNode: TTreeNode);
117	+	var
118	+	cNode: TDOMNode;
119	+	s: string;
120	+	begin
121	+	if Node = nil then Exit; // Stops if reached a leaf
122	+
123	+	// Adds a node to the tree
124	+	if Node.HasAttributes and (Node.Attributes.Length>0) then
125	+	s:=Node.Attributes[0].NodeValue
126	+	else
127	+	s:='';
128	+	TreeNode := tree.Items.AddChild(TreeNode, s);
129	+
130	+	// Goes to the child node
131	+	cNode := Node.FirstChild;
132	+
133	+	// Processes all child nodes
134	+	while cNode <> nil do
135	+	begin
136	+	ProcessNode(cNode, TreeNode);
137	+	cNode := cNode.NextSibling;
138	+	end;
139	+	end;
140	+
141	+	begin
142	+	iNode := XMLDoc.DocumentElement.FirstChild;
143	+	while iNode <> nil do
144	+	begin
145	+	ProcessNode(iNode, nil); // Recursive
146	+	iNode := iNode.NextSibling;
147	+	end;
148	+	end;
149	+	```
150	+
151	+	### Modificare un documento XML
152	+
153	+	La prima cosa da ricordare è che TDOMDocument rappresenta l'"handle" al DOM. E' possibile ottenere una istanza di questa classe creandone una o caricando un documento XML.
154	+
155	+	D'altro canto i nodi non possono essere creati come normali oggetti. Per crearli si devono utilizzare i metodi forniti da TDOMDocument, quindi utilizzare altri metodi per posizionarli nella posizione corretta nell'albero. Questo accade perché in DOM i nodi devono "appartenere" ad un documento specifico.
156	+
157	+	Qui di seguito sono riportati alcuni metodi comuni di TDOMDocument:
158	+
159	+	``` pascal
160	+	function CreateElement(const tagName: DOMString): TDOMElement; virtual;
161	+	function CreateTextNode(const data: DOMString): TDOMText;
162	+	function CreateCDATASection(const data: DOMString): TDOMCDATASection;
163	+	virtual;
164	+	function CreateAttribute(const name: DOMString): TDOMAttr; virtual;
165	+	```
166	+
167	+	E qui un metodo di esempio che localizza l'elemento selezionato in un TTreeView e inserisce un nodo figlio nel documento XML che rappresenta. Il TreeView deve essere preventivamente riempito con il contenuto di un file XML utilizzando la [[Networking\|funzione XML2Tree]].
168	+
169	+	``` pascal
170	+	procedure TForm1.actAddChildNode(Sender: TObject);
171	+	var
172	+	position: Integer;
173	+	NovoNo: TDomNode;
174	+	begin
175	+	{*******************************************************************
176	+	* Detects the selected element
177	+	*******************************************************************}
178	+	if TreeView1.Selected = nil then Exit;
179	+
180	+	if TreeView1.Selected.Level = 0 then
181	+	begin
182	+	position := TreeView1.Selected.Index;
183	+
184	+	NovoNo := XMLDoc.CreateElement('item');
185	+	TDOMElement(NovoNo).SetAttribute('nome', 'Item');
186	+	TDOMElement(NovoNo).SetAttribute('arquivo', 'Arquivo');
187	+	with XMLDoc.DocumentElement.ChildNodes do
188	+	begin
189	+	Item[position].AppendChild(NovoNo);
190	+	Free;
191	+	end;
192	+
193	+	{*******************************************************************
194	+	* Updates the TreeView
195	+	*******************************************************************}
196	+	TreeView1.Items.Clear;
197	+	XML2Tree(TreeView1, XMLDoc);
198	+	end
199	+	else if TreeView1.Selected.Level >= 1 then
200	+	begin
201	+	{*******************************************************************
202	+	* This function only works on the first level of the tree,
203	+	* but can easely modifyed to work for any number of levels
204	+	*******************************************************************}
205	+	end;
206	+	end;
207	+	```
208	+
209	+	### Creare un TXMLDocument da una stringa
210	+
211	+	Dato un file XML in MyXmlString, il seguente codice creerà il corrispondente DOM:
212	+
213	+	``` pascal
214	+	Var
215	+	S : TStringStream;
216	+	XML : TXMLDocument;
217	+
218	+	begin
219	+	S:= TStringStream.Create(MyXMLString);
220	+	Try
221	+	S.Position:=0;
222	+	XML:=Nil;
223	+	ReadXMLFile(XML,S); // Complete XML document
224	+	// Alternatively:
225	+	ReadXMLFragment(AParentNode,S); // Read only XML fragment.
226	+	Finally
227	+	S.Free;
228	+	end;
229	+	end;
230	+	```
231	+
232	+	### Validare un documento
233	+
234	+	A partire da Marzo 2007, al parser XML della FCL è stata aggiunta la capacità di validare i DTD. La validazione consiste nel controllare che la struttura logica del documento sia conforme a regole prestabilite, chiamate Document Type Definition (DTD).
235	+
236	+	Ecco un esempio di un documento XML con un DTD:
237	+
238	+	``` xml
239	+	<?xml version='1.0'?>
240	+	<!DOCTYPE root [
241	+	<!ELEMENT root (child)+ >
242	+	<!ELEMENT child (#PCDATA)>
243	+	]>
244	+	<root>
245	+	<child>This is a first child.</child>
246	+	<child>And this is the second one.</child>
247	+	</root>
248	+	```
249	+
250	+	Questo DTD specifica che l'elemento 'root' deve avere uno o più elementi 'child', e che gli elementi 'child' possono avere al loro interno soltanto caratteri. Se il parser individua una violazione di queste regole, le riporterà.
251	+
252	+	Caricare un documento di questo tipo è leggermente più complicato. Assumiamo di avere dei dati XML in un oggetto TStream:
253	+
254	+	``` pascal
255	+	procedure TMyObject.DOMFromStream(AStream: TStream);
256	+	var
257	+	Parser: TDOMParser;
258	+	Src: TXMLInputSource;
259	+	TheDoc: TXMLDocument;
260	+	begin
261	+	// create a parser object
262	+	Parser := TDOMParser.Create;
263	+	// and the input source
264	+	Src := TXMLInputSource.Create(AStream);
265	+	// we want validation
266	+	Parser.Options.Validate := True;
267	+	// assign a error handler which will receive notifications
268	+	Parser.OnError := @ErrorHandler;
269	+	// now do the job
270	+	Parser.Parse(Src, TheDoc);
271	+	// ...and cleanup
272	+	Src.Free;
273	+	Parser.Free;
274	+	end;
275	+
276	+	procedure TMyObject.ErrorHandler(E: EXMLReadError);
277	+	begin
278	+	if E.Severity = esError then // we are interested in validation errors only
279	+	writeln(E.Message);
280	+	end;
281	+	```
282	+
283	+	### Generare un file XML
284	+
285	+	Di seguito c'è il codice completo per scrivere su un file XML. (E' stato preso da un tutorial sul blog DeveLazarus) Ricordate di aggiungere le librerie DOM e XMLWrite sotto la clausola uses
286	+
287	+	``` pascal
288	+	unit Unit1;
289	+
290	+	{$mode objfpc}{$H+}
291	+
292	+	interface
293	+
294	+	uses
295	+	Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls,
296	+	DOM, XMLWrite;
297	+
298	+	type
299	+	{ TForm1 }
300	+	TForm1 = class(TForm)
301	+	Button1: TButton;
302	+	Label1: TLabel;
303	+	Label2: TLabel;
304	+	procedure Button1Click(Sender: TObject);
305	+	private
306	+	{ private declarations }
307	+	public
308	+	{ public declarations }
309	+	end;
310	+
311	+	var
312	+	Form1: TForm1;
313	+
314	+	implementation
315	+
316	+	{ TForm1 }
317	+
318	+	procedure TForm1.Button1Click(Sender: TObject);
319	+	var
320	+	xdoc: TXMLDocument; // variable to document
321	+	RootNode, parentNode, nofilho: TDOMNode; // variable to nodes
322	+	begin
323	+	//create a document
324	+	xdoc := TXMLDocument.create;
325	+
326	+	//create a root node
327	+	RootNode := xdoc.CreateElement('register');
328	+	Xdoc.Appendchild(RootNode); // save root node
329	+
330	+	//create a parent node
331	+	RootNode:= xdoc.DocumentElement;
332	+	parentNode := xdoc.CreateElement('usuario');
333	+	TDOMElement(parentNode).SetAttribute('id', '001'); // create atributes to parent node
334	+	RootNode.Appendchild(parentNode); // save parent node
335	+
336	+	//create a child node
337	+	parentNode := xdoc.CreateElement('nome'); // create a child node
338	+	//TDOMElement(parentNode).SetAttribute('sexo', 'M'); // create atributes
339	+	nofilho := xdoc.CreateTextNode('Fernando'); // insert a value to node
340	+	parentNode.Appendchild(nofilho); // save node
341	+	RootNode.ChildNodes.Item[0].AppendChild(parentNode); // insert child node in respective parent node
342	+
343	+	//create a child node
344	+	parentNode := xdoc.CreateElement('idade'); // create a child node
345	+	//TDOMElement(parentNode).SetAttribute('ano', '1976'); // create atributes
346	+	nofilho := xdoc.CreateTextNode('32'); // insert a value to node
347	+	parentNode.Appendchild(nofilho); // save node
348	+	RootNode.ChildNodes.Item[0].AppendChild(parentNode); // insert a childnode in respective parent node
349	+
350	+	writeXMLFile(xDoc,'teste.xml'); // write to XML
351	+	Xdoc.free; // free memory
352	+	end;
353	+
354	+	initialization
355	+	{$I unit1.lrs}
356	+
357	+	end.
358	+	```
359	+
360	+	Il risultato sarà il file XML seguente:
361	+
362	+	``` xml
363	+	<?xml version="1.0"?>
364	+	<register>
365	+	<usuario id="001">
366	+	<nome>Fernando</nome>
367	+	<idade>32</idade>
368	+	</usuario>
369	+	</register>
370	+	```
371	+
372	+	--Fernandosinesio 22:28, 24 April 2008 (CEST)fernandosinesio@gmail.com
373	+
374	+	### Codifica
375	+
376	+	A partire dalla revisione SVN 12582, il lettore XML è capace di processare i dati in qualsiasi codifica attraverso l'uso di decodificatori esterni. Vedere [[XML Decoders]] per maggiori dettagli.
377	+
378	+	Secondo lo standard XML, l'attributo encoding nella prima linea del file XML è opzionale nel caso in cui l'effettiva codifica sia UTF-8 o UTF-16 (che viene individuata dalla presenza di BOM). Dalla versione 0.9.26 di Lazarus, c'è una proprietà encoding in TXMLDocument, ma è ignorata. writeXMLFile utilizza in ogni caso UTF-8 e non genera un attributo encoding nella prima linea del file XML.
379	+
380	+	## Link Esterni
381	+
382	+	- [W3Schools](http://www.w3schools.com/xml/default.asp) Xml Tutorial
383	+
384	+	- [Thomas Zastrow article](http://www.thomas-zastrow.de/texte/fpcxml/index.php) [link alternativo](http://web.archive.org/web/20080802150722/http://www.thomas-zastrow.de/texte/fpcxml/index.php) FPC and XML
385	+
386	+	------------------------------------------------------------------------
387	+
388	+	---
389	+	From the Free Pascal wiki, page "XML Tutorial/it", as it stood on 2020-03-02 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history