Scala For-Schleife | For-Schleife in Scala: Erklärt

In Scala wird eine for-Schleife auch als for-comprehensions bezeichnet . Es kann verwendet werden, um eine geprobte Sammlung zu iterieren, zu filtern und zurückzugeben. Die for-Verständnis sieht einer for-Schleife in imperativen Sprachen ziemlich ähnlich ; Der Unterschied besteht jedoch darin, dass es eine Liste der Ergebnisse von Alliterationen zusammenstellt.

Es gibt mehrere Formen der for-Schleife in Scala , die im Folgenden beschrieben werden:

For-Schleife mit Ranges

Syntax

Die unkomplizierteste Syntax einer for-Schleife mit Bereichen in Scala sieht wie folgt aus:

for( var x <- Bereich ) {

Aussage(n);

}

Wie oben dargestellt, kann der Bereich ein beliebiger Zahlenbereich sein, der als i bis j oder manchmal als i bis j dargestellt wird . Der Linkspfeil ←-Operator wird als Generator bezeichnet, da er einzelne Werte aus einem Bereich generiert.

Alternativ kann man auch die Syntax verwenden:

for(w <-bereich){

// Code..

}

Hier ist w eine Variable, das Linkspfeilzeichen ← der Operator ist der Generator, und der Bereich ist der Wert, der die Start- und Endwerte enthält. Der Bereich wird dargestellt, indem entweder i bis j oder i bis j verwendet wird.

Beispiel einer Scala-For-Schleife mit dem Schlüsselwort „to“

Die Verwendung von 'to' mit for-Schleife schließt sowohl den Anfangs- als auch den Endwert ein. Im unten gezeigten Beispiel können wir „to“ verwenden, um Werte zwischen 0 und n auszugeben. Mit anderen Worten, die Schleife beginnt bei 0 und endet bei 10, was bedeutet, dass wir Seitenzahlen von 0 bis 10 drucken können.

// Scala-Programm zur Veranschaulichung der Vorgehensweise

// For-Schleife mit to erstellen

Objekt Haupt

{

def main(args: Array[String])

{

println("Der Wert von w ist:");

// Hier beginnt die for-Schleife bei 0

// und endet um 10

für ( w <- 0 bis 10)

{

println(w);

}

}

}

Ausgabe:

Im oben gezeigten Beispiel ist der Wert von w:

0

1

2

3

4

5

6

7

8

9

10

Lesen Sie: Die 10 wichtigsten Fähigkeiten, um ein Full-Stack-Entwickler zu werden

Beispiel einer Scala-For-Schleife mit dem Schlüsselwort „until“

Der Unterschied zwischen der Verwendung von until und to ist; to schließt die Anfangs- und Endwerte eines Bereichs ein, während until den letzten Wert des angegebenen Bereichs ausschließt. In dem unten abgebildeten for-Schleife- Beispiel können wir until verwenden , um Werte zwischen 0 und n-1 auszugeben. Mit anderen Worten, die Schleife beginnt bei 0 und endet bei n-1, was 9 ergibt. Wir können also die Seitenzahlen 0 bis 9 drucken.

// Scala-Programm zur Veranschaulichung der Vorgehensweise

// For-Schleife mit until erstellen

Objekt Haupt

{

def main(args: Array[String])

{

println("Der Wert von w ist:");

// Hier beginnt die for-Schleife bei 0

// und endet um 10

für( w <- 0 bis 10)

{

println(w);

}

}

}

Ausgabe:

Im oben gezeigten Beispiel ist der Wert von w:

0

1

2

3

4

5

6

7

8

9

Lesen Sie auch: Python vs. Scala

Mehrere Werte in der For-Schleife

Wir können auch mehrere Bereiche in einer einzigen for-Schleife verwenden . Diese Bereiche werden durch ein Semikolon (;) getrennt. Lassen Sie uns dies anhand einer Illustration verstehen. In dem unten angegebenen Beispiel haben wir zwei verschiedene Bereiche in einer einzigen Schleife verwendet, dh w < – 0 bis 3; z <- 8 bis 10.

// Scala-Programm zur Veranschaulichung der Vorgehensweise

// mehrere Bereiche in for-Schleife erstellen

Objekt Haupt

{

def main(args: Array[String])

{

// for-Schleife mit mehreren Bereichen

for( w <- 0 bis 3; z <- 8 bis 10 )

{

println("Wert von w ist:" +w);

println("Wert von y ist:" +z);

}

}

}

Ausgabe:

Der Wert von w ist:0

Wert von y ist:8

Der Wert von w ist:0

Wert von y ist:9

Der Wert von w ist:1

Wert von y ist:8

Der Wert von w ist :1

Wert von y ist:9

Der Wert von w ist:2

Wert von y ist:8

Der Wert von w ist:2

Wert von y ist:9

Der Wert von w ist:3

Wert von y ist:8

Der Wert von w ist:3

Wert von y ist:9

Checkout: Full-Stack-Entwicklergehalt in Indien

For-Schleife mit Sammlungen

In Scala können wir die for-Schleife verwenden , um Sammlungen wie Listen, Sequenzen usw. effizient zu iterieren, indem wir entweder eine for-each-Schleife oder eine for-comprehensions-Schleife verwenden . Die Syntax einer for-Schleife mit Sammlungen in Scala sieht wie folgt aus:

Syntax

for( var x <- Liste ){

Erklärung(en);

}

Hier ist die Variablenliste ein Sammlungstyp mit einer Liste von Elementen, und eine for-Schleife durchläuft alle Elemente, die jeweils ein Element in der x-Variablen zurückgeben.

Schauen wir uns das unten angegebene Demoprogramm an, um eine for-Schleife mit Sammlungen zu verstehen . In der Abbildung haben wir eine Sammlung mit der List -Variablen erstellt, um Autoren basierend auf ihren Rängen aufzulisten.

// Scala-Programm zur Veranschaulichung der Vorgehensweise

// for-Schleife mit Sammlung verwenden

Objekt Haupt

{

def main(args: Array[String])

{

Var-Rang = 0;

val Rangliste = Liste (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// For-Schleife mit Sammlung

for( Rang <- Rangliste) {

println("Autor-Rang ist: " +Rang);

}

}

}

Ausgabe:

Autorenrang ist: 1

Autorenrang ist: 2

Autorenrang ist: 3

Autorenrang ist: 4

Autorenrang ist: 5

Autorenrang ist: 6

Autorenrang ist: 7

Autorenrang ist: 8

Autorenrang ist: 9

Autorenrang ist: 10

For-Schleife mit Filtern

Mit der for-Schleife in Scala können Sie Elemente aus einer bestimmten Sammlung mithilfe einer oder mehrerer if - Anweisungen in der for-Schleife filtern . Benutzer können auch mehr als einen Filter zu einem „for“ -Ausdruck hinzufügen, indem sie Semikolons (;) verwenden, um sie zu trennen. Unten ist die Syntax für for-Schleife mit Filtern aufgeführt .

Syntax

for( var x <-List

wenn Bedingung1; wenn Bedingung2…

){

Erklärung(en);

}

Lassen Sie uns dies anhand eines Beispiels besser verstehen. Die folgende Abbildung verwendet zwei Filter, um die angegebene Sammlung zu trennen. Im folgenden Beispiel eliminieren die Filter beispielsweise die Liste der Autoren mit Rängen größer als 2 und kleiner als 7.

// Scala-Programm zur Veranschaulichung der Vorgehensweise

// For-Schleife mit Filtern verwenden

Objekt Haupt

{

def main(args: Array[String])

{

Var-Rang = 0;

val Rangliste = Liste (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// For-Schleife mit Filtern

for( rank <- rangliste

wenn Rang < 7; wenn Rang > 2 )

{

println("Autor-Rang ist: " +Rang);

}

}

}

Ausgabe:

Autorenrang ist: 3

Autorenrang ist: 4

Autorenrang ist: 5

Autorenrang ist: 6

For-Schleife mit Yield

In Scala wird der Rückgabewert der Schleife in einer Variablen gespeichert oder kann über eine Funktion zurückgegeben werden. Dazu sollten Sie dem Hauptteil des 'for'- Ausdrucks das Schlüsselwort yield voranstellen . Unten ist die Syntax für for-Schleife mit yield aufgeführt .

Syntax

var retVal = for{ var x <- Liste

wenn Bedingung1; wenn Bedingung2…

}

Ausbeute x

Hinweis − Die geschweiften Klammern listen die Variablen und Bedingungen auf, und retVal ist eine Variable, in der alle Werte von x in Form einer Sammlung gespeichert werden.

Lassen Sie uns dies anhand einer Illustration besser verstehen. In dem unten angegebenen Beispiel ist die Ausgabe eine Variable, in der alle Rangwerte in Form einer Sammlung gespeichert sind. Die for-Schleife zeigt nur die Liste der Autoren an, deren Rang größer als 4 und kleiner als 8 ist.

// Scala-Programm zur Veranschaulichung der Vorgehensweise

// For-Schleife mit Erträgen verwenden

Objekt Haupt

{

def main(args: Array[String])

{

Var-Rang = 0;

val Rangliste = Liste (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// For-Schleife mit Erträgen

var output = for{ rank <- ranklist

wenn Rang > 4; wenn Rang != 8 }

Rang erbringen

// Ergebnis anzeigen

für (Rang <- Ausgabe)

{

println("Autor-Rang ist: " + Rang);

}

}

}

Ausgabe:

Autorenrang ist: 5

Autorenrang ist: 6

Autorenrang ist: 7

Autorenrang ist: 9

Autorenrang ist: 10

Lernen Sie Softwareentwicklungskurse online von den besten Universitäten der Welt. Verdienen Sie Executive PG-Programme, Advanced Certificate-Programme oder Master-Programme, um Ihre Karriere zu beschleunigen.

Fazit

Wenn Sie mehr über Full-Stack-Softwareentwicklung erfahren möchten, schauen Sie sich das Executive PG-Programm in Full-Stack-Softwareentwicklung von upGrad & IIIT-B an, das für Berufstätige konzipiert ist und mehr als 500 Stunden strenge Schulungen, mehr als 9 Projekte, und Aufgaben, IIIT-B-Alumni-Status, praktische praktische Abschlussprojekte und Arbeitsunterstützung bei Top-Unternehmen.