XPath - Tous les frères et sœurs à l'exception d'abord des éléments spécifiques

Disons que je suis l'interrogation d'un document xhtml, et je veux l'interroger tous des frères et sœurs à la suite d'une table avec id='target'. Aussi, je ne veux la première <table> frère, ni le premier <ol> frère de cet élément particulier. Voici le mieux que je pouvais venir avec:

//table[@id='target']/following-sibling::*[not(self::table[1]) and not(self::ol[1])]

Cependant, ce n'est pas de retourner tous les résultats quand il le faut. Évidemment, je ne suis pas la compréhension de certains de la syntaxe (je ne pouvais pas trouver une bonne source d'information). Je serais très reconnaissant si quelqu'un de plus expérimenté avec la syntaxe XPath pourrait me donner un coup de main. Aussi, pour des raisons purement académique, je serais curieux de savoir ce que le ci-dessus est en fait en train de faire.

Mise à JOUR:
Voir LarsH réponse à l'explication de pourquoi mon XPath n'étais pas de travail, et de voir Dimitre réponse à la solution retenue.

Bonne question, +1. Voir ma réponse pour une seule expression XPath qui permet de sélectionner exactement le voulait nœuds. 🙂

OriginalL'auteur Shaun | 2010-11-29

  1. 13

    Utilisation:

     /table[@id='target']/following-sibling::*[not(self::table) and not(self::ol)] 
| 
 /table[@id='target']/following-sibling::table[position() > 1]
|
 /table[@id='target']/following-sibling::ol[position() > 1]

    Cela sélectionne tous les frères et sœurs de la table qui ne sont pas table et ne sont pas ol et toutes les suivantes table frères et sœurs à la position 2 ou supérieure, et toutes les suivantes ol frères et sœurs à la position 2 ou plus.

    Qui est exactement ce que vous voulez: tous à la suite les frères et sœurs, à l'exception de la première table la suite de la fratrie et de la première ol suivant les frères et sœurs.

    C'est de la pure XPath 1.0 et ne pas utiliser toutes les fonctions XSLT.

    C'est exactement la solution que je cherchais, et c'est en fait assez simple. Il n'a jamais eu lieu pour moi d'obtenir l'union des trois ensembles mutuellement exclusifs contenant tout, à l'exception de ces deux éléments. Merci!!!!
    Ah, devrait avoir pensé plus difficile. 🙂 J'ai tenté une union solution, mais ne pouvait pas l'obtenir. Faute de frappe: en fonction de la question d'origine, // plutôt que / est nécessaire avant de table.
    Heh, pour une raison que j'ai décidé d'un syndicat solution serait mauvaise et plus précisément évité de l'utiliser. +1 pour ne pas être boneheaded comme moi. 🙂

    OriginalL'auteur Dimitre Novatchev

  2. 2

    De répondre à la deuxième question: ce qui précède est en train de faire est de sélectionner tous les frères et sœurs qui ne sont ni table ni ol éléments.

    Voici pourquoi: self::table[1] sélectionne le nœud de contexte de l'auto (ssi il passe le table nom de l'élément de test) et les filtres pour sélectionner uniquement le premier nœud le long de la self:: l'axe. Il y a au plus un nœud sur le self:: axe passant le nom de l'élément de test, de sorte que le [1] est redondante. self::table[1] sélectionne le nœud de contexte à chaque fois qu'il est un élément de la table, quelle que soit sa position parmi ses frères et sœurs. Donc not(self::table[1]) renvoie la valeur false à chaque fois que le nœud de contexte est un élément de la table, quelle que soit sa position entre frères et sœurs.

    De même pour self::ol[1].

    Comment faire ce que vous essayez de faire:
    @John Kugelman la réponse est presque correct, mais laisse de côté le fait que nous devons ignorer les éléments frères avant et y compris table[@id='target']. Je ne pense pas que c'est possible de le faire correctement dans le plus pur XPath 1.0. Vous avez la possibilité d'utiliser XPath 2.0? Si vous travaillez dans un navigateur, la réponse est généralement pas.

    Quelques solutions de contournement serait:

    • Ignorer le premier tableau suivant frère et la première suivantes ol frère par filtrage sur une autre base, tels que leurs attributs;
    • Sélectionnez //table[@id='target'] comme un ensemble de nœuds, de retour à l'hôte de l'environnement (i.e. en dehors de XPath, par exemple en JavaScript), en boucle par le biais de cette ensemble de nœuds; à l'intérieur de la boucle: sélectionnez following-sibling::* via XPath, itérer sur que à l'extérieur de XPath, et de tester chaque résultat (en dehors de XPath) pour voir si c'est la première table ou ol.
    • Sélectionnez //table[@id='target'] comme un ensemble de nœuds, de retour à l'hôte de l'environnement (i.e. en dehors de XPath, par exemple en JavaScript), en boucle par le biais de cette ensemble de nœuds; à l'intérieur de la boucle: sélectionnez generate-id(following-sibling::table[1]) et generate-id(following-sibling::ol[1]) via XPath, de recevoir ces valeurs dans des variables JS t1id et o1id, et de construire une chaîne de caractères pour l'expression XPath en utilisant le formulaire 'following-sibling::*[generate-id() != ' + t1id + ' and generate-id() != ' + o1id + ']'. Sélectionnez la chaîne dans XPath et vous avez votre réponse! :-p

    Mise à jour: Une solution est possible en XSLT 1.0 - voir @Dimitre.

    Kugelman: Prendre un coup d'oeil à mon amswer pur et pas trop complexe XPath 1.0 solution.
    Merci pour la grande explication du pourquoi de ma tentative de requête a été un échec. J'ai finalement allé avec Dimitre de XPath pour résoudre le problème.

    OriginalL'auteur LarsH

  3. 1

    Il n'y a qu'un nœud lorsque vous utilisez le self:: de l'axe, donc je crois self::*[1] sera toujours vrai. Chaque nœud va être le premier (et seul) nœud sur son propre self:: de l'axe. Cela signifie que votre expression entre crochets est équivalent à [not(self::table) and not(self::ol)], ce qui signifie que tous les tableaux et listes sont filtrés.

    Je n'ai pas d'environnement de test mis en place, mais sur le dessus de ma tête, cela pourrait faire mieux:

    /table[@id='target']/following-sibling::*
    [not(self::table and not(preceding-sibling::table)) and
     not(self::ol    and not(preceding-sibling::ol))]

    C'aurez besoin de quelques ajustements, mais l'idée est de filtrer tables qui n'ont pas de précédent-frère tables, et ols qui n'ont pas de précédent-frère ols.

    comme je l'ai indiqué dans ma réponse, cette solution manque le fait que la table cible ne doit pas être considéré comme un précédent,-de la fratrie lorsque vous effectuez le test suivant frères et sœurs pour voir ce qui est [1]. Aussi, n'importe quelle table ou ol éléments avant la table cible doivent être ignorés par le précédent-frère de test.

    OriginalL'auteur John Kugelman