≡×ՄԵՆՈՒ

• Windows 10
• Ինտերնետ, WiFi
• Օգտակար
• Windows 7
• Սխալներ

Սովորում ենք xml զրոյից: XML հիմունքներ սկսնակների համար. XML-ը կօգտագործվի ամենուր

XML-ն այս օրերին շատ տարածված և ճկուն ձևաչափ է: Յուրաքանչյուր ծրագրավորող պետք է հասկանա դա, դա պարզապես պարտադիր է: Այսօր ակտիվորեն կիրառվում են բազմաթիվ տեխնոլոգիաներ, որոնց թվում են ժամանակակիցները։

Ներածություն

Բարև իմ հոդվածի սիրելի ընթերցողներ: Ուզում եմ անմիջապես ասել, որ սա միայն առաջին հոդվածն է իմ երեք հոդվածների շարքից։ Ամբողջ ցիկլի հիմնական նպատակն է յուրաքանչյուր ընթերցողին նվիրել XML-ին և տալ, եթե ոչ ամբողջական բացատրություն և հասկացողություն, ապա գոնե լավ մղել դրան՝ բացատրելով հիմնական կետերն ու բաները: Ամբողջ ցիկլը լինելու է մեկ անվանակարգում՝ «Ուշադրություն մանրուքներին»., իսկ 3 հոդվածի բաժանումն արվում է գրառումներում նիշերի սահմանաչափի մեջ տեղավորվելու և ավելի լավ հասկանալու համար մեծ քանակությամբ նյութեր ավելի փոքր մասերի բաժանելու նպատակով։ Առաջին հոդվածը կկենտրոնանա հենց XML-ի և դրա մասին, ինչպես նաև XML ֆայլերի սխեմաների ձևավորման եղանակներից մեկի վրա՝ DTD: Սկզբից ուզում եմ մի փոքրիկ նախաբան անել նրանց համար, ովքեր դեռևս ընդհանրապես ծանոթ չեն XML-ին՝ վախենալու կարիք չկա։ XML-ն այնքան էլ բարդ չէ և պետք է հասկանալի լինի ցանկացած ծրագրավորողի կողմից, քանի որ այն այսօր շատ ճկուն, արդյունավետ և տարածված ֆայլի ձևաչափ է՝ ձեր ուզած բոլոր տեսակի տեղեկությունների պահպանման համար: XML-ն օգտագործվում է Ant, Maven, Spring-ում: Ցանկացած ծրագրավորողի կարիք ունի XML-ի իմացություն: Հիմա, երբ ուժ ու մոտիվացիա եք հավաքել, սկսենք ուսումնասիրել։ Ես կփորձեմ հնարավորինս պարզ դասավորել ամբողջ նյութը, հավաքելով միայն ամենակարևորը և չմտնելով ջունգլիներում:

XML

Ավելի պարզ բացատրության համար ավելի ճիշտ կլինի XML-ը պատկերացնել օրինակով։< ? xml version= "1.0" encoding= "UTF-8" ? > < company> < name> ՏՏ դրախտ< / 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 ֆայլ կարող է ունենալ միայն մեկ արմատային տարր:Այն պետք է հայտարարվի հետո xml ֆայլի հայտարարություններ(օրինակի առաջին տողը) և պարունակում է բոլոր մյուս տարրերը: Մի փոքր հռչակագրի մասին պարտադիրև անհրաժեշտ է փաստաթուղթը որպես XML նույնականացնելու համար: Այն ունի երեք կեղծ հատկանիշ (հատուկ նախապես սահմանված ատրիբուտներ) տարբերակ (ըստ 1.0 ստանդարտի), կոդավորում (կոդավորում) և ինքնուրույն (ինքնուրույն. եթե այո և արտաքին սխեմաները միացված են փաստաթղթին, ապա սխալ կլինի, կանխադրվածը ոչ): Տարրերսուբյեկտներ են, որոնք տվյալները պահում են՝ օգտագործելով այլ տարրեր և ատրիբուտներ: Հատկանիշներլրացուցիչ տեղեկատվություն է տարրի մասին, որը նշված է տարրը ավելացնելիս: Եթե ​​բացատրությունը թարգմանենք OOP դաշտում, ապա կարող ենք բերել հետևյալ օրինակը. մենք ունենք մեքենա, յուրաքանչյուր մեքենա ունի բնութագրեր (գույն, տարողունակություն, ապրանքանիշ և այլն) - սրանք ատրիբուտներ են, և կան սուբյեկտներ, որոնք գտնվում են ներսում: մեքենա՝ դռներ, պատուհաններ, շարժիչ, ղեկը՝ այլ տարրեր։ Դուք կարող եք պահպանել հատկությունները որպես առանձին տարրեր կամ ատրիբուտներ՝ կախված ձեր ցանկությունից: Ի վերջո, XML-ը չափազանց ճկուն ձևաչափ է ինչ-որ բանի մասին տեղեկատվություն պահելու համար: Բացատրություններից հետո բավական է, որ վերը բերված օրինակը վերլուծենք, որպեսզի ամեն ինչ իր տեղը գա։ Օրինակում մենք նկարագրեցինք ընկերության պարզ կառուցվածքը. կա ընկերություն, որն ունի անուն և գրասենյակներ, իսկ գրասենյակներում կան աշխատողներ: Աշխատակիցների և գրասենյակների տարրերը փաթաթման տարրեր են. դրանք ծառայում են նույն տիպի տարրեր հավաքելու համար, ըստ էության, դրանք մեկ հավաքածուի մեջ միավորելով՝ դրանց մշակման հարմարության համար: Հատուկ ուշադրության են արժանի հատակն ու սենյակը։ Սրանք գրասենյակային ատրիբուտներն են (հատակը և համարը), այլ կերպ ասած՝ դրա հատկությունները։ Եթե ​​մենք ունենայինք «պատկեր» տարր, ապա մենք կարող էինք փոխանցել դրա չափերը: Դուք կարող եք նկատել, որ ընկերությունը չունի անվան հատկանիշ, բայց ունի անվան տարր: Պարզապես դուք կարող եք նկարագրել կառույցները, ինչպես ուզում եք: Ոչ ոք ձեզ չի պարտավորեցնում տարրերի բոլոր հատկությունները գրել միայն ատրիբուտներում, դուք կարող եք օգտագործել պարզապես տարրեր և դրանց ներսում գրել որոշ տվյալներ։ Օրինակ, մենք կարող ենք գրանցել մեր աշխատակիցների անունը և պաշտոնը որպես հատկանիշներ.< ? xml version= "1.0" encoding= "UTF-8" ? > < company> < name> ՏՏ դրախտ< / 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> ՏՏ դրախտ< / 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 Schema: Այս հոդվածը կկենտրոնանա միայն առաջինի վրա:

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) ) >Այնուհետև կընտրվեր տարրերից մեկը՝ անունը կամ գրասենյակները, բայց եթե դրանք միանգամից երկուսը լինեին ընկերության ներսում, ապա վավերացումը չէր անցնի։ Կարող եք նաև նկատել, որ աշխատողի մոտ ԴԱՏԱՐԿ բառն է, սա նշանակում է, որ տարրը պետք է դատարկ լինի: Կա նաև ՑԱՆԿԱՑԱԾ՝ ցանկացած էլեմենտ: #PCDATA - տեքստային տվյալներ: ԱՏԼԻՍՏՕգտագործվում է տարրերին ատրիբուտներ ավելացնելու համար: ATTLIST-ին հաջորդում է պահանջվող տարրի անվանումը, իսկ «attribute name - հատկանիշի տեսակ» ձևի բառարանից հետո, իսկ վերջում կարող եք ավելացնել #IMPLIED (ըստ ցանկության) կամ #REQUIRED (պարտադիր): CDATA - տեքստային տվյալներ: Կան այլ տեսակներ, բայց դրանք բոլորը փոքրատառ են: ENTITY ENTITY-ը ծառայում է հապավումների և դրանց կցվող տեքստի հայտարարագրման համար: Փաստորեն, մենք կարող ենք պարզապես օգտագործել XML-ում, ամբողջական տեքստի փոխարեն, պարզապես կազմակերպության անվանումը նշանով & դիմաց և; հետո։ Օրինակ՝ HTML-ում նշումը պարզապես նիշերից տարբերելու համար ձախ անկյունային փակագիծը հաճախ բացվում է lt-ով; , բայց պետք է նաև սահմանել & նախքան lt. Այնուհետև մենք չենք օգտագործի նշում, այլ պարզապես խորհրդանիշ< . Как вы можете видеть, все довольно просто: объявляете элементы, объясняете, какие элементы объявленные элементы способны содержать, добавление атрибутов этим элементам и, по желанию, можете добавить сущности, чтобы сокращать какие-то записи. И тут вы должны были бы спросить: а как использовать наши правила в нашем XML файле? Ведь мы просто объявили правила, но мы не использовали их в XML. XML-ում դրանք օգտագործելու երկու եղանակ կա. 1. Ներարկում - գրել DTD կանոններ հենց XML ֆայլի ներսում, պարզապես գրեք արմատային տարրը 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> ՏՏ դրախտ< / 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 ֆայլում, որից հետո օգտագործում ենք DOCTYPE կոնստրուկցիան XML ֆայլի առաջին մեթոդից, միայն քառակուսի փակագծերի փոխարեն պետք է գրել SYSTEM և նշել բացարձակ կամ հարաբերական ճանապարհ դեպի ֆայլի ընթացիկ գտնվելու վայրը. < ? xml version= "1.0" encoding= "UTF-8" ? > < ! DOCTYPE company SYSTEM "dtd_example1.dtd" > < company> < name> ՏՏ դրախտ< / 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>Հնարավոր է նաև SYSTEM-ի փոխարեն օգտագործել PUBLIC հիմնաբառը, բայց դժվար թե այն օգտակար լինի ձեզ համար: Եթե ​​դուք հետաքրքրված եք, կարող եք մանրամասն կարդալ դրա մասին (և SYSTEM-ի մասին նույնպես) այստեղ՝ հղում: Այժմ մենք չենք կարող օգտագործել այլ տարրեր առանց դրանք DTD-ում հայտարարագրելու, և ամբողջ XML-ը ենթակա է մեր կանոններին: Կարող եք փորձել գրել այս կոդը IntelliJ IDEA-ում առանձին .xml ֆայլում և փորձել ավելացնել որոշ նոր տարրեր կամ հեռացնել որևէ տարր մեր DTD-ից և նկատել, թե ինչպես է IDE-ն ձեզ ցույց տալու սխալի վրա: Այնուամենայնիվ, DTD-ները ունեն իրենց բացասական կողմերը.

• Այն ունի իր սեփական շարահյուսությունը, որը տարբերվում է xml շարահյուսությունից:
• DTD-ները չունեն տեսակի ստուգում և կարող են պարունակել միայն տողեր:
• DTD-ում անունների տարածություն չկա:

Սեփական շարահյուսության խնդրի մասին. դուք պետք է հասկանաք միանգամից երկու շարահյուսություն՝ XML և DTD շարահյուսություն: Նրանք տարբեր են, և դա կարող է ձեզ շփոթեցնել: Այն նաև դժվարացնում է հսկայական XML ֆայլերի սխալները հետագծելը նույն DTD սխեմաների հետ համատեղ: Եթե ​​ինչ-որ բան ձեզ մոտ չի ստացվում, դուք պետք է ստուգեք տարբեր շարահյուսությունների հսկայական քանակությամբ տեքստ: Դա նման է միաժամանակ երկու գիրք կարդալուն՝ ռուսերեն և անգլերեն: Իսկ եթե մեկ լեզվի իմացությունը քեզ համար ավելի վատ է, ապա նույնքան դժվար կլինի հասկանալ տեքստը։ Տվյալների տիպի ստուգման խնդրի մասին. DTD-ների ատրիբուտները իսկապես ունեն տարբեր տեսակներ, բայց դրանք բոլորն էլ իրենց հիմքում ինչ-որ բանի, ցուցակների կամ հղումների լարային ներկայացումներ են: Այնուամենայնիվ, դուք չեք կարող պահանջել միայն թվեր, առավել եւս դրական կամ բացասական: Եվ դուք կարող եք ընդհանրապես մոռանալ օբյեկտների տեսակների մասին: Վերջին խնդիրը կքննարկվի հաջորդ հոդվածում, որը նվիրված կլինի անվանատարածքներին և XML սխեմաներին, քանի որ այստեղ քննարկելն անիմաստ է։ Շնորհակալ եմ բոլորիդ ուշադրության համար, ես մեծ աշխատանք եմ կատարել և շարունակում եմ դա անել, որպեսզի ժամանակին ավարտեմ հոդվածների ամբողջ շարքը։ Իրականում, ես պարզապես պետք է հասկանամ XML սխեմաները և դրանց ավելի պարզ բառերով բացատրեմ, որպեսզի ավարտեմ 2-րդ հոդվածը: Դրա կեսն արդեն արված է, այնպես որ շուտով կարող եք սպասել: Վերջին հոդվածը ամբողջությամբ նվիրված կլինի Java-ի միջոցով XML ֆայլերի հետ աշխատելուն: Հաջողություն բոլորին և հաջողություն ծրագրավորման մեջ :) Հաջորդ հոդվածը. 1. Ներածություն

Եթե ​​ձեզանից որևէ մեկը երբևէ փորձել է ինքնուրույն սովորել XML, դուք կարող եք հանդիպել շատ շփոթեցնող հասկացությունների, որոնք ինձ հարվածել են անցյալում: DTD, XML Schema, namespaces (namespaces), 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 ձևաչափով:

ապակի 6 16 սառցե ուղղանկյունանիստ ծղոտ ջուր այո

Նշենք, որ ֆայլի առաջին տողը () առայժմ հատուկ տեսք ունի, պարզապես հիշեք, որ այն պետք է այնտեղ լինի: 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 ֆայլը բեռնվում է այս կերպ, այն կարող է մանիպուլյացիայի ենթարկվել՝ օգտագործելով Document Object Model-ի հատկությունները, մեթոդները և իրադարձությունները: Այստեղից է գալիս XML-ի օգտակարությունը: Փաստաթղթի օբյեկտի մոդելը մեծապես նպաստում է XML ֆայլի տեղեկատվության որոնմանը և մշակմանը: Ես այստեղ չեմ խոսելու փաստաթղթի օբյեկտի մոդելի բոլոր հատկանիշների մասին, պարզապես կխոսեմ որոշ հիմնական հատկանիշների մասին, որոնք կօգնեն հասնել այս հոդվածի նպատակին: Ես պատրաստվում եմ վերցնել DOM XML ֆայլը, որը ես հենց նոր ստեղծեցի, բեռնեմ այն ​​Document Object Model-ում և մի քանի բան կանեմ դրա հետ: Ես կպահեմ Document Object Model-ի մնացած հատկանիշներն ու հնարավորությունները հաճախորդի կողմից XML-ի հաջորդ հոդվածի համար: Նկատի ունեցեք, որ չնայած Document Object Model-ը շատ գեղեցիկ է և հարմար է մշակողների համար, այն պահանջում է բավականին զգալի քանակությամբ համակարգի ռեսուրսներ: Հետևաբար, կա XML ֆայլերի վերլուծության ևս մեկ մեթոդ, որը հայտնի է որպես SAX: Իմ հոդվածը չի հավակնում լինել այս թեմայի վերաբերյալ տեղեկատվության սպառիչ աղբյուր, ուստի օգտակար կլինի նաև օգտագործել XML SDK-ն:

Եկեք նայենք օրինակին, օգտագործելով Microsoft-ի XML վերլուծիչ տարբերակը 3.0 (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 = Նոր DOMDocument30 xmlDoc.async = Կեղծ xmlDoc.validateOnParse = Կեղծ xmlDoc.load ("c:\inetpub\wwwroot.Bxml" xmlDoc.xml ASP սերվերի կոդ Visual Basic-ում. Dim xmlDoc Սահմանել xmlDoc = Server.CreateObject("Msxml2.DOMDocument.3.0") xmlDoc.async = Սխալ xmlDoc.validateOnParse = Սխալ xmlDoc.load "/xml/cup.xml" ASP Server-Side Java Script կոդը. var xmlDoc = Server.CreateObject("Msxml2.DOMDocument.3.0"); xmlDoc.async = կեղծ; xmlDoc.validateOnParse = կեղծ; xmlDoc.load ("/xml/cup.xml");

Վերոնշյալ կոդի բացատրությունը - եկեք անցնենք VB6-ի կոդը

Տող 1:Խոնավացրեք xmlDoc-ը որպես MSXML2.DOMDocument30

Այս առաջին տողում մենք սահմանում ենք հղում «Microsoft XML, v3.0»: Այս տողում ես սահմանել եմ xmlDoc փոփոխականը՝ որպես հղում XML փաստաթղթին: MSXML2-ը գրադարան է (օգտագործեք այդ անունը, մի փորձեք գրել MSXML3, այն չի աշխատի): DODocument30-ը սահմանում է 3.0 տարբերակին համապատասխանող XML փաստաթղթի օբյեկտ: Դուք կարող եք նաև տեսնել այս կոդը՝ dim xmlDoc-ը որպես MSXML2.DOMDdocument: Այս կառուցվածքը սովորաբար օգտագործվում է, երբ դուք չեք ցանկանում նշել XML փաստաթղթի կոնկրետ տարբերակը: Այս դեպքում կօգտագործվի համակարգում լռելյայն գրանցված անալիզատորը։ Միակ խնդիրը կարող է լինել այն, որ լռելյայնորեն գրանցված անալիզատորի տարբերակը կարող է տարբերվել տարբեր համակարգիչների վրա: Եթե ​​ցանկանում եք վստահ լինել, որ ձեր գրած կոդը կաշխատի անալիզատորի ցանկացած տարբերակի հետ, ապա մի օգտագործեք անալիզատորի կոնկրետ տարբերակներին հատուկ կոնստրուկցիաներ։ Որովհետև երաշխիք չկա, որ այն օգտվողը, ով կօգտագործի ձեր կոդը, ունի անալիզատորի այն տարբերակի անունը, որի տակ դուք գրել եք ձեր կոդը: Կոդ մշակելու մեկ այլ առավելություն, որը անկախ է անալիզատորի տարբերակից, այն է, որ երբ ավելին նոր տարբերականալիզատոր, այն հաստատ հետամնաց կլինի նախորդ տարբերակների հետ, և ստիպված չես լինի նորից կոմպիլացնել քո կոդը։

Տող 2:Սահմանեք xmlDoc = նոր DOMDocument30

Այս տողը սկզբնավորում է xmlDoc փոփոխականը որպես XML փաստաթղթի օբյեկտի 3.0 տարբերակի նոր օրինակ:

Տող 3: xmlDoc.async = Սխալ

XML ֆայլերը կարող են բեռնվել կամ համաժամանակյա կամ ասինխրոն: Եթե ​​xmlDoc.async = False, ապա XML ֆայլի բովանդակությունը կբեռնվի, և միայն դրանից հետո կառավարումը կփոխանցվի զանգի գործընթացին: Եթե ​​xmlDoc.async = True, ապա վերահսկողությունը անմիջապես կփոխանցվի զանգի գործընթացին, առանց սպասելու XML ֆայլի բովանդակության ամբողջական բեռնմանը:

Տող 4: xmlDoc.validateOnParse = Սխալ

Այս կոդը ասում է վերլուծողին չվավերացնել բեռնված 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): Գործարկեք հավելվածը վրիպազերծման ռեժիմում: Երբ կատարման գործընթացը հասնում է ընդմիջման կետին, զանգահարեք «Տեղականներ» պատուհանը և նայեք Փաստաթղթի օբյեկտի մոդելին: Դուք կարող եք շատ բան սովորել՝ դիտելով այն, ինչ ցուցադրվում է այս պատուհանում: «Տեղացիներ» պատուհանը պետք է նման լինի ստորև նկարում պատկերվածին: Ահա Փաստաթղթի օբյեկտի մոդելի մի քանի հետաքրքիր հատկություններ:

XML փաստաթղթի օբյեկտի մոդելը միշտ պարունակում է երկու վերին մակարդակի հանգույց.

• Item1-ը փաստաթղթի կետի ճյուղի արմատն է (անտեսել այն)
• Item2-ը իրականում փաստաթղթի առաջին տարրն է (հիշեք սա)

nodeName կամ baseName - կարող է օգտագործվել տարրի կամ հատկանիշի անունը փնտրելիս:
nodeType - օգտագործել ընթացիկ հանգույցի տեսակը ստանալու համար:
nodeValue - օգտագործել հանգույցի տվյալների արժեքը պարզելու համար:
childNodes-ը մանկական հանգույցների հավաքածու է: Դրանք կարող են լինել տարրերի հանգույցներ, տեքստային հանգույցներ և CDATA հանգույցներ: Կարող են լինել այլ տեսակի հանգույցներ, որոնց ես հիմա չեմ անդրադառնա, բայց դուք կարող եք ամեն ինչ իմանալ դրանց մասին XML SDK-ում:
հատկանիշները ատրիբուտների հանգույցների հավաքածու է ընթացիկ տարրի համար:
երկարություն - օգտագործվում է ծառի հանգույցների քանակը որոշելու համար, որոնք ուղղակիորեն պատկանում են ընթացիկին:
xml - այս հատկությունը առկա է բոլոր հանգույցներում և կարող է օգտագործվել փաստաթղթում ներկայիս դիրքը ներկայացնելու համար: XML տողը սկսվում է ընթացիկ հանգույցից և իջնում ​​մինչև ծառի վերջը: Սա շատ օգտակար հատկություն է։ Փորձեք դրա հետ և տեսեք, թե ինչ է տեղի ունենում:

2.2.2. Տարրերի հանգույցներ

Տարրերի հանգույցը կարող է պարունակել տարր, հատկանիշ, տեքստ կամ CDATA հետնորդ հանգույցներ: Ստորև բերված նկարը ցույց է տալիս հետևյալ տեղեկատվությունը «SOLID» հանգույցի մասին.

nodeType - Ընթացիկ հանգույցի տեսակը = NODE_ELEMENT - այսինքն. ընթացիկ հանգույցը տարր է:
nodeName կամ baseName կամ tagName - Ընթացիկ հանգույցի (տարրի) անվանումը = SOLID:
Դրա մայր տարրը ԲՈՎԱՆԴԱԿՈՒԹՅՈՒՆ ունի 4 երեխա:
Սա կարող եք տեսնել հետևյալ նկարում, սակայն SOLID-ն ունի մեկ երեխա, որը տեքստային տվյալների տեսակ է:
տեքստ - «սառցե խորանարդը» սղագրության մեթոդ է ընթացիկ հանգույցի արժեքը ստանալու համար՝ առանց երեխայի տեքստային հանգույց տեղափոխվելու:

2.2.3. Հատկանիշային հանգույցներ

Հատկանիշների հանգույցները կարող են բաղկացած լինել միայն տեքստից կամ CDATA-ի զավակներից: Հետևյալ նկարը ցույց է տալիս, թե ինչ տեղեկատվություն կարելի է ձեռք բերել «քանակ» հանգույցի մասին.

nodeType - Ընթացիկ հանգույցի տեսակը = NODE_ATTRIBUTE - ընթացիկ հանգույցը հատկանիշ է:
nodeName կամ baseName - Ընթացիկ հանգույցի անվանումը (հատկանիշներ) = ք

Հետևյալ նկարից պարզ է դառնում նաև, որ qty-ն ունի մեկ երեխա, որն ունի տեքստային տվյալների տեսակ:
տեքստ կամ արժեք - «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-ի վերջի պիտակը և փորձեմ նորից գործարկել ծրագիրը, կստանամ հետևյալ արդյունքը. Առաջին օգտակար տեղեկատվությունն այն է, որ մեր հաջորդ եղբայրն այժմ պարունակում է Ոչինչի արժեքը: Այժմ, եթե նայեք 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 Document Node տեսակի objNode փոփոխականը: Կարևոր է հասկանալ, որ XML փաստաթղթի հանգույցը նույնպես օբյեկտ է: Դա արժեք չէ: Այն բաղկացած է իրենից, ինչպես նաև իր ատրիբուտներից և ժառանգից (childNodes): Այս կերպ դուք կարող եք կտրել ծառի ավելորդ ճյուղերը՝ ընտրելով միայն ձեզ անհրաժեշտը։

Տող 2Մուգ 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 է, ապա հանգույցը հեռացվում է: Դրանից հետո մեր արդյունքը կրճատվում է երեք հանգույցի (

Տող 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 ձևաչափի: Նպատակն է ստանալ գրքերի վերնագրերը Pubs տվյալների բազայի Titles աղյուսակից և վերադարձնել դրանք XML ձևաչափով։ Ես կօգտագործեմ այն ​​արդյունքը, որը ես ստանում եմ իմ հաջորդ հոդվածում: Դուք կարող եք ասել, որ ADO-ն ունի արդյունքը XML ձևաչափով պահելու իր մեթոդները, այնպես չէ՞: Այո, բայց եթե ես վստահում եմ ADO-ին դա անել, ապա ես հայտնվում եմ XML ֆայլի այնպիսի սարսափելի ձևաչափով, որ անհնար կլինի աշխատել դրա հետ: ADO-ն կստեղծի XML ֆայլ՝ օգտագործելով անվանատարածքը, որն ինձ ընդհանրապես պետք չէ հիմա: Երկրորդ, ADO-ն կստեղծի XML ֆայլ, որը կլինի ատրիբուտների տեսքով: Այլ կերպ ասած, յուրաքանչյուր գրառում կդառնա տարր, իսկ յուրաքանչյուր դաշտ՝ հատկանիշ.

Եվ ես կցանկանայի ստանալ XML ֆայլ տարրերի տեսքով, որտեղ յուրաքանչյուր գրառում կպարունակվի պիտակի մեջ , և յուրաքանչյուր դաշտ կլինի տարր պիտակի ներսում . Իմ XML տողի շարահյուսությունը կլինի.

տվյալները աղյուսակից տվյալները աղյուսակից տվյալները աղյուսակից տվյալները աղյուսակից տվյալները աղյուսակից տվյալները աղյուսակից տվյալների բազայից

Ի դեպ, այն, ինչ ես պարզապես արեցի, իմ XML տողի համար սխեմա ստեղծելն էր: Այժմ, եթե ես պետք է վավերացնեմ XML փաստաթղթի կառուցվածքը սխեմայի դեմ, ինձ մնում է միայն սխեման վերափոխել ճիշտ ձևաչափի: Այսինքն՝ DTD կամ XDR շարահյուսությամբ։ Ուշադրություն դարձրեք, որ ես յուրաքանչյուր տարրին ավելացրել եմ որոշ հատկանիշներ: . Դրա պատճառներից մեկն այն է, որ այս տեղեկատվությունը կարող է օգտագործվել հաճախորդի կողմից: Prettyname-ը կարող է օգտագործվել որպես տվյալների պիտակներ: Datatype հատկանիշը կարող է օգտագործվել հաճախորդի կողմից տվյալները վավերացնելու համար: Բայց եթե անկեղծ լինենք, այս հատկանիշների իրական պատճառն այն է, որ դրանք հատուկ նպատակ ունեն XSL ֆայլի ձևանմուշում, որը ես հաճախ օգտագործում եմ SQL հարցումների «where» բաժինը կառուցելու համար: Միգուցե շուտով այս մոտեցումը ցուցադրող հոդված կտեղադրեմ: Կաղապարն իրականում շատ օգտակար է։ Երբ XML կառուցվածքը կիրառվում է Titles աղյուսակի տվյալների վրա, արդյունքը կունենա հետևյալ տեսքը.

The Busy Executive-ի տվյալների բազայի ուղեցույց BU1032 The Busy Executive-ի տվյալների բազայի ուղեցույց բիզնես 19.99 4095 Հասանելի տվյալների բազայի համակարգերի ակնարկ՝ շեշտը դնելով ընդհանուր բիզնես հավելվածների վրա: պատկերազարդված. 6/12/1991 Խոհարարություն համակարգչով. Զարմանալի հաշվեկշիռներ BU1111 Խոհարարություն համակարգչով. Զարմանալի հաշվեկշիռներ բիզնես 11.95 3876 Օգտակար ակնարկներ այն մասին, թե ինչպես լավագույնս օգտագործել ձեր էլեկտրոնային ռեսուրսները: 6/9/1991

Հիմա ես ինչ-որ բան ունեմ աշխատելու:

Ցուցակ 1 - CUP.XML

ապակի 6 16 սառցե ուղղանկյունանիստ ծղոտ ջուր այո

Dim xmlDoc As MSXML2.DOMDocument30 Սահմանել xmlDoc = Նոր DOMDocument30 xmlDoc.async = Կեղծ xmlDoc.validateOnParse = Կեղծ xmlDoc.Load("c:\inetpub\wwwroot\xml\cup.xml") MsgMjBOMDe As: ListOfNodes Որպես IXMLDOMNodeList xmlDoc.setProperty "SelectionLanguage", "XPath" MsgBox "Ձեր բաժակը պարունակում է հետևյալ տարրերը" Սահմանել objListOfNodes = xmlDoc.selectNodes("//CONTENTS/*[@qty>0]") Յուրաքանչյուր objNode No objBoxf-ում: Տեքստ Հաջորդ Սահմանել objNode = xmlDoc.selectSingleNode("/CUP/LID") If objNode.Text = "yes" Ապա MsgBox "Մենք ունենք կափարիչ" Ուրիշ MsgBox "Այս բաժակի վրա կափարիչ չկա" Վերջ, եթե

Ցուցակ 3 – ActiveX Control՝ ADO դեպի XML (WebClass.dll) (xmlControl.cls)

Բացահայտ տարբերակ «Տվյալների բազայի փոփոխականները հռչակել Private m_dbConnection As New ADODB.Connection Private m_dbCommand As ADODB.Command Private m_adors As ADODB.Recordset Private m_adoErrors As ADODB.Errors Private Assistancem_dbPublicErrors TimeOut As Variant Public strConnect As Variant Public strAppName As Տողային Հանրային strLogPath Որպես տող Հանրային strՏվյալների բազա Որպես տող Հանրային strUser Որպես String Public strԳաղտնաբառ Որպես String Հանրային strServer Որպես String Public strVersion Որպես տող Հանրային lMSADO Որպես Բուլյան «Մասնավոր գլոբալ փոփոխականներ Private gnErrNum Որպես Տարբերակ PrivateSrrrrariant gstrrariant Private Gstrrrrariant Private Asstr. strDB As String Private gstrADOError As String Private Const adLeonNoRecordset As Integer = 129 Private gtableName(6) As String Private gcolumnName(6) As String Private gprettyName(6) As String Private gdatatype(6) As String Private Asfiltering(6) Private Asfilter Եթե ​​Len(strConnect) = 0 Այնուհետև «սահմանեք լռելյայնները If Len(strDatabase) = 0 Ապա strDatabase = «pubs» Վերջ Եթե nConnectionTimeOut = 0 Ապա nConnectionTimeOut = 600 Վերջ Եթե nCommandTimeOut = 0 Հետո nCommandTimeOut = 0 Հետո nCommandTimeOut = 0 Այնուհետև nCommandTimeOut = 0 Այնուհետեւ strAppName = "xmlControl" End If If Len(strUser) = 0 Այնուհետեւ strUser = "sa" End If Len(strPassword) = 0 Այնուհետեւ strPassword = "" End If strConnect = "Provider=SQLOLEDB.1 ; " & _ "Application Name=" & strAppName & _ "; Տվյալների աղբյուր = "&strServer&"; Initial Catalog="&strDatabase&"; "&_" Օգտվողի ID="&strUser&"; Գաղտնաբառ=" & strPassword & ";" End If "connect to SQL Server and open database On Error GoTo SQLErr "Enable error handler With m_dbConnection .ConnectionTimeout = nConnectionTimeOut .CommandTimeout = nCommandTimeOut With Error Connectionen St.Open" GoTo 0 "disable error handler OpenDatabase = Ճիշտ է "շտեմարանը հաջողությամբ բացվեց Ելք ֆունկցիայից SQLErr. Call logerror("OPEN") OpenDatabase = False End Function Private Function BuildSQLwhere(tmpWhere) As String "This is for the future End Function Public Function (GetalT) xmlWhere As Variant) As String Dim whereClause As String Dim strSQL As String Call OpenDatabase "open database pubs If IsMissing(xmlWhere) then "when query fails whereClause = "" Else whereClause = BuildSQLwhere(xmlWhere) Եթե ուղղել"sql: սկզբնավորել sql հայտարարություն, որը կհարցնի գրքերի վերնագրերը strSQL = "ընտրել title_id,title,type,price,ytd_sales,notes,pubdate from the titles" & whereClause Call NewRecordSet "create a database "set cursorlocation m_adors. CursorLocation = adUseClient "բացել գրառումների հավաքածու m_adoRs. Բացել strSQL, m_dbConnection, adOpenForwardOnly, adLockReadOnly, adCmdText "անջատվել տվյալների բազայից Set m_adors.ActiveConnection = Սխալ չկա, GoTo_dbConnection. EOF Ապա GetTitlesXML = "" "հարցումը ոչ մի արժեք չի վերադարձրել, Այլապես Եթե lMSADO Այնուհետեւ GetTitlesXML = msado(m_adoRs) "փոխակերպեք տվյալների բազան Microsoftado-->xml Այլապես GetTitlesXML = ADOtoXML(m_adors, True) "վերափոխեք ado գրառումների հավաքածուն մաքսային xml-ի: End If End Եթե «փակել տվյալների հավաքածուն Call CloseRecordset Ելք գործառույթը SQLErr. Call logerror(strSQL) End Function Private Function ADOtoXML(tmprs As ADODB.Recordset, tmpMP As Boolean) As String Dim adoFields As ADODB.Fields a collection to «de Dim դաշտեր adoField As ADODB.Field «օգտագործվում է հավաքածուից յուրաքանչյուր դաշտ ստանալու համար Dim xmlDoc As msxml2.DOMDocument30 Dim tmpLine As String «պահում է յուրաքանչյուր գրքի xml ներկայացումը Dim tmpXML As String» օգտագործվում է xml տողերը Dim i Որպես ամբողջ թիվ միացնելու համար: Եթե ​​tmprs.EOF Այնուհետեւ «հարցումը ոչ մի գրառում չի վերադարձրել ADOtoXML = "" Ելքի գործառույթը Այլապես Սահմանել adoFields = tmprs.Fields "ստեղծել դաշտերի հավաքածու Վերջ Եթե tmpXML = " Բոլոր գրքերը կփակվեն պիտակի մեջ Կատարեք մինչև tmprs.EOF «անցկացրեք տվյալների բազայի յուրաքանչյուր տող i = 0 «I-ն դաշտի ado ինդեքսն է, որը սկսվում է 0-ից. առաջին դաշտը կլինի դաշտ(0) tmpLine = " " & tmprs("title") & vbCrLf Յուրաքանչյուր adoField-ի համար adoFields-ում «շրջել բոլոր դաշտերի միջով» ստեղծել xml թեգ և դրա ատրիբուտները ընթացիկ դաշտի համար tmpLine = tmpLine & " " & adoField.Value tmpLine = tmpLine & "«& vbCrLf i = i + 1 «գնալ հաջորդ դաշտ Հաջորդ tmpXML = tmpXML & tmpLine & "" & vbCrLf "վերջ պիտակը վերջին դաշտից հետո tmprs.MoveNext "next header Loop Set adoField = Ոչինչ "ոչնչացնել դաշտի օբյեկտը Սահմանել adoFields = Ոչինչ "ոչնչացնել դաշտի հավաքածուի օբյեկտ tmpXML= tmpXML & "«& vbCrLf» փակման պիտակը Սահմանել xmlDoc = Նոր msxml2.DOMDocument30 "create xmlDOM xmlDoc.async = False" սպասել, որ փաստաթուղթը բեռնվի xmlDoc.validateOnParse = False "մի ստուգեք սխեմայի հետ xmlDoc.loadXML(tmpXML) "բեռնել տողը Error Resume Modele-ում" եթե ֆայլը գոյություն չունի, կարգավորեք այս սխալը Kill("c:\temp\custom.xml") "ջնջեք ֆայլը, եթե այն կա Սխալով GoTo 0 "ասեք սխալ մշակողին դադարեցնել, երբ սխալ է հանդիպում xmlDoc.save (" c:\temp\custom. xml") "save xml to file ADOtoXML=xmlDoc.xml "վերադարձնում է xml string Սահմանել xmlDoc=Nothing"destroy Document Object Model End Function Private Function msado(tmprs As ADODB.Recordset) As String Dim xmlDoc msxml2.DOMDocument30 Սխալի դեպքում Վերսկսել Հաջորդը «եթե ֆայլը գոյություն չունի, ստացեք «Սպանել» սխալ («c:\temp\msado.xml») «ջնջել ֆայլը, եթե այն կա Սխալում GoTo 0 «ասեք սխալ մշակողին դադարեցնել: սխալի դեպքում tmprs.save "c:\temp\msado .xml", adPersistXML "save xml ֆայլում Սահմանել xmlDoc = Նոր msxml2.DOMDocument30 "create xml փաստաթղթի օբյեկտի մոդել xmlDoc.async = Սխալ "սպասել xml փաստաթուղթը բեռնելու xmlDoc.validateOnP = False "մի ստուգեք սխեմայի հետ xmlDoc.Load("C: \temp\msado.xml") "բեռնել ֆայլը փաստաթղթի օբյեկտի մոդելի մեջ msado = xmlDoc.xml "վերադարձնել xml string Սահմանել xmlDoc = Ոչինչ "ոչնչացնել փաստաթղթի օբյեկտի մոդելի ավարտի գործառույթը" Մասնավոր SubCloseRecordset() "փակել տվյալների բազան m_adoRs.Close Set m_adors =Nothing End Sub Private Sub Private Sub NewRecordSet() Set m_adoRs= Nothing Set m_adoRs=New ADODB.Recordset End Sub Private Sub Private Sub CloseDatabase() m_dvatebConnection. Ենթ logerror(errSQL Որպես տող) Dim hFile որպես ամբողջ թիվ Dim expFile As String On Error GoTo 0 gnErrNum = Err.Number gstrErrDesc =Err.Նկարագրություն gstrErrSrc = Err.Source Set m_adoErrors = m_dbConnectionError m_dbConnection m_dbConnection. adoErr.Նկարագրություն & "," & CStr(m_adoErr.NativeError) _ & ", " & CStr(m_adoErr.Number) & "," & m_adoErr.Source _ & "," & CStr(m_adoErr.SQLState) Հաջորդ hFile =FreeFile If Len(strLogPath ) = 0 Հետո strLogPath = "C:\temp\" Վերջ Եթե expFile = strLogPath & strAppName & ".err" Բացեք expFile For Append As #hFile Print #hFile,"**************** ************** *******" Տպել #hFile, Now() Print#hFile, "**************** ************** ****" Տպել #hFile,"Ենթակարգ. " & tmpPro Print #hFile, "Error Number" & gnErrNum Print#hFile, "Error Description: " & gstrErrDesc Տպել #hFile, «Սխալի աղբյուր.» & gstrErrSrc Տպել # hFile, «Ado error String. 1. 1" "title_id,title,type,price,ytd_sales,notes,pubdate gtableName(0) = "titles" gcolumnName(0) = "title_id" gprettyName(0) = "Վերնագրի նույնականացման համար" gdatatype(0) = "համար" gfilter(0) = "" gtableName(1) = "վերնագրեր" gcolumnName(1) = "վերնագիր" gprettyName(1) = "Գրքի վերնագիր" gdatatype(1) = "տեքստ" gfilter(1) = "" gtableName (2) = «վերնագրեր» gcolumnName(2) = «տեսակ» gprettyName(2) = «Գրքի տեսակը» gdatatype(2) = «տեքստ» gfilter(2) = «" gtableName(3) = «վերնագրեր» gcolumnName( 3) = «գին» gprettyName(3) = «Գրքի գինը» gdatatype(3) = «համար» gfilter(3) = «» gtableName(4) = «վերնագրեր» gcolumnName(4) = «ytd_sales» gprettyName( 4) = «Տարեկան վաճառքներ» gdatatype(4) = «համար» gfilter(4) = «» gtableName(5) = «titles» gcolumnName(5) = «նշումներ» gprettyName(5) = «Ծանոթագրություններ գրքի մասին " gdatatype(5) = "memo" gfilter(5) = "" gtableName(6) = "titles" gcolumnName(6) = "pubdate" gprettyName(6) = "Հրապարակման ամսաթիվ" gdatatype(6) = "ամսաթիվ" gֆիլտր (6) = "" Վերջ ենթ

Ցուցակ 4 - VB թեստային հավելված WebClass փորձարկելու համար

Մասնավոր ենթաօրենսդրական հրաման1_Click() Dim objWC As xmlControl Dim xml As String Set objWC = Նոր xmlControl objWC.strDatabase = «pubs» objWC.strServer = «ltweb» objWC.strUser = «sa» objWC.strMSGADjWC = «sa» objWC.strMS. .Value objWC.strAppName = «Article1» Text1.Text = objWC.getTitlesXML Վերջ ենթ.

Ցուցակ 5 - ASP WebClass-ի փորձարկման համար

Մինչ օրս վեբ տեխնոլոգիաների ոլորտի բոլոր մասնագետների համար ակնհայտ է դարձել, որ ինտերնետով տվյալների փոխանցման գործող ստանդարտները բավարար չեն։ HTML ձևաչափը, ժամանակին բեկումնային դառնալով ինտերնետային հանգույցների բովանդակության ցուցադրման ոլորտում, այլևս չի բավարարում ներկայումս անհրաժեշտ բոլոր պահանջներին։ Այն թույլ է տալիս նկարագրել, թե ինչպես պետք է տվյալները ցուցադրվեն վերջնական օգտագործողի էկրանին, սակայն որևէ միջոց չի տրամադրում փոխանցված տվյալները արդյունավետ նկարագրելու և կառավարելու համար:

Բացի այդ, գայթակղություն է զարգացման մեջ ներգրավված բազմաթիվ ընկերությունների համար ծրագրային ապահովում, տարբեր բաղադրիչների համատեղ օգտագործման անհրաժեշտությունն է, դրանց փոխազդեցության ապահովումը, նրանց միջեւ տվյալների փոխանակման հնարավորությունը։

Մինչև վերջերս չկար որևէ ստանդարտ, որն ապահովում էր տեղեկատվության խելացի որոնման, տվյալների փոխանակման, ստացված տվյալների ադապտիվ մշակման գործիքներ։

Վերը նկարագրված բոլոր խնդիրների լուծումը 1998 թվականին W3C (EN) միջազգային կազմակերպության կողմից հաստատված XML լեզուն էր։ XML-ը (eXtensible Markup Language) ընդարձակվող նշագրման լեզու է՝ կառուցվածքային տվյալները տեքստային ձևով նկարագրելու համար: Այս տեքստի (տեքստի վրա հիմնված) ձևաչափը, որը շատ առումներով նման է HTML-ին, նախատեսված է հատուկ տվյալների պահպանման և փոխանցման համար:

XML-ը թույլ է տալիս նկարագրել և փոխանցել կառուցվածքային տվյալներ, ինչպիսիք են՝

• առանձին փաստաթղթեր;
• մետատվյալներ, որոնք նկարագրում են ցանկացած ինտերնետային կայքի բովանդակությունը.
• օբյեկտներ, որոնք պարունակում են տվյալներ և դրանց հետ աշխատելու մեթոդներ (օրինակ, ActiveX վերահսկիչները կամ Java օբյեկտները);
• անհատական ​​գրառումներ (օրինակ, տվյալների բազայի հարցումների կատարման արդյունքները);
• Ինտերնետի տեղեկատվության և մարդկային ռեսուրսների բոլոր տեսակի վեբ հղումներ (հասցեներ Էլ, հիպերտեքստային հղումներ և այլն)։

XML փաստաթղթերի ստեղծում

XML-ում նկարագրված տվյալները կոչվում են XML փաստաթղթեր: XML լեզուն հեշտ է կարդալ և բավական հեշտ հասկանալի: Եթե ​​ծանոթ էիք HTML-ին, ապա XML փաստաթղթեր գրել սովորելը ձեզ համար դժվար չի լինի:

XML փաստաթղթի սկզբնաղբյուր տեքստը բաղկացած է XML տարրերի մի շարքից, որոնցից յուրաքանչյուրը պարունակում է սկզբի և ավարտի պիտակ: Յուրաքանչյուր զույգ պիտակ ներկայացնում է տվյալների մի հատված: Այսինքն, ինչպես HTML-ը, XML-ն օգտագործում է պիտակներ՝ տվյալները նկարագրելու համար: Բայց, ի տարբերություն HTML-ի, XML-ը թույլ է տալիս պիտակների անսահմանափակ թվով զույգեր, որոնցից յուրաքանչյուրը ներկայացնում է ոչ թե այն, թե ինչպես պետք է պարունակի տվյալները, այլ այն, թե ինչ է դա նշանակում:

Բարի առավոտ ԼՈՒՐԵՐ Նուրբ թույն սերիա Հրաշքների դաշտ (կրկնել) Մ.ֆ. Առողջություն ԼՈՒՐԵՐ Վայելեք ձեր լոգանքը: Մ.ֆ. Միասին ԼՈՒՐԵՐ լավագույն ժամ ԼՈՒՐԵՐ Եղանակ GOOG գիշեր երեխաներ ԺԱՄԱՆԱԿ Տեսողություն

Այս տեքստը կարող է ստեղծվել պարզ տեքստի ձևաչափով և պահպանվել որպես XML ֆայլ:

XML փաստաթղթի ցանկացած տարր կարող է ունենալ ատրիբուտներ, որոնք նշում են դրա բնութագրերը: Հատկանիշը name="value" զույգ է, որը նշվում է, երբ տարրը սահմանվում է սկզբնական թեգում: Վերևի օրինակում տարրը ունի date = "December 25" հատկանիշ, և տարրն ունի - հատկանիշի անունը = "ORT".

XML լեզվի ընդարձակելիության սկզբունքը XML փաստաթղթի ստեղծողի կողմից սահմանված անսահմանափակ թվով պիտակների զույգերի օգտագործման հնարավորությունն է: Օրինակ, հեռուստատեսային ուղեցույցի վերը նշված նկարագրությունը կարող է ընդլայնվել՝ ներառելով տեղեկատվություն հեռարձակման տարածաշրջանի և PTP ալիքի ծրագրային ուղեցույցի մասին: Այս դեպքում XML նկարագրությունը կունենա հետևյալ ձևը.

Ռուսաստան Սանկտ Պետերբուրգ Բարի առավոտ ԼՈՒՐԵՐ Նուրբ թույն սերիա Հրաշքների դաշտ (կրկնել) Մ.ֆ. Առողջություն ԼՈՒՐԵՐ Վայելեք ձեր լոգանքը: Մ.ֆ. Միասին ԼՈՒՐԵՐ լավագույն ժամ ԼՈՒՐԵՐ Եղանակ GOOG գիշեր երեխաներ ԺԱՄԱՆԱԿ Տեսողություն Մ.ֆ. Եղանակ RTR Post Բարի լույս Երկիր: ինքը՝ ռեժիսորը Մանուշակագույն մառախուղ ՈՍԿԵ ԲԱՆԱԼ Ֆեդերացիա Գաղտնի գործակալներ Բոյարսկի Դվոր Իմ ընտանիքը Ֆուլ հաուս ԼՈՒՐԵՐ ԱՍՏԵՐՈԻԴ (ԱՄՆ) Ընթրիք FRED'S-ում (ԱՄՆ) Եղանակ

Այժմ այս XML նկարագրությունից կարող եք դուրս բերել ORT և RTR ալիքների ծրագրային ուղեցույցը դեկտեմբերի 25-ին Ռուսաստանի Սանկտ Պետերբուրգ քաղաքում:

Փաստաթղթի ներքին կառուցվածքի սահմանման անկախության սկզբունքը տվյալ տեղեկատվության ներկայացման եղանակներից տվյալների առանձնացումն է դրանց մշակման և ցուցադրման գործընթացից: Այսպիսով, ստացված տվյալները կարող են օգտագործվել հաճախորդի կարիքներին համապատասխան, այսինքն՝ ընտրել ցանկալի դիզայնը, կիրառել մշակման անհրաժեշտ մեթոդներ:

Դուք կարող եք վերահսկել տարրերի ցուցադրումը հաճախորդի ծրագրի պատուհանում (օրինակ, բրաուզերի պատուհանում) օգտագործելով հատուկ հրահանգներ՝ XSL ոճի թերթիկներ (eXstensible Stylesheet Language): Այս XSL աղյուսակները թույլ են տալիս սահմանել տարրի տեսքը՝ հիմնվելով փաստաթղթում նրա գտնվելու վայրի վրա, ինչը նշանակում է, որ նույն անունով երկու տարրերը կարող են ունենալ տարբեր ձևաչափման կանոններ, որոնք կիրառվում են դրանց նկատմամբ: Բացի այդ, XSL-ի հիմքում ընկած լեզուն XML-ն է, ինչը նշանակում է, որ XSL աղյուսակներն ավելի բազմակողմանի են, և DTD-ները կամ տվյալների սխեմաները, որոնք քննարկվում են ստորև, կարող են օգտագործվել՝ վերահսկելու նման ոճային թերթիկների ճշգրտությունը:

XML ձևաչափը, համեմատած HTML-ի հետ, ունի պարզ վերլուծման կանոնների փոքր փաթեթ, որոնք թույլ են տալիս XML փաստաթղթերը վերլուծել՝ առանց օգտագործվող XML տարրերի արտաքին նկարագրությունների դիմելու: Ընդհանուր առմամբ, XML փաստաթղթերը պետք է համապատասխանեն հետևյալ պահանջներին.

• Յուրաքանչյուր բացման պիտակ, որը սահմանում է փաստաթղթի տվյալների որոշ մասը, պետք է հետևի փակման պիտակին, այսինքն, ի տարբերություն HTML-ի, փակվող պիտակները չեն կարող բաց թողնել:
• XML-ում պիտակների տեղադրումը խստորեն վերահսկվում է, ուստի պիտակների բացման և փակման կարգը պետք է վերահսկվի:
• XML-ը մեծատառերի զգայուն է:
• Բոլոր տեղեկությունները, որոնք գտնվում են սկզբի և վերջի պիտակների միջև, դիտարկվում են որպես տվյալներ XML-ում, և, հետևաբար, հաշվի են առնվում բոլոր ձևաչափման նիշերը (այսինքն, բացատները, նոր տողերը, ներդիրները չեն անտեսվում, ինչպես HTML-ում):
• XML-ն ունի վերապահված նիշերի մի շարք, որոնք պետք է նշվեն XML փաստաթղթում միայն հատուկ ձևով: Այս նիշերը և դրանք սահմանող նիշերի հավաքածուներն են.
  

  <	<
  &	&
  >	>
  "	"
  "	"

• Յուրաքանչյուր XML փաստաթուղթ պետք է ունենա եզակի արմատային տարր: Մեր օրինակում այս տարրը տարրն է .
• Բոլոր ատրիբուտների արժեքները, որոնք օգտագործվում են պիտակների սահմանման մեջ, պետք է փակվեն չակերտների մեջ:

Եթե ​​XML փաստաթուղթը չի խախտում վերը նշված կանոնները, ապա այն կոչվում է պաշտոնապես ճիշտ.

Այսօր XML փաստաթղթի ճշգրտությունը վերահսկելու երկու եղանակ կա՝ DTD սահմանումներ (Փաստաթղթի տեսակի սահմանում) և տվյալների սխեմաներ (իմաստային սխեման): Եթե ​​XML փաստաթուղթը ստեղծվում և ուղարկվում է DTD-ների կամ սխեմաների միջոցով, ապա այն կոչվում է վավեր.

Սխեման XML փաստաթղթերի կառուցման կանոններ ստեղծելու միջոց է, այսինքն՝ նշելով վավեր անուններ, տեսակներ, ատրիբուտներ և տարրերի հարաբերություններ XML փաստաթղթում: սխեմաներն են այլընտրանքային ճանապարհ XML փաստաթղթերի ստեղծման կանոնների ստեղծում: Համեմատած DTD-ների հետ, սխեմաներն ավելի հզոր են տվյալների բարդ կառուցվածքները սահմանելու համար, ավելի հստակ ձև են տալիս լեզվի քերականությունը նկարագրելու համար և կարող են հեշտությամբ թարմացվել և ընդլայնվել: Սխեմաների անկասկած առավելությունն այն է, որ դրանք թույլ են տալիս նկարագրել XML փաստաթղթի կանոնները՝ օգտագործելով հենց XML-ը: Այս տեսանկյունից XML լեզուն կարելի է անվանել ինքնանկարագրող։

Քանի որ նույն փաստաթղթում օգտագործվող XML տարրերը կարող են ծագել տարբեր XML սխեմաներից, տարրի անվանման հակասություններ կարող են առաջանալ: Անվան բացատները լուծում են այս խնդիրը: Անվանատարածքները թույլ են տալիս տարբերակել նույն անունով, բայց տարբեր նշանակություն ունեցող տարրերը: Այնուամենայնիվ, նրանք չեն նշում, թե ինչպես են մշակվում այդպիսի տարրերը, սա այն է, ինչ անում են ստորև քննարկված XML վերլուծիչները:

XML սխեմաների նպատակն ու օգտագործումը ավելի լավ հասկանալու համար եկեք դիտենք վերը քննարկված հեռուստացույցի օրինակի սխեման:

Այս XML սխեման պետք է պահպանվի TV-ProgramSchema.XML ֆայլում: Այս XML ֆայլի արմատային տարրը տարրն է , որի ատրիբուտներն են TV-ProgramSchema սխեմայի անվանումը և հղումը այն անվանատարածքներին, որոնք սահմանում են այս սխեմայում օգտագործվող տվյալների ներկառուցված տեսակները. xmlns="urn:schemas-microsoft-com:xml-data" : Այս սխեմայի minOccurs և maxOccurs տարրերի ատրիբուտները սահմանում են համապատասխանաբար սխեմայում այդպիսի տարրերի նվազագույն և առավելագույն հնարավոր քանակը: Օրինակ, գիծը նշանակում է, որ առարկայի տիպի տարրերի քանակը (այսինքն՝ հեռուստացույցներն իրենք են ցուցադրում) սխեմայում կարող է լինել 0-ից մինչև անսահմանություն:

Եթե ​​վերը նշված սխեման օգտագործվում է հեռուստատեսային ծրագրի ուղեցույցի XML նկարագրության ճշգրտությունը վերահսկելու համար, ապա օգտագործված սխեման պետք է նշվի XML փաստաթղթի վերնագրում: Այնուհետև ORT ալիքի հեռուստահաղորդման XML նկարագրությունը կունենա հետևյալ տեսքը.

Ռուսաստան Սանկտ Պետերբուրգ Բարի առավոտ ԼՈՒՐԵՐ Նուրբ թույն սերիա Հրաշքների դաշտ (կրկնել) Մ.ֆ. Առողջություն ԼՈՒՐԵՐ Վայելեք ձեր լոգանքը: Մ.ֆ. Միասին ԼՈՒՐԵՐ լավագույն ժամ ԼՈՒՐԵՐ Եղանակ GOOG գիշեր երեխաներ ԺԱՄԱՆԱԿ Տեսողություն

Այժմ արմատային տարրը այս XML նկարագրությունն ունի xmlns="x-schema:TV-ProgramSchema.xml" հատկանիշը, որը հղում է օգտագործված XML սխեմային:

XML փաստաթղթերի վերլուծություն

Տրվում է XML փաստաթղթից տվյալների ստացում, ինչպես նաև XML փաստաթղթերի ճշգրտության ստուգում անալիզատորներ(վերլուծիչներ) XML փաստաթղթեր: Եթե ​​XML փաստաթուղթը պաշտոնապես ճիշտ է, ապա XML փաստաթղթերը վերլուծելու համար նախատեսված բոլոր վերլուծիչները կկարողանան ճիշտ աշխատել դրա հետ:

Քանի որ DTD-ների օգտագործումը XML-ում պարտադիր չէ, ցանկացած պաշտոնական վավեր փաստաթուղթ կարող է ճանաչվել և վերլուծվել XML փաստաթղթերը վերլուծելու համար նախատեսված ծրագրի կողմից: Օրինակ, այս փաստաթղթում տրված ցանկացած XML նկարագրություն ֆորմալ առումով ճիշտ է, ուստի այն ճիշտ կճանաչվի ցանկացած XML վերլուծողի կողմից:

Եթե ​​XML վերլուծիչը ստանում է XML փաստաթուղթ, որն օգտագործում է XML սխեման որպես մուտքագրում, ապա այն կվերլուծվի, կստուգվի ճշտության և սխեմային համապատասխանության համար: Օրինակ, TV-ProgramSchema.xml սխեմայով RTR ալիքի հեռուստահաղորդումների ուղեցույցի XML նկարագրությունը կճանաչվի որպես պաշտոնապես ճիշտ և վավեր:

XML վերլուծիչները թույլ են տալիս, եթե փաստաթղթում նշված լեզվական կոնստրուկցիաները շարահյուսորեն ճիշտ են, ճիշտ հանել իրենց կողմից սահմանված փաստաթղթի տարրերը և փոխանցել դրանք կիրառական ծրագրին, որն իրականացնում է ցուցադրման անհրաժեշտ գործողությունները: Այսինքն, XML փաստաթուղթը վերլուծելուց հետո, շատ դեպքերում, կիրառական ծրագրին տրամադրվում է օբյեկտի մոդել, որը ցուցադրում է ստացված XML փաստաթղթի բովանդակությունը և դրա հետ աշխատելու համար անհրաժեշտ գործիքները (քայլել տարրի ծառի միջով):

Քանի որ XML-ը, ի տարբերություն HTML-ի, ոչ մի կերպ չի սահմանում, թե ինչպես են ցուցադրվում և օգտագործվում իր հետ նկարագրված փաստաթղթի տարրերը, XML վերլուծողին հնարավորություն է տրվում ընտրել ցանկալի դիզայնը:

Ինչպես արդեն նշվեց, XSL աղյուսակները կարող են օգտագործվել XML տարրերի տեսքը սահմանելու համար: XML փաստաթղթերի մշակման սկզբունքը ոճային թերթիկների միջոցով հետևյալն է. XSL փաստաթուղթը վերլուծելիս վերլուծիչ ծրագիրը մշակում է այս լեզվի հրահանգները և վերագրում է մի շարք պիտակներ XML ծառի յուրաքանչյուր տարրին, որը որոշում է այս տարրի ձևաչափումը: Այսինքն՝ XSL աղյուսակների օգնությամբ նշվում է XML տարրերի ֆորմատավորման կաղապար, և այս կաղապարն ինքնին կարող է ունենալ XML փաստաթղթի համապատասխան հատվածի կառուցվածք։ XSL հայտարարությունները սահմանում են XML տարրի ճշգրիտ գտնվելու վայրը ծառում, ուստի հնարավոր է կիրառել տարբեր ոճավորում նույն տարրի վրա՝ կախված այն կոնտեքստից, որում այն ​​օգտագործվում է:

Որոշ վերլուծիչներում փաստաթղթի կառուցվածքի ներկայացման ձևը հիմնված է Document Object Model (DOM) բնութագրման վրա, որը թույլ է տալիս խիստ հիերարխիկ DOM օգտագործել XML փաստաթղթեր ստեղծելիս:

XML վերլուծիչի օրինակ է ներկառուցված Microsoft Internet-ը: Explorer տարբերակը 5.0 XML վերլուծիչ MSXML: Այն թույլ է տալիս կարդալ տվյալները XML ֆայլից, մշակել այն, ստեղծել տարրերի ծառ, ցուցադրել տվյալները՝ օգտագործելով XSL ոճային թերթիկներ և ներկայացնել բոլոր տվյալների տարրերը որպես օբյեկտներ՝ օգտագործելով DOM-ը:

Օգտագործելով XML

Շատերը XML-ի մասին պատկերացնում են որպես նոր տեխնոլոգիածրագրային բաղադրիչների ինտեգրում: XML-ի օգտագործման հիմնական առավելություններն են.

• Տարբեր աղբյուրներից ստացված տվյալների ինտեգրում: XML-ը կարող է օգտագործվել եռաստիճան վեբ համակարգերի, տվյալների բազաների միջին մակարդակում տարասեռ կառուցվածքային տվյալները համադրելու համար:
• Տեղական տվյալների մշակում. XML ձևաչափով ստացված տվյալները կարող են վերլուծվել, մշակվել և ցուցադրվել անմիջապես հաճախորդի վրա՝ առանց սերվերի լրացուցիչ զանգերի:
• Տվյալների դիտում և շահարկում տարբեր բաժիններում:Ստացված տվյալները հաճախորդի կողմից կարող են մշակվել և դիտվել տարբեր ձևերով՝ կախված վերջնական օգտագործողի կարիքներից:
• Տվյալների մասնակի թարմացման հնարավորություն։ XML-ով դուք կարող եք թարմացնել միայն կառուցվածքային տվյալների այն մասը, որը փոխվել է, այլ ոչ թե ամբողջ կառուցվածքը:

Այս բոլոր առավելությունները XML-ին դարձնում են անփոխարինելի գործիք տվյալների բազայի ճկուն որոնումների, հզոր եռաստիճան վեբ հավելվածների և գործարքներին աջակցող հավելվածների մշակման համար: Այլ կերպ ասած, XML-ի միջոցով հնարավոր է հարցումներ ձևավորել տարբեր կառույցների տվյալների շտեմարաններում, ինչը թույլ է տալիս տեղեկատվություն փնտրել միմյանց հետ անհամատեղելի բազմաթիվ տվյալների բազաներում: XML-ի օգտագործումը եռաստիճան վեբ հավելվածների միջին շերտում թույլ է տալիս տվյալների արդյունավետ փոխանակում էլեկտրոնային առևտրի համակարգերի հաճախորդների և սերվերների միջև:

Բացի այդ, XML լեզուն կարող է օգտագործվել որպես այլ լեզուների քերականությունը նկարագրելու և փաստաթղթերի ճշգրտությունը վերահսկելու գործիք:

XML ձևաչափով ստացված տվյալների մշակման գործիքները կարող են մշակվել Visual Basic, Java կամ C++ միջավայրում։

Այս բաժինը XML-ի հետ աշխատելու մասին է: Այն կներառի ինչպես տեսական, այնպես էլ գործնական նյութ։ Կդիտարկվեն հիմնական գործառնությունները XML ֆայլերի հետ, ինչպես նաև փոխազդեցությունը LINQ-ի հետ և շատ ավելին:

XML ֆայլի ստեղծում

XML(Extensible Markup Language) - ընդարձակվող նշագրման լեզու, որն օգտագործվում է տվյալների բազաներ, վեբ էջեր ստեղծելու համար, օգտագործվում է ծրագրերի միջև տեղեկատվության փոխանակման համար, օգտագործվում է այնպիսի տեխնոլոգիաներում, ինչպիսիք են 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» տարր:

Արմատային տարրը հայտարարելուց հետո կարող եք ցանկացած քանակի տարրեր ավելացնել ձեր . Բոլոր ավելացված տարրերը պետք է տեղադրվեն արմատային տարրի պիտակների միջև:

«գրադարան»-ը գրքի տարր պարունակող արմատային տարրն է, որը պարունակում է ներդիր տարրեր՝ վերնագիր, հեղինակ, տարի։

xml ֆայլի հատկանիշներ

Հատկանիշները սահմանվում են ցանկացած տարրի բացման պիտակում:

Շարահյուսություն. անուն = «արժեք» փակցված է կրկնակի չակերտների մեջ:

Կարող է լինել ցանկացած թվով հատկանիշ, բայց դրանք չպետք է կրկնվեն, և դրանց անունները չպետք է պարունակեն բացատներ:

• սխալ
• սխալ

Սխալ, կան երկու կրկնօրինակ «id» հատկանիշ, և id-ի և թվի միջև կա բացատ:

• Ճիշտ
• Ճիշտ

հետո XML փաստաթուղթստեղծված, այն պետք է պահպանվի, և մի մոռացեք փոխել ֆայլի ընդլայնումը:

• ֆայլի անուն.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-ը ոչինչ չի անում: Նշման այս լեզուն ստեղծվել է տեղեկատվության կառուցվածքի, պահպանման և հաղորդակցման համար: Հետևյալ օրինակը Anton Ire-ի գրառումն է, որը ներկայացված է XML-ով.

Իրա

Անտոն

Հիշեցում

Մի մոռացեք հանդիպել այս շաբաթ:

Ինչպես տեսնում եք, XML լեզուն շատ հակիրճ է:

Մի նշում ( ) բաղկացած է վերնագրից ( ) և բովանդակությունը ( ) նամակներ. Այն պարունակում է ուղարկողին (պիտակ - «ումից է նամակը») և ստացողը (պիտակ - "ում"). Բայց այս նամակը ոչինչ չի անում։ Սա պիտակների մեջ փաթաթված մաքուր տեղեկատվություն է: Այս տեղեկատվությունը ուղարկելու, ստանալու և ցուցադրելու համար ինչ-որ մեկը պետք է ծրագիր գրի:

XML-ը անվճար ընդարձակվող նշագրման լեզու է

XML պիտակները նախապես սահմանված չեն: Դուք կարող եք մուտքագրել ձեր սեփական պիտակները:

HTML-ում պիտակները և փաստաթղթի կառուցվածքը նախապես սահմանված են: html փաստաթղթի ստեղծողը կարող է օգտագործել միայն ստանդարտներով սահմանված պիտակները։

XML-ը թույլ է տալիս մուտքագրել ձեր թեգերը և փաստաթղթի կառուցվածքը xml փաստաթղթի հեղինակին: Օրինակում ցուցադրված պիտակները (օրինակ, Եվ ) սահմանված չեն XML ստանդարտով: Այս թեգերը ներկայացվել են փաստաթղթի հեղինակի կողմից:

XML-ը HTML-ի լրացումն է

XML-ը չի փոխարինում HTML-ին:

Կարևոր է հասկանալ, որ XML-ը չի փոխարինում HTML-ին: Ապագայում վեբ մշակողները կօգտագործեն XML տվյալները նկարագրելու համար, մինչդեռ HTML-ը կօգտագործվի այդ տվյալները ձևաչափելու և ցուցադրելու համար:

XML-ի իմ լավագույն սահմանումը սա է.

Նշում. Cross-platform - հարմար է ցանկացած օպերացիոն համակարգի և ցանկացած սարքավորման համար:

Եթե ​​գիտեք, որ կան տարբեր ՕՀ, բացառությամբ ծանոթ Windows-ի: Սրանք են OS Linux, Mac և այլն:

Ինչ վերաբերում է ապարատային, ապա կարող ենք ասել հետևյալը՝ դա կարող է լինել սովորական ԱՀ, նոթբուք, PDA և այլն։

XML-ը վեբ զարգացման ապագայում

XML-ը կօգտագործվի ամենուր:

Մենք XML-ի զարգացման ականատեսն ենք նրա սկզբից: Զարմանալի էր տեսնել, թե որքան արագ է մշակվել XML ստանդարտը և որքան արագ են ծրագրային ապահովման մեծ թվով վաճառողներ ընդունել ստանդարտը: Մենք խորապես հավատում ենք, որ XML-ը նույնքան կարևոր կլինի ինտերնետի ապագայի համար, որքան HTML-ը, որը համացանցի հիմքն է, և որ XML-ը կլինի ամենալայն կիրառվող գործիքը բոլոր տվյալների մանիպուլյացիայի և հաղորդակցման համար: