Efficace itération avec index en Scala

Il a été mentionné que la Scala ne de syntaxe pour for boucles:

for (i <- 0 until xs.length) ...

ou tout simplement

for (i <- xs.indices) ...

Toutefois, il est également demandé pour l'efficacité. Il s'avère que la Scala for syntaxe est effectivement sucre syntaxique pour les ordre élevé, des méthodes telles que map, foreach, etc. Ainsi, dans certains cas, ces boucles peuvent être inefficaces, par exemple Comment optimiser pour des inclusions et des boucles en Scala?

(La bonne nouvelle est que la Scala équipe est de travailler sur l'amélioration de la ce. Voici la question dans le bug tracker: https://issues.scala-lang.org/browse/SI-4633)

Pour un maximum d'efficacité, on peut utiliser un while boucle ou, si vous insistez sur l'élimination des utilisations de var, la queue de la récursivité:

import scala.annotation.tailrec

@tailrec def printArray(i: Int, xs: Array[String]) {
  if (i < xs.length) {
    println("String #" + i + " is " + xs(i))
    printArray(i+1, xs)
  }
}
printArray(0, Array("first", "second", "third"))

Noter que le facultatif @tailrec annotation est utile pour s'assurer que la méthode est en fait la queue récursive. La Scala compilateur traduit la queue-les appels récursifs dans le byte code équivalent de la boucle while.

En fait, scala a old Java de style de boucles avec index:

scala> val xs = Array("first","second","third")
xs: Array[java.lang.String] = Array(first, second, third)

scala> for (i <- 0 until xs.length)
     | println("String # " + i + " is "+ xs(i))

String # 0 is first
String # 1 is second
String # 2 is third

Où 0 until xs.length ou 0.until(xs.length) est un RichInt méthode qui renvoie la Range adapté pour la lecture en boucle.

Aussi, vous pouvez essayer de boucle avec to:

scala> for (i <- 0 to xs.length-1)
     | println("String # " + i + " is "+ xs(i))
String # 0 is first
String # 1 is second
String # 2 is third

En boucle dans la scala est assez simple.
Créer un tableau de votre choix pour ex.

val myArray = new Array[String](3)
myArray(0)="0";
myArray(1)="1";
myArray(2)="2";

Types de boucles,

for(data <- myArray)println(data)

for (i <- 0 until myArray.size)
println(i + ": " + myArray(i))

Il n'y a rien dans la stdlib qui va le faire pour vous sans la création d'un tuple des ordures, mais il n'est pas trop dur à écrire votre propre. Malheureusement, je n'ai jamais pris la peine de comprendre comment faire le bon CanBuildFrom implicite raindance pour faire de telles choses générique dans le type de collecte auquel ils sont appliqués, mais si c'est possible, je suis sûr que quelqu'un va nous éclairer. 🙂

def foreachWithIndex[A](as: Traversable[A])(f: (Int,A) => Unit) {
var i = 0
for (a <- as) {
f(i, a)
i += 1
}
}
def mapWithIndex[A,B](in: List[A])(f: (Int,A) => B): List[B] = {
def mapWithIndex0(in: List[A], gotSoFar: List[B], i: Int): List[B] = {
in match {
case Nil         => gotSoFar.reverse
case one :: more => mapWithIndex0(more, f(i, one) :: gotSoFar, i+1)
}
}
mapWithIndex0(in, Nil, 0)
}
//Tests....
@Test
def testForeachWithIndex() {
var out = List[Int]()
ScalaUtils.foreachWithIndex(List(1,2,3,4)) { (i, num) =>
out :+= i * num
}
assertEquals(List(0,2,6,12),out)
}
@Test
def testMapWithIndex() {
val out = ScalaUtils.mapWithIndex(List(4,3,2,1)) { (i, num) =>
i * num
}
assertEquals(List(0,3,4,3),out)
}

J'ai les approches suivantes

object HelloV2 {
def main(args: Array[String]) {
//Efficient iteration with index in Scala
//Approach #1
var msg = "";
for (i <- args.indices)
{
msg+=(args(i));
}
var msg1="";
//Approach #2
for (i <- 0 until args.length) 
{
msg1 += (args(i));
}
//Approach #3
var msg3=""
args.foreach{
arg =>
msg3 += (arg)
}
println("msg= " + msg);
println("msg1= " + msg1);
println("msg3= " + msg3);
}
}

Les solutions proposées souffrent du fait qu'ils soit explicitement itérer sur une collection ou des objets de la collection dans une fonction. Il est plus naturel de les coller avec de l'habitude de les idiomes de la Scala et de mettre l'index à l'intérieur de la carte d'habitude - ou foreach-méthodes. Cela peut être fait en utilisant memoizing. Le code résultant peut ressembler à

myIterable map (doIndexed(someFunction))

Ici est une façon d'atteindre ce but. Envisager 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 que vous devez. Vous pouvez appliquer la présente par exemple comme suit:

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

qui résultats dans la liste

List(97, 99, 101)

De cette façon, vous pouvez utiliser l'habituel Traversable-fonctions au détriment de l'emballage de votre fonction. Profitez-en!