Lặp lại hiệu quả với chỉ mục trong Scala

Vì Scala không có các forvòng lặp kiểu Java cũ với chỉ mục,

// does not work
val xs = Array("first", "second", "third")
for (i=0; i<xs.length; i++) {
  println("String #" + i + " is " + xs(i))
}

Làm thế nào chúng ta có thể lặp lại một cách hiệu quả mà không cần sử dụng var's?

Bạn có thể làm điều này

val xs = Array("first", "second", "third")
val indexed = xs zipWithIndex
for (x <- indexed) println("String #" + x._2 + " is " + x._1)

nhưng danh sách được duyệt hai lần - không hiệu quả lắm.

Tệ hơn nhiều so với việc duyệt hai lần, nó tạo ra một mảng trung gian của các cặp. Bạn có thể sử dụng view. Khi bạn làm vậy collection.view, bạn có thể nghĩ về các cuộc gọi tiếp theo như hành động một cách lười biếng trong quá trình lặp lại. Nếu bạn muốn lấy lại một bộ sưu tập đã được thực hiện đầy đủ thích hợp, bạn gọi điện forceở cuối. Ở đây điều đó sẽ vô ích và tốn kém. Vì vậy, hãy thay đổi mã của bạn thành

for((x,i) <- xs.view.zipWithIndex) println("String #" + i + " is " + x)

Nó đã được đề cập rằng Scala không có cú pháp cho forvòng:

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

hoặc đơn giản

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

Tuy nhiên, bạn cũng yêu cầu hiệu quả. Nó chỉ ra rằng forcú pháp Scala thực sự là một đường cú pháp cho các phương thức bậc cao hơn, chẳng hạn như map, foreachv.v. Như vậy, trong một số trường hợp, các vòng lặp này có thể không hiệu quả, ví dụ: Làm thế nào để tối ưu hóa các phần và vòng lặp trong Scala?

(Tin tốt là nhóm Scala đang làm việc để cải thiện điều này. Đây là sự cố trong trình theo dõi lỗi: https://issues.scala-lang.org/browse/SI-4633 )

Để đạt hiệu quả cao nhất, người ta có thể sử dụng một whilevòng lặp hoặc, nếu bạn nhấn mạnh vào việc loại bỏ việc sử dụng var, đệ quy đuôi:

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"))

Lưu ý rằng chú thích tùy chọn @tailrec rất hữu ích để đảm bảo rằng phương thức thực sự là đệ quy đuôi. Trình biên dịch Scala dịch các cuộc gọi đệ quy đuôi thành mã byte tương đương với các vòng lặp while.

Một cách nữa:

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

scala> for (i <- xs.indices)
     |   println(i + ": " + xs(i))
0: first
1: second
2: third

Trên thực tế, scala có các vòng lặp kiểu Java cũ với chỉ mục:

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

Where 0 until xs.lengthhoặc 0.until(xs.length)là một RichIntphương thức trả về Rangephù hợp với lặp.

Ngoài ra, bạn có thể thử vòng lặp với 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

Còn cái này thì sao?

val a = Array("One", "Two", "Three")
a.foldLeft(0) ((i, x) => {println(i + ": " + x); i + 1;} )

Đầu ra:

0: One
1: Two
2: Three

Vòng lặp trong scala khá đơn giản. Tạo bất kỳ mảng nào bạn chọn cho người yêu cũ.

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

Các loại vòng lặp,

for(data <- myArray)println(data)

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

Thật vậy, việc gọi zipWithIndexmột bộ sưu tập sẽ đi qua nó và cũng tạo ra một bộ sưu tập mới cho các cặp. Để tránh điều này, bạn chỉ có thể gọi zipWithIndextrình vòng lặp cho bộ sưu tập. Điều này sẽ chỉ trả về một trình lặp mới theo dõi chỉ mục trong khi lặp, do đó mà không cần tạo thêm một bộ sưu tập hoặc duyệt bổ sung.

Đây là cách scala.collection.Iterator.zipWithIndexhiện được triển khai trong 2.10.3:

  def zipWithIndex: Iterator[(A, Int)] = new AbstractIterator[(A, Int)] {
    var idx = 0
    def hasNext = self.hasNext
    def next = {
      val ret = (self.next, idx)
      idx += 1
      ret
    }
  }

Điều này thậm chí sẽ hiệu quả hơn một chút so với việc tạo chế độ xem trên bộ sưu tập.

Không có gì trong stdlib sẽ làm điều đó cho bạn mà không cần tạo tuple rác, nhưng không quá khó để viết cho riêng bạn. Thật không may, tôi chưa bao giờ bận tâm để tìm ra cách thực hiện CanBuildF thích hợp từ mưa ngầm để biến những thứ như vậy trở nên chung chung trong loại bộ sưu tập mà chúng áp dụng, nhưng nếu có thể, tôi chắc rằng ai đó sẽ khai sáng cho chúng tôi. :)

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)
}

Một số cách khác để lặp lại:

scala>  xs.foreach (println) 
first
second
third

foreach, và tương tự, map, sẽ trả về một thứ gì đó (kết quả của hàm, đối với println, Unit, vì vậy một Danh sách các Unit)

scala> val lens = for (x <- xs) yield (x.length) 
lens: Array[Int] = Array(5, 6, 5)

làm việc với các phần tử, không phải chỉ mục

scala> ("" /: xs) (_ + _) 
res21: java.lang.String = firstsecondthird

gấp

for(int i=0, j=0; i+j<100; i+=j*2, j+=i+2) {...}

có thể được thực hiện với đệ quy:

def ijIter (i: Int = 0, j: Int = 0, carry: Int = 0) : Int =
  if (i + j >= 100) carry else 
    ijIter (i+2*j, j+i+2, carry / 3 + 2 * i - 4 * j + 10) 

Phần mang theo chỉ là một số ví dụ, để làm điều gì đó với i và j. Nó không cần phải là một Int.

đối với những thứ đơn giản hơn, gần với vòng lặp for thông thường:

scala> (1 until 4)
res43: scala.collection.immutable.Range with scala.collection.immutable.Range.ByOne = Range(1, 2, 3)

scala> (0 to 8 by 2)   
res44: scala.collection.immutable.Range = Range(0, 2, 4, 6, 8)

scala> (26 to 13 by -3)
res45: scala.collection.immutable.Range = Range(26, 23, 20, 17, 14)

hoặc không có lệnh:

List (1, 3, 2, 5, 9, 7).foreach (print) 

Tôi có các cách tiếp cận sau

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);

   }
}

Một cách đơn giản và hiệu quả, lấy cảm hứng từ việc triển khai transformtrong SeqLike.scala

    var i = 0
    xs foreach { el =>
      println("String #" + i + " is " + xs(i))
      i += 1
    }

Các giải pháp được đề xuất gặp phải thực tế là chúng hoặc lặp lại một cách rõ ràng qua một bộ sưu tập hoặc nhồi bộ sưu tập vào một hàm. Tự nhiên hơn là gắn bó với các thành ngữ thông thường của Scala và đặt chỉ mục bên trong các phương thức map- hoặc foreach thông thường. Điều này có thể được thực hiện bằng cách sử dụng ghi nhớ. Mã kết quả có thể trông giống như

myIterable map (doIndexed(someFunction))

Đây là một cách để đạt được mục đích này. Hãy xem xét tiện ích sau:

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)
    }
}

Đây đã là tất cả những gì bạn cần. Bạn có thể áp dụng điều này ví dụ như sau:

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

kết quả nào trong danh sách

List(97, 99, 101)

Bằng cách này, bạn có thể sử dụng các chức năng Traversable thông thường với chi phí đóng gói chức năng hiệu quả của bạn. Thưởng thức!