Elixir en Phoenix: schaalbare backendontwikkeling · Les

Lui evalueren met de Stream-module

Verwerk grote of oneindige collecties efficiënt met Elixir-streams, die waarden pas op verzoek berekenen.

Les 4 van 413 stappen

Lui evalueren met de Stream-module is een gratis Elixir en Phoenix: schaalbare backendontwikkeling-les op CoddyKit. Dit is les 4 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 Elixir en Phoenix: schaalbare backendontwikkeling. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Eager versus lazy

Enum is eager: elke stap maakt een volledige tussentijdse lijst. Stream is lazy: het combineert bewerkingen en rekent ze pas uit wanneer dat nodig is.

De kosten van eager-pipelines

Door meerdere aanroepen van Enum aan elkaar te koppelen, wordt de volledige verzameling meerdere keren doorlopen en wordt in elke fase een lijst toegewezen.

1..1_000_000
|> Enum.map(&(&1 * 2))
|> Enum.filter(&(rem(&1, 3) == 0))
|> Enum.take(5)
|> IO.inspect()

Een stream opbouwen

Vervang Enum door Stream om werk uit te stellen. Er wordt niets uitgevoerd totdat een consumerende functie wordt aangeroepen.

stream =
  1..1_000_000
  |> Stream.map(&(&1 * 2))
  |> Stream.filter(&(rem(&1, 3) == 0))
IO.inspect(stream)

Evaluatie afdwingen

Een stream blijft inactief totdat een functie van Enum (zoals take of to_list) waarden erdoorheen trekt.

result =
  1..1_000_000
  |> Stream.map(&(&1 * 2))
  |> Enum.take(5)
IO.inspect(result)

Waarom streams efficiënt zijn

Lazy-pipelines voegen de stappen samen en stoppen zodra er genoeg elementen zijn geproduceerd, zodat enorme tussentijdse lijsten worden vermeden.

Oneindige streams

Stream.iterate/2 maakt eindeloze reeksen die veilig zijn doordat ze lazy worden geëvalueerd.

Stream.iterate(0, &(&1 + 1))
|> Enum.take(5)
|> IO.inspect()

Stream.cycle voor herhaling

Stream.cycle herhaalt een eindige lijst voor altijd, wat handig is om afwisselende waarden toe te wijzen.

Stream.cycle(["a", "b", "c"])
|> Enum.take(7)
|> IO.inspect()

Genereren met Stream.unfold

Stream.unfold/2 bouwt een stream op basis van een status en een functie die de volgende waarde en de nieuwe status retourneert.

Stream.unfold(1, fn n -> {n, n * 2} end)
|> Enum.take(5)
|> IO.inspect()

Bestanden regel voor regel streamen

File.stream!/1 leest een bestand lazy, één regel per keer, zodat je enorme bestanden met constant geheugengebruik kunt verwerken.

# File.stream!("big.log")
# |> Stream.filter(&String.contains?(&1, "ERROR"))
# |> Enum.count()

Stream.chunk_every

Groepeer een stream lazy in batches. Dat is handig om werk over pagina's te verdelen zonder alles te laden.

1..10
|> Stream.chunk_every(3)
|> Enum.to_list()
|> IO.inspect()

Wanneer kies je Stream?

Gebruik Stream voor grote gegevensverzamelingen, pipelines met meerdere stappen, oneindige reeksen of IO. Gebruik Enum voor kleine verzamelingen waarbij eenvoud de voorkeur heeft.

Korte controle

Test je kennis van lazy evaluatie.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt lazy evaluatie geleerd:

Enum is eager; Stream is lazy en combineerbaar
Streams worden pas berekend wanneer ze door een functie van Enum worden verbruikt
Ze maken oneindige reeksen en bestandsverwerking met constant geheugengebruik mogelijk
Gebruik bij voorkeur streams voor grote gegevensverzamelingen en pipelines met meerdere stappen, en Enum voor kleine gegevensverzamelingen

Gratis beginnen

Leer Elixir 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: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Lui evalueren met de Stream-module” gratis?

Ja — de volledige tekst van “Lui evalueren met de Stream-module” 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 Elixir en Phoenix: schaalbare backendontwikkeling wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Wat leer ik in “Lui evalueren met de Stream-module”?

Verwerk grote of oneindige collecties efficiënt met Elixir-streams, die waarden pas op verzoek berekenen. Je oefent met Elixir en Phoenix: schaalbare backendontwikkeling 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 Elixir en Phoenix: schaalbare backendontwikkeling te beginnen?

Ervaring vooraf is niet nodig. Elixir en Phoenix: schaalbare backendontwikkeling 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 4 van 4.

Hoe lang duurt de les “Lui evalueren met de Stream-module”?

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 Elixir en Phoenix: schaalbare backendontwikkeling?

Ja. Elke les over Elixir en Phoenix: schaalbare backendontwikkeling 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

← Terug naar Elixir en Phoenix: schaalbare backendontwikkeling