为什么在 Kotlin 中删除了索引 for 循环？

Question

我仍然认为使用 for 循环的“传统”方式非常强大，可以完全控制索引。为什么它在 Kotlin 中被移除？

我应该在 kotlin 中使用以下 java 代码做什么

for (int i = 0; i < n - 1; i++) {
   for (int j = i + 1; j < n; j++) {
   ....

Answer 1

答案是：因为他们决定删除它。 你仍然可以使用这个语法：

for (a in 1..10) print("$a ")              // >>> 1 2 3 4 5 6 7 8 9 10

for (a in 10 downTo 1 step 2) print("$a ") // >>> 10 8 6 4 2 

更多信息：Ranges & Loops

Answer 2

如果你想同时获取索引和值，可以使用这个。

for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}

这很简单。

来源：Kotlin Official Documentation - Control Flow

Answer 3

保留这些索引的另一种有用的方法是使用withIndex() 方法进行迭代（即Iterable）。例如：

for((i, element) in myIterable.withIndex()){
    //do something with your element and the now known index, i
}

我注意到这与 this 答案中建议的实现相同，但我认为如果我们使用 Iterables 已经为此类情况提供的内置方法而不是再次实现它们会更好。我们可以说这也类似于forEachIndexed{} lambda：

myIterable.forEachIndexed{i, element ->
    //do something here as well
}

Answer 4

我认为他们这样做的原因（“未删除”）是因为他们想让 Kotlin 更具表现力。

例如，在java中我们可以这样创建一个for循环：

for(int x = 1; x <= 10; x++) {
   System.out.print(x);
}

你想要做的只是，你想打印出 从 1 到 10 的值，就是这样。所以 Kotlin 决定把你的话翻译成代码，去掉不必要的冗长。

for (x in 1..10) print("$x") 

Answer 5

在 Kotlin 中无需使用传统的 for 循环，因为您可以使用 Kotlin lambda 使您的代码更具表现力和可读性。例如：

arrayOf(1, 2, 3).forEachIndexed { index, item -> /**TODO**/}

Kotlin 只支持for-each 循环， for-each 循环接受任何 Iterables/ Arrays/ 类型具有 iterator 运算符。

IF你想回用for-each循环表达式，你可以写如下代码，你可以看到for-each循环会比lamda多，这是为什么java-8中引入了stream api和功能接口：

val array  = arrayOf(1, 2, 3)

for(index in array.indices){
  val item = array[index]
  // todo
}

如果你需要回到传统的for循环你可以使用repeat来代替，例如：

repeat(5){index-> /**TODO**/}

Answer 6

它没有被“删除”。新语言的设计不是从任何现有语言的功能集开始的；我们从一门没有特征的语言开始，然后开始添加以良好和惯用的方式表达某些行为所必需的特征。到目前为止，我们还没有发现 C 风格的“for”循环是表达它的最好和最惯用的方式。

Answer 7

您可以创建自己的函数来实现“完全控制索引的传统循环”。 或非传统。 例如，混合forEachIndexed()、with()、count()，索引为 1。

inline fun <T> Iterable<T>.forWithIndexed1(action: T.(index: Int) -> Unit): Int {
    var index = 0
    for (item in this) item.action(++index)
    return index
}

Answer 8

这没有任何意义，因为有时您希望拥有更多带有自定义步骤的自定义循环，而这种结构会从逻辑中删除它

var array = ["-m", "/test/app", "-w", "us"];

for (var i = 0; i < array.length; i += 2) {
    console.log("option =" + array[i]);
    console.log("value =" + array[i+1])
}

使用当前的 kotlin 循环，我们失去了一些简单性。

Answer 9

Kotlin 正在尝试强制执行流畅的迭代，它涵盖了绝大多数循环结构。但是，我需要一个具有立即终止状态范围的传统 for 循环（如 java）、在循环体执行之前评估的退出条件和执行后操作（我的用例很复杂：我需要使用动态退出重复基于压缩例程和 2) 的幂的条件。我想出了这些通用功能：

fun <S> forloop(state: S, condition: (s: S) -> Boolean, postExecution: (s: S) -> Unit, block: (s: S) -> Unit) {
  while (condition(state)) {
    block(state)
    postExecution(state)
  }
}

data class SingleIndex(var i: Int)
fun forloop(i: Int, condition: (s: SingleIndex) -> Boolean, postExecution: (s: SingleIndex) -> Unit, block: (s: SingleIndex) -> Unit) {
  forloop(SingleIndex(i), condition, postExecution, block)
}

例子here:

fun main() {
    forloop(0, {it.i < 10}, {++it.i}) {
        println("forloop test: i=${it.i}")
    }

    data class State(var i: Int, var j: Int)
    forloop(State(0, 1), {it.i < 10}, {++it.i; it.j += it.i}) {
        println("forloop test: i=${it.i}, j=${it.j}")
    }
}

尽管根据语言哲学，您应该只在极少数情况下使用它。

Answer 10

generateSequence(0) { it + 2 }.takeWhile { it < array.length }.forEach {
    // Do something useful
}

Answer 11

它没有被删除。这只是它的不同语法。 相当于Java代码：

for (int i = 0; i < n - 1; i++) {
   for (int j = i + 1; j < n; j++) {

在 Kotlin 中会这样写：

val n = 10
for (i in 0..n-2) {
    for (j in i+1..n-1) {
        println("I'm low level for loop! I just look more friendly.")
    }
}

为了代码简洁，Kotlin 使用Ranges 来定义循环的迭代器。

Answer 12

为什么？ “传统”循环是“索引超出范围”异常的原因，不像 集合项目的循环。

Answer 13

对于这种确切情况，可以使用以下双循环：

for (i in 0 until n) {
        for (j in (i + 1) .. n) {

Answer 14

for (i in generateSequence(0) { it + 2 }.takeWhile { it < array.length }) {
    // do something useful
}