Scala för backendutveckling och funktionell programmering · Lektion

Uttryck framför satser

Allt är ett uttryck.

Lektion 3 av 413 steg

Uttryck framför satser är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 3 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.

Uttryck jämfört med satser

En sats utför något men returnerar inget användbart. Ett uttryck utvärderas till ett värde.

I Scala är nästan allt ett uttryck. Det är en grundidé som påverkar hur Ni skriver kod.

if är ett uttryck

I många språk är if en sats. I Scala returnerar if/else ett värde, så Ni kan tilldela det direkt till en val.

Det behövs ingen separat variabel som tilldelas i varje gren.

object Main {
  def main(args: Array[String]): Unit = {
    val temp = 30
    val label = if (temp > 25) "hot" else "mild"
    println(label)
  }
}

Block är uttryck

Ett block { ... } är också ett uttryck. Dess värde är värdet på den sista raden.

Ni kan alltså beräkna mellanliggande värden och avsluta med resultatet.

object Main {
  def main(args: Array[String]): Unit = {
    val result = {
      val a = 2
      val b = 3
      a * b
    }
    println(result)
  }
}

match är ett uttryck

Mönstermatchning med match returnerar också ett värde. Varje gren ger ett resultat, och hela uttrycket får värdet från den gren som matchade.

object Main {
  def main(args: Array[String]): Unit = {
    val day = 3
    val name = day match {
      case 1 => "Mon"
      case 2 => "Tue"
      case 3 => "Wed"
      case _ => "Other"
    }
    println(name)
  }
}

Unit-typen

Vissa uttryck finns bara för sina sidoeffekter, till exempel println. De returnerar Unit, som skrivs ().

Unit liknar void i andra språk, men är fortfarande ett faktiskt värde.

object Main {
  def main(args: Array[String]): Unit = {
    val nothing: Unit = println("side effect")
    println(nothing)
  }
}

Returnera från funktioner

Eftersom kroppen i en funktion är ett uttryck blir det sista uttrycket dess returvärde. Ni behöver sällan nyckelordet return.

Här består funktionskroppen av ett enda uttryck.

object Main {
  def max(a: Int, b: Int): Int = if (a > b) a else b
  def main(args: Array[String]): Unit = {
    println(max(7, 4))
  }
}

Uttrycksorienterade funktioner

En funktion kan vara ett blockuttryck där den sista raden är resultatet. Det håller logiken kompakt och undviker föränderliga temporära värden.

object Main {
  def discount(price: Double): Double = {
    val rate = if (price > 100) 0.2 else 0.1
    price * (1 - rate)
  }
  def main(args: Array[String]): Unit = {
    println(discount(150.0))
  }
}

Ingen förändring behövs

Eftersom if och match är uttryck kan Ni tilldela deras resultat till en val i stället för att ändra en var.

Det leder till renare och mer funktionell kod.

object Main {
  def main(args: Array[String]): Unit = {
    val score = 85
    val grade = if (score >= 90) "A"
      else if (score >= 80) "B"
      else "C"
    println(grade)
  }
}

Kombinera uttryck

Eftersom allt returnerar ett värde kan uttryck kapslas in i och kombineras med varandra utan begränsningar. Resultatet från ett uttryck blir indata till ett annat.

Denna kombinerbarhet är en viktig anledning till att Scala känns uttrycksfullt.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 7
    val message = "n is " + (if (n % 2 == 0) "even" else "odd")
    println(message)
  }
}

Varför det spelar roll

Uttrycksorienterad kod:

Minskar behovet av föränderliga variabler
Gör värdeflödet tydligt
Kan naturligt kombineras till större program
Passar perfekt ihop med oföränderlighet

Allt tillsammans

Här innehåller ett blockuttryck ett if-uttryck, där allt tilldelas ett enda oföränderligt resultat.

object Main {
  def main(args: Array[String]): Unit = {
    val total = {
      val items = 3
      val each = 12
      val raw = items * each
      if (raw > 30) raw - 5 else raw
    }
    println(total)
  }
}

Snabbtest

Kontrollera Er förståelse av uttryck.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er att nästan allt i Scala är ett uttryck:

if/else, match och block returnerar alla värden
Värdet för ett block är dess sista uttryck
Uttryck med sidoeffekter returnerar Unit (())
Det sista uttrycket i en funktion är dess returvärde
Detta minskar förändringar och förbättrar kombinerbarheten

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 ”Uttryck framför satser” gratis?

Ja – hela texten till ”Uttryck framför satser” 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 ”Uttryck framför satser”?

Allt är ett uttryck. 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 3 av 4.

Hur lång tid tar lektionen ”Uttryck framför satser”?

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