Comment fonctionne XPath. Technologie XPath. Utiliser les fonctions PHP avec XPath
Solution standard via xsl : choisir et ses inconvénients
De tels problèmes dans XSLT sont traditionnellement résolus de cette manière :
< xsl : choose > < xsl : when essai = " $cond " > < xsl : copy-of sélectionner = " un $ " /> < xsl : otherwise > < xsl : copy-of sélectionner = " deux $ " />Cependant, cette solution, outre la lourdeur évidente, présente un autre, très inconvénient majeur: ce qui en résulte est RTF. Ceux. le résultat d'une telle expression est acceptable dans le flux de sortie, mais ne peut en aucun cas être utilisé (par au moins dans le cadre du XSLT 1.0 "pur", sans extensions) pour les transformations ultérieures.
Bien sûr, en utilisant exsl:node-set (ou son équivalent), nous pouvons transformer ce RTF en un ensemble de nœuds à part entière, mais il y aura un problème : il nouveau un ensemble de nœuds qui ne sont en aucun cas connectés aux documents sources. Le nœud obtenu à la suite de la transformation sera son nœud racine - nous ne pourrons plus lui appliquer, par exemple, l'axe ancêtre.
Essayons de surmonter cet inconvénient.
Solution basée sur XPath 1.0 pur
Solution
Profitons du fait que lors de la spécification des axes d'échantillonnage, nous pouvons utiliser des prédicats qui leur imposent des conditions limites : $one[$cond] | deux $.
Ses inconvénients
Cette expression est dépourvue des inconvénients de la version « classique », mais elle a les siens, les « complétant » :
- Si xsl:choose ne peut pas être utilisé (de manière multiprocesseur) pour obtenir des ensembles de nœuds, alors cette option, au contraire, peut fonctionner seulement avec des ensembles de nœuds comme paramètres et résultat.
Ceux. l'exemple donné fonctionnera seulement si $one et $two sont des ensembles de nœuds. Insérer une chaîne ou un nombre dans cette expression ne fonctionnera plus.
- Si dans l'exemple vous utilisez une expression complexe au lieu de la variable $cond, le résultat de son évaluation peut dépendre du contenu de $one et $two .
Par exemple $one | $two - la valeur de count(.) sera différente dans les deux cas, et pas du tout ce que l'hypothétique auteur potentiel d'une telle expression aurait évidemment en tête...
- L'expression originale est assez difficile à comprendre. Lorsque j'ai donné un exemple de son utilisation dans le forum, j'ai dû entendre des commentaires qui « en fait | en xslt, ce n'est pas un or , mais une union d'ensembles de nœuds..."
Absolument vrai, mais ou dans XPath ne fonctionne pas comme la plupart des utilisateurs sont habitués langues vivantes. Il renvoie le résultat déjà converti en type booléen, ce qui le rend totalement inadapté à cette tâche. Et ici, il est nécessaire d'utiliser une union avec vérification ultérieure, même si cela n'est pas évident.
- Lors du traitement de cette expression, les calculs sont effectués les deux succursales et alors seulement leur conformité à la condition est vérifiée. Bien que cela ne pose presque jamais de problèmes (expressions XSLT je ne devrais pas ont des effets secondaires) - parfois, cela reste important.
Déclaration "Aucune fonction dans XSLT n'a d'effets secondaires" — faux . En plus des fonctions des extensions (et il est tout à fait possible qu'elles aient des effets secondaires), il existe au moins un Il s'agit d'une fonctionnalité incluse dans la spécification XSLT 1.0. Il s'agit de la fonction document : en effet, presque personne ne prétendrait que l'appel de document("http://example.com/cgi-bin/counter.pl") n'aura pas d'effets secondaires...
Notons d'emblée qu'il est impossible de pallier ces défauts de cette expression dans le cadre du XSLT 1.0 « pur » (c'est-à-dire sans extensions). Dans ce cas, il ne reste plus qu'à suggérer d'utiliser cette option si nous avons besoin d'un ensemble de nœuds en sortie, et l'option « classique » dans tous les autres cas.
Utiliser les extensions EXSLT
Si nous réduisons les exigences de compatibilité et autorisons l'utilisation d'EXSLT, nous avons alors une excellente opportunité d'écrire notre propre fonction qui émule opérateur ternaire dépourvu de la plupart de ces inconvénients.
Pour créer des fonctions d'extension, EXSLT fournit les éléments func:function et func:result, où le préfixe func: correspond à xmlns http://exslt.org/functions .
Le premier correspond presque exactement à l’élément xsl:function XSLT 2.0. Il n’existe pas d’analogue au résultat ; la syntaxe standard du constructeur de séquence est utilisée pour créer des valeurs de retour.
Solution pour le cas général
Alors, définissons notre propre fonction d'extension (lib: est le préfixe de notre propre espace de noms, disons urn:xslt:library) :
< func : function nom = " lib:si " >Notre exemple d'utilisation s'écrira ainsi : lib:if($cond, $one, $two) .
S'il y a des effets secondaires
La version ci-dessus est dépourvue de nombreux inconvénients inhérents à solutions standards. Il est compact, facile à comprendre, peut être utilisé avec des arguments de tout type et $cond est évalué lorsque la fonction est appelée. Cependant, un problème demeure : les deux les paramètres restants sont également calculés au moment de l'appel de la fonction.
Dans la plupart des cas, cela peut être ignoré. Mais si nos arguments ont effets secondaires- c'est inacceptable. Par conséquent, pour résoudre ce problème, nous utiliserons une autre fonction EXSLT - dyn:evaluate, où xmlns:dyn = "http://exslt.org/dynamic" . Comme vous pouvez le deviner, il prend une chaîne comme argument et l'évalue comme une expression XPath. directement dans ce contexte, dans lequel il est appelé :
< func : function nom = " lib:if-dyn " >Ainsi, toute expression que nous transmettons à cette fonction est comme une ficelle, ne l'oublie pas- ne sera calculé que s'il est effectivement utilisé. Mais il convient de noter que lib:if devrait généralement s'exécuter plus rapidement (et ne nécessite pas un autre module d'extension) - donc si nous n'avons pas besoin de cette fonctionnalité supplémentaire, Toujours lib:if doit être utilisé.
Exemples d'utilisation de XPath à partir de la pratique d'analyse des informations provenant de sites Web. Des sections du code XPath sont affichées.
Obtenir le texte du titre h1
//h1/texte()
Obtenir le texte du titre avec la classe productName
//h1[@class="produnctName"]/text()
Obtenez la valeur d'une étendue spécifique par classe
//durée[@class="prix"]
Obtenez de la valeur attribut de titre pour un bouton avec la classe addtocart_button
//entrée[@class="addtocart_button"]/@title
//a/texte()
//a/@href
Source de l'image
//img/@src
L'image est immédiatement après un certain élément dans le DOM, l'axe suit
//h1[@class="produnctName"]//following::div/img/@src
Image en 4 divs selon le compte
//div/img/@src
XPath(XML Path Language) - langage de requête pour Éléments XML-document. Conçu pour donner accès à des parties d'un document XML dans des fichiers de transformation XSLT et constitue une norme du W3C. XPath est conçu pour implémenter la navigation DOM en XML.
XML a une structure arborescente. Un élément d'arbre a toujours des descendants et des ancêtres, à l'exception de l'élément racine, qui n'a pas d'ancêtres, ainsi que des éléments sans issue (feuilles d'arbre), qui n'ont pas de descendants.
A chaque étape du chemin, des éléments sont sélectionnés qui répondent aux conditions de sélection à cette étape, et suite à l'accès au document le long du chemin, un ensemble d'éléments est obtenu qui satisfont ce chemin.
Fonctions sur les ensembles de nœuds
- * - désigne n'importe lequel un nom ou un ensemble de caractères le long de l'axe spécifié, par exemple : * - n'importe quel nœud enfant ; @* — n'importe quel attribut.
- $name - accès à une variable, où name est le nom de la variable ou du paramètre.
- — conditions supplémentaires des échantillons ou, ce qui revient au même, un prédicat d'étape d'adressage. Doit contenir une valeur booléenne. S'il contient une valeur numérique, il est considéré comme le numéro de série du nœud, ce qui équivaut à préfixer ce numéro par l'expression « position()= »
- () - s'il est utilisé dans une balise d'un autre langage (par exemple HTML), alors le processeur XSLT considère le contenu accolades comme XPath.
- / - détermine le niveau de l'arborescence, c'est-à-dire qu'il sépare les étapes d'adressage
- | — combine le résultat. Autrement dit, vous pouvez écrire plusieurs chemins d'analyse en utilisant le signe | et le résultat d’une telle expression inclura tout ce qui est trouvé par n’importe lequel de ces chemins.
- ensemble de nœuds nœud()
Renvoie tous les nœuds. Le substitut "*" est souvent utilisé à la place de cette fonction, mais contrairement à l'astérisque, la fonction node() renvoie également texte nœuds.
- chaîne texte()
Renvoie un ensemble de nœuds de texte ;
- ensemble de nœuds actuel()
Renvoie un ensemble d'un élément qui est l'élément actuel. Si nous fixons le traitement avec des conditions, alors le seul moyen Cette fonction atteindra de cette condition à l'élément courant.
- nombre position()
Renvoie la position d'un élément dans un ensemble. Fonctionne correctement uniquement en boucle
- nombre dernier()
Renvoie le numéro du dernier élément d'un ensemble. Fonctionne correctement uniquement en boucle
- nombre compter(ensemble de nœuds)
Renvoie le nombre d'éléments dans un ensemble de nœuds.
- chaîne nom(ensemble de nœuds ?)
Retours nom et prénom la première balise de l’ensemble.
- chaîne espace de noms-uri(ensemble de nœuds ?)
- chaîne nom-local(ensemble de nœuds ?)
Renvoie le nom de la première balise de l'ensemble, sans espace de noms.
- ensemble de nœuds identifiant(objet)
Recherche un élément avec un identifiant unique
Les haches sont base Langage XPath. Certains axes ont des abréviations.
- ancêtre::- Renvoie de nombreux ancêtres.
- ancêtre ou soi ::— Renvoie l'ensemble des ancêtres et l'élément actuel.
- attribut::— Renvoie un ensemble d'attributs de l'élément actuel. Cet appel peut être remplacé par «@»
- enfant::— Renvoie un ensemble d'enfants un niveau en dessous. Ce nom est complètement abrégé, c'est-à-dire qu'il peut être complètement omis.
- descendant::— Renvoie l'ensemble complet des enfants (c'est-à-dire les enfants immédiats et tous leurs enfants).
- descendant ou soi-même ::— Renvoie l'ensemble complet des enfants et l'élément actuel. L'expression "/descendant-or-self::node()/" peut être raccourcie en «//» . En utilisant cet axe, par exemple, vous pouvez organiser la sélection d'éléments à partir de n'importe quel nœud, et pas seulement à partir de la racine, dans un deuxième temps : il suffit de prendre tous les descendants de la racine dans un premier temps. Par exemple, le chemin "//span" sélectionnera tous les nœuds span du document, quelle que soit leur position dans la hiérarchie, en regardant à la fois le nom de l'élément racine et les noms de tous ses enfants, dans toute la profondeur de leur nidification.
- suivant::— Renvoie l'ensemble brut sous l'élément actuel.
- frère-sœur suivant : :— Renvoie l'ensemble des éléments au même niveau suivant celui actuel.
- espace de noms ::— Renvoie un ensemble qui a un espace de noms (c'est-à-dire que l'attribut xmlns est présent).
- mère::— Renvoie l'ancêtre d'un niveau en arrière. Cet appel peut être remplacé par «..»
- précédent:— Renvoie l'ensemble des éléments traités à l'exclusion de l'ensemble des ancêtres.
- frère-sœur précédent : :— Renvoie l'ensemble des éléments au même niveau précédant celui actuel.
- soi::— Renvoie l'élément actuel. Cet appel peut être remplacé par «.»
- Tutoriel
Traduction continue de la documentation non officielle de Selenium pour Python.
Traduction réalisée avec la permission de l'auteur Baiju Muthukadan.
L'original peut être trouvé.
1.Installation
2. Premiers pas
3. Navigation
4. Rechercher des éléments
5. Attentes
6. Objets de page
7. API WebDriver
8. Annexe : Foire aux questions
4. Rechercher des éléments
Il existe plusieurs façons de rechercher des éléments sur une page. Vous avez le droit d'utiliser le plus approprié tâches spécifiques. Selenium fournit les méthodes suivantes pour rechercher des éléments sur une page :- find_element_by_id
- find_element_by_name
- find_element_by_xpath
- find_element_by_link_text
- find_element_by_partial_link_text
- find_element_by_tag_name
- find_element_by_class_name
- find_element_by_css_selector
- find_elements_by_name
- find_elements_by_xpath
- find_elements_by_link_text
- find_elements_by_partial_link_text
- find_elements_by_tag_name
- find_elements_by_class_name
- find_elements_by_css_selector
En plus des méthodes publiques répertoriées ci-dessus, il existe deux méthodes privées qui peuvent être très utiles si vous connaissez les pointeurs d'objet de page : find_element et find_elements.
Exemple d'utilisation :
Depuis l'importation selenium.webdriver.common.by Par driver.find_element (By.XPATH, "//button") driver.find_elements (By.XPATH, "//button")
Les attributs suivants sont disponibles pour la classe By :
ID = "id" XPATH = "xpath" LINK_TEXT = "texte du lien" PARTIAL_LINK_TEXT = "texte du lien partiel" NAME = "nom" TAG_NAME = "nom de la balise" CLASS_NAME = "nom de la classe" CSS_SELECTOR = "sélecteur CSS"
4.1. Rechercher par identifiant
Utilisez cette méthode lorsque l’identifiant de l’élément est connu. Si aucun élément ne satisfait valeur définie id, une NoSuchElementException sera levée.
L'élément de formulaire peut être défini comme suit :
Login_form = driver.find_element_by_id("loginForm")
4.2. Rechercher par nom
Utilisez cette méthode lorsque l'attribut name de l'élément est connu. Le résultat sera le premier élément avec la valeur souhaitée attribut de nom. Si aucun élément ne correspond à la valeur du nom donné, une NoSuchElementException sera levée.Par exemple, considérons ce qui suit code source pages :
Les éléments nommés nom d'utilisateur et mot de passe peuvent être définis comme suit :
Nom d'utilisateur = driver.find_element_by_name("nom d'utilisateur") mot de passe = driver.find_element_by_name("mot de passe")
Le code suivant obtiendra le bouton « Connexion » situé avant le bouton « Effacer » :
Continuer = driver.find_element_by_name("continuer")
4.3. Recherche par XPath
XPath est un langage utilisé pour rechercher des nœuds d'arborescence dans un document XML. Depuis dans Basé sur HTML peut mentir Structure XML(XHTML), les utilisateurs de Selenium peuvent utiliser ce langage puissant pour rechercher des éléments dans leurs applications Web. XPath va au-delà méthodes simples recherche par attributs d'identifiant ou de nom (et en même temps les prend en charge), et ouvre une gamme de nouvelles possibilités, comme la recherche d'une troisième case à cocher sur une page, par exemple.Une bonne raison d'utiliser XPath est qu'il existe des situations dans lesquelles vous ne disposez pas d'attributs adaptés aux pointeurs, tels que l'identifiant ou le nom, pour l'élément que vous souhaitez récupérer. Vous pouvez utiliser XPath pour rechercher un élément soit par chemin absolu (non recommandé), soit par chemin relatif (pour les éléments avec un identifiant ou un nom donné). Les pointeurs XPath peuvent également être utilisés pour définir des éléments à l'aide d'attributs autres que l'identifiant et le nom.
Chemin absolu XPath contient tous les nœuds de l'arborescence depuis la racine (html) jusqu'à élément requis, et, par conséquent, est sujet à des erreurs résultant du moindre ajustement du code source de la page. Si vous trouvez l'élément le plus proche avec les attributs id ou name (idéalement l'un des éléments parents), vous pouvez déterminer l'élément que vous recherchez en utilisant une relation parent-enfant. Ces connexions seront beaucoup plus stables et rendront vos tests résistants aux modifications du code source de la page.
Par exemple, considérons le code source de la page suivante :
L'élément de formulaire peut être défini des manières suivantes :
Login_form = driver.find_element_by_xpath("/html/body/form") login_form = driver.find_element_by_xpath("//form") login_form = driver.find_element_by_xpath("//form[@id="loginForm"]")
- Chemin absolu (s'interrompt au moindre changement Structures HTML pages)
- Premier élément de formulaire dans une page HTML
- Un élément de formulaire qui a un attribut défini avec le nom id et la valeur loginForm
Nom d'utilisateur = driver.find_element_by_xpath("//form") nom d'utilisateur = driver.find_element_by_xpath("//form[@id="loginForm"]/input") nom d'utilisateur = driver.find_element_by_xpath("//input[@name="nom d'utilisateur " "]")
- Le premier élément de formulaire avec un élément d'entrée enfant qui a un attribut défini avec le nom et la valeur nom d'utilisateur
- Premier élément enfant élément d'entrée formulaire, pour lequel un attribut avec le nom id et la valeur loginForm est défini
- Le premier élément d'entrée qui a un attribut défini avec le nom et la valeur nom d'utilisateur
Clear_button = driver.find_element_by_xpath("//input[@name="continue"][@type="button"]") clear_button = driver.find_element_by_xpath("//form[@id="loginForm"]/input")
- Un élément d'entrée qui a un attribut nommé name avec une valeur de continue et un attribut nommé type avec une valeur de bouton
- Le quatrième élément d'entrée enfant d'un élément de formulaire qui possède un attribut nommé id et une valeur loginForm
- Tutoriel XPath - avec des exemples interactifs
- XPath Checker - Reçoit les chemins XPath et peut être utilisé pour vérifier les résultats des chemins XPath
- Firebug - La récupération XPath n'est qu'une des nombreuses fonctionnalités puissantes prises en charge par ce plugin très utile
- Assistant XPath - pour Google Chrome
4.4. Rechercher des hyperliens par texte d'hyperlien
Utilisez cette méthode lorsque vous connaissez le texte à l’intérieur de la balise d’ancrage. En utilisant cette méthode, vous obtiendrez le premier élément avec la valeur de texte de balise souhaitée. Si aucun élément ne satisfait la valeur recherchée, une NoSuchElementException sera levée.Par exemple, considérons le code source de la page suivante :
Êtes-vous sûr de vouloir faire cela ?
Continuer AnnulerUn élément de lien hypertexte avec l'adresse "continue.html" peut être obtenu comme suit :
Continue_link = driver.find_element_by_link_text("Continuer") continue_link = driver.find_element_by_partial_link_text("Conti")
4.5. Recherche d'éléments par balise
Utilisez cette méthode lorsque vous souhaitez rechercher un élément par sa balise. De cette façon, vous obtiendrez le premier élément avec le nom de balise spécifié. Si la recherche ne renvoie aucun résultat, une NoSuchElementException sera levée.Par exemple, considérons le code source de la page suivante :
Accueillir
Le contenu du site va ici.
L'élément d'en-tête h1 peut être trouvé comme ceci :
Titre1 = driver.find_element_by_tag_name("h1")
4.6. Trouver des éléments par classe
Utilisez cette méthode dans les cas où vous souhaitez rechercher un élément par valeur attribut de classe. De cette façon, vous obtiendrez le premier élément avec le nom de classe requis. Si la recherche échoue, une NoSuchElementException sera levée.Par exemple, considérons le code source de la page suivante :
Le contenu du site va ici.
L'élément « p » peut être trouvé comme ceci :
Contenu = driver.find_element_by_class_name("content")
4.7. Rechercher des éléments à l'aide d'un sélecteur CSS
Utilisez cette méthode lorsque vous souhaitez récupérer un élément à l'aide de la syntaxe du sélecteur CSS. De cette façon, vous obtiendrez le premier élément qui correspond au sélecteur CSS. Si aucun des éléments ne satisfait Sélecteur CSS, une NoSuchElementException sera levée.Par exemple, considérons le code source de la page suivante :
Le contenu du site va ici.
L'élément « p » peut être défini comme suit :
Contenu = driver.find_element_by_css_selector("p.content")
Sauce Labs a
XPath est utilisé pour naviguer dans les éléments et attributs d'un document XML. XPath est l'un des éléments centraux de la norme W3C XSLT.
1 Ce qui s'est passé XPath
Expressions XPath
XPath utilise des expressions de chemin pour sélectionner des nœuds individuels ou un ensemble de nœuds dans un document XML. Ces expressions sont très similaires aux expressions que vous voyez lorsque vous travaillez avec des système de fichiers ordinateur.
Fonctions XPath standard
XPath comprend plus de 100 fonctions intégrées. Il existe des fonctions pour les valeurs de chaîne et numériques, la date et l'heure, la comparaison de nœuds et la manipulation de QName, la gestion des séquences, valeurs booléennes, et bien plus encore.
XPath est utilisé dans XSLT
XPath est l'un des éléments centraux de la norme XSLT. Sans connaissance de XPath, vous ne pourrez pas créer de documents XSLT.
2 Terminologie XPath
Nœuds
Il existe sept types de nœuds dans XPath : élément, attribut, texte, espace de noms, instructions de traitement, commentaires et nœuds de document. Les documents XML sont traités comme des arborescences de nœuds. L’élément supérieur de l’arborescence est appelé élément racine. Regardez le document XML suivant :
Exemples de nœuds dans le document XML ci-dessus :
Valeurs atomiques
Les valeurs atomiques sont des nœuds qui n'ont ni enfants ni parents. Exemple de valeurs atomiques :
J.K. Rowling "fr"
Éléments
Les éléments sont des valeurs atomiques ou des nœuds.
3 Relation nœuds
Mère
Chaque élément et attribut a un parent. Dans l'exemple suivant, l'élément book est le parent des éléments titre, auteur, année et prix :
Descendance
Les nœuds d'éléments peuvent avoir zéro, un ou plusieurs enfants. Dans l'exemple suivant, les éléments « titre », « auteur », « année » et « prix » sont tous des enfants de l'élément livre :
Éléments de même niveau
Ce sont des nœuds qui ont le même parent. Dans l'exemple suivant, les éléments « titre », « auteur », « année » et « prix » sont tous des éléments de même niveau :
Ancêtres
Parent du nœud, parent du parent du nœud, etc. Dans l'exemple suivant, les ancêtres de l'élément title sont les éléments book et bookstore :
Descendance
Enfants d'un nœud, enfants d'enfants d'un nœud, etc. Dans l'exemple suivant, les enfants de l'élément « bookstore » sont les éléments « book », « title », « author », « year » et « price » :
4 Syntaxe XPath
XPath utilise des expressions de chemin pour sélectionner des nœuds ou des ensembles de nœuds dans un document XML. Un nœud peut être sélectionné en suivant un chemin ou par étapes. Nous utiliserons le document XML suivant dans les exemples ci-dessous.
Sélection de nœud
En utilisant des expressions XPath pour sélectionner des nœuds dans un document XML, vous pouvez sélectionner un nœud en suivant un chemin ou des étapes. Les expressions de chemin les plus utiles sont répertoriées ci-dessous :
Le tableau ci-dessous répertorie certains chemins d'expression et le résultat de l'exécution de l'expression :
| Expression XPath | Résultat |
|---|---|
| librairie | Sélectionne tous les nœuds nommés "librairie" |
| /librairie | Sélectionne l'élément racine de la librairie Note: Si un chemin commence par une barre oblique (/), il s'agit toujours d'un chemin absolu vers l'élément ! |
| librairie/livre | Sélectionne tous les éléments "book" qui sont des enfants de l'élément "bookstore" |
| //livre | Sélectionne tous les éléments "livre" quel que soit leur emplacement dans le document |
| librairie//livre | Sélectionne tous les éléments "book" qui sont des enfants de l'élément "bookstore", quel que soit leur emplacement sous l'élément "bookstore" |
| //@lang | Sélectionne tous les attributs nommés « lang » |
Prédicats
Les prédicats sont utilisés pour rechercher un nœud spécifique ou un nœud contenant une valeur spécifique. Les prédicats sont toujours entourés de crochets. Le tableau ci-dessous répertorie quelques expressions de chemin avec des prédicats et le résultat de l'expression :
| Expressions XPath | Résultat |
|---|---|
| /librairie/livre | Sélectionne le premier élément « book », qui est un enfant de l'élément « bookstore ». Note: Dans IE 5,6,7,8,9, le premier nœud a un indice de , mais selon les directives du W3C, il s'agit de . Pour résoudre ce problème dans IE, définissez l'option « SelectionLanguage » pour XPath : En JavaScript : xml.setProperty("SelectionLanguage", "XPath"); |
| /librairie/livre | Sélectionne dernier élément"book" (book), qui est un élément enfant de l'élément "bookstore" (librairie) |
| /librairie/livre | Sélectionne l'avant-dernier élément "book", qui est un enfant de l'élément "bookstore" |
| /librairie/livre | Sélection des deux premiers éléments "book" enfants de l'élément "bookstore" |
| //titre[@lang] | Sélectionne tous les éléments "title" qui ont un attribut nommé "lang" |
| //titre[@lang="fr"] | Sélectionne tous les éléments "titre" qui ont un attribut "langue" avec une valeur de "en" |
| /librairie/livre | Sélectionne tous les éléments « livre » après l'élément « librairie » qui ont un élément « prix » d'une valeur supérieure à 35,00 |
| /librairie/livre/titre | Sélectionne tous les éléments "titre" du livre de l'élément "librairie" qui ont un élément "prix" d'une valeur supérieure à 35,00 |
Sélection de nœuds inconnus
Les caractères spéciaux XPath peuvent être utilisés pour sélectionner des nœuds XML inconnus.
Dans le tableau ci-dessous, nous avons répertorié certains chemins d'expression et résultats d'expression :
Sélection de plusieurs chemins
Utilisation de l'opérateur | dans les expressions XPath, vous pouvez sélectionner plusieurs chemins. Le tableau ci-dessous répertorie plusieurs expressions de chemin et leurs résultats :
5 Essieux XPath
Nous utiliserons ce qui suit Document XML plus loin dans l'exemple.
Les axes définissent des ensembles de nœuds, par rapport au nœud actuel.
| Nom de l'axe | Résultat |
|---|---|
| ancêtre | Sélectionne tous les ancêtres (parents, grands-parents, etc.) du nœud actuel |
| ancêtre ou soi | Sélectionne tous les ancêtres (parents, grands-parents, etc.) du nœud actuel et du nœud actuel lui-même |
| attribut | |
| enfant | |
| descendant | Sélectionne tous les enfants (enfants, petits-enfants, etc.) du nœud actuel |
| descendant ou soi-même | Sélectionne tous les enfants (enfants, petits-enfants, etc.) du nœud actuel et du nœud actuel lui-même |
| suivant | Sélectionne tout ce qui se trouve dans le document après la fermeture de la balise du nœud actuel |
| frère ou sœur suivant | Sélectionne tous les nœuds du même niveau après le nœud actuel |
| espace de noms | Sélectionne tous les nœuds dans espace donné espace de noms du nœud actuel |
| mère | Sélectionne le parent du nœud actuel |
| précédent | Sélectionne tous les nœuds qui apparaissent avant le nœud actuel dans le document, à l'exclusion des ancêtres, des nœuds d'attribut et des nœuds d'espace de noms. |
| frère-sœur précédent | Sélectionne tous les frères et sœurs jusqu'au nœud actuel |
| soi | Sélectionne le nœud actuel |
6 Expressions chemins d'échantillonnage
Le chemin de localisation peut être absolu ou relatif. Un chemin d’emplacement absolu commence par une barre oblique (/), mais pas un chemin relatif. Dans les deux cas, le chemin d'échantillonnage est constitué d'une ou plusieurs étapes séparées par des barres obliques :
Chemin de localisation absolu :
/pas/pas/...
Chemin de récupération de l'emplacement relatif :
Étape/étape/...
Chaque étape est évaluée par rapport aux nœuds de l'ensemble de nœuds actuel. L'étape consiste à :
- axe (définit la relation arborescente entre les nœuds sélectionnés et le nœud actuel) ;
- vérification des nœuds (identifie un nœud dans un axe) ;
- zéro ou plusieurs prédicats (pour affiner davantage l'ensemble de nœuds sélectionné)
La syntaxe de l'étape de récupération est :
Axisname :: nodetestAxisname :: nodetest [prédicteur]
| Exemple | Résultat |
|---|---|
| enfant::livre | Sélectionne tous les nœuds de livre qui sont des enfants du nœud actuel |
| attribut ::lang | Sélectionne l'attribut de langue (lang) du nœud actuel |
| enfant::* | Sélectionne tous les enfants du nœud actuel |
| attribut::* | Sélectionne tous les attributs du nœud actuel |
| enfant :: texte () | Sélectionne tous les nœuds de texte du nœud actuel |
| enfant::noeud() | Sélectionne tous les enfants immédiats du nœud actuel |
| descendant :: livre | Sélectionne tous les enfants du nœud actuel |
| ancêtre::livre | Sélectionne tous les ancêtres des "livres" du nœud courant |
| ancêtre-ou-soi::livre | Sélectionne tous les ancêtres du livre du nœud actuel - et le nœud actuel s'il s'agit également d'un livre |
| enfant::*/enfant::prix | Sélectionne tous les enfants du "prix" à un niveau du nœud actuel |
7 Opérateurs XPath
Les expressions XPath sont renvoyées sous la forme d'un ensemble de nœuds, de chaînes, de booléens ou valeurs numériques. Vous trouverez ci-dessous une liste des opérateurs utilisés dans les expressions XPath :
| Opérateur | Description | Exemple |
|---|---|---|
| | | Calcule deux ensembles de nœuds | //livre | //CD |
| + | Ajout | 6 + 4 |
| - | Soustraction | 6 - 4 |
| * | Multiplication | 6 * 4 |
| div | Division | 8 division 4 |
| = | Égalité | prix=9,80 |
| != | Inégalité | prix!=9,80 |
| < | Moins que | prix<9.80 |
| <= | Inférieur ou égal à | prix≤9,80 |
| > | Plus que | prix>9.80 |
| >= | Supérieur ou égal à | prix≤9,80 |
| ou | Ou | prix=9,80 ou prix=9,70 |
| et | ET | prix>9,00 et prix<9.90 |
| module | Reste de la division | 5 modules 2 |
8 Exemples XPath
Regardons la base Syntaxe XPath sur plusieurs exemples. Nous utiliserons le document XML suivant "books.xml" dans les exemples ci-dessous :
Chargement d'un document XML
Utilisez XMLHttpRequest pour télécharger des documents XML, qui est pris en charge par la plupart des navigateurs modernes :
Var xmlhttp=new XMLHttpRequest()
Code pour les anciens navigateurs Microsoft (IE 5 et 6) :
Var xmlhttp=new ActiveXObject("Microsoft.XMLHTTP")
Sélection de nœud
Malheureusement, XPath peut fonctionner différemment dans Internet Explorer et dans les autres navigateurs. Dans nos exemples, nous utiliserons du code qui devrait fonctionner dans la plupart des navigateurs. Internet Explorer utilise la méthode « selectNodes() » pour sélectionner des nœuds dans un document XML :
XmlDoc.selectNodes(xpath);
Firefox, Chrome, Opera et Safari utilisent la méthode évaluer() pour sélectionner des nœuds dans un document XML :
XmlDoc.evaluate(xpath, xmlDoc, null, XPathResult.ANY_TYPE, null);
Sélectionnez tous les titres
L'exemple suivant sélectionne tous les nœuds d'en-tête :
/librairie/livre/titre
Choisir le titre du premier livre
L'exemple suivant sélectionne le titre du premier nœud « book » après l'élément « bookstore » :
/librairie/livre/titre
Sélectionnez tous les prix
L'exemple suivant sélectionne le texte de tous les nœuds de prix :
/librairie/livre/prix
Sélectionne les nœuds avec un prix >35
L'exemple suivant sélectionne tous les nœuds dont les prix sont supérieurs à 35 :
/librairie/livre/prix
Sélection de nœuds d'en-tête avec un prix > 35
L'exemple suivant sélectionne tous les nœuds de titre dont le prix est supérieur à 35 :
/librairie/livre/titre
Aujourd'hui, nous examinerons de plus près le sujet de l'utilisation de XPath avec PHP. Vous verrez dans les exemples comment XPath réduit considérablement la quantité de code. Examinons l'utilisation des requêtes et des fonctions dans XPath.
Au début, je vous fournirai deux types de documents : DTD et XML, à l'aide desquels nous verrons le fonctionnement de PHP DOM XPath. Voici à quoi ils ressemblent :
Requêtes XPath de base
La syntaxe simple XPath vous permet d'accéder aux éléments d'un document XML. La plupart d'une manière simple, vous pouvez spécifier le chemin d'accès à l'élément souhaité. À l'aide du document XML fourni ci-dessus, la requête XPath suivante renverra la collection des éléments actuels trouvés dans l'élément book :
//bibliothèque/livre
Comme ça! Deux barres obliques définissent l'élément racine du document et une barre oblique permet de passer à l'élément enfant du livre. C'est simple et rapide, n'est-ce pas ?
Mais que faire si tu veux choisir élément spécifique un livre parmi beaucoup ? Supposons que vous souhaitiez des livres d'un "certain auteur". La requête XPath pour cela serait :
//bibliothèque/livre/auteur/..
Vous pouvez utiliser texte() V crochets pour comparer la valeur du nœud. Aussi «/..» signifie que nous voulons utiliser élément parent(c'est-à-dire que nous remontons d'un nœud plus haut).
Les requêtes XPath sont effectuées à l'aide d'une ou deux fonctions : requête() Et évaluer(). Les deux forment une requête, mais la différence réside dans le résultat renvoyé. query() reviendra toujours DOMNodeList, contrairement à évaluer() renverra un résultat texte si possible. Par exemple, si votre requête XPath renvoyait le nombre de livres écrits par un auteur particulier, alors query() renverrait une DOMNodeList vide, évaluer() renverrait simplement un nombre, vous pourriez l'utiliser directement pour récupérer les données du nœud. .
Code XPath et avantages en termes de vitesse
Regardons un exemple simple qui renverra le nombre de livres écrits par un auteur spécifique. Nous examinerons la première méthode comme nous le faisons toujours, sans utiliser XPath. Vous comprendrez maintenant comment procéder sans XPath et combien il est plus facile de le faire avec XPath.
domDocument->getElementsByTagName("auteur");
foreach ($elements as $element) ( if ($element->nodeValue == $author) ( $total++; ) ) renvoie $number; )
La méthode suivante renvoie le même résultat, mais utilise XPath pour sélectionner les livres écrits par un auteur spécifique.
domDocument); $result = $xpath->query($query); return $result->length; )
Notez que nous n'avons pas besoin de revérifier la valeur de chaque élément pour déterminer quel auteur a écrit chaque livre. Mais nous pouvons simplifier davantage le code en utilisant la fonction XPath
compter()
pour compter le contenu des éléments de ce chemin.
domDocument);
return $xpath->evaluate($query); )
Nous pouvons obtenir les informations dont nous avons besoin avec une requête XPath sur une seule ligne. Il n'est pas nécessaire de créer de nombreux filtres PHP. C’est le moyen le plus simple et le plus rapide d’écrire cette fonctionnalité !
Vous le savez déjà grâce à l’exemple de la fonction count(). Utilisons la fonction id() pour obtenir les titres de livres avec les ISBN donnés. Pour ce faire, vous devez utiliser l'expression XPath suivante :
identifiant("isbn1234 isbn1235")/titre
Notez que les valeurs que vous recherchez ne doivent pas être placées entre parenthèses, mais simplement séparées par des espaces. Aussi, ne pensez même pas à ajouter une virgule :
domDocument);
$result = $xpath->query($query);
$livres = tableau();
foreach ($result as $node) ( $book = array("title" => $booknode->nodeValue); $books = $book; ) return $books; )
La gestion de fonctions complexes dans XPath est incroyablement simple.
Utiliser les fonctions PHP avec XPath
Parfois, vous aurez besoin de plus de fonctionnalités que les fonctions XPath standard ne peuvent pas fournir. Heureusement, le DOM PHP permet aux fonctions PHP natives d'interagir avec les requêtes XPath.
Regardons un exemple qui renvoie le nombre de mots dans le titre d'un livre. Dans cette fonction la plus simple, nous écrirons ce qui suit :
domDocument);
$result = $xpath->query($query);
$title = $result->item(0)->getElementsByTagName("title") ->item(0)->nodeValue;
return str_word_count($titre); )
php:functionString("str_word_count",(//library/book[@isbn = "$isbn"]/title))
L'enregistrement des fonctions PHP ne se limite pas aux fonctions incluses dans PHP. Vous pouvez définir vos propres fonctions et les utiliser dans XPath. La seule différence est que vous devrez utiliser « php:function » au lieu de « php:functionString ».
Écrivons une fonction en dehors de la classe pour démontrer les fonctionnalités de base. La fonction que nous utiliserons renvoie les livres de l'auteur "George Orwell". Il doit renvoyer true pour chaque nœud que vous souhaitez inclure dans la requête.
nodeValue == "George Orwell"; } !}
L'argument transmis à la fonction est un tableau d'éléments DOM. Cette fonction parcourt le tableau et détermine les éléments nécessaires, puis les inclut dans DOMNodeList. Dans cet exemple, le nœud testé était /book, et nous avons également utilisé /author pour déterminer les éléments requis.
Nous pouvons maintenant créer la fonction getGeorgeOrwellBooks() :
domDocument);
$xpath->registerNamespace("php", "http://php.net/xpath");
//bibliothèque/livre
$xpath->registerPHPFunctions();
$query = "//bibliothèque/livre1";
XPath$result = $xpath->query($query);