Sign in Join
Wiki copytemporary

XML Tutorial/hu: what changed

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

Title: XML Tutorial/hu

OldNewLine
1+# XML Tananyag
2+
3+## Bevezetés
4+
5+A Kiterjeszthető jelölőnyelv (Extensible Markup Language) egy, a [W3C](http://www.w3.org/) által ajánlott nyelv, amely azért jött létre, hogy információcserét tegyen lehetővé különböző rendszerek között. Ez egy szövegalapú módszere az információ tárolásnak. A modern adatcsere nyelvek, mint az XHTML, úgy, mint a legtöbb WebServices technológia, XML alapú.
6+
7+Jelenleg, van egy unit-készlet, amely támogatja az XML használatát Free Pascal-lal. Ezek a unit-ok a következők: "XMLRead", "XMLWrite" és a "DOM". Ezek részei a szabad komponenstárnak (FCL). Az FCL már szerepel a Lazarus unit keresési útvonalai között, tehát neked már csak annyi a dolgod, hogy ezeket a unit-okat hozzáadd a *uses* szekciódhoz az XML támogatás használatához. Az FCL nincs dokumentálva jelenleg (2005. októbere), tehát ennek a segédletnek az a célja, hogy bemutassa az XML használatát ezekkel a unit-okkal.
8+
9+Az XML DOM (Dokumentum Objektum Modell), szabványosított objektumok gyűjteménye, amely hasonló felületet nyújt az XML használatához különféle nyelveken és rendszereken. A szabvány csak a metódusokat, tulajdonságokat és az objektum egyéb elemeit határozza meg, szabadon hagyva az implementáció lehetőségét a különböző nyelveknek. Az FCL jelenleg a teljes [XML DOM 1.0](http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/)-t támogatja.
10+
11+## Példák
12+
13+Lejjebb találsz egy listát az XML adatok kezelésével kapcsolatos példákról, fokozatosan növekvő bonyolultsággal.
14+
15+### Szövegelem olvasása
16+
17+Delphi programozóknak: Vedd figyelembe, hogy amikor egy TXMLDocument-tel dolgozunk, az elemen belüli szöveg, egy különálló szövegelemként van kezelve. Ennek eredményeként: egy elem szövegét úgy tudod elérni, ha különálló elemként tekinted. Másik megoldás: a **TextContent** tulajdonság használható, hogy egy adott elem összes szövegtartalmát, összefűzve megszerezd.
18+
19+A **ReadXMLFile** függvény mindig létrehoz egy új **TXMLDocument**-et, tehát neked nem kell előzőleg kézzel létrehoznod. Ellenben, ne felejtsd el felszabadítani a dokumentumot a **Free** meghívásával, amikor kész vagy.
20+
21+Például, vegyük a következő XML-t:
22+
23+``` xml
24+ <?xml version="1.0"?>
25+ <request>
26+ <request_type>PUT_FILE</request_type>
27+ <username>123</username>
28+ <password>abc</password>
29+ </request>
30+```
31+
32+A következő példakód bemutatja mind a helyes, mind a helytelen módját egy szövegelem értékének megszerzéséhez:
33+
34+``` pascal
35+ var
36+ PassNode: TDOMNode;
37+ Doc: TXMLDocument;
38+ begin
39+ // XML fájl beolvasása a lemezről
40+
41+ ReadXMLFile(Doc, 'c:\xmlfiles\test.xml');
42+
43+ // A "password" elem beolvasása
44+
45+ PassNode := Doc.DocumentElement.FindNode('password');
46+
47+ // A kiválasztott elem értékének kiíratása
48+
49+ WriteLn(PassNode.NodeValue); // üres lesz
50+
51+ // Az elem szövege valójában egy különálló gyerek elem
52+
53+ WriteLn(PassNode.FirstChild.NodeValue); // helyesen kiírja az "abc"-t
54+
55+ // másképpen:
56+
57+ WriteLn(PassNode.TextContent);
58+
59+ // végül, felszabadítjuk a dokumentumot:
60+
61+ Doc.Free;
62+end;
63+```
64+
65+### Az elemek nevének kiíratása
66+
67+Egy gyors megjegyzés a DOM fában való navigáláshoz: Amikor az elemeket sorrendben kell elérned, a legjobb a **FirstChild** és a **NextSibling** tulajdonságok használata (előre való lépkedéshez), vagy a **LastChild** és a **PreviousSibling** (hátrafelé lépkedéshez). Véletlenszerű eléréshez használhatók a **ChildNodes** vagy a **GetElementsByTagName** metódusok, de ezek egy TDOMNodeList objektumot fognak létrehozni, amit szintén fel kell szabadítani. Ez eltér más DOM implementációktól, mint pl. az MSXML, mert az FCL implementáció objektum, nem pedig interfész alapú.
68+
69+A következő példa bemutatja, hogy hogyan írassuk ki az elemek nevét egy TMemo-ba.
70+
71+Ez a 'C:\Programok\test.xml' fájl tartalma:
72+
73+``` xml
74+ <?xml version="1.0"?>
75+ <images directory="mydir">
76+ <imageNode URL="graphic.jpg" title="">
77+ <Peca DestinoX="0" DestinoY="0">Pecacastelo.jpg1.swf</Peca>
78+ <Peca DestinoX="0" DestinoY="86">Pecacastelo.jpg2.swf</Peca>
79+ </imageNode>
80+ </images>
81+```
82+
83+És itt a Pascal kód a feladat végrehajtásához:
84+
85+``` pascal
86+ var
87+ Document: TXMLDocument;
88+ Child: TDOMNode;
89+ j: Integer;
90+ begin
91+ ReadXMLFile(Document, 'C:\Programok\test.xml');
92+ Memo.Lines.Clear;
93+
94+ // FirstChild és NextSibling használatával:
95+
96+ Child := Document.DocumentElement.FirstChild;
97+ while Assigned(Child) do
98+ begin
99+ Memo.Lines.Add(Child.NodeName + ' ' + Child.Attributes.Item[0].NodeValue);
100+
101+ // ChildNodes metódus használatával:
102+
103+ with Child.ChildNodes do
104+ try
105+ for j := 0 to (Count - 1) do
106+ Memo.Lines.Add(Item[j].NodeName + ' ' + Item[j].FirstChild.NodeValue);
107+ finally
108+ Free;
109+ end;
110+ Child := Child.NextSibling;
111+ end;
112+ Document.Free;
113+ end;
114+```
115+
116+Ez lesz a kimenet:
117+
118+ imageNode graphic.jpg
119+ Peca Pecacastelo.jpg1.swf
120+ Peca Pecacastelo.jpg1.swf
121+
122+### Fastruktúra feltöltése XML-lel
123+
124+Egy elterjedt módja az XML fájlok használatának, az, hogy a tartalmukat egy fastruktúrában használjuk fel. A TTreeView komponens a "Common Controls" fülön található a Lazarus-ban.
125+
126+A lenti függvény egy előzőleg betöltött vagy a kódban generált XML dokumentum alapján feltölt egy fastruktúrát a tartalmával. Minden egyes elem megnevezése az első attribútumának tartalma lesz.
127+
128+``` pascal
129+procedure TForm1.XML2Tree(tree: TTreeView; XMLDoc: TXMLDocument);
130+var
131+ iNode: TDOMNode;
132+
133+ procedure ProcessNode(Node: TDOMNode; TreeNode: TTreeNode);
134+ var
135+ cNode: TDOMNode;
136+ s: string;
137+ begin
138+ if Node = nil then Exit; // Kilépés, ha egy ág végére értünk
139+
140+ // Elem hozzáadása a fához
141+ if Node.HasAttributes and (Node.Attributes.Length>0) then
142+ s:=Node.Attributes[0].NodeValue
143+ else
144+ s:='';
145+ TreeNode := tree.Items.AddChild(TreeNode, s);
146+
147+ // Ugrás az első gyerek elemhez
148+ cNode := Node.FirstChild;
149+
150+ // Gyerek elemek feldolgozása
151+ while cNode <> nil do
152+ begin
153+ ProcessNode(cNode, TreeNode);
154+ cNode := cNode.NextSibling;
155+ end;
156+ end;
157+
158+begin
159+ iNode := XMLDoc.DocumentElement.FirstChild;
160+ while iNode <> nil do
161+ begin
162+ ProcessNode(iNode, nil); // Rekurzívan
163+ iNode := iNode.NextSibling;
164+ end;
165+end;
166+```
167+
168+### XML dokumentum módosítása
169+
170+Az első dolog, amit meg kell jegyezni, az hogy a TDOMDocument a "handle" a DOM-hoz. Úgy jöhet létre ennek az osztálynak példánya, hogy saját kezűleg létrehozod, vagy egy XML dokumentumot betöltesz.
171+
172+Másfelől, az elemek nem hozhatók létreh úgy, mint egy normál objektum. A TDOMDocument metódusait KELL használod, hogy létrehozd őket, és később más metódusokat, hogy a megfelelő helyre tehesd őket a szerkezetben. Ez azért van, mert az elemeket egy meghatározott dokumentumnak kell birtokolnia a DOM-ban.
173+
174+Lejjebb található a TDOMDocument néhány általános metódusa:
175+
176+``` pascal
177+ function CreateElement(const tagName: DOMString): TDOMElement; virtual;
178+ function CreateTextNode(const data: DOMString): TDOMText;
179+ function CreateCDATASection(const data: DOMString): TDOMCDATASection;
180+ virtual;
181+ function CreateAttribute(const name: DOMString): TDOMAttr; virtual;
182+```
183+
184+És itt egy példa, ami megkeresi a TTreeView-ben kijelölt elemet és elhelyez egy gyerek elemet abba az XML dokumentumba, amelyet reprezentál. A fastruktúrát előtte fel kell tölteni egy XML fájl tartalmával a [[Networking|XML2Tree function]] használatával.
185+
186+``` pascal
187+procedure TForm1.actAddChildNode(Sender: TObject);
188+var
189+ position: Integer;
190+ NovoNo: TDomNode;
191+begin
192+ {*******************************************************************
193+ * Megkeresi a kijelölt elemet
194+ *******************************************************************}
195+ if TreeView1.Selected = nil then Exit;
196+
197+ if TreeView1.Selected.Level = 0 then
198+ begin
199+ position := TreeView1.Selected.Index;
200+
201+ NovoNo := XMLDoc.CreateElement('item');
202+ TDOMElement(NovoNo).SetAttribute('nome', 'Item');
203+ TDOMElement(NovoNo).SetAttribute('arquivo', 'Arquivo');
204+ with XMLDoc.DocumentElement.ChildNodes do
205+ begin
206+ Item[position].AppendChild(NovoNo);
207+ Free;
208+ end;
209+
210+ {*******************************************************************
211+ * A fastruktúra frissítése
212+ *******************************************************************}
213+ TreeView1.Items.Clear;
214+ XML2Tree(TreeView1, XMLDoc);
215+ end
216+ else if TreeView1.Selected.Level >= 1 then
217+ begin
218+ {*******************************************************************
219+ * Ez a függvény a fának csak az első szintjén működik,
220+ * de egyszerűen módosítható úgy, hogy bármelyiken működjön
221+ *******************************************************************}
222+ end;
223+end;
224+```
225+
226+### TXMLDocument létrehozása string-ből
227+
228+Adott egy XML fájl a MyXmlString-ben. A következő kód létrehozza a DOM-ját:
229+
230+``` pascal
231+Var
232+ S : TStringStream;
233+ XML : TXMLDocument;
234+
235+begin
236+ S:= TStringStream.Create(MyXMLString);
237+ Try
238+ S.Position:=0;
239+ XML:=Nil;
240+ ReadXMLFile(XML,S); // Teljes XML dokumentum
241+ // Másképpen:
242+ ReadXMLFragment(AParentNode,S); // Csak az XML töredék beolvasása.
243+ Finally
244+ S.Free;
245+ end;
246+end;
247+```
248+
249+### Dokumentum érvényesítése
250+
251+2007\. márciusa óta, a DTD érvényesítési képesség lett hozzáadva az FCL XML feldogozóhoz. Az érvényesítés ellenőrzi a dokumentum logikai felépítését az előre meghatározott szabályoknak alapján (ez a *Document Type Definition* /DTD/).
252+
253+Itt egy példa DTD-vel ellátott XML dokumentumra:
254+
255+``` xml
256+ <?xml version='1.0'?>
257+ <!DOCTYPE root [
258+ <!ELEMENT root (child)+ >
259+ <!ELEMENT child (#PCDATA)>
260+ ]>
261+ <root>
262+ <child>Ez az első gyerek.</child>
263+ <child>Ez a második gyerek.</child>
264+ </root>
265+```
266+
267+Ez a DTD meghatározza, hogy a 'root' elemnek egy vagy több 'child' elemének kell lennie, és hogy a 'child' elemek csak karakteres adatot tartalmazhatnak. Ha a feldolgozó eltérést érzékel ehhez képest, jelenteni fogja.
268+
269+Egy ilyen dokumentum beolvasása jóval bonyolultabb. Vegyük azt, hogy XML adatunk van egy TStream objektumban:
270+
271+``` pascal
272+procedure TMyObject.DOMFromStream(AStream: TStream);
273+var
274+ Parser: TDOMParser;
275+ Src: TXMLInputSource;
276+ TheDoc: TXMLDocument;
277+begin
278+ // feldolgozó objektum létrehozása
279+
280+ Parser := TDOMParser.Create;
281+
282+ // és a bemeneti forrás
283+
284+ Src := TXMLInputSource.Create(AStream);
285+
286+ // kérünk érvényesítést
287+
288+ Parser.Options.Validate := True;
289+
290+ // hibakezelő hozzárendelése, ami figyeli a jelentéseket
291+
292+ Parser.OnError := @ErrorHandler;
293+
294+ // most jöhet a feldolgozás
295+
296+ Parser.Parse(Src, TheDoc);
297+
298+ // ...és most takarítás
299+
300+ Src.Free;
301+ Parser.Free;
302+end;
303+
304+procedure TMyObject.ErrorHandler(E: EXMLReadError);
305+begin
306+ if E.Severity = esError then // csak az érvényesítési hibák érdekelnek
307+ writeln(E.Message);
308+end;
309+```
310+
311+### XML fájl létrehozása
312+
313+Lejjebb található egy teljes kód XML fájlba íráshoz. (Ez a DeveLazarus blog-ból lett másolva) Ne felejtsd el a DOM és az XMLWrite unit-okat a uses szekcióban!
314+
315+``` pascal
316+unit Unit1;
317+
318+{$mode objfpc}{$H+}
319+
320+interface
321+
322+uses
323+ Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls,
324+ DOM, XMLWrite;
325+
326+type
327+ { TForm1 }
328+ TForm1 = class(TForm)
329+ Button1: TButton;
330+ Label1: TLabel;
331+ Label2: TLabel;
332+ procedure Button1Click(Sender: TObject);
333+ private
334+ { private declarations }
335+ public
336+ { public declarations }
337+ end;
338+
339+var
340+ Form1: TForm1;
341+
342+implementation
343+
344+{ TForm1 }
345+
346+procedure TForm1.Button1Click(Sender: TObject);
347+var
348+ xdoc: TXMLDocument; // dokumentum változó
349+ RootNode, parentNode, nofilho: TDOMNode; // elemek változói
350+begin
351+ // dokumentum létrehozása
352+ xdoc := TXMLDocument.create;
353+
354+ // gyökér elem létrehozása
355+ RootNode := xdoc.CreateElement('register');
356+ Xdoc.Appendchild(RootNode); // gyökér elem mentése
357+
358+ // szülő elem létrehozása
359+ RootNode:= xdoc.DocumentElement;
360+ parentNode := xdoc.CreateElement('usuario');
361+ TDOMElement(parentNode).SetAttribute('id', '001'); // attribútumok létrehozása a szülő elemhez
362+ RootNode.Appendchild(parentNode); // szülő elem mentése
363+
364+ // gyerek elem létrehozása
365+ parentNode := xdoc.CreateElement('nome');
366+ //TDOMElement(parentNode).SetAttribute('sexo', 'M'); // attribútumok létrehozása
367+ nofilho := xdoc.CreateTextNode('Fernando'); // értékadás az elemhez
368+ parentNode.Appendchild(nofilho); // elem mentése
369+ RootNode.ChildNodes.Item[0].AppendChild(parentNode); // gyerek elem hozzáadása a hozzátartozó szülőhöz
370+
371+ // gyerek elem létrehozása
372+ parentNode := xdoc.CreateElement('idade');
373+
374+ //TDOMElement(parentNode).SetAttribute('ano', '1976'); // attribútumok létrehozása
375+ nofilho := xdoc.CreateTextNode('32'); // értékadás az elemhez
376+ parentNode.Appendchild(nofilho); // elem mentése
377+ RootNode.ChildNodes.Item[0].AppendChild(parentNode); // gyerek elem hozzáadása a hozzátartozó szülőhöz
378+
379+ writeXMLFile(xDoc,'teste.xml'); // kiírás XML-be
380+ Xdoc.free; // memória felszabadítása
381+end;
382+
383+initialization
384+ {$I unit1.lrs}
385+
386+end.
387+```
388+
389+Az eredmény a következő XML fájl:
390+
391+``` xml
392+<?xml version="1.0"?>
393+<register>
394+ <usuario id="001">
395+ <nome>Fernando</nome>
396+ <idade>32</idade>
397+ </usuario>
398+</register>
399+```
400+
401+--Fernandosinesio 22:28, 24 April 2008 (CEST)fernandosinesio@gmail.com
402+
403+### Kódolás
404+
405+Az 12582-es SVN revíziótól kezdődően, az XML olvasó alkalmas bármilyen kódolású adat feldolgozásához, külső dekódolók használatával. Lásd: [[XML Decoders]] tovább részletekért.
406+
407+Az XML szabvány alapján, az 'encoding' attribútum az XML első sorában opcionális, abban az esetben, ha a kódolás UTF-8 vagy UTF-16 (ami a BOM jelenlétéből határozható meg). A 0.9.26-os Lazarus verziótól, a TXMLDocument-nek van 'encoding' tulajdonsága, de ez tiltva van. A WriteXMLFile mindig UTF-8-at használ és nem hoz létre encoding attribútumot az XML fájl első sorában.
408+
409+## Külső hivatkozások
410+
411+- [W3Schools](http://www.w3schools.com/xml/default.asp) Xml tananyag
412+
413+- [Thomas Zastrow cikke](http://www.thomas-zastrow.de/texte/fpcxml/index.php) FPC és XML
414+
415+---
416+*From the Free Pascal wiki, page "XML Tutorial/hu", 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