ეს განყოფილებაეძღვნება XML-თან მუშაობას. იგი შეიცავს როგორც თეორიულ, ასევე პრაქტიკულ მასალას. განხილული იქნება ძირითადი ოპერაციები XML ფაილებით, ასევე ინტერაქცია LINQ-თან და მრავალი სხვა.
XML ფაილის შექმნა
XML(გაფართოებული მარკირების ენა) - გაფართოებადი მარკირების ენა, რომელიც გამოიყენება მონაცემთა ბაზების შესაქმნელად, ვებ გვერდები, გამოიყენება პროგრამებს შორის ინფორმაციის გაცვლისთვის, გამოიყენება ისეთ ტექნოლოგიებში, როგორიცაა Ajax, SOAP და ასევე წარმოადგენს XAML ენის საფუძველს, რომელსაც შეიძლება შეხვდეთ WPF-თან მუშაობისას.
xml ფაილის შესაქმნელად, უბრალოდ უნდა შევიტანოთ
XML ფაილის სტრუქტურა
ნებისმიერი XML ფაილი იწყება დეკლარაციის დეკლარაციით.
დეკლარაცია
დეკლარაცია xmlფაილი მოიცავს:
ვერსია - XML ენის ვერსიის ნომერი, 1.0 და 1.1
თუ იყენებთ, მაშინ არ გჭირდებათ დეკლარაციის ხაზის მითითება, თუ იყენებთ ვერსიას 1.1, მაშინ უნდა მიუთითოთ ეს ხაზი.
კოდირება - განსაზღვრავს ფაილის კოდირებას
ამ ჩანაწერით თქვენ არ აყენებთ ფიზიკური ფაილის კოდირებას! მაგრამ თქვენ უბრალოდ აუხსენით პროგრამას, რომელიც დაამუშავებს ამ ფაილს, რა კოდირებით შეიცავს ფაილის შიგნით არსებული მონაცემები. ამ შემთხვევაში, თქვენ უნდა უზრუნველყოთ, რომ დოკუმენტის კოდირება და დეკლარაციის ხაზში მითითებული კოდირება ემთხვევა.
დოკუმენტის კოდირების დასაყენებლად შეგიძლიათ გამოიყენოთ, მაგალითად, Notepad++ პროგრამა
xml ფაილის ელემენტები
XML შედგება ელემენტებისაგან.
ელემენტი არის სტრიქონი, რომელიც შეიცავს გახსნის და დახურვის ტეგებს, ასევე მათ შორის მოთავსებულ მონაცემებს.
მნიშვნელობა - ელემენტი
ერთი ფაილი შეიძლება შეიცავდეს ნებისმიერი რაოდენობის ელემენტს.
ტეგები
როგორც უკვე აღვნიშნეთ, ელემენტი შედგება ტეგებისგან.
- ტეგი
ტეგების სახელები შეიძლება დაიწყოს ასოებით, ხაზგასმით ან ორწერტილით და შემდეგ შეიძლება მოჰყვეს ნებისმიერი სიმბოლოს.
არსებობს ორი ტიპის ტეგი: ორადგილიანი და ერთეული.
- მარტოხელა
ერთი ტეგი შეიძლება გამოვიყენოთ ისეთ სიტუაციაში, როდესაც ტეგებს შორის ინფორმაცია არ არის, მაგრამ იმისათვის, რომ არ იყოს მითითებული დაწყვილებული ტეგი და მათ შორის სივრცე, გამოიყენეთ ერთი ტეგი, რომელიც ნებისმიერ დროს შეიძლება შეიცვალოს დაწყვილებული ტეგით. ერთი ტეგი უნდა დაიხუროს!
XML დოკუმენტის აგებისას ძალიან მნიშვნელოვანია იმის უზრუნველყოფა, რომ ტეგები სწორად არის ჩასმული:
- არასწორი
- უფლება
XML რეგისტრის მგრძნობიარე ენა
კომენტარები
XML დოკუმენტის კომენტარები იყენებს იგივე სინტაქსს, როგორც HTML-ში.
დეკლარაციის გამოცხადების და XML ენის ძირითადი კომპონენტების გაცნობის შემდეგ გადავდივართ ჩვენი ფაილის შევსებაზე.
ძირეული ელემენტი
ძირეული ელემენტი ყოველთვის პირველ რიგში არის ჩამოთვლილი ერთ XML დოკუმენტში შეიძლება იყოს მხოლოდ ერთი ძირეული ელემენტი!
ამ მაგალითში იქმნება ორი ძირეული ელემენტი
- არასწორი
- უფლება
მეორე მაგალითში იქმნება ერთი ძირეული ელემენტი "Root", რომელიც შეიცავს რეგულარულ ელემენტს "Admin".
root ელემენტის გამოცხადების შემდეგ, შეგიძლიათ დაამატოთ ნებისმიერი რაოდენობის ელემენტი თქვენს . ყველა დამატებული ელემენტი უნდა განთავსდეს ძირეული ელემენტის ტეგებს შორის.
წიგნის ელემენტის შემცველი „ბიბლიოთეკის“ ძირეული ელემენტი, რომელიც შეიცავს ჩადგმულ ელემენტებს: სათაური, ავტორი, წელი.
xml ფაილის ატრიბუტები
ატრიბუტები მითითებულია ნებისმიერი ელემენტის გახსნის ტეგში.
სინტაქსი: სახელი = "მნიშვნელობა" ჩასმული ორმაგ ბრჭყალებში.
ატრიბუტების ნებისმიერი რაოდენობა შეიძლება იყოს, მაგრამ ისინი არ უნდა განმეორდეს და მათი სახელები არ უნდა შეიცავდეს სივრცეებს.
შეცდომა, არის ორი დუბლიკატი "id" ატრიბუტი და არის სივრცე id-სა და რიცხვს შორის.
შემდეგ XML დოკუმენტიშექმნილია, თქვენ უნდა შეინახოთ იგი, მაგრამ არ დაგავიწყდეთ ფაილის გაფართოების შეცვლა.
- file_name.xml
თუ რომელიმე თქვენგანს ოდესმე უცდია XML-ის დამოუკიდებლად სწავლა, შეიძლება შეგხვედროდათ იგივე დამაბნეველი კონცეფციები, რომლებსაც მე წარსულში შევხვდი. DTD, XML სქემა, სახელების სივრცეები, XPath, XPointers, XSL, XSLT, DOM, SAX, SOAP, უარს ვამბობ. მე მხოლოდ დავამატებ, რომ ამ მასალების უმეტესობა ეფუძნება იმპლემენტაციას, რომლის კოდი შეიძლება შეიცავდეს შეცდომებს. ალბათ მილიონობით გზა არსებობს XML-ის დანერგვისა და გამოყენებისთვის, მაგრამ ისინი ყველა შეიძლება საკმაოდ რთული იყოს. და იცით, XML შეიძლება იყოს ძალიან მარტივი. თუ დავივიწყებთ DTD, XML სქემებს, სახელთა სივრცეებს და ა.შ.
იმისათვის, რომ სწრაფად გასწავლოთ XML-თან მუშაობა, მე, თუ ეს შესაძლებელია, იგნორირებას გავაკეთებ იმ ინფორმაციის სოლიდურ რაოდენობაზე, რომელიც უკვე შეგიძლიათ წაიკითხოთ შესაბამის ლიტერატურაში. და პირველი, რასაც ვაპირებ იგნორირებას, არის სახელთა სივრცეები და სქემები. ეს შეიძლება უცნაურად მოგეჩვენოთ, რადგან წიგნების უმეტესობა იწყება ამ ცნებების ახსნით, მაგრამ შეეცადეთ XML წარმოიდგინოთ, როგორც კონკრეტული პრობლემის გადაჭრის საშუალება, როგორიცაა ჩაქუჩი. თქვენ ნამდვილად უნდა იცოდეთ როგორ ავაშენოთ სახლი ჩაქუჩის გამოსაყენებლად? რა მოხდება, თუ მე მჭირდება მხოლოდ ლურსმანში ჩაქუჩი, რომ სურათი დავკიდო? იგივეა XML-ის შემთხვევაშიც, ის შეიძლება იყოს ძალიან რთული, საკმარისად ზოგადი გამოსაყენებლად ასობით თუ არა ათასობით აპლიკაციაში და ძალიან მარტივი, თუ ყურადღებას არ მიაქცევთ რამდენიმე რამეს. ამ სტატიაში ყურადღებას გავამახვილებ XML-ის გამოყენებით კონკრეტული პრობლემების გადაჭრაზე.
მაშ კონკრეტულად რა არის პრობლემა? დავუშვათ, რომ XML-ის გამოყენებით მინდა აღვწერო მარტივი ობიექტი, როგორიცაა ჭიქა. რატომ ვაპირებ ამისთვის XML-ის გამოყენებას? კარგად, პირველ რიგში, სწორედ ამისთვის არის შექმნილი XML. XML აღწერს მონაცემებს. ჩემს მაგალითში, მინა არის მონაცემები. რეალურ ცხოვრებაში მონაცემები შეიძლება იყოს Word დოკუმენტები, ცხრილები, სურათები, წიგნი, მონაცემთა ბაზის ჩანაწერი, ან თუნდაც C++ ან Visual Basic კლასები. მეორეც, XML გაფართოებულია. XML საშუალებას მაძლევს შევქმნა იმდენი ფუნქცია, რამდენიც საჭირო იქნება მონაცემების აღსაწერად და ეს ფუნქციები იქნება რაც მინდა. და ბოლოს, რადგან XML სწრაფად ხდება სტანდარტი. თუ მარსზე სიცოცხლეა, მაშინ დარწმუნებული უნდა იყოთ, რომ იქ ჩემი XML ფაილის გაგებას შეძლებენ.
რა ძირითადი თვისებები გვაძლევს საშუალებას აღვწეროთ ჭიქა?
როგორ გამოიყურება იგივე XML ფორმატში?
|
|
გაითვალისწინეთ, რომ ფაილის პირველი ხაზი () ახლა განსაკუთრებული სახე აქვს, უბრალოდ დაიმახსოვრე, რომ აქ უნდა იყოს. XML ფორმატის სილამაზე იმაში მდგომარეობს, რომ ყველას შეუძლია გაიგოს, რას ამბობს ის, მხოლოდ ყურადღებით დათვალიერებით. ასევე ნათელია, რომ ეს არ არის შუშის ერთადერთი შესაძლო XML აღწერა. თუ 10 ადამიანს ვთხოვ, შეიმუშაონ იგივე თვისებების მქონე ჭიქის XML აღწერა, ისინი ალბათ ყველა შექმნიან განსხვავებულ, მაგრამ სწორ აღწერილობას. სწორედ აქ არის პრობლემა. შესაძლოა, ჩვენთვის არა, მაგრამ როდესაც კომპიუტერი კითხულობს XML ფაილს, კარგი იდეა იქნება, რომ აცნობოთ მას, თუ რა არის ეს ფაილი. სწორედ აქ მოქმედებს სახელთა სივრცეები და სქემები. მარტივად რომ ვთქვათ, სქემები გამოიყენება XML ფაილის ადექვატური სტრუქტურის დასადგენად.
ახლა დროა ვისაუბროთ რამდენიმე მარტივ XML წესზე, რომლებიც უნდა დაიცვათ:
XML წესი #1: მოქმედი XML ფაილი ზუსტად უნდა ემთხვეოდეს მის სქემას. მაგრამ მასალის გასაგებად, არცერთი ჩემი მაგალითი არ გამოიყენებს დიაგრამებს. ასე რომ, მკაცრად რომ ვთქვათ, არცერთი ჩემი მაგალითი არ არის „ადეკვატური“. მაგრამ სიმართლე გითხრათ, არ მაინტერესებს. სახლის აშენებას არ ვაპირებ, უბრალოდ სურათის ჩამოკიდება მჭირდება. ამაზე მეტს მოგვიანებით ვისაუბრებ, როდესაც განვიხილავთ XML დოკუმენტის ობიექტის მოდელს.
XML წესი #2შენიშვნა: თუ დაპროგრამებთ VB-ში, გახსოვდეთ: XML არის რეგისტრის მგრძნობიარე. XML არის რეგისტრის მგრძნობიარე. XML არის რეგისტრის მგრძნობიარე. XML არის რეგისტრის მგრძნობიარე. დაწერეთ ეს წინადადება 1000 ჯერ და არასოდეს დაგავიწყდებათ.
XML წესი #3: ტეგებს ჩვეულებრივ ელემენტებს უწოდებენ და თითოეულ გახსნის ტეგს უნდა ჰქონდეს შესაბამისი დახურვის ტეგი. ამ წესის დაცვით, თქვენ მიიღებთ სწორ XML ფაილს. ეს ძალიან მნიშვნელოვანია, რადგან სანამ XML ფაილი სწორად არ დაფორმატდება, ის არ იქნება გაანალიზებული და ჩატვირთული Document Object Model-ში. გაითვალისწინეთ, რომ თუ ელემენტი არ შეიცავს მნიშვნელობებს და არ შეიცავს სხვა (ბუდე) ელემენტებს, დახურვის ტეგი შეიძლება გამოიყურებოდეს
XML წესი #4: ელემენტები შეიძლება შეიცავდეს ატრიბუტებს და ატრიბუტების მნიშვნელობები უნდა იყოს ჩასმული ბრჭყალებში (ერთჯერადი ან ორმაგი).
XML წესი #5: შეგიძლიათ რამდენჯერმე გამოიყენოთ ატრიბუტების სახელები, მაგრამ ელემენტების სახელები უნდა იყოს უნიკალური მთელ ფაილში. წინა მაგალითში, qty ატრიბუტს განსხვავებული მნიშვნელობა ჰქონდა იმისდა მიხედვით, თუ რომელ ელემენტში იყო გამოყენებული
XML წესი #6: XML-ში არის რამდენიმე სპეციალური სიმბოლო, რომელთა პირდაპირ გამოყენება შეუძლებელია, რადგან ისინი დაცულია XML სინტაქსში. ამიტომ, ასეთი სიმბოლოების გამოსაყენებლად, თქვენ მოგიწევთ გამოიყენოთ რეზერვირებული კონსტრუქცია, რომელიც იწყება & სიმბოლოთი და სპეციალური კოდით, (& სიმბოლო უნდა დაიწეროს როგორც &) (" სიმბოლო უნდა დაიწეროს როგორც") (სიმბოლო< должен писаться как <) (символ >უნდა დაიწეროს როგორც >) და (" სიმბოლო უნდა დაიწეროს როგორც "). ამის ნაცვლად, თქვენ ასევე შეგიძლიათ გამოიყენოთ ინსტრუქცია, სადაც "...." შეიძლება იყოს სიმბოლოების ნებისმიერი თანმიმდევრობა, გარდა "]]>. ეს კონსტრუქცია შეიძლება ყველგან გამოჩნდეს, მაგრამ მისი ბუდობა შეუძლებელია.
2. XML დოკუმენტის ობიექტის მოდელი
XML დოკუმენტის ობიექტის მოდელი საშუალებას აძლევს პროგრამისტებს ჩატვირთონ XML ფაილის შინაარსი მეხსიერებაში. მას შემდეგ, რაც XML ფაილი იტვირთება ამ გზით, მისი მანიპულირება შესაძლებელია დოკუმენტის ობიექტის მოდელის თვისებების, მეთოდებისა და მოვლენების გამოყენებით. ეს არის სადაც XML გამოდგება. Document Object Model მნიშვნელოვნად უწყობს ხელს XML ფაილის ინფორმაციის მოძიებას და დამუშავებას. აქ არ ვისაუბრებ დოკუმენტის ობიექტის მოდელის ყველა შესაძლებლობებზე, ვისაუბრებ მხოლოდ რამდენიმე ძირითად მახასიათებელზე, რაც ხელს შეუწყობს ამ სტატიის მიზნის მიღწევას. მე ავიღებ XML ფაილს, რომელიც ახლახან შევქმენი, რომელიც აღწერს შუშას, ჩავტვირთავ მას Document Object Model-ში და რამდენიმე რამეს გავაკეთებ მასთან. დოკუმენტის ობიექტის მოდელის დანარჩენ მახასიათებლებსა და შესაძლებლობებს შევინახავ შემდეგი სტატიისთვის, სადაც საუბარია კლიენტის XML-ზე. გაითვალისწინეთ, რომ მიუხედავად იმისა, რომ დოკუმენტის ობიექტის მოდელი ძალიან კარგი და მოსახერხებელია დეველოპერებისთვის, ის მოითხოვს სისტემის რესურსების საკმაოდ მნიშვნელოვან რაოდენობას. აქედან გამომდინარე, არსებობს XML ფაილების გარჩევის კიდევ ერთი მეთოდი, რომელიც ცნობილია როგორც SAX. ჩემი სტატია არ არის პრეტენზია, რომ არის ინფორმაციის ამომწურავი წყარო ამ საკითხთან დაკავშირებით, ამიტომ სასარგებლო იქნება XML SDK-ის გამოყენებაც.
მოდით შევხედოთ მაგალითს Microsoft-ის XML პარსერის ვერსიის 3.0 (msxml3.dll) გამოყენებით, რათა გავიგოთ, როგორ მუშაობს ეს ყველაფერი. თუ არ გაქვთ ანალიზატორი, უახლესი ვერსია შეგიძლიათ ჩამოტვირთოთ Microsoft-ის ვებსაიტიდან.
ვთქვათ, მე შევინახე ჭიქის აღწერის მაგალითი XML ფორმატში ფაილში "http://web_server/xml/cup.xml" (ლოკალური გზა C:\inetpub\wwwroot\xml\cup.xml) და ახლა მინდა ჩატვირთეთ იგი დოკუმენტის ობიექტის მოდელში. შემდეგი კოდი ვარაუდობს, რომ ანალიზატორი უკვე დატვირთულია და მუშაობს.
| Visual Basic 6.0 კოდი:(დაამყარეთ კავშირი Microsoft XML-თან, v3.0) XmlDoc-ის ჩაქრობა, როგორც MSXML2.DOMDocument30 დააყენეთ xmlDoc = New DOMDocument30 xmlDoc.async = False xmlDoc.validateOnParse = False xmlDoc.load ("c:\inetml\cup.x. ) msgBox xmlDoc.xml ASP სერვერის კოდი Visual Basic-ში: Dim xmlDoc Set xmlDoc = Server.CreateObject("Msxml2.DOMDocument.3.0") xmlDoc.async = False xmlDoc.validateOnParse = False xmlDoc.load "/xml/cup.xml" ASP სერვერის კოდი Java Script-ში: var xmlDoc = Server.CreateObject("Msxml2.DOMDocument.3.0"); xmlDoc.async = false; xmlDoc.validateOnParse = false; xmlDoc.load("/xml/cup.xml"); |
ზემოაღნიშნული კოდის ახსნა – გადავხედოთ VB6 კოდს
ხაზი 1:ჩამქრალი xmlDoc, როგორც MSXML2.DOMDocument30
ამ პირველ სტრიქონში ჩვენ განვსაზღვრავთ მითითებას "Microsoft XML, v3.0". ამ სტრიქონში მე განვსაზღვრე xmlDoc ცვლადი, როგორც XML დოკუმენტის მითითება. MSXML2 არის ბიბლიოთეკა (გამოიყენეთ ეს სახელი, ნუ ცდილობთ დაწეროთ MSXML3, ის არ იმუშავებს). DODocument30 განსაზღვრავს XML დოკუმენტის ობიექტს, რომელიც შეესაბამება 3.0 ვერსიას. თქვენ ასევე შეგიძლიათ იხილოთ ასეთი კოდი: dim xmlDoc როგორც MSXML2.DOMDocument. ეს კონსტრუქცია ჩვეულებრივ გამოიყენება, როდესაც არ გსურთ XML დოკუმენტის კონკრეტული ვერსიის მითითება. ამ შემთხვევაში გამოყენებული იქნება სისტემაში რეგისტრირებული ნაგულისხმევი ანალიზატორი. ერთადერთი პრობლემა შეიძლება იყოს ის, რომ ნაგულისხმევად რეგისტრირებული ანალიზატორის ვერსია შეიძლება განსხვავდებოდეს სხვადასხვა კომპიუტერზე. თუ გსურთ დარწმუნებული იყოთ, რომ თქვენს მიერ დაწერილი კოდი იმუშავებს ანალიზატორის ნებისმიერ ვერსიასთან, მაშინ არ გამოიყენოთ კონსტრუქციები, რომლებიც სპეციფიკურია ანალიზატორის კონკრეტული ვერსიებისთვის. იმის გამო, რომ არ არსებობს გარანტია, რომ მომხმარებელს, რომელიც გამოიყენებს თქვენს კოდს, დაინსტალირებული იქნება ანალიზატორის იგივე ვერსია, რომელზეც თქვენ დაწერეთ თქვენი კოდი. კოდის შემუშავების კიდევ ერთი უპირატესობა, რომელიც ანალიზატორისგან დამოუკიდებელი ვერსიაა, არის ის, რომ როდესაც ანალიზატორის უფრო ახალი ვერსია გამოვა, ის წინა ვერსიებთან თავსებადი იქნება და არ მოგიწევთ თქვენი კოდის ხელახლა შედგენა.
ხაზი 2:დააყენეთ xmlDoc = ახალი DOMDocument30
ეს ხაზი ახდენს xmlDoc ცვლადის ინიციალიზებას, როგორც ვერსიის 3.0 XML დოკუმენტის ობიექტის ახალ ინსტალაციას.
ხაზი 3: xmlDoc.async = მცდარი
XML ფაილები შეიძლება ჩაიტვირთოს სინქრონულად ან ასინქრონულად. თუ xmlDoc.async = False, ეს ნიშნავს, რომ XML ფაილის შიგთავსი იტვირთება და მხოლოდ ამის შემდეგ გადაეცემა დარეკვის პროცესს კონტროლი. თუ xmlDoc.async = True, ეს ნიშნავს, რომ კონტროლი დაუყოვნებლივ გადაეცემა გამოძახების პროცესს, XML ფაილის შინაარსის სრულად ჩატვირთვამდე მოლოდინის გარეშე.
ხაზი 4: xmlDoc.validateOnParse = False
ეს კოდი მიუთითებს, რომ პარსერმა არ უნდა შეამოწმოს XML ფაილი, რომელიც იტვირთება მისი სქემის მიხედვით (validateOnParse = False). იმისათვის, რომ ჩართოთ სქემის შესაბამისობის შემოწმება, თქვენ უნდა დაწეროთ validateOnParse = True.
ხაზი 5: xmlDoc.load ("C:\inetpub\wwwroot\xml\cup.xml")
ეს ხაზი იძახებს მეთოდს მითითებული XML ფაილის ჩატვირთვისთვის. არსებობს ორი სახის დატვირთვის მეთოდი. პირველი, რომელიც დაწერილია მე-5 სტრიქონზე, იტვირთება ფაილი დოკუმენტის ობიექტის მოდელში და აუცილებელია XML ფაილის სრული გზის გავლა. ჩატვირთვის მეორე ვარიანტი მოიცავს xml სტრიქონის პარამეტრად გადაცემას. ამ ტიპის დატვირთვას შეიძლება ეწოდოს, მაგალითად, ასე: xmlDoc.loadXML ("valid xml string"). მე გაჩვენებთ როგორ გამოიყენოთ ეს მეთოდი მოგვიანებით.
ხაზი 6: MsgBox xmlDoc.xml
ეს ხაზი აჩვენებს გადმოწერილი XML ფაილის შინაარსს. შედეგად, ჩვენ უნდა მივიღოთ ორიგინალური XML ფაილი, რომელიც ადრე შევქმენით.
2.2. XML დოკუმენტის ობიექტის მოდელის შესწავლა
შექმენით ახალი პროექტი Visual Basic-ში და დაარქვით standard.exe. ჩასვით ზემოაღნიშნული კოდი თქვენი პროექტის მთავარი ფანჯრის ჩატვირთვის მეთოდში. დარწმუნდით, რომ განაცხადეთ მითითება "Microsoft XML v3.0". ამისათვის დააწკაპუნეთ Project-->References, შემდეგ გადაახვიეთ სიაში, რომელიც გამოჩნდება და იპოვეთ მასში სასურველი ბმული. გთხოვთ გაითვალისწინოთ, რომ ანალიზატორის ვერსია 3.0 უნდა იყოს დაინსტალირებული თქვენს კომპიუტერში, წინააღმდეგ შემთხვევაში ის არ იქნება ჩამოთვლილი. დააყენეთ წყვეტის წერტილები კოდის ბოლო სტრიქონზე (msgbox xmlDoc.xml). გაუშვით აპლიკაცია გამართვის რეჟიმში. როდესაც შესრულების პროცესი მიაღწევს გაჩერების წერტილს, გამოიძახეთ "Locals" ფანჯარა და შეხედეთ დოკუმენტის ობიექტის მოდელს. ბევრი რამის სწავლა შეგიძლიათ ამ ფანჯარაში ნაჩვენების ნახვით. "ადგილობრივი" ფანჯარა უნდა გამოიყურებოდეს ქვემოთ მოცემულ სურათზე. აქ მოცემულია დოკუმენტის ობიექტის მოდელის რამდენიმე საინტერესო თვისება.
XML დოკუმენტის ობიექტის მოდელი ყოველთვის შეიცავს ორ ზედა დონის კვანძს:
- Item1 არის დოკუმენტის ელემენტების ფილიალის ფესვი (უგულებელყოთ იგი)
- Item2 ფაქტიურად დოკუმენტის პირველი ელემენტია (გახსოვდეთ ეს)
nodeName ან baseName - შეიძლება გამოყენებულ იქნას ელემენტის ან ატრიბუტის სახელის ძიებისას.
nodeType - გამოიყენება მიმდინარე კვანძის ტიპის მისაღებად.
nodeValue - გამოიყენება კვანძის მონაცემების მნიშვნელობის გასარკვევად.
childNodes არის საბავშვო კვანძების კოლექცია. ისინი შეიძლება იყოს ელემენტის კვანძები, ტექსტური კვანძები და CDATA კვანძები. შეიძლება არსებობდეს სხვა ტიპის კვანძები, რომლებზეც ახლა არ ვისაუბრებ, მაგრამ თქვენ შეგიძლიათ გაიგოთ ყველაფერი მათ შესახებ XML SDK-ში.
ატრიბუტები არის ატრიბუტების კვანძების კოლექცია მიმდინარე ელემენტისთვის.
სიგრძე - გამოიყენება ხეში კვანძების რაოდენობის დასადგენად, რომლებიც უშუალოდ მიეკუთვნება მიმდინარე.
xml - ეს თვისება წარმოდგენილია ყველა კვანძში და შეიძლება გამოყენებულ იქნას დოკუმენტში მიმდინარე პოზიციის წარმოსადგენად. XML სტრიქონი იწყება მიმდინარე კვანძიდან და ეშვება ხის ბოლომდე. ეს ძალიან სასარგებლო თვისებაა. ექსპერიმენტი ჩაატარეთ და ნახეთ რა მოხდება.
2.2.2. ელემენტის კვანძები
ელემენტის კვანძი შეიძლება შეიცავდეს ელემენტების, ატრიბუტების, ტექსტის ან CDATA-ს შვილობილ კვანძებს. ქვემოთ მოყვანილი ფიგურიდან შეგიძლიათ იხილოთ შემდეგი ინფორმაცია "სოლიდ" კვანძის შესახებ:
nodeType - მიმდინარე კვანძის ტიპი = NODE_ELEMENT - ე.ი. მიმდინარე კვანძი არის ელემენტი.
nodeName ან baseName ან tagName - მიმდინარე კვანძის (ელემენტის) სახელი = SOLID.
მის მშობელ ელემენტს CONTENTS ჰყავს 4 შვილი.
ეს ჩანს შემდეგ ფიგურაში, მაგრამ SOLID-ს ჰყავს ერთი შვილი, რომელიც არის ტექსტური მონაცემთა ტიპი.
ტექსტი - "ყინულის კუბი" არის მალსახმობის მეთოდი, რომელიც საშუალებას გაძლევთ მიიღოთ მიმდინარე კვანძის მნიშვნელობა ბავშვურ ტექსტურ კვანძზე გადასვლის გარეშე.
2.2.3. ატრიბუტების კვანძები
ატრიბუტების კვანძები შეიძლება შედგებოდეს მხოლოდ ტექსტის ან CDATA შვილობილი კვანძებისგან. შემდეგი სურათი გვიჩვენებს, თუ რა ინფორმაციის მიღება შესაძლებელია კვანძის "რაოდენობის" შესახებ:
nodeType - მიმდინარე კვანძის ტიპი = NODE_ATTRIBUTE - მიმდინარე კვანძი არის ატრიბუტი.
nodeName ან baseName - მიმდინარე კვანძის სახელი (ატრიბუტები) = რაოდენობა
ქვემოთ მოყვანილი სურათიდან ასევე ირკვევა, რომ რაოდენობას ჰყავს ერთი შვილი, რომელსაც აქვს ტექსტური მონაცემთა ტიპი.
ტექსტი ან მნიშვნელობა - "2" არის მალსახმობის მეთოდი, რომელიც საშუალებას გაძლევთ მიიღოთ მიმდინარე კვანძის მნიშვნელობა ბავშვურ ტექსტურ კვანძზე გადასვლის გარეშე.
2.2.4. ტექსტი და CDATA კვანძები
ტექსტს ან CDATA კვანძებს ბავშვები არ ჰყავთ. ტექსტური კვანძები შეიცავს მათი მშობელი კვანძის დამუშავებულ ტექსტურ მონაცემებს. CDATA შეიცავს მისი მშობელი კვანძის ნედლეულ ტექსტურ მონაცემებს. CDATA კვანძები იქმნება, როდესაც მონაცემები XML ფაილში ჩარჩოშია სპეციალური გზით. CDATA იარლიყი ეუბნება პარსერს, არ გაანალიზოს მონაცემები და მიიღოს ეტიკეტის შიგნით არსებული სიმბოლოები მონაცემებად. CDATA განყოფილება განსაკუთრებით სასარგებლოა, როდესაც გჭირდებათ კოდის ჩასმა XML ფაილში. შემდეგი სურათი გვიჩვენებს, თუ რა ინფორმაციის მიღება შეიძლება მიმდინარე ტექსტის კვანძიდან:
nodeType - მიმდინარე კვანძის ტიპი = NODE_TEXT - მიმდინარე კვანძი შეიცავს ტექსტურ მონაცემებს.
nodeName - მიმდინარე კვანძის სახელი (ტექსტი) = #text - ყველა ტექსტურ კვანძს ეწოდება #text
მონაცემები ან ტექსტი ან მნიშვნელობა - "2" არის მიმდინარე კვანძის მონაცემები.
2.2.5. შეცდომები დოკუმენტის ჩატვირთვისას
დოკუმენტის ობიექტის მოდელის parseError განყოფილება შეიძლება სასარგებლო იყოს XML დოკუმენტის ჩატვირთვისას წარმოქმნილი პრობლემების იდენტიფიცირებისთვის. თუ ამოვიღებ დახურვის ტეგს OTHER-დან ჩვენს სამაგალითო ფაილში და ვეცდები პროგრამის ხელახლა გაშვებას, მივიღებ შემდეგ შედეგს. პირველი სასარგებლო ინფორმაცია არის ის, რომ ჩვენი შემდეგი ძმა ახლა შეიცავს მნიშვნელობას Nothing. ახლა, თუ გადავხედავთ childNodes-ს, ხედავთ, რომ სიგრძის ველი ახლა არის 0. ორივე ეს ნიშანი მიუთითებს იმაზე, რომ ჩვენი XML დოკუმენტი არ იყო ჩატვირთული. იმის გასარკვევად, თუ რატომ, მე ვხსნი parseError კვანძს და ვიღებ შეცდომის შესახებ ყველა ინფორმაციას.
ასე რომ, მე გაჩვენეთ, როგორ ჩატვირთოთ XML ფაილი Document Object Model-ში, მაგრამ რას აკეთებთ მასთან? ერთ-ერთი მთავარი ფუნქცია, რომელიც შეგიძლიათ გამოიყენოთ, არის XML დოკუმენტზე სხვადასხვა მოთხოვნების შესრულება. ამისათვის, რა თქმა უნდა, შეგიძლიათ გადახედოთ მთელ დოკუმენტს, სანამ არ იპოვით თქვენთვის სასურველ ინფორმაციას. მაგრამ ყველაზე სასურველი გზაა DODocument კლასის ორიდან ერთ-ერთი მეთოდის გამოყენება. ჩვენს წინა მაგალითში კვანძების მოსაძებნად გამოყენებული ორი მეთოდი შეიძლება გამოიყურებოდეს xmlDoc.SelectSingleNode(patternString) რათა მივიღოთ კვანძი, რომელსაც ვეძებთ, ან xmlDoc.SelectNodes(patternString) მივიღოთ კვანძების სია, რომლებსაც ვეძებთ. patternString პარამეტრი სწორედ მოთხოვნაა. ის შეიძლება ჩამოყალიბდეს ორიდან ერთი გზით. როგორც XSL მოთხოვნა ან როგორც XPath მოთხოვნა. XML დოკუმენტის შეკითხვის უფრო ახალი და სასურველი გზა არის XPath. patternString ფორმატი წინასწარ უნდა იყოს დაყენებული, მონაცემთა მოთხოვნის ორი მეთოდიდან პირველ გამოძახებამდე, წინააღმდეგ შემთხვევაში სტანდარტულად გამოყენებული იქნება მოთხოვნების ფორმირების XSL მეთოდი. patternString-ის ფორმირების ტიპის დასაყენებლად გამოიყენეთ setProperty("SelectionLanguage", "format"). იმისათვის, რომ შეცვალოთ მოთხოვნები ჩვენს მაგალითში XPath გზის გამოსაყენებლად, მე დავამატებ შემდეგ ბრძანებას: setProperty ("SelectionLanguage", "XPath"). ჩემი აზრით, XPath არის ყველაზე მნიშვნელოვანი XML ტექნოლოგია შესასწავლად. მე მოგცემთ რამდენიმე მარტივ XPath შეკითხვას. კარგი ადგილი ამ ტექნოლოგიის სწავლის დასაწყებად არის Microsoft XML SDK. ამის ახსნის კიდევ ერთი გზა იქნება მარტივი Visual Basic აპლიკაციის დაწერა, რომელიც საშუალებას მოგცემთ შეიყვანოთ მოთხოვნები და გამოიყვანოთ შედეგი. თქვენ შეიძლება იპოვოთ რამდენიმე უფასო აპლიკაცია, რომელიც იგივეს აკეთებს, მაგრამ XPath საკმაოდ ახალია და შეიძლება სრულად არ იყოს მხარდაჭერილი ამ აპების მიერ.
2.3.1. XPATH-ის გამოყენება დოკუმენტის ობიექტის მოდელის შეკითხვისთვის
მოდით დავამატოთ რამდენიმე კოდი ჩვენი წინა მაგალითის ბოლოს, რათა დავაბრუნოთ ჩვენი შეკვეთის წიგნის შინაარსი:
დიდი! ახლა დავამატოთ კიდევ ერთი შეკითხვა, რომელიც საშუალებას მოგვცემს დავადგინოთ, აქვს თუ არა მინას სახურავი. დაამატეთ შემდეგი კოდი წინა კოდის ბოლოს:
| დააყენეთ objNode = xmlDoc.selectSingleNode("/CUP/LID") თუ objNode.text="yes" მაშინ MsgBox "ჩვენ გვაქვს სახურავი" სხვაგვარად MsgBox "ამ თასზე სახურავი არ არის" დასრულდება, თუ |
მოდით გადავიდეთ კოდის ხაზ-სტრიქონში:
ხაზი 1: Dim objNode როგორც IXMLDOMNode
ეს ხაზი განსაზღვრავს XML დოკუმენტის კვანძის objNode ცვლადს. მნიშვნელოვანია გვესმოდეს, რომ XML დოკუმენტის კვანძი ასევე არის ობიექტი. არ აქვს მნიშვნელობა. იგი შედგება როგორც საკუთარი თავისგან, ასევე მისი ატრიბუტებისაგან და ბავშვებისგან (childNodes). ამ გზით თქვენ შეგიძლიათ მოჭრათ არასაჭირო ხის ტოტები, შეარჩიოთ მხოლოდ ის, რაც გჭირდებათ.
ხაზი 2: Dim objListOfNodes როგორც IXMLDOMNodeList
ეს ხაზი განსაზღვრავს objListOfNodes ცვლადს, რომელსაც აქვს XML დოკუმენტის კვანძების სიის ტიპი (კვანძების ჯგუფი).
ხაზი 3: xmlDoc.set თვისება "SelectionLanguage", "XPath"
ეს ხაზი ადგენს, თუ როგორ იქმნება patternString, როგორც XPath.
ხაზი 4: MsgBox "თქვენი ჭიქა შეიცავს შემდეგ ელემენტებს:"
ხაზი 5: დააყენეთ objListOfNodes = xmlDoc.selectNodes("//CONTENTS/*[@qty>0]")
ეს ხაზი ასრულებს XPath მოთხოვნას, რომელიც დააბრუნებს კვანძების ჯგუფს და შეინახავს მათ objListOfNodes ცვლადში. მოთხოვნა დაყოფილია შემდეგ ნაწილებად:
- //CONTENTS - აიღეთ ყველა CONTENTS ელემენტი XML დოკუმენტში. შენიშვნა: // არის სტენოგრამა XML დოკუმენტის მთელი შინაარსისთვის.
- /* - CONTENTS ელემენტების სიიდან აიღეთ ყველა (* - გამოიყენება ყველა) შთამომავალი ელემენტის აღსანიშნავად. ეს ამცირებს შედეგს ოთხ ელემენტის კვანძამდე (
). ეს ოთხი კვანძი პირდაპირ ხვდება CONTENTS კვანძში. - [@qty>0] - შეამოწმეთ თითოეული შვილობილი ელემენტი, რათა დარწმუნდეთ, რომ მისი qty ატრიბუტი (@ - ნიშნავს ატრიბუტს) 0-ზე მეტია. თუ ეს პირობა არ დაკმაყოფილდება, კვანძი გაუქმებულია. ყველაფერს XPath მოთხოვნის შიგნით შეუძლია მიიღოს მნიშვნელობები True ან False. თუ შედეგი არის True, მაშინ კვანძი შენახულია. თუ შედეგი არის False, მაშინ კვანძი გაუქმებულია. ამის შემდეგ, ჩვენი შედეგი მცირდება სამ კვანძამდე (
ხაზი 6-8: თითოეული objNode-ისთვის objListOfNodes / MsgBox objNode.Text / შემდეგი
ეს რიგები აჩვენებს თითოეული ელემენტის კვანძის მნიშვნელობებს, რომლებიც შეესაბამება მოთხოვნას. ("ყინულის კუბი", "ჩალა", "წყალი").
ხაზი 9: დააყენეთ objNode = xmlDoc.selectSingleNode("/CUP/LID")
ეს ხაზი აბრუნებს ყველა LID ელემენტს, რომელიც ეკუთვნის CUP ელემენტს, რომელიც თავის მხრივ მომდინარეობს ხის ფესვიდან (როდესაც მოთხოვნა იწყება /-ით, ეს ნიშნავს, რომ თქვენ უნდა დაიწყოთ ძირიდან). ეს ძალიან ჰგავს ფაილის ან საქაღალდის გზას. ჩვენს მაგალითში, ეს მოთხოვნა დააბრუნებს LID ელემენტს, რომელიც შეიცავს მნიშვნელობას "დიახ". აქ მთავარია ის, რომ მე ვუთხარი მოთხოვნა XML დოკუმენტის ძირეული ელემენტიდან დაწყებულიყო. მოთხოვნები ყოველთვის არ იწყება ძირეული ელემენტებიდან, ისინი ჩვეულებრივ იწყება მიმდინარე კვანძიდან. ჩვენს მაგალითში ამას მნიშვნელობა არ აქვს, რადგან მიმდინარე კვანძი (xmlDoc) არის XML დოკუმენტის ძირეული ელემენტი (მაგრამ ეს ყველა შემთხვევაში ასე არ არის).
ხაზი 10-15: თუ objNode.text="yes" მაშინ / MsgBox "ჩვენ გვაქვს სახურავი" /
else / MsgBox "ამ თასზე სახურავი არ არის" /ბოლო თუ
ეს ხაზი აჩვენებს შეტყობინებას "ჩვენ გვაქვს სახურავი", რადგან ელემენტის LID ტექსტის თვისება არის "დიახ".
3. გადაიყვანეთ ADO XML-ად
ახლა, როდესაც გესმით XML-ის საფუძვლები, მოდით შევქმნათ ActiveX კონტროლი, რომელიც გადააქცევს ADO მონაცემთა ბაზას XML ფორმატში. მიზანია წიგნების სათაურების მიღება პაბების მონაცემთა ბაზის სათაურების ცხრილიდან და მათი დაბრუნება XML ფორმატში. შედეგს გამოვიყენებ ჩემს შემდეგ სტატიაში. შეიძლება ითქვას, რომ ADO-ს აქვს საკუთარი მეთოდები შედეგის XML ფორმატში შესანახად, არა? დიახ, მაგრამ თუ მე ვენდობი ADO-ს ამის გაკეთებას, მე მივიღე XML ფაილი ისეთი საშინელი ფორმატით, რომლითაც შეუძლებელი იქნება მუშაობა. ADO შექმნის XML ფაილს სახელთა სივრცის გამოყენებით და მე ეს საერთოდ არ მჭირდება ახლა. მეორეც, ADO შექმნის XML ფაილს, რომელიც წარმოდგენილი იქნება ატრიბუტების სახით. სხვა სიტყვებით რომ ვთქვათ, ყველა ჩანაწერი გახდება ელემენტი და ყველა ველი ატრიბუტი:
| |
მაგრამ მე მინდა მივიღო XML ფაილი ელემენტების სახით, სადაც თითოეული ჩანაწერი იქნება ტეგში
| |
სხვათა შორის, რაც მე გავაკეთე იყო სქემის შექმნა ჩემი XML სტრიქონისთვის. ახლა, თუ მჭირდება XML დოკუმენტის სტრუქტურის შემოწმება სქემის წინააღმდეგ, ყველაფერი რაც უნდა გავაკეთო არის სქემის სწორ ფორმატში გადაყვანა. ანუ DTD ან XDR სინტაქსით. გაითვალისწინეთ, რომ მე დავამატე რამდენიმე ატრიბუტი თითოეულ ელემენტს
| |
ახლა რაღაც მაქვს სამუშაო!
ჩამონათვალი 1 - CUP.XML
|
|
| Dim xmlDoc როგორც MSXML2.DOMDocument30 დააყენეთ xmlDoc = New DOMDocument30 xmlDoc.async = False xmlDoc.validateOnParse = მცდარი xmlDoc.Load ("c:\inetpub\wwwroot\xml\cup.xml") MslDMjBde No istOfNodes როგორც IXMLDOMNodeList xmlDoc.setProperty "SelectionLanguage", "XPath" MsgBox "თქვენი ჭიქა შეიცავს შემდეგ ელემენტებს" დააყენეთ objListOfNodes = xmlDoc.selectNodes("//CONTENTS/*[@qty>0]") ყოველი objNode No objBoxf. ტექსტი შემდეგი დააყენეთ objNode = xmlDoc.selectSingleNode("/CUP/LID") თუ objNode.Text = "yes" მაშინ MsgBox "ჩვენ გვაქვს სახურავი" Else MsgBox "ამ თასზე სახურავი არ არის" დასრულება თუ |
ჩამონათვალი 3 - ActiveX კონტროლი: ADO XML-ში (WebClass.dll) (xmlControl.cls)
| ოფცია ექსპლიციტ "მონაცემთა ბაზის ცვლადების გამოცხადება Private m_dbConnection როგორც ახალი ADODB.Connection Private m_dbCommand As ADODB.Command Private m_adoRs As ADODB.Recordset Private m_adoErrors As ADODBErrors, როგორც ADODB Timeout როგორც Variant Public strConnect As Variant Public strAppName As სტრიქონი საჯარო strLogPath როგორც სტრიქონი საჯარო strმონაცემთა ბაზა როგორც სტრიქონი საჯარო strUser როგორც სტრიქონი საჯარო strპაროლი როგორც სტრიქონი საჯარო strServer როგორც სტრიქონი საჯარო strVersion როგორც სტრიქონი საჯარო lMSADO როგორც ლოგიკური "პირადი გლობალური ცვლადები Private gnErrNum როგორც Variant Private AsrrrcAstr DB როგორც სიმებიანი პირადი gstrADOError As String Private Const adLeonNoRecordset როგორც მთელი რიცხვი = 129 Private gtableName(6) As String Private gcolumnName(6) As String Private gprettyName(6) As String Private gdatatype(6) როგორც String Private Asfilter თუ Len(strConnect) = 0, მაშინ "დააყენეთ ნაგულისხმევი მნიშვნელობები, თუ Len(strDatabase) = 0, მაშინ strDatabase = "pubs" დასრულდეს, თუ nConnectionTimeOut = 0, მაშინ nConnectionTimeOut = 600 დასრულდეს, თუ nCommandTimeOut = 0 6TimeOut = 0, შემდეგ 0Out, If Len (strAppName) = 0 შემდეგ strAppName = "xmlControl" End If If Len(strUser) = 0 then strUser = "sa" End If If Len(strPassword) = 0 then strPassword = "" End If strConnect = "Provider=SQLOLEDB. 1 ; " & _ "აპლიკაციის სახელი=" & strAppName & _ "; მონაცემთა წყარო=" & strServer & "; საწყისი კატალოგი="&strDatabase&"; " & _ " მომხმარებლის ID=" & strUser & "; პაროლი=" & strPassword & ";" End If "დაკავშირდით SQL Server-თან და გახსენით მონაცემთა ბაზა შეცდომის შესახებ GoTo SQLErr "ჩართეთ შეცდომის დამმუშავებელი m_dbConnection .ConnectionTimeout = nConnectionTimeOut .CommandTimeout = nCommandTimeOutConnection-ის გამოყენებით. დასრულება შეცდომით გადადით 0 "გამორთეთ შეცდომის დამმუშავებელი OpenDatabase = True "მონაცემთა ბაზა წარმატებით გაიხსნა გასვლა ფუნქციიდან SQLErr: Call logerror("OPEN") OpenDatabase = False End Function Private Function BuildSQLwhere(tmpWhere) როგორც სტრიქონი "ეს არის მომავალი დასასრულისთვის ფუნქცია საჯარო ფუნქცია GetTitlesXML (არასავალდებულო xmlWhere As Variant) As String Dim WhereClause As String Dim strSQL როგორც String Call OpenDatabase "გახსენით pubs მონაცემთა ბაზა If IsMissing(xmlWhere) მაშინ "როდესაც მოთხოვნა ვერ მოხდება WhereClause = "" Else WhereSmlWherew" დააკონვერტიროთ შეკითხვა სწორ ერთ sql-ში ბოლოს თუ "დაიწყეთ sql გამოხატულება, რომელიც მოთხოვნის წიგნის სათაურებს strSQL = "აირჩიეთ title_id,title,type,price,ytd_sales,notes,pubdate სათაურებიდან " & whereClause Call NewRecordSet "შექმენით მონაცემთა ნაკრები" დააყენეთ კურსორის მდებარეობა m_adoRs. CursorLocation = adUseClient "გახსენით ჩანაწერების ნაკრები m_adoRs. გახსენით strSQL, m_dbConnection, adOpenForwardOnly, adLockReadOnly, adCmdText "გათიშეთ მონაცემთა ნაკრებიდან Set m_adoRs.ActiveConnection = Nothing On Error "გაათავისუფლეთ "შეცდომის გამორთვა" და შეცვალეთ კავშირი CloseDatabase If m_adoRs, then GetTitlesXML = "" "მოთხოვნამ არ დააბრუნა რაიმე მნიშვნელობები Else If lMSADO then GetTitlesXML = msado(m_adoRs) "გადააკეთეთ ado ჩანაწერების ნაკრები მორგებულ xml. ფუნქცია SQLErr: Call logerror(strSQL) დასრულება ფუნქცია პირადი ფუნქცია ADOtoXML(tmprs როგორც ADODB.Recordset, tmpMP როგორც ლოგიკური) როგორც სტრიქონის Dim adoFields როგორც ADODB.Fields "გამოაცხადეთ კოლექცია ველების შესანახად Dim adoBField როგორც ADis. თითოეული ველი კოლექციიდან Dim xmlDoc As msxml2.DOMDocument30 Dim tmpLine As String "ინახავს თითოეული წიგნის xml წარმოდგენას Dim tmpXML As String "გამოიყენება xml სტრიქონების შესაერთებლად Dim i მთელ რიცხვად თუ tmprs.EOF მაშინ "შეკითხვამ არ დააბრუნა ჩანაწერები. ADOtoXML = "" ფუნქციიდან გასვლა სხვაგან დააყენეთ adoFields = tmprs.Fields "შექმენით ველების კოლექცია End If tmpXML = " |
ჩამონათვალი 4 - VB ტესტის აპლიკაცია WebClass-ის შესამოწმებლად
| Private Sub Command1_Click() Dim objWC როგორც xmlControl Dim xml როგორც სტრიქონის ნაკრები objWC = ახალი xmlControl objWC.strDatabase = "pubs" objWC.strServer = "ltweb" objWC.strUser = "sa" objWC.strMSPassword = "sa" objWC.strMSPassword =. .მნიშვნელობა objWC.strAppName = "Article1" Text1.Text = objWC.getTitlesXML ბოლო ქვე |
ჩამონათვალი 5 - ASP WebClass ტესტირებისთვის
XML არის ძალიან პოპულარული და მოქნილი ფორმატი დღესდღეობით. ეს ყველა პროგრამისტმა უნდა გაიგოს, ეს უბრალოდ აუცილებელია. დღეს ბევრი ტექნოლოგიაა დაკავშირებული, აქტიურად იყენებენ და მათ შორის არის თანამედროვეც.
შესავალი
გამარჯობა, ჩემი სტატიის ძვირფასო მკითხველებო. დაუყოვნებლივ მინდა ვთქვა, რომ ეს მხოლოდ პირველი სტატიაა ჩემი სამი სტატიის სერიიდან. მთელი სერიის მთავარი მიზანია თითოეული მკითხველის XML-ში ინიცირება და თუ არა სრული ახსნა და გაგება, მაშინ მაინც კარგი ბიძგი მისკენ, ძირითადი პუნქტებისა და საგნების ახსნა. მთელი ციკლი იქნება ერთი ნომინაციისთვის - "ყურადღება დეტალებზე", და 3 სტატიად დაყოფა გაკეთდა იმისთვის, რომ შეესაბამებოდეს სიმბოლოების ლიმიტს პოსტებში და დაყოს დიდი რაოდენობით მასალა უფრო მცირე ნაწილებად მეტი გაგებისთვის. პირველი სტატია დაეთმობა თავად XML-ს და რა არის ის, ასევე XML ფაილებისთვის სქემის შექმნის ერთ-ერთ გზას - DTD. დასაწყისისთვის, მინდა მცირე წინასიტყვაობა გავაკეთო მათთვის, ვინც ჯერ კიდევ არ იცნობს XML-ს: არ არის საჭირო შეშინება. XML არ არის ძალიან რთული და უნდა გაიგოს ნებისმიერი პროგრამისტისთვის, რადგან ის არის ძალიან მოქნილი, ეფექტური და პოპულარული ფაილის ფორმატი დღეს თქვენთვის სასურველი მრავალფეროვანი ინფორმაციის შესანახად. XML გამოიყენება Ant, Maven, Spring. ნებისმიერ პროგრამისტს სჭირდება XML-ის ცოდნა. ახლა, როცა ძალა და მოტივაცია მოიკრიბეთ, დავიწყოთ სწავლა. ვეცდები, რაც შეიძლება მარტივად ჩამოვაყალიბო ყველა მასალა, შევაგროვო მხოლოდ ყველაზე მნიშვნელოვანი და არ შევიდე სარეველაში.XML
უფრო მკაფიო ახსნისთვის, უკეთესი იქნება XML-ის ვიზუალიზაცია მაგალითით.< ? xml version= "1.0" encoding= "UTF-8" ? > < company> < name> IT სამოთხე< / name> < offices> < office floor= "1" room= "1" > < employees> < employee> < name> მაქსიმ< / name> < job> Middle Software Developer< / job> < / employee> < employee> < name> ივანე< / name> < job> უმცროსი პროგრამული უზრუნველყოფის შემქმნელი< / job> < / employee> < employee> < name> ფრანკლინი< / name> < job> უმცროსი პროგრამული უზრუნველყოფის შემქმნელი< / job> < / employee> < / employees> < / office> < office floor= "1" room= "2" > < employees> < employee> < name> მაცნე< / name> < job> Middle Software Developer< / job> < / employee> < employee> < name> ადამ< / name> < job> Middle Software Developer< / job> < / employee> < employee> < name> ლეროი< / name> < job> უმცროსი პროგრამული უზრუნველყოფის შემქმნელი< / job> < / employee> < / employees> < / office> < / offices> < / company>HTML და XML მსგავსია სინტაქსით, რადგან მათ აქვთ საერთო მშობელი - SGML. თუმცა, HTML-ში არის მხოლოდ კონკრეტული სტანდარტის ფიქსირებული ტეგები, ხოლო XML-ში შეგიძლიათ შექმნათ თქვენი საკუთარი ტეგები, ატრიბუტები და, ზოგადად, გააკეთოთ ის, რაც გსურთ, შეინახოთ მონაცემები ისე, როგორც თქვენთვის შესაფერისია. სინამდვილეში, XML ფაილების წაკითხვა შეუძლია ყველას, ვინც იცის ინგლისური. ეს მაგალითი შეიძლება გამოსახული იყოს ხის გამოყენებით. ხის ფესვი- კომპანია. ის ასევე არის ძირეული (ძირეული) ელემენტი, საიდანაც მოდის ყველა სხვა ელემენტი. თითოეულ XML ფაილს შეიძლება ჰქონდეს მხოლოდ ერთი root ელემენტი.ამის შემდეგ უნდა გამოცხადდეს xml ფაილის დეკლარაცია(პირველი ხაზი მაგალითში) და შეიცავს ყველა სხვა ელემენტს. ცოტა რამ დეკლარაციის შესახებ: ის სავალდებულოდა საჭიროა დოკუმენტის XML-ად იდენტიფიცირებისთვის. მას აქვს სამი ფსევდო ატრიბუტი (სპეციალური წინასწარ განსაზღვრული ატრიბუტი): ვერსია (1.0 სტანდარტის მიხედვით), კოდირება (დაშიფვრა) და დამოუკიდებელი (ავტონომია: თუ დიახ და გარე სქემები დაკავშირებულია დოკუმენტთან, მაშინ იქნება შეცდომა, ნაგულისხმევი არის არა). ელემენტებიარის ერთეულები, რომლებიც ინახავს მონაცემებს სხვა ელემენტებისა და ატრიბუტების გამოყენებით. ატრიბუტები– ეს არის დამატებითი ინფორმაცია ელემენტის შესახებ, რომელიც მითითებულია ელემენტის დამატებისას. თუ ახსნას გადავთარგმნით OOP ველში, შეგვიძლია მოვიყვანოთ შემდეგი მაგალითი: ჩვენ გვყავს მანქანა, თითოეულ მანქანას აქვს მახასიათებლები (ფერი, ტევადობა, ბრენდი და ა. : კარები, ფანჯრები, ძრავი, საჭე სხვა ელემენტებია. თქვენ შეგიძლიათ შეინახოთ თვისებები, როგორც ცალკეული ელემენტები ან ატრიბუტები, თქვენი სურვილიდან გამომდინარე. ყოველივე ამის შემდეგ, XML არის უკიდურესად მოქნილი ფორმატი ნებისმიერი ინფორმაციის შესანახად. ახსნა-განმარტებების შემდეგ, ჩვენ უბრალოდ უნდა გადავხედოთ ზემოთ მოცემულ მაგალითს, რომ ყველაფერი თავის ადგილზე დადგეს. მაგალითში ჩვენ აღვწერეთ კომპანიის მარტივი სტრუქტურა: არის კომპანია, რომელსაც აქვს სახელი და ოფისები, ხოლო ოფისებში არის თანამშრომლები. თანამშრომლების და ოფისების ელემენტები შეფუთვის ელემენტებია - ისინი ემსახურებიან იმავე ტიპის ელემენტების შეგროვებას, არსებითად აერთიანებს მათ ერთ ნაკრებში დამუშავების სიმარტივისთვის. იატაკი და ოთახი განსაკუთრებულ ყურადღებას იმსახურებს. ეს არის ოფისის ატრიბუტები (სართული და ნომერი), სხვა სიტყვებით რომ ვთქვათ, მისი თვისებები. თუ ჩვენ გვქონდა "გამოსახულების" ელემენტი, მაშინ შეგვეძლო მისი ზომების გადატანა. თქვენ შეიძლება შეამჩნიოთ, რომ კომპანიას არ აქვს სახელის ატრიბუტი, მაგრამ აქვს სახელის ელემენტი. თქვენ შეგიძლიათ უბრალოდ აღწეროთ სტრუქტურები ისე, როგორც გსურთ. არავინ ავალდებულებს თქვენ დაწეროთ ელემენტების ყველა თვისება მხოლოდ ატრიბუტებში, შეგიძლიათ გამოიყენოთ მხოლოდ ელემენტები და ჩაწეროთ გარკვეული მონაცემები მათ შიგნით. მაგალითად, ჩვენ შეგვიძლია ჩავწეროთ ჩვენი თანამშრომლების სახელი და თანამდებობა, როგორც ატრიბუტები:< ? xml version= "1.0" encoding= "UTF-8" ? > < company> < name> IT სამოთხე< / name> < offices> < office floor= "1" room= "1" > < employees> < employee name= "Maksim" job= "Middle Software Developer" > < / employee> < employee name= "Ivan" job= "Junior Software Developer" > < / employee> < employee name= "Franklin" job= "Junior Software Developer" > < / employee> < / employees> < / office> < office floor= "1" room= "2" > < employees> < employee name= "Herald" job= "Middle Software Developer" > < / employee> < employee name= "Adam" job= "Middle Software Developer" > < / employee> < employee name= "Leroy" job= "Junior Software Developer" > < / employee> < / employees> < / office> < / offices> < / company>როგორც ხედავთ, ახლა თითოეული თანამშრომლის სახელი და თანამდებობა მისი ატრიბუტებია. და თქვენ შეგიძლიათ შეამჩნიოთ, რომ არაფერია თანამშრომლის ერთეულში (ტეგი), ყველა თანამშრომლის ელემენტი ცარიელია. შემდეგ შეგიძლიათ თანამშრომელი ცარიელ ელემენტად აქციოთ - დახურეთ იგი ატრიბუტების გამოცხადებისთანავე. ეს კეთდება საკმაოდ მარტივად, უბრალოდ დაამატეთ ხაზი:< ? xml version= "1.0" encoding= "UTF-8" ? > < company> < name> IT სამოთხე< / name> < offices> < office floor= "1" room= "1" > < employees> < employee name= "Maksim" job= "Middle Software Developer" / > < employee name= "Ivan" job= "Junior Software Developer" / > < employee name= "Franklin" job= "Junior Software Developer" / > < / employees> < / office> < office floor= "1" room= "2" > < employees> < employee name= "Herald" job= "Middle Software Developer" / > < employee name= "Adam" job= "Middle Software Developer" / > < employee name= "Leroy" job= "Junior Software Developer" / > < / employees> < / office> < / offices> < / company>როგორც ხედავთ, ცარიელი ელემენტების დახურვით ჩვენ შევინარჩუნეთ ინფორმაციის მთელი მთლიანობა და მნიშვნელოვნად შევამოკლეთ ჩანაწერი, რაც ინფორმაცია უფრო ლაკონური და წასაკითხი გახდა. დასამატებლად კომენტარი(ტექსტი, რომელიც გამოტოვებული იქნება ფაილის ანალიზისას) XML-ში არის შემდეგი სინტაქსი:< ! -- Иван недавно уволился, только неделю отработать должен. Не забудьте потом удалить его из списка. -- >და ბოლო დიზაინი არის CDATA , ნიშნავს "სიმბოლო მონაცემებს". ამ დიზაინის წყალობით, შესაძლებელია ტექსტის დაწერა, რომელიც არ იქნება ინტერპრეტირებული, როგორც XML მარკირება. ეს სასარგებლოა, თუ XML ფაილის შიგნით გაქვთ ერთეული, რომელიც ინახავს XML მარკირებას ინფორმაციაში. მაგალითი:< ? xml version= "1.0" encoding= "UTF-8" ? > < bean> < information> < ! [ CDATA[ < name> ივანე< / name> < age> 26 < / age> ] ] > < / information> < / bean>XML-ის საქმე ის არის, რომ თქვენ შეგიძლიათ გააფართოვოთ ის, როგორც გსურთ: გამოიყენეთ თქვენი საკუთარი ელემენტები, საკუთარი ატრიბუტები და ააწყვეთ ის, როგორც გსურთ. თქვენ შეგიძლიათ გამოიყენოთ როგორც ატრიბუტები, ასევე ელემენტები მონაცემების შესანახად (როგორც წინა მაგალითში იყო ნაჩვენები). თუმცა, თქვენ უნდა გესმოდეთ, რომ თქვენ შეგიძლიათ შექმნათ თქვენი საკუთარი ელემენტები და ატრიბუტები, როგორც გინდათ, მაგრამ რა მოხდება, თუ თქვენ მუშაობთ პროექტზე, სადაც სხვა პროგრამისტს სურს სახელის ელემენტის გადატანა ატრიბუტებში და მთელი თქვენი პროგრამის ლოგიკა. ისე წერია რომ სახელი ელემენტი იყო? როგორ შეგიძლიათ შექმნათ თქვენი საკუთარი წესები იმის შესახებ, თუ რა ელემენტები უნდა იყოს, რა ატრიბუტები აქვთ და სხვა, რომ შეძლოთ XML ფაილების ვალიდაცია და დარწმუნებული იყოთ, რომ წესები გახდება სტანდარტული თქვენს პროექტში და არავინ დაარღვევს მათ? იმისათვის, რომ დაწეროთ თქვენი საკუთარი XML მარკირების ყველა წესი, არსებობს სპეციალური ხელსაწყოები. ყველაზე ცნობილი: DTD და XML სქემა. ამ სტატიაში ვისაუბრებთ მხოლოდ პირველზე.DTD
DTD შექმნილია დოკუმენტების ტიპების აღსაწერად. DTD უკვე მოძველებულია და ახლა აქტიურად არის მიტოვებული XML-ში, მაგრამ ჯერ კიდევ არის ბევრი XML ფაილი, რომელიც იყენებს DTD-ს და, ზოგადად, მისი გაგება სასარგებლოა. DTD არის ტექნოლოგია XML დოკუმენტების ვალიდაციისთვის. DTD აცხადებს სპეციფიკურ წესებს დოკუმენტის ტიპისთვის: მისი ელემენტები, რა ელემენტები შეიძლება იყოს ელემენტის შიგნით, ატრიბუტები, საჭიროა თუ არა ისინი, მათი გამეორებების რაოდენობა, ასევე ერთეულები. XML-ის მსგავსად, DTD შეიძლება ვიზუალიზდეს მაგალითით უფრო ნათელი ახსნისთვის.< ! -- Объявление возможных элементов -- > < ! ELEMENT employee EMPTY> < ! ELEMENT employees (employee+ ) > < ! ELEMENT office (employees) > < ! ELEMENT offices (office+ ) > < ! ELEMENT name (#PCDATA) > < ! ELEMENT company (name, offices) > < ! -- Добавление атрибутов для элементов employee и office -- > < ! ATTLIST employee name CDATA #REQUIRED job CDATA #REQUIRED > < ! ATTLIST office floor CDATA #REQUIRED room CDATA #REQUIRED > < ! -- Добавление сущностей -- > < ! ENTITY M "Maksim" > < ! ENTITY I "Ivan" > < ! ENTITY F "Franklin" >აქ გვაქვს ასეთი მარტივი მაგალითი. ამ მაგალითში ჩვენ გამოვაცხადეთ ჩვენი მთელი იერარქია XML მაგალითიდან: თანამშრომელი, თანამშრომლები, ოფისი, ოფისები, სახელი, კომპანია. DTD ფაილების შესაქმნელად გამოიყენება 3 ძირითადი კონსტრუქცია ნებისმიერი XML ფაილის აღსაწერად: ELEMENT (ელემენტების აღსაწერად), ATTLIST (ელემენტების ატრიბუტების აღსაწერად) და ENTITY (ტექსტის შემოკლებული ფორმებით ჩანაცვლებისთვის). ელემენტიგამოიყენება ელემენტის აღსაწერად. ელემენტები, რომლებიც შეიძლება გამოყენებულ იქნას აღწერილ ელემენტში, ჩამოთვლილია ფრჩხილებში სიის სახით. თქვენ შეგიძლიათ გამოიყენოთ რაოდენობები რაოდენობის აღსანიშნავად (ისინი მსგავსია რიგითი გამონათქვამების რაოდენობებთან): + ნიშნავს 1+ * ნიშნავს 0+ ? ნიშნავს 0 ან 1 თუ არ დაემატა რაოდენობები, მაშინ ითვლება, რომ უნდა იყოს მხოლოდ 1 ელემენტი.თუ ჩვენ გვჭირდებოდა ელემენტების ჯგუფიდან ერთი, შეგვიძლია დავწეროთ ასე:< ! ELEMENT company ((name | offices) ) >შემდეგ შეირჩევა ერთ-ერთი ელემენტი: სახელი ან ოფისები, მაგრამ კომპანიის შიგნით რომ იყოს ორი, მაშინ ვალიდაცია არ გაივლის. თქვენ ასევე შეგიძლიათ შეამჩნიოთ, რომ თანამშრომელში არის სიტყვა EMPTY - ეს ნიშნავს, რომ ელემენტი უნდა იყოს ცარიელი. ასევე არსებობს ნებისმიერი - ნებისმიერი ელემენტი. #PCDATA – ტექსტური მონაცემები. ATTLISTგამოიყენება ელემენტების ატრიბუტების დასამატებლად. ATTLIST-ის შემდეგ მოდის სასურველი ელემენტის სახელი, შემდეგ კი ლექსიკონი ფორმის "ატრიბუტის სახელი - ატრიბუტის ტიპი", და ბოლოს შეგიძლიათ დაამატოთ #IMPLIED (სურვილისამებრ) ან #REQUIRED (საჭიროა). CDATA - ტექსტური მონაცემები. არსებობს სხვა ტიპები, მაგრამ ისინი ყველა მცირე რეგისტრია. ENTITY ENTITY გამოიყენება აბრევიატურების და ტექსტის გამოსაცხადებლად, რომელიც განთავსდება მათზე. ფაქტობრივად, ჩვენ შეგვიძლია უბრალოდ გამოვიყენოთ XML-ში, სრული ტექსტის ნაცვლად, მხოლოდ სუბიექტის სახელი, რომელზეც & ნიშანია და; შემდეგ. მაგალითად: HTML მარკირებისა და უბრალოდ სიმბოლოების განმასხვავებლად, მარცხენა კუთხის ფრჩხილი ხშირად იშლება lt-ით; , თქვენ უბრალოდ უნდა დააყენოთ & ადრე lt. მაშინ ჩვენ არ გამოვიყენებთ მარკირებას, არამედ უბრალოდ სიმბოლოს< . Как вы можете видеть, все довольно просто: объявляете элементы, объясняете, какие элементы объявленные элементы способны содержать, добавление атрибутов этим элементам и, по желанию, можете добавить сущности, чтобы сокращать какие-то записи. И тут вы должны были бы спросить: а как использовать наши правила в нашем XML файле? Ведь мы просто объявили правила, но мы не использовали их в XML. მათი XML-ში გამოყენების ორი გზა არსებობს: 1. განხორციელება - ჩაწერეთ DTD წესები თავად XML ფაილში, უბრალოდ ჩაწერეთ root ელემენტი DOCTYPE საკვანძო სიტყვის შემდეგ და ჩადეთ ჩვენი DTD ფაილი კვადრატულ ფრჩხილებში. < ? xml version= "1.0" encoding= "UTF-8" ? > < ! DOCTYPE company [ < ! -- Объявление возможных элементов -- > < ! ELEMENT employee EMPTY> < ! ELEMENT employees (employee+ ) > < ! ELEMENT office (employees) > < ! ELEMENT offices (office+ ) > < ! ELEMENT name (#PCDATA) > < ! ELEMENT company (name, offices) > < ! -- Добавление атрибутов для элементов employee и office -- > < ! ATTLIST employee name CDATA #REQUIRED job CDATA #REQUIRED > < ! ATTLIST office floor CDATA #REQUIRED room CDATA #REQUIRED > < ! -- Добавление сущностей -- > < ! ENTITY M "Maksim" > < ! ENTITY I "Ivan" > < ! ENTITY F "Franklin" > ] > < company> < name> IT სამოთხე< / name> < ! -- Иван недавно уволился, только неделю отработать должен. Не забудьте потом удалить его из списка. -- > < offices> < office floor= "1" room= "1" > < employees> < employee name= "&M;" job= "Middle Software Developer" / > < employee name= "&I;" job= "Junior Software Developer" / > < employee name= "&F;" job= "Junior Software Developer" / > < / employees> < / office> < office floor= "1" room= "2" > < employees> < employee name= "Herald" job= "Middle Software Developer" / > < employee name= "Adam" job= "Middle Software Developer" / > < employee name= "Leroy" job= "Junior Software Developer" / > < / employees> < / office> < / offices> < / company> 2. იმპორტი - ჩვენ ყველა ჩვენს წესს ვწერთ ცალკე DTD ფაილში, რის შემდეგაც XML ფაილში ვიყენებთ DOCTYPE კონსტრუქციას პირველი მეთოდიდან, მხოლოდ კვადრატული ფრჩხილების ნაცვლად უნდა ჩაწეროთ SYSTEM და მიუთითოთ აბსოლუტური ან ფარდობითი გზა. ფაილის მიმდინარე მდებარეობა. < ? xml version= "1.0" encoding= "UTF-8" ? > < ! DOCTYPE company SYSTEM "dtd_example1.dtd" > < company> < name> IT სამოთხე< / name> < ! -- Иван недавно уволился, только неделю отработать должен. Не забудьте потом удалить его из списка. -- > < offices> < office floor= "1" room= "1" > < employees> < employee name= "&M;" job= "Middle Software Developer" / > < employee name= "&I;" job= "Junior Software Developer" / > < employee name= "&F;" job= "Junior Software Developer" / > < / employees> < / office> < office floor= "1" room= "2" > < employees> < employee name= "Herald" job= "Middle Software Developer" / > < employee name= "Adam" job= "Middle Software Developer" / > < employee name= "Leroy" job= "Junior Software Developer" / > < / employees> < / office> < / offices> < / company>თქვენ ასევე შეგიძლიათ გამოიყენოთ PUBLIC საკვანძო სიტყვა SYSTEM-ის ნაცვლად, მაგრამ ნაკლებად სავარაუდოა, რომ ის თქვენთვის სასარგებლო იყოს. თუ გაინტერესებთ, შეგიძლიათ წაიკითხოთ ამის შესახებ (და ასევე SYSTEM-ის შესახებ) დეტალურად აქ: ბმული. ახლა ჩვენ ვერ გამოვიყენებთ სხვა ელემენტებს DTD-ში მათი გამოცხადების გარეშე და ყველა XML ექვემდებარება ჩვენს წესებს. შეგიძლიათ სცადოთ ამ კოდის ჩაწერა IntelliJ IDEA-ში ცალკე ფაილი.xml გაფართოებით და სცადეთ დაამატოთ რამდენიმე ახალი ელემენტი ან ამოიღოთ ელემენტი ჩვენი DTD-დან და შეამჩნიეთ, როგორ მიუთითებს IDE შეცდომაზე. თუმცა, DTD-ს აქვს თავისი ნაკლოვანებები:- მას აქვს საკუთარი სინტაქსი, რომელიც განსხვავდება xml სინტაქსისგან.
- DTD-ს არ აქვს მონაცემთა ტიპის შემოწმება და შეიძლება შეიცავდეს მხოლოდ სტრიქონებს.
- DTD-ში სახელთა სივრცე არ არის.
დღეს ჩვენ დავიწყებთ განიხილოს ძალიან პოპულარული და მოსახერხებელი XML მარკირების ენა. ვინაიდან მონაცემთა წარმოდგენის ეს ფორმატი ძალიან მოქნილი და უნივერსალურია და მისი გამოყენება შესაძლებელია თითქმის ყველგან, ეს ნიშნავს კეთილსინდისიერად რაღაცას. ამიტომ, ახალბედა პროგრამისტს ადრე თუ გვიან მოუწევს ამ ენასთან შეხება და არ აქვს მნიშვნელობა რას აკეთებთ, იქნება ეს ვებ პროგრამირება თუ მონაცემთა ბაზის ადმინისტრირება, რადგან ყველა იყენებს XML-ს და თქვენ ასევე გამოიყენებთ ამოცანების განსახორციელებლად. გჭირდებათ.
დავიწყებთ, ჩვეულებისამებრ, თეორიით, ვნახოთ, როგორი ენაა, რატომ არის კარგი, როგორ გამოვიყენოთ და სად გამოიყენება.
XML ენის განმარტება
XML (გაფართოებული მარკირების ენა) არის უნივერსალური და გაფართოებადი მონაცემთა მარკირების ენა, რომელიც დამოუკიდებელია ოპერაციული სისტემისა და დამუშავების გარემოსგან. Xml გამოიყენება გარკვეული მონაცემების სტრუქტურის სახით წარმოსადგენად და შეგიძლიათ ეს სტრუქტურა თავად განავითაროთ ან დააკონფიგურიროთ კონკრეტული პროგრამის ან სერვისისთვის. ამიტომაც მოცემული ენაგაფართოებას უწოდებენ და ეს არის მისი მთავარი უპირატესობა, რისთვისაც ასე ფასდება.
მოგეხსენებათ, მარკირების ენა საკმაოდ ბევრია, მაგალითად, HTML ენა, მაგრამ ყველა მათგანი, ასე თუ ისე, დამოკიდებულია პროცესორზე, მაგალითად, იგივე html, რომლის კოდს ბრაუზერი აანალიზებს, არის სტანდარტიზებული და არა გაფართოებადი, იქ არის მკაფიო ტეგები, სინტაქსი, რომლის დარღვევაც შეუძლებელია და xml-ში შეგიძლიათ შექმნათ თქვენი საკუთარი ტეგები, ე.ი. თქვენი მარკირება. HTML-სა და XML-ს შორის მთავარი განსხვავება ისაა, რომ html მხოლოდ აღწერს მარკირებას მონაცემების ჩვენებისთვის, ხოლო xml არის მონაცემთა აბსტრაქტული სტრუქტურა, რომელიც შეიძლება დამუშავდეს და გამოჩნდეს როგორც გინდათ და ყველგან, და ამიტომ არ არის საჭირო ამ ენების შედარება, მათ აქვთ სრულიად განსხვავებული მიზნებისთვის.
როგორც ზემოთ აღვნიშნეთ, xml არის ძალიან გავრცელებული და უნივერსალური ენა, რომლის საშუალებითაც თითქმის ყველა აპლიკაცია, როგორც ვებ, ასევე მხოლოდ კომპიუტერისთვის, იყენებს მას ინფორმაციის გაცვლის მიზნით, რადგან მისი დახმარებით თქვენ შეგიძლიათ მარტივად გაცვალოთ მონაცემები აპლიკაციებს შორის ან სერვისები, რომლებზეც კი იწერება სხვადასხვა ენებზე. ამასთან დაკავშირებით, ყველა ახალბედა პროგრამისტს, რომელიც ჩართულია აბსოლუტურად ნებისმიერ პროგრამირებაში, უნდა იცოდეს XML. თუ გსურთ გახდეთ ვებ ოსტატი, მაშინ უბრალოდ უნდა იცოდეთ XML და ჩვენ უკვე განვიხილეთ, თუ როგორ გახდეთ WEB Master და რა უნდა იცოდეთ ამისათვის.
მაგალითად, ერთხელ მქონდა დავალება დამეწერა გარკვეული სერვისი, რომელსაც მოთხოვნისთანავე უნდა დაებრუნებინა მონაცემები xml სახით, ე.ი. აპლიკაციის სერვერის ნაწილის ერთგვარი განვითარება და წარმოდგენა არ მქონდა რაში იყო დაწერილი კლიენტი, რომელიც დაამუშავებდა ამ მონაცემებს და რომ დავწერე სერვისი, რომელიც მონაცემებს აბრუნებდა xml სახით და ეს იყო, აპლიკაცია მშვენივრად მუშაობდა . და ეს მხოლოდ მაგალითია, რომლებთანაც გამკლავება მომიწია, მაგრამ ახლა წარმოიდგინეთ, რამდენი სხვადასხვა ორგანიზაცია თანამშრომლობს და კეთილსინდისიერად ავითარებს პროგრამულ უზრუნველყოფას და ცვლის მონაცემებს და არ გამიკვირდება, რომ ეს მონაცემები იყოს xml სახით.
მაგალითად, ერთხელ მქონდა დავალება დამეწერა გარკვეული სერვისი, რომელიც მოთხოვნისთანავე უნდა დააბრუნოს მონაცემები xml სახით, ე.ი. აპლიკაციის სერვერის ნაწილის ერთგვარი განვითარება და წარმოდგენა არ მქონდა რაში იყო დაწერილი კლიენტი, რომელიც დაამუშავებდა ამ მონაცემებს და რომ დავწერე სერვისი, რომელიც მონაცემებს აბრუნებდა xml სახით და ეს იყო, აპლიკაცია მშვენივრად მუშაობდა . და ეს მხოლოდ მაგალითია, რომლებთანაც გამკლავება მომიწია, მაგრამ ახლა წარმოიდგინეთ, რამდენი სხვადასხვა ორგანიზაცია თანამშრომლობს და კეთილსინდისიერად ავითარებს პროგრამულ უზრუნველყოფას და ცვლის მონაცემებს და არ გამიკვირდება, რომ ეს მონაცემები იყოს xml სახით.
ასევე, ერთხელ მომიწია xml მონაცემების შენახვა MS SQL 2008 მონაცემთა ბაზაში, რათა უკეთ წარმომედგინა ეს მონაცემები და გავცვალო იგი სერვერსა და აპლიკაციის კლიენტ ნაწილს შორის, ეს განვიხილეთ სტატიაში - Transact-sql - xml-თან მუშაობა. .
თავად XML ენა ძალიან მარტივია და მასში დაბნეულობა უბრალოდ შეუძლებელია, წარმოიქმნება ზუსტად XML-ის დამუშავებისა და ურთიერთქმედებისას სხვა აპლიკაციებთან, ტექნოლოგიებთან, ე.ი. ყველაფერი, რაც გარს xml-ს აკრავს, სადაც ადვილად შეიძლება დაიბნე.
დღეს ჩვენ ვსაუბრობთ მხოლოდ XML-ის საფუძვლებზე და არ გავამახვილებთ ყურადღებას ამ ენასთან დამუშავებისა და ურთიერთქმედების ტექნოლოგიებზე, რადგან ეს მართალია, ძალიან მოცულობითი მასალაა, მაგრამ ვფიქრობ, მომავალში გავაგრძელებთ შესაბამის ტექნოლოგიების გაცნობას. .
მოდით გადავიდეთ პრაქტიკაზე. და მე დავწერ ყველა მაგალითს, რომელსაც განვიხილავთ Notepad++-ში მხოლოდ იმიტომ, რომ ეს ძალიან მოსახერხებელია, მაგრამ ახლა ამაზე არ ვისაუბრებთ, რადგან ჩვენ უკვე განვიხილეთ ეს სტატიაში - რა არის კარგი Notepad ++ ახალბედა დეველოპერისთვის.
XML ტეგები
XML ენა იყენებს ტეგებს ( ტეგები რეგისტრის მგრძნობიარეა), ოღონდ არა იგივე ტეგები, როგორც html-ში, არამედ ის, რაც თქვენ თვითონ გამოგივიდათ, მაგრამ xml დოკუმენტსაც აქვს მკაფიო სტრუქტურა, ე.ი. არის გახსნის და დახურვის ტეგი, არის ჩასმული ტეგები და, რა თქმა უნდა, არის მნიშვნელობები, რომლებიც განთავსებულია ამ ტეგებში. სხვა სიტყვებით რომ ვთქვათ, ყველაფერი რაც თქვენ გჭირდებათ xml-ის საბაზისო ცოდნისთვის არის მხოლოდ ამ წესების დაცვა. ერთად გახსნის, დახურვის ტეგს და მნიშვნელობას ეწოდება ელემენტი და მთელი xml დოკუმენტი შედგება ზუსტად ელემენტებისაგან, რომლებიც ერთად ქმნიან მონაცემთა სტრუქტურას. xml დოკუმენტს შეიძლება ჰქონდეს მხოლოდ ერთი ძირეული ელემენტი, გახსოვდეთ ეს, რადგან თუ დაწერთ ორ ძირეულ ელემენტს, ეს იქნება შეცდომა.
და დროა მოვიყვანოთ xml მარკირების მაგალითი და პირველი მაგალითი ახლა არის სინტაქსისთვის:
<Начало элемента> <Начало вложенного элемента>ჩადგმული ელემენტის მნიშვნელობა
როგორც ხედავთ, ყველაფერი საკმაოდ მარტივია და შეიძლება ბევრი ასეთი ელემენტი იყოს ერთმანეთში ჩასმული.
ახლა მოდით მივცეთ რეალური xml დოკუმენტის მაგალითი:
როგორც ხედავთ, მე მხოლოდ აქ მოვიყვანე ერთგვარი წიგნების კატალოგის მაგალითი, მაგრამ ეს დოკუმენტი არ გამიცხადებია, ე.ი. მე არ დავწერე XML დეკლარაცია, რომელიც ეუბნება აპლიკაციას, რომელიც დაამუშავებს ამ მონაცემებს, რომ XML მონაცემები აქ მდებარეობს და რა კოდირებით არის წარმოდგენილი. თქვენ ასევე შეგიძლიათ დაწეროთ კომენტარები და ატრიბუტები, ასე რომ, მოდით მივცეთ ასეთი დოკუმენტის მაგალითი:
სადაც პირველი სტრიქონი არის დეკლარაციის განცხადება, რომ ის არის XML დოკუმენტიდა ის უნდა წაიკითხოთ UTF-8 კოდირებით.
დამუშავების გარეშე, ეს მონაცემები გამოიყურება, მაგალითად, ბრაუზერში ( Mozilla Firefox) შემდეგნაირად:
იმედია გესმით, რომ აქ კატალოგი არის ძირეული ელემენტი, რომელიც შედგება წიგნის ელემენტებისაგან, რომელიც თავის მხრივ შედგება სახელის, ავტორისა და კომენტარის ელემენტებისგან და მაგალითად, მე ასევე დავაყენე რამდენიმე ატრიბუტი კატალოგის ელემენტისთვის და წიგნის ელემენტისთვის. .
საფუძვლებისთვის, ვფიქრობ, რომ ეს საკმარისია, რადგან თუ ჩვენ უფრო და უფრო ღრმად ჩავუღრმავდებით XML-ს და ყველა ტექნოლოგიას, რომელიც დაკავშირებულია ამ ენასთან, მაშინ ეს სტატია არასოდეს დასრულდება. ასე რომ, ეს ყველაფერი დღეისთვის. ნახვამდის!
XML შეიქმნა მონაცემების აღსაწერად იმის გათვალისწინებით, თუ რას წარმოადგენს ეს მონაცემები.
HTML შეიქმნა მონაცემების საჩვენებლად იმის გათვალისწინებით, თუ როგორ გამოიყურება ნაჩვენები მონაცემები.
რა არის XML?
- XML ნიშნავს გაფართოებადი მარკირების ენა
- XML არის მარკირების ენა HTML-ის მსგავსი
- XML შეიქმნა ამისთვის მონაცემთა აღწერილობები
- XML ტეგები არ არის წინასწარ განსაზღვრული. შეგიძლია გამოიყენეთ თქვენი ტეგები
- XML იყენებს დოკუმენტის ტიპის განმარტება (DTD)ან XML სქემამონაცემების აღსაწერად
- XML რეკომენდებულია W3C-ის მიერ
მთავარი განსხვავება XML და HTML-ს შორის
XML შეიქმნა მონაცემთა გადაცემისთვის.
XML არ არის HTML-ის შემცვლელი.
XML და HTML შეიქმნა სხვადასხვა მიზნებისთვის:
- XML შეიქმნა მონაცემების აღსაწერად და ფოკუსირებულია იმაზე, თუ რა მონაცემები გადადის
- HTML შექმნილია მონაცემთა ჩვენებისთვის ფოკუსირებული მონაცემების ჩვენებაზე
- ამრიგად, HTML უფრო მეტად ეხება ინფორმაციის ჩვენებას, ხოლო XML უფრო მეტად ეხება ინფორმაციის აღწერას.
XML არაფერს აკეთებს
XML არ იყო შექმნილი არაფრის გასაკეთებლად.
შეიძლება ადვილი გასაგები არ იყოს, მაგრამ XML არაფერს აკეთებს. მარკირების ეს ენა შეიქმნა ინფორმაციის სტრუქტურირებისთვის, შესანახად და კომუნიკაციისთვის. შემდეგი მაგალითი არის ანტონ აირის ჩანაწერი, რომელიც წარმოდგენილია XML-ში:
როგორც ხედავთ, XML ძალიან ლაკონურია.
შენიშვნა (
XML არის უფასო გაფართოებადი მარკირების ენა
XML ტეგები არ არის წინასწარ განსაზღვრული. თქვენ შეგიძლიათ შეიყვანოთ თქვენი საკუთარი ტეგები.
ტეგები და დოკუმენტის სტრუქტურა HTML-ში წინასწარ არის განსაზღვრული. HTML დოკუმენტის შემქმნელს შეუძლია გამოიყენოს მხოლოდ სტანდარტებით განსაზღვრული ტეგები.
XML საშუალებას გაძლევთ შეიყვანოთ თქვენი ტეგები და დოკუმენტის სტრუქტურა xml დოკუმენტის ავტორთან. მაგალითში ნაჩვენები ტეგები (მაგალითად,
XML არის HTML-ის დამატება
XML არ არის HTML-ის შემცვლელი.
მნიშვნელოვანია გვესმოდეს, რომ XML არ არის HTML-ის შემცვლელი. მომავალში, ვებ დეველოპერები გამოიყენებენ XML-ს მონაცემების აღსაწერად, ხოლო HTML გამოყენებული იქნება ამ მონაცემების ფორმატირებისთვის და ჩვენებისთვის.
ჩემი საუკეთესო განმარტება XML არის ეს: XML არის კროს-პლატფორმული, პროგრამული და აპარატურის დამოუკიდებელი ინფორმაციის გადაცემის ინსტრუმენტი.
შენიშვნა:კროს-პლატფორმა - შესაფერისია ნებისმიერი ოპერაციული სისტემისთვის და ნებისმიერი ტექნიკისთვის.
თუ იცით, არსებობს სხვადასხვა ოპერაციული სისტემები, გარდა ნაცნობი Windows-ისა. ეს არის Linux OS, Mac და სხვა.
რაც შეეხება აპარატურას, შეგვიძლია ვთქვათ შემდეგი: ეს შეიძლება იყოს ჩვეულებრივი კომპიუტერები, ლეპტოპები, PDA და ა.შ.
XML ვებ განვითარების მომავალში
XML ყველგან იქნება გამოყენებული.
XML-ის განვითარების მოწმენი ვართ მისი დაარსების დღიდან. გასაოცარი იყო იმის დანახვა, თუ რამდენად სწრაფად განვითარდა XML სტანდარტი და რამდენად სწრაფად დიდი რაოდენობამომწოდებლები პროგრამული უზრუნველყოფამიიღო ეს სტანდარტი. ჩვენ მტკიცედ გვჯერა, რომ XML იქნება მომავალი ინტერნეტის ისეთივე მნიშვნელოვანი კომპონენტი, როგორც HTML, რომელიც არის ინტერნეტის საფუძველი, და რომ XML იქნება ყველაზე გავრცელებული ინსტრუმენტი ყველა მონაცემის მანიპულაციისა და კომუნიკაციისთვის.