Wiederholung mit while

Computer sind ideal für sich wiederholende Aufgaben.

Die grundlegendste Form der Wiederholung verwendet das Schlüsselwort while. Dies wiederholt einen Block, solange der kontrollierende boolesche Ausdruck true ist:

while (Boolean-expression) {
  // Code to be repeated
}

Der boolesche Ausdruck wird einmal zu Beginn der Schleife und erneut vor jeder weiteren Iteration durch den Block ausgewertet.

// RepetitionWithWhile/WhileLoop.kt

fun condition(i: Int) = i < 100  // [1]

fun main() {
  var i = 0
  while (condition(i)) {         // [2]
    print(".")
    i += 10                      // [3]
  }
}
/* Output:
..........
*/

• [1] Der Vergleichsoperator < liefert ein Boolescher Wert Ergebnis, daher leitet Kotlin Boolescher Wert als Ergebnistyp für condition() ab.
• [2] Der bedingte Ausdruck für das while besagt: “Wiederhole die Anweisungen im Körper, solange condition() true zurückgibt.”
• [3] Der += Operator addiert 10 zu i und weist das Ergebnis i in einem einzigen Vorgang zu (i muss eine var sein, damit dies funktioniert). Dies entspricht:

i = i + 10

Es gibt eine zweite Möglichkeit, while in Verbindung mit dem Schlüsselwort do zu verwenden:

do {
  // Code to be repeated
} while (Boolean-expression)

Das Umschreiben von WhileLoop.kt, um eine do-while-Schleife zu verwenden, ergibt:

// RepetitionWithWhile/DoWhileLoop.kt

fun main() {
  var i = 0
  do {
    print(".")
    i += 10
  } while (condition(i))
}
/* Output:
..........
*/

Der einzige Unterschied zwischen while und do-while besteht darin, dass der Körper von do-while immer mindestens einmal ausgeführt wird, selbst wenn der boolesche Ausdruck anfänglich false ergibt. Bei einem while wird der Körper nie ausgeführt, wenn die Bedingung beim ersten Mal false ist. In der Praxis ist do-while weniger verbreitet als while.

Die Kurzformen der Zuweisungsoperatoren sind für alle arithmetischen Operationen verfügbar: +=, -=, *=, /=, und %=. Hier werden -= und %= verwendet:

// RepetitionWithWhile/AssignmentOperators.kt

fun main() {
  var n = 10
  val d = 3
  print(n)
  while (n > d) {
    n -= d
    print(" - $d")
  }
  println(" = $n")

  var m = 10
  print(m)
  m %= d
  println(" % $d = $m")
}
/* Output:
10 - 3 - 3 - 3 = 1
10 % 3 = 1
*/

Um den Rest der ganzzahligen Division von zwei natürlichen Zahlen zu berechnen, beginnen wir mit einer while-Schleife und verwenden dann den Restoperator.

Das Hinzufügen und Subtrahieren von 1 zu einer Zahl ist so häufig, dass sie eigene Inkrement- und Dekrementoperatoren haben: ++ und --. Sie können i += 1 durch i++ ersetzen:

// RepetitionWithWhile/IncrementOperator.kt

fun main() {
  var i = 0
  while (i < 4) {
    print(".")
    i++
  }
}
/* Output:
....
*/

In der Praxis werden while-Schleifen nicht zum Iterieren über einen Bereich von Zahlen verwendet. Stattdessen wird die for-Schleife verwendet. Dies wird im nächsten Atom behandelt.

Übungen und Lösungen finden Sie unter www.AtomicKotlin.com.