Trouver tous les nœuds qui ont un attribut qui correspond à une certaine valeur avec scala

J'ai vu l'exemple suivant sur Nabbleoù l'objectif était de revenir tous les nœuds qui contiennent un attribut avec un id de X qui contient une valeur de Y:

//find all nodes with an attribute "class" that contains the value "test"
val xml = XML.loadString( """<div>
<span class="test">hello</span>
<div class="test"><p>hello</p></div>
</div>""" )

def attributeEquals(name: String, value: String)(node: Node) = 
{ 
    node.attribute(name).filter(_==value).isDefined
}

val testResults = (xml \\ "_").filter(attributeEquals("class","test")) 
//prints: ArrayBuffer(
//<span class="test">hello</span>, 
//<div class="test"><p>hello</p></div>
//) 
println("testResults: " + testResults )

Comme une extension de cette comment pourrait-on faire le suivant: Rechercher tous les nœuds qui contiennent tout attribut contient une valeur de Y:

//find all nodes with any attribute that contains the value "test"
val xml = XML.loadString( """<div>
 <span class="test">hello</span>
 <div id="test"><p>hello</p></div>
 <random any="test"/></div>""" )
 //should return: ArrayBuffer(
 //<span class="test">hello</span>, 
 //<div id="test"><p>hello</p></div>, 
 //<random any="test"/> )

Je pensais que je pouvais utiliser une _ comme suit:

val testResults = (xml \\ "_").filter(attributeEquals("_","test"))

Mais ça ne fonctionne pas. Je sais que je peux utiliser le pattern matching, mais je voulais juste voir si je pouvais faire de la magie avec le filtrage.

Hourras Ed

source d'informationauteur ed.

18

Tout d'abord, XML sont des littéraux dans Scala, donc:
```
val xml = <div><span class="test">hello</span><div class="test"><p>hello</p></div></div>
```
Maintenant, comme pour le problème:
```
def attributeValueEquals(value: String)(node: Node) = {
     node.attributes.exists(_.value.text == value)
}
```
En fait, j'aurais utilisé "exists" au lieu de "filter" et "defined" pour le problème d'origine.

Enfin, personnellement, je préfère l'opérateur de la syntaxe de style, en particulier lorsque vous avez un prêt de fonction, au lieu d'un anonyme, pour passer à "filter":
```
val testResults = xml \\ "_" filter attributeValueEquals("test")
```
L'origine des mélanges opérateur de style pour "\\" et de point de style pour "filter", qui se termine assez moche.
3

Extrait de Code en question n'a pas de travail avec Scala 2.8 - en raison de cette comparasion
```
(_ == value)
```
doit être remplacé par (_.text == value) ou (_ == Text(value)) ou changer le type de la valeur de Chaîne de Texte.

Et Daniel en réponse (_.value == value) doit être remplacé par (_.value.text == value).

Les solutions précédentes ne fonctionne pas pour moi, car ils se ressemblent tous pour tout valeur qui correspond. Si vous voulez chercher un particulier attribut avec une valeur, ici, c'est ma solution:

def getByAtt(e: Elem, att: String, value: String) = {
    def filterAtribute(node: Node, att: String, value: String) =  (node \ ("@" + att)).text == value   
    e \\ "_" filter { n=> filterAtribute(n, att, value)} 
}

Et puis

getByAtt(xml, "class", "test")

Cela fera la différence entre class="test" et "notclass="test"

Je suis assez nouveau à la Scala, je vous propose cette solution, mais je ne suis pas sûr que c'est le meilleur:

def attributeValueEquals(value: String)(node: Node) = {
  node.attributes.foldLeft(false)((a : Boolean, x : MetaData) => a | (x.value == value))
}

val testResults = (xml \\ "_").filter(attributeValueEquals("test")) 
println("testResults: " + testResults )

//prints: testResults: ArrayBuffer(<span class="test">hello</span>, 
//<div id="test"><p>hello</p></div>, 
//<random any="test"></random>)

def nodeHasValue(node:Node,value:String) = node.attributes.value != null && node.attributes.value.contains(value)

(x \\ "_").filter( nodeHasValue(_,"test"))

Vous devez vous connecter pour publier un commentaire.