Scala voor backend-engineering en functioneel programmeren · Les

Tuples maken

Bundel gerelateerde waarden.

Les 1 van 413 stappen

Tuples maken is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Scala voor backend-engineering en functioneel programmeren. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.

Wat is een tuple?

Een tuple groepeert een vast aantal waarden, ook als die waarden verschillende typen hebben.

In tegenstelling tot een lijst, waarvan elk element hetzelfde type heeft, kan een tuple tegelijk een Int, een String en een Boolean bevatten.

Tuples zijn ideaal om een handvol verwante waarden terug te geven of te bundelen zonder een volledige klasse te schrijven.

Uw eerste tuple maken

U maakt een tuple door door komma's gescheiden waarden tussen haakjes te zetten.

Hier koppelen we een naam aan een leeftijd. Scala leidt de typen automatisch af.

val person = ("Alice", 30)
println(person)

Typen vrij combineren

Een van de beste eigenschappen van tuples is dat u typen binnen één waarde kunt combineren.

Deze tuple bevat samen een String, een Int en een Boolean. Elke positie behoudt zijn eigen type.

val record = ("Bob", 42, true)
println(record)

Tupletypen

Het type van een tuple toont elk elementtype in de juiste volgorde.

Een paar van een String en een Int heeft het type (String, Int). U kunt het type expliciet schrijven als u duidelijkheid wilt.

val pair: (String, Int) = ("Cara", 25)
println(pair)

Paren komen vaak voor

Een tuple met precies twee elementen heet een paar, en paren komen overal in Scala voor.

Zo worden maps opgebouwd uit sleutel-waardeparen. Als u paren eerst leert, wordt de rest van de taal eenvoudiger.

val score = ("Math", 95)
println(score)

Pijlsyntaxis voor paren

Voor tuples met twee elementen biedt Scala een handige pijlsyntaxis.

key -> value schrijven is precies hetzelfde als (key, value). Het leest prettig, vooral bij het opbouwen van maps.

val entry = "name" -> "Dana"
println(entry)

Grotere tuples

Tuples kunnen meer dan twee of drie waarden bevatten.

Scala ondersteunt tuples met maximaal 22 elementen, hoewel kleine tuples het gemakkelijkst te lezen zijn. Als u veel velden nodig hebt, is een case class meestal duidelijker.

val data = (1, 2, 3, 4, 5)
println(data)

Opmerking over één element

Een tuple met één element heeft geen praktisch nut. Eén waarde tussen haakjes levert gewoon die waarde weer op.

(5) is dus gewoon het getal 5, geen tuple. Tuples beginnen pas bij twee elementen.

val notATuple = (5)
println(notATuple)

Tuples zijn onveranderlijk

Zodra u een tuple maakt, veranderen de waarden ervan nooit.

Door deze onveranderlijkheid kunt u tuples veilig delen en blijft de code eenvoudig te begrijpen. Voor een andere tuple maakt u gewoon een nieuwe.

val a = (1, "one")
val b = (2, "two")
println(a)
println(b)

Meerdere waarden teruggeven

Een veelgebruikte toepassing van tuples is meerdere waarden tegelijk uit een functie teruggeven.

Hier geeft een functie zowel een som als een product terug als één tuple, zodat u geen aparte klasse nodig hebt.

def stats(a: Int, b: Int) = (a + b, a * b)
println(stats(3, 4))

Tuples nesten

Omdat een tuple gewoon een waarde is, kunt u een tuple in een andere tuple plaatsen.

Zo kunt u verwante subparen samen groeperen. Houd het nesten beperkt, zodat uw code leesbaar blijft.

val nested = (("x", 1), ("y", 2))
println(nested)

Korte controle

Test wat u hebt geleerd over het maken van tuples.

Samenvatting

U hebt geleerd dat tuples een vast aantal waarden, eventueel van verschillende typen, tussen haakjes groeperen.

Voor paren kunt u ook de syntaxis key -> value gebruiken. Tuples zijn onveranderlijk en handig om meerdere waarden terug te geven. Hierna leert u hoe u die waarden er weer uithaalt.

Gratis beginnen

Leer Scala met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
39
Lessen
143

Veelgestelde vragen

Is de les “Tuples maken” gratis?

Ja — de volledige tekst van “Tuples maken” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Scala voor backend-engineering en functioneel programmeren wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.

Wat leer ik in “Tuples maken”?

Bundel gerelateerde waarden. Je oefent met Scala voor backend-engineering en functioneel programmeren door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Scala voor backend-engineering en functioneel programmeren te beginnen?

Ervaring vooraf is niet nodig. Scala voor backend-engineering en functioneel programmeren op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Tuples maken”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Scala voor backend-engineering en functioneel programmeren?

Ja. Elke les over Scala voor backend-engineering en functioneel programmeren bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Tuples maken
  2. Tuples destructureren
  3. Ranges bouwen
  4. Ranges in lussen
← Terug naar Scala voor backend-engineering en functioneel programmeren