Kotlin terugkeren, breken, doorgaan Trefwoorden

1. Overzicht

In deze tutorial bespreken we het gebruik van structurele spronguitdrukkingen in Kotlin.

Simpel gezegd, Kotlin heeft drie structurele spronguitdrukkingen: terugkeren, breken, doorgaan. In de volgende secties bespreken we hun functionaliteiten met en zonder label.

2. Etiketten in Kotlin

Alle uitdrukkingen in Kotlin kunnen worden gemarkeerd met een label.

We maken een label door een identifier te gebruiken gevolgd door de "@” teken. Bijvoorbeeld, [e-mail beveiligd], [e-mail beveiligd] zijn geldige labels.

Om een ​​uitdrukking te labelen, voegen we het label er gewoon voor toe:

[e-mail beschermd] voor (i in 1..10) {// enige code}

3. Het Breken Uitspraak

Zonder label, breken beëindigt de dichtstbijzijnde omsluitende lus.

Laten we een voorbeeld bekijken:

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

Als alternatief kunnen we gebruiken breken met een label, dat de lus beëindigt die met dat label is gemarkeerd:

@Test plezier gegevenLoop_whenBreakWithLabel_thenComplete () {var value = "" [e-mail beveiligd] voor (i in 'a' .. 'd') {voor (j in 1..3) {waarde + = "" + i + j if (i == 'b' && j == 1) [email protected] _loop}} assertEquals ("a1a2a3b1", value)}

In dit geval wordt de buitenste lus beëindigd wanneer de ik en j variabelen zijn respectievelijk gelijk aan "b" en "1".

4. Het Doorgaan met Uitspraak

Laten we vervolgens eens kijken naar het doorgaan met trefwoord, dat we ook met of zonder label kunnen gebruiken.

Zonder label, doorgaan met zal doorgaan naar de volgende iteratie van de omsluitende lus:

@Test plezier gegevenLoop_whenContinue_thenComplete () {var result = "" for (i in "hello_world") {if (i == '_') vervolg resultaat + = i} assertEquals ("helloworld", resultaat)}

Aan de andere kant, wanneer we gebruiken doorgaan met met een label dat een lus markeert, gaat het door naar de volgende iteratie van die lus:

@Test plezier gegevenLoop_whenContinueWithLabel_thenComplete () {var result = "" [e-mail beveiligd] voor (i in 'a' .. 'c') {voor (j in 1..3) {if (i == 'b') [ beveiligd met e-mail] _loop resultaat + = "" + i + j}} assertEquals ("a1a2a3c1c2c3", resultaat)}

In dit voorbeeld hebben we gebruikt doorgaan met om een ​​herhaling van de lus met het label over te slaan outer_loop.

5. Het Keer terug Uitspraak

Zonder label wel keert terug naar de dichtstbijzijnde omsluitende functie of anonieme functie:

@Test plezier gegevenLambda_whenReturn_thenComplete () {var resultaat = returnInLambda (); assertEquals ("hallo", resultaat)} privé plezier returnInLambda (): String {var result = "" "hello_world" .forEach {if (it == '_') resultaat resultaat + = it.toString ()} // deze regel wordt niet bereikt retour resultaat; }

Keer terug is ook handig als we dat willen van toepassing zijn doorgaan met logica op anoniemfuncties:

@Test plezier gegevenAnonymousFunction_return_thenComplete () {var result = "" "hello_world" .forEach (fun (element) {if (element == '_') resultaat retourneren + = element.toString ()}) assertEquals ("helloworld", resultaat )}

In dit voorbeeld is de terugkeer -verklaring keert terug naar de beller van het anonieme plezier, d.w.z. de voor elk lus.

In het geval van een lambda-uitdrukking kunnen we ook gebruiken terugkeer met een label om een ​​vergelijkbaar resultaat te bereiken:

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

Als alternatief kunnen we ook terugkeer met behulp van een impliciet label:

@Test fun givenLambda_whenReturnWithImplicitLabel_thenComplete () {var result = "" "hello_world" .forEach {if (it == '_') {// lokale terugkeer naar de beller van de lambda, dwz de forEach loop [email protected]} resultaat + = it.toString ()} assertEquals ("helloworld", resultaat)}

In het bovenstaande voorbeeld keert de return-instructie ook terug naar de aanroeper van de lambda - de voor elk lus.

Tenslotte, terugkeer kan worden gebruikt met een label aan van toepassing zijn breken logica voor lambda-uitdrukkingen doorterugkeren naar een label buiten:

@Test plezier gegevenAnonymousFunction_returnToLabel_thenComplete () {var result = "" run [e-mail beschermd] {"hello_world" .forEach {if (it == '_') [e-mail beschermd] resultaat + = it.toString ()}} assertEquals (" hallo ", resultaat)}

6. Conclusie

In dit artikel hebben we de use-cases van terugkeren, breken, doorgaan in Kotlin.

De voorbeeldcode kan worden gevonden op GitHub.