XPath ტესტერი — XPath გამოსახულებების შეფასება XML/HTML დოკუმენტებზე

XPath არის მოთხოვნის ენა, რომელიც გამოიყენება XML (ან HTML) დოკუმენტიდან კვანძების ასარჩევად გზის გამოსახულებების საშუალებით, ისევე როგორც ფაილის გზა ირჩევს ფაილს საქაღალდეთა სტრუქტურაში. ეს ხელსაწყო საშუალებას გაძლევთ ჩასვათ ნებისმიერი XML, დაწეროთ XPath გამოსახულება და დაუყოვნებლივ ნახოთ, რომელი კვანძები ემთხვევა — მათ შორის კვანძების რაოდენობა, სერიალიზებული გამოტანა და ნათელი შეცდომის შეტყობინებები არასწორი XML-ის ან არასწორი XPath სინტაქსისთვის. ის მთლიანად თქვენს ბრაუზერში მუშაობს, ყოველი თანამედროვე ბრაუზერის ჩაშენებული `document.evaluate` ძრავის გამოყენებით, ასე რომ, რასაც ჩასვამთ, არასდროს იტვირთება არსად.

რა არის ეს ხელსაწყო?

XPath (XML Path Language) არის W3C-ის სტანდარტი კვანძების — ელემენტების, ატრიბუტების, ტექსტის — ნავიგაციისა და არჩევისთვის XML დოკუმენტის შიგნით, კომპაქტური, გზის მსგავსი სინტაქსით, მაგალითად, `//book[price>30]/title` ირჩევს ყველა `<title>`-ს, რომლის მეზობელი `<price>` ელემენტი 30-ზე მეტია, დოკუმენტის ნებისმიერ ადგილას. მას იყენებენ XSLT სტილის ფურცლები, XML ვალიდაციის ხელსაწყოები, ვებ სქრეპერები, ბრაუზერის ავტომატიზაციის ჩარჩოები (Selenium, Playwright) და ბევრი პროგრამირების ენის XML ბიბლიოთეკები.

მიმდინარე ვერსია, რომელსაც ყველა მთავარი ბრაუზერი — Chrome, Firefox, Safari, Edge — ახორციელებს, არის XPath 1.0, 1999 წლის ორიგინალური W3C რეკომენდაცია. ეს ხელსაწყო იყენებს ზუსტად იმავე ჩაშენებულ ძრავას ბრაუზერის `document.evaluate()` API-ის მეშვეობით, ასე რომ, აქ მიღებული შედეგები ემთხვევა იმას, რასაც მიიღებდით ბრაუზერის დეველოპერულ ხელსაწყოებში ან ბრაუზერში გაშვებულ ნებისმიერ JavaScript-ში. ის არ ახორციელებს შემდგომ XPath 2.0/3.0/3.1 სპეციფიკაციებს (ისინი ამატებენ ისეთ ფუნქციებს, როგორიცაა `for`, თანმიმდევრობები და regex-ით დამთხვევა) — იხილეთ ხშირად დასმული კითხვები, თუ ეს პრაქტიკულად რას ნიშნავს.

გამოსახულებამ შეიძლება დააბრუნოს ორი სახის შედეგიდან ერთ-ერთი: კვანძთა ნაკრები (node-set — ნული ან მეტი დამთხვეული ელემენტი, ატრიბუტი ან ტექსტური კვანძი, რომელსაც ეს ხელსაწყო სერიალიზებს და თითო ხაზზე ერთს ჩამოთვლის რაოდენობასთან ერთად), ან სკალარული მნიშვნელობა — რიცხვი, სტრიქონი ან ლოგიკური მნიშვნელობა — როდესაც თავად გამოსახულება ითვლის მნიშვნელობას, როგორიცაა `count(//book)` ან `//book[1]/title = 'Dune'`.

რატომ გამოვიყენო ის?

გამართეთ XPath გამოსახულება, სანამ მას მყარად ჩააშენებთ ვებ სქრეპერში, Selenium/Playwright ტესტში ან XSLT სტილის ფურცელში.
სწრაფად შეამოწმეთ, ირჩევს თუ არა მოცემული XPath თქვენთვის მოსალოდნელ კვანძს რეალური XML/HTML ნიმუშიდან.
ნახეთ დამთხვევების ზუსტი რაოდენობა და სერიალიზებული გამოტანა, კოდიდან გამოცნობის ნაცვლად.
მიიღეთ დაუყოვნებელი, გასაგები შეცდომის შეტყობინებები დაზიანებული XML-ისთვის ან არასწორი XPath სინტაქსისთვის, ბუნდოვანი stack trace-ის ნაცვლად.
100% მუშაობს კლიენტის მხარეს: თქვენი XML და გამოსახულება არასდროს ტოვებს თქვენს ბრაუზერს.

როგორ გამოვიყენო

ჩასვით ან შეასწორეთ თქვენი XML (ან HTML) შეყვანის ველში — წიგნის მაღაზიის ნიმუშ დოკუმენტი უკვე შევსებულია, რათა დაუყოვნებლივ ნახოთ მისი მუშაობა.
აკრიფეთ XPath გამოსახულება გამოსახულების ველში, ან შეასწორეთ წინასწარ შევსებული მაგალითი.
დააჭირეთ „Evaluate“-ს (ან Enter-ს გამოსახულების ველში).
წაიკითხეთ დამთხვეული კვანძები ქვემოთ, რაოდენობა ზემოთ ჩანს; სკალარული შედეგები (რიცხვები, სტრიქონები, ლოგიკური მნიშვნელობები) ნაჩვენებია პირდაპირ.
თუ XML ან გამოსახულება არასწორია, შედეგების ნაცვლად გამოჩნდება კონკრეტული შეცდომის შეტყობინება.

მაგალითი

შეყვანა

XML:
<bookstore>
  <book><title>The Great Gatsby</title><price>12.99</price></book>
  <book><title>Learning XPath</title><price>34.50</price></book>
  <book><title>Dune</title><price>45.00</price></book>
</bookstore>

XPath: //book[price>30]/title

შედეგი

✓ 2 node(s) matched
<title>Learning XPath</title>
<title>Dune</title>

3 წიგნიდან მხოლოდ 2-ს აქვს 30-ზე მაღალი ფასი, ასე რომ, ბრუნდება ზუსტად 2 <title> ელემენტი — მესამე წიგნი (Gatsby, $12.99) სწორად არის გამორიცხული.

XPath და CSS სელექტორები — მიმოხილვა

ორივე ენა ირჩევს კვანძებს დოკუმენტიდან, მაგრამ სხვადასხვა პრობლემას წყვეტს. გამოიყენეთ ეს ცხრილი, რომ მოცემული ამოცანისთვის სწორი ხელსაწყო აირჩიოთ.

შესაძლებლობა	XPath	CSS სელექტორები
შერჩევა ტეგის/კლასის/ID-ის მიხედვით ქვემოთ	დიახ	დიახ — და, ჩვეულებრივ, უფრო სწრაფად
შერჩევა ხილული/ტექსტური შინაარსის მიხედვით	დიახ — `contains(text(),'x')`	არა
ზემოთ, მშობელთან/წინაპართან გადაადგილება	დიახ — `//div[span]/..`	არა (`:has()` არის ახალი, ნაწილობრივი გამონაკლისი)
მეზობელი მნიშვნელობების შედარება (მაგ. `price>30`)	დიახ	არა
მუშაობს ბრაუზერის გარეთაც (სერვერის მხარის XML ხელსაწყოები, XSLT)	დიახ	არა — CSS სელექტორები სპეციფიკურია ბრაუზერისთვის/DOM-ისთვის

დაკავშირებული ხელსაწყოები

მუშაობთ სტრუქტურირებული მონაცემთა ფორმატებთან? ეს ხელსაწყოები კარგად ერწყმის XPath ტესტირებას.

→

ხშირად დასმული კითხვები

რისთვის გამოიყენება XPath?

XPath ირჩევს კვანძებს — ელემენტებს, ატრიბუტებს ან ტექსტს — XML ან HTML დოკუმენტიდან გზის სინტაქსის საშუალებით. ეს არის შერჩევის ენა XSLT ტრანსფორმაციების, ბევრი XML ვალიდატორის მიღმა, და ფართოდ გამოიყენება ვებ სქრეპინგსა და ბრაუზერის ტესტების ავტომატიზაციაში (Selenium, Playwright, Cypress) გვერდზე ელემენტების მოსაძებნად, განსაკუთრებით მაშინ, როცა მხოლოდ CSS სელექტორები ვერ გამოხატავენ საჭირო პირობას.

XPath თუ CSS სელექტორები — რომელი გამოვიყენო?

ისინი ნაწილობრივ ერთმანეთს ემთხვევა, მაგრამ ეკვივალენტური არ არის. XPath-ს შეუძლია მშობლის შერჩევა შვილის შინაარსის მიხედვით (`//div[span='Total']`), ზემოთ, წინაპრებამდე გადაადგილება, და ხილული ტექსტის მიხედვით შერჩევა (`//button[contains(text(),'Submit')]`) — CSS სელექტორებს არ შეუძლიათ ხისებრ სტრუქტურაში ზემოთ ასვლა და საერთოდ ვერ ახდენენ დამთხვევას ტექსტური შინაარსის მიხედვით. თუ უბრალოდ ირჩევთ ტეგის, კლასის ან ID-ის მიხედვით დოკუმენტში ქვემოთ, CSS სელექტორების დაწერა უფრო მარტივია და, ზოგადად, უფრო სწრაფად ფასდება. XPath-ს მიმართეთ სპეციალურად მაშინ, როცა გჭირდებათ „აირჩიე ამ ტექსტის მშობელი“ ან „აირჩიე იმის მიხედვით, რასაც ელემენტი ამბობს“, და არა მხოლოდ იმის მიხედვით, რა ტეგი ან კლასი აქვს.

უჭერს თუ არა მხარს ეს ხელსაწყო XPath 2.0 ან 3.0 ფუნქციებს?

არა — და არც ერთი ბრაუზერი არ უჭერს მხარს. ბრაუზერები ახორციელებენ XPath 1.0-ს (1999 წლის W3C რეკომენდაცია) `document.evaluate()`-ის მეშვეობით, და ეს ხელსაწყო იყენებს ზუსტად იმავე ჩაშენებულ ძრავას, ასე რომ ის ზუსტად შეესაბამება იმას, რასაც მიიღებდით იმავე გამოსახულების გაშვებით ბრაუზერის დეველოპერულ ხელსაწყოებში ან JavaScript-ში. XPath 2.0/3.0/3.1-ში დანერგილი ფუნქციები და შესაძლებლობები (როგორიცაა `for` გამოსახულებები, თანმიმდევრობები, ან regex-იანი `matches()`) ხელმისაწვდომი არ არის — აქ მუშაობს მხოლოდ 1.0 ვერსიის ფუნქციები, როგორიცაა `contains()`, `starts-with()`, `substring()`, `count()`, `position()` და `last()`.

რომელი გავრცელებული XPath გამოსახულებები უნდა ვიცოდე?

`//tag` ირჩევს ყველა `<tag>`-ს დოკუმენტის ნებისმიერ ადგილას. `//tag[@attr='value']` ირჩევს `<tag>` ელემენტებს, რომელთა `attr` ატრიბუტი უტოლდება `value`-ს. `//tag[contains(text(),'x')]` ირჩევს `<tag>` ელემენტებს, რომელთა უშუალო ტექსტი შეიცავს `x`-ს. `//tag[1]` ირჩევს პირველ `<tag>` მეზობელს თითოეულ მშობელში. `//parent/child` ირჩევს `<child>` ელემენტებს, რომლებიც `<parent>`-ის უშუალო შვილები არიან. `count(//tag)` აბრუნებს რიცხვს კვანძთა ნაკრების ნაცვლად.

ამუშავებს თუ არა ეს ხელსაწყო XML სახელთა სივრცეებს (namespaces)?

სუფთად მხოლოდ ჩვეულებრივი, სახელთა სივრცის გარეშე შემთხვევა არის მხარდაჭერილი, რაც მოიცავს ხელით დაწერილი ან სქრეპილი XML/HTML-ის დიდ უმრავლესობას. თუ თქვენი დოკუმენტი აცხადებს XML სახელთა სივრცეს (მაგ. `xmlns="..."` root ელემენტზე), `document.evaluate` მოითხოვს სახელთა სივრცის შემცნობ resolver ფუნქციას, რომელიც პრეფიქსებს URI-ებზე ასახავს, რასაც ეს მარტივი ხელსაწყო არ აწყობს — სახელთა სივრცის მქონე XML-ის მიმართ გამოსახულებებმა შეიძლება ნული დამთხვევა დააბრუნონ, თუნდაც სწორად გამოიყურებოდნენ. ეს ცნობილი შეზღუდვაა, არა შეცდომა: მოაშორეთ სახელთა სივრცის დეკლარაცია თქვენს ნიმუშს, ან გამოსავლად გამოიყენეთ local-name() ფუნქცია (მაგ. `//*[local-name()='title']`).

იგზავნება თუ არა ჩემი XML ან XPath გამოსახულება სერვერზე?

არა. ყველაფერი მუშაობს ლოკალურად, თქვენი ბრაუზერის ჩაშენებული `DOMParser`-ისა და `document.evaluate()`-ის გამოყენებით — იმავე ძრავით, რომელსაც თქვენი ბრაუზერი უკვე შინაგანად იყენებს. ის, რასაც აკრეფთ ან ჩასვამთ, არასდროს ტოვებს თქვენს მოწყობილობას.