Kotlin kehrt zurück, bricht ab, weiter Keywords

Kotlin zurück, Pause, weiter Keywords

1. Überblick

In diesem Tutorial werden wir die Verwendung von strukturellen Sprungausdrücken in Kotlin diskutieren.

Einfach ausgedrückt,Kotlin has three structural jump expressions: return, break, continue. In den nächsten Abschnitten werden wir ihre Funktionen mit und ohne Beschriftung behandeln.

2. Etiketten in Kotlin

Beliebige Ausdrücke in Kotlin können mit einem Label gekennzeichnet werden.

We create a label by using an identifier followed by the “@” sign. Beispielsweise sind[email protected],[email protected] gültige Bezeichnungen.

Um einen Ausdruck zu beschriften, fügen wir einfach die Beschriftung davor hinzu:

[email protected] for (i in 1..10) {
    // some code
}

3. DieBreak-Anweisung

Ohne Beschriftung beendetbreak die nächste umschließende Schleife.

Schauen wir uns ein Beispiel an:

@Test
fun givenLoop_whenBreak_thenComplete() {
    var value = ""
    for (i in "hello_world") {
        if (i == '_') break
        value += i.toString()
    }
    assertEquals("hello", value)
}

Alternativ können wirbreak with a label, which terminates the loop marked with that label: verwenden

@Test
fun givenLoop_whenBreakWithLabel_thenComplete() {
    var value = ""
    [email protected] for (i in 'a'..'d') {
        for (j in 1..3) {
            value += "" + i + j
            if (i == 'b' && j == 1)
                [email protected]_loop
        }
    }
    assertEquals("a1a2a3b1", value)
}

In diesem Fall wird die äußere Schleife beendet, wenn die Variableni undj gleich "b" bzw. "1" sind.

4. DieContinue-Anweisung

Schauen wir uns als nächstes das Schlüsselwortcontinuean, das wir auch mit oder ohne Beschriftung verwenden können.

Ohne Beschriftung fährtcontinue mit der nächsten Iteration der umschließenden Schleife fort:

@Test
fun givenLoop_whenContinue_thenComplete() {
    var result = ""
    for (i in "hello_world") {
        if (i == '_') continue
        result += i
    }
    assertEquals("helloworld", result)
}

Andererseits istwhen we use continue with a label marking a loop, it will proceed to the next iteration of that loop:

@Test
fun givenLoop_whenContinueWithLabel_thenComplete() {
    var result = ""
    [email protected] for (i in 'a'..'c') {
        for (j in 1..3) {
            if (i == 'b') [email protected]_loop
            result += "" + i + j
        }
    }
    assertEquals("a1a2a3c1c2c3", result)
}

In diesem Beispiel haben wircontinue verwendet, um eine Iteration der mitouter_loop. bezeichneten Schleife zu überspringen

5. DieReturn-Anweisung

Ohne Label ist esreturns to the nearest enclosing function or anonymous function:

@Test
fun givenLambda_whenReturn_thenComplete() {
    var result = returnInLambda();
    assertEquals("hello", result)
}

private fun returnInLambda(): String {
    var result = ""
    "hello_world".forEach {
        if (it == '_') return result
        result += it.toString()
    }
    //this line won't be reached
    return result;
}

Return ist auch nützlich, wenn wirapply continue logic on anonymousfunctions: wollen

@Test
fun givenAnonymousFunction_return_thenComplete() {
    var result = ""
    "hello_world".forEach(fun(element) {
        if (element == '_') return
        result += element.toString()
    })
    assertEquals("helloworld", result)
}

In diesem Beispiel kehrt die Anweisungreturnzum Aufrufer des anonymen Spaßes zurück, d. H. dieforEach-Schleife.

In the case of a lambda expression, we can also use return with a label, um ein ähnliches Ergebnis zu erzielen:

@Test
fun givenLambda_whenReturnWithExplicitLabel_thenComplete() {
    var result = ""
    "hello_world".forEach [email protected]{
        if (it == '_') {
            [email protected]
        }
        result += it.toString()
    }
    assertEquals("helloworld", result)
}

Alternativ können wir auchreturn using an implicit label:

@Test
fun givenLambda_whenReturnWithImplicitLabel_thenComplete() {
    var result = ""
    "hello_world".forEach {
        if (it == '_') {
            // local return to the caller of the lambda, i.e. the forEach loop
            [email protected]
        }
        result += it.toString()
    }
    assertEquals("helloworld", result)
}

Im obigen Beispiel kehrt die return-Anweisung auch zum Aufrufer des Lambda zurück - derforEach-Schleife.

Schließlich kannreturn mit einer Bezeichnung fürapply break logic to lambda expressions byreturning to a label outside verwendet werden:

@Test
fun givenAnonymousFunction_returnToLabel_thenComplete() {
    var result = ""
    run [email protected]{
        "hello_world".forEach {
            if (it == '_') [email protected]
            result += it.toString()
        }
    }
    assertEquals("hello", result)
}

6. Fazit

In diesem Artikel haben wir die Anwendungsfälle vonreturn, break, continue in Kotlin durchgearbeitet.

Der Beispielcode konnteover on Github. gefunden werden

TOC