Elixir og Phoenix: Skalerbar backend-udvikling · Lektion

Doven evaluering med Stream-modulet

Behandl store eller uendelige samlinger effektivt med Elixir-streams, som beregner værdier dovent efter behov.

Lektion 4 af 413 trin

Doven evaluering med Stream-modulet er en gratis Elixir og Phoenix: Skalerbar backend-udvikling-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Elixir og Phoenix: Skalerbar backend-udvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Elixir og Phoenix: Skalerbar backend-udvikling-kurset indeholder 4 lektioner i alt.

Iværksættende kontra doven evaluering

Enum er iværksættende: hvert trin opbygger en fuld mellemliggende liste. Stream er doven: det sammensætter operationer og beregner kun, når det er nødvendigt.

Omkostningen ved iværksættende pipelines

Når du kæder flere kald til Enum, gennemløbes hele samlingen flere gange, og der allokeres en liste på hvert trin.

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

Oprettelse af en stream

Erstat Enum med Stream for at udskyde arbejdet. Intet køres, før en forbrugende funktion kaldes.

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

Tving evaluering

En stream forbliver inaktiv, indtil en Enum-funktion (som take eller to_list) trækker værdier gennem den.

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

Derfor er streams effektive

Lazy pipelines sammensmelter trinnene og stopper, så snart der er produceret tilstrækkeligt mange elementer, så store mellemliggende lister undgås.

Uendelige streams

Stream.iterate/2 opretter endeløse sekvenser, som er sikre, fordi evalueringen er doven.

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

Stream.cycle til gentagelser

Stream.cycle gentager en endelig liste for evigt, hvilket er nyttigt til at tildele roterende værdier.

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

Generering med Stream.unfold

Stream.unfold/2 opbygger en stream ud fra en tilstand og en funktion, der returnerer den næste værdi og den nye tilstand.

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

Streaming af filer linje for linje

File.stream!/1 læser en fil dovent, én linje ad gangen, så du kan behandle meget store filer med konstant hukommelsesforbrug.

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

Stream.chunk_every

Gruppér en stream dovent i portioner. Det er praktisk til at sideinddele arbejde uden at indlæse alt.

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

Hvornår skal du vælge Stream

Brug Stream til store datasæt, pipelines med flere trin, uendelige sekvenser eller IO. Brug Enum til små samlinger, hvor enkelhed er vigtigst.

Hurtig kontrol

Test din viden om doven evaluering.

Besvar den i den interaktive lektion

Opsummering

Du har lært om doven evaluering:

Enum er iværksættende; Stream er doven og kan sammensættes
Streams beregner kun, når de forbruges af en Enum-funktion
De muliggør uendelige sekvenser og filbehandling med konstant hukommelsesforbrug
Foretræk streams til store pipelines med flere trin og Enum til små datamængder

Gratis at komme i gang

Lær Elixir med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Doven evaluering med Stream-modulet” gratis?

Ja — hele teksten til “Doven evaluering med Stream-modulet” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Elixir og Phoenix: Skalerbar backend-udvikling-kurset, skal du opgradere til CoddyKit PRO. Elixir og Phoenix: Skalerbar backend-udvikling-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Doven evaluering med Stream-modulet”?

Behandl store eller uendelige samlinger effektivt med Elixir-streams, som beregner værdier dovent efter behov. Du øver dig i Elixir og Phoenix: Skalerbar backend-udvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Elixir og Phoenix: Skalerbar backend-udvikling?

Der kræves ingen tidligere erfaring. Elixir og Phoenix: Skalerbar backend-udvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Doven evaluering med Stream-modulet”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Elixir og Phoenix: Skalerbar backend-udvikling-lektion?

Ja. Alle Elixir og Phoenix: Skalerbar backend-udvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Elixir og Phoenix: Skalerbar backend-udvikling