Scala för backendutveckling och funktionell programmering · Lektion

Använda REPL

Interaktiv Scala.

Lektion 1 av 413 steg

Använda REPL är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad är REPL?

REPL står för Read-Eval-Print Loop. Det är ett interaktivt skal där Ni skriver Scala-uttryck och omedelbart ser deras resultat.

Ni startar det genom att köra scala (eller scala-cli repl) i terminalen. Det är det snabbaste sättet att experimentera med språket utan att skriva ett helt program.

Ert första uttryck

Skriv valfritt uttryck och tryck på Enter. REPL utvärderar det och skriver ut resultatet, dess typ och ett genererat namn.

Om Ni till exempel skriver 1 + 1 visas något i stil med val res0: Int = 2.

object Main {
  def main(args: Array[String]): Unit = {
    println(1 + 1)
  }
}

res-variabler

Varje resultat Ni beräknar sparas automatiskt i en variabel med namnet resN (res0, res1, ...).

Ni kan återanvända dessa namn i senare uttryck, vilket får REPL att kännas som en kalkylator som hela tiden är igång.

object Main {
  def main(args: Array[String]): Unit = {
    val res0 = 2 + 3
    val res1 = res0 * 10
    println(res1)
  }
}

Typinformation

En av de mest användbara funktionerna är att REPL visar typen för varje resultat.

Om Ni skriver "hello" skrivs val res0: String = hello ut. Det hjälper Er att lära Er vilken typ Scala härleder för olika uttryck.

object Main {
  def main(args: Array[String]): Unit = {
    val greeting = "hello"
    println(greeting)
  }
}

Definiera värden

Ni kan definiera namngivna värden i REPL med hjälp av val. De finns kvar under resten av sessionen.

När de har definierats kan Ni referera till dem på alla senare rader.

object Main {
  def main(args: Array[String]): Unit = {
    val pi = 3.14159
    val radius = 2.0
    println(pi * radius * radius)
  }
}

Definiera funktioner

Ni är inte begränsad till enradsuttryck. Ni kan definiera funktioner direkt i REPL och anropa dem direkt.

På så sätt kan Ni bygga upp små hjälpverktyg och testa dem omedelbart.

object Main {
  def square(x: Int): Int = x * x
  def main(args: Array[String]): Unit = {
    println(square(5))
  }
}

Indata över flera rader

Om Ni skriver något ofullständigt, till exempel en oavslutad klammerparentes, visar REPL en fortsättningsprompt och väntar på resten.

Det innebär att Ni naturligt kan klistra in eller skriva definitioner över flera rader utan att REPL försöker utvärdera dem för tidigt.

object Main {
  def main(args: Array[String]): Unit = {
    val total =
      1 +
      2 +
      3
    println(total)
  }
}

Importera i REPL

Ni kan använda import var som helst i REPL, precis som i en fil. Det är praktiskt när Ni vill ta in hjälpverktyg från standardbiblioteket.

Exempelvis ger import scala.math.* Er tillgång till sqrt, abs med mera.

import scala.math.sqrt
object Main {
  def main(args: Array[String]): Unit = {
    println(sqrt(16.0))
  }
}

Användbara REPL-kommandon

REPL har särskilda kommandon som börjar med ett kolon:

:help listar alla kommandon
:reset rensar sessionen
:quit avslutar REPL
:type expr visar typen för ett uttryck utan att köra det

Varför använda REPL?

REPL passar perfekt för att:

Snabbt prova ett obekant API
Kontrollera vilken typ ett uttryck ger
Ta fram en prototyp av logik innan Ni lägger till den i ett projekt
Lära Er språket interaktivt

Kombinera allt

Under en och samma session kan Ni definiera värden, skriva funktioner, importera bibliotek och kedja ihop resultat. REPL håller allt detta i omfånget.

Här är ett litet exempel som Ni kan bygga rad för rad.

object Main {
  def celsiusToF(c: Double): Double = c * 9 / 5 + 32
  def main(args: Array[String]): Unit = {
    val temps = List(0.0, 25.0, 100.0)
    println(temps.map(celsiusToF))
  }
}

Snabbtest

Testa Er förståelse av Scala REPL.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er att REPL är en interaktiv Read-Eval-Print Loop för Scala.

Det skriver ut värdet, typen och ett automatiskt resN-namn för varje resultat
Ni kan definiera val och funktioner som finns kvar i sessionen
Ni kan importera bibliotek och använda indata över flera rader
Kommandon som :type, :reset och :quit styr sessionen

Gratis att börja

Lär dig Scala med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 143

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Använda REPL” gratis?

Ja – hela texten till ”Använda REPL” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Använda REPL”?

Interaktiv Scala. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?

Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Använda REPL”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?

Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Scala för backendutveckling och funktionell programmering