Comment puis-je utiliser la carte et recevoir un index aussi à Scala?

Je crois que vous recherchez zipWithIndex?

 scala> val ls = List("Mary", "had", "a", "little", "lamb") scala> ls.zipWithIndex.foreach{ case (e, i) => println(i+" "+e) } 0 Mary 1 had 2 a 3 little 4 lamb 

De: http://www.artima.com/forums/flat.jsp?forum=283&thread=243570

Vous avez aussi des variantes comme:

 for((e,i) <- List("Mary", "had", "a", "little", "lamb").zipWithIndex) println(i+" "+e) 

ou:

 List("Mary", "had", "a", "little", "lamb").zipWithIndex.foreach( (t) => println(t._2+" "+t._1) ) 

Utilisation . carte dans zipWithIndex

 val myList = List("a", "b", "c") myList.zipWithIndex.map { case (element, index) => println(element, index) s"${element}(${index})" } 

Résultat:

 List("a(0)", "b(1)", "c(2)") 

Les solutions proposées souffrent du fait qu’elles créent des collections intermédiaires ou introduisent des variables qui ne sont pas ssortingctement nécessaires. En fin de compte, il vous suffit de suivre le nombre d’étapes d’une itération. Cela peut être fait en utilisant la mémorisation. Le code résultant pourrait ressembler à

 myIterable map (doIndexed(someFunction)) 

doIndexed encapsule la fonction interne qui reçoit à la fois un index et les éléments de myIterable . Cela pourrait vous être familier avec JavaScript.

Voici un moyen d’atteindre cet objective. Considérons l’utilitaire suivant:

 object TraversableUtil { class IndexMemoizingFunction[A, B](f: (Int, A) => B) extends Function1[A, B] { private var index = 0 override def apply(a: A): B = { val ret = f(index, a) index += 1 ret } } def doIndexed[A, B](f: (Int, A) => B): A => B = { new IndexMemoizingFunction(f) } } 

C’est déjà tout ce dont vous avez besoin. Vous pouvez appliquer ceci par exemple comme suit:

 import TraversableUtil._ List('a','b','c').map(doIndexed((i, char) => char + i)) 

qui résulte dans la liste

 List(97, 99, 101) 

De cette façon, vous pouvez utiliser les fonctions Traversable habituelles au désortingment de votre fonction efficace. La surcharge est la création de l’object de mémorisation et du compteur. Sinon, cette solution est aussi bonne (ou mauvaise) en termes de mémoire ou de performances que l’utilisation d’une map non indexée. Prendre plaisir!

Il y a CountedIterator dans 2.7.x (que vous pouvez obtenir à partir d’un iterator normal avec .counted). Je crois qu’il a été déprécié (ou simplement supprimé) en 2.8, mais il est assez facile de le faire. Vous devez être en mesure de nommer l’iterator:

 val ci = List("These","are","words").elements.counted scala> ci map (i => i+"=#"+ci.count) toList res0: List[java.lang.Ssortingng] = List(These=#0,are=#1,words=#2) 

Ou, en supposant que votre collection dispose d’un temps d’access constant, vous pouvez mapper la liste des index au lieu de la collection réelle:

 val ls = List("a","b","c") 0.until(ls.length).map( i => doStuffWithElem(i,ls(i)) )