Funktioner, moduler og pipelining
Lær at definere funktioner, organisere kode i moduler og bruge pipe-operatoren til tydelige datatransformationer.
Funktioner, moduler og pipelining er en gratis Elixir og Phoenix: Skalerbar backend-udvikling-lektion på CoddyKit. Dette er lektion 1 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.
Introduktion til Elixir-funktioner
I Elixir er funktioner byggestenene i dine programmer. De modtager input, udfører handlinger og returnerer output.
Elixir-funktioner er designet til at være rene: de ændrer ikke data uden for deres scope og producerer altid det samme output for det samme input. Det gør din kode forudsigelig og lettere at forstå.
Definition af offentlige funktioner
Du definerer offentlige funktioner med nøgleordet def. Disse funktioner kan kaldes fra alle steder i din app, så længe de er en del af et modul.
Lad os oprette en simpel funktion, der lægger to tal sammen:
defmodule MathOperations do
def add(a, b) do
a + b
end
end
IO.puts "Sum of 5 and 3: #{MathOperations.add(5, 3)}"Definition af private funktioner
Nogle gange har du brug for hjælpefunktioner, der kun skal bruges internt i et modul. Til dem bruger du nøgleordet defp.
Private funktioner kan ikke kaldes direkte uden for det modul, hvor de er defineret. Det hjælper med at indkapsle logikken.
defmodule SecretOperations do
defp secret_add(a, b) do
a + b + 10 # A 'secret' addition
end
def public_operation(x, y) do
secret_add(x, y)
end
end
IO.puts "Result of public operation: #{SecretOperations.public_operation(2, 3)}"
# SecretOperations.secret_add(1, 2) would cause an error if called directly outside the module.Funktioners aritet og klausuler
Arity henviser til det antal argumenter, en funktion modtager. I Elixir kan du definere flere funktionsklausuler med samme navn, men med forskellige ariteter eller forskellige mønstre for argumenterne.
Det muliggør effektiv mønstermatchning (som blev gennemgået i en tidligere lektion), så forskellige scenarier kan håndteres tydeligt i én funktionsdefinition.
defmodule Greeter do
def greet("Alice"), do: "Hello, Alice!"
def greet(name), do: "Hi there, #{name}!"
end
IO.puts Greeter.greet("Alice")
IO.puts Greeter.greet("Bob")Anonyme funktioner
Anonyme funktioner (også kaldet lambdaer) er funktioner uden navn. De bruges ofte, når du skal sende en funktion som argument til en anden funktion eller til korte engangsoperationer.
Du definerer dem med nøgleordet fn.
adder = fn a, b -> a + b end
multiplier = fn x, y -> x * y end
IO.puts "Anonymous add: #{adder.(10, 20)}"
IO.puts "Anonymous multiply: #{multiplier.(4, 5)}"Organisering af kode med moduler
Moduler i Elixir er beholdere til organisering af relaterede funktioner og data. De hjælper med at forhindre navnekonflikter og gør din kode mere struktureret og vedligeholdelsesvenlig.
Du definerer et modul med nøgleordet defmodule. Det er almindelig praksis, at modulnavne begynder med et stort bogstav i overensstemmelse med Elixirs navngivningskonventioner.
Oprettelse af dit første modul
Lad os placere funktionen add i et modul kaldet Calculator. Det gør det tydeligt, at funktionen add er en del af et sæt lommeregnerrelaterede handlinger.
defmodule Calculator do
def add(a, b) do
a + b
end
def subtract(a, b) do
a - b
end
end
IO.puts "Module defined!"Kald af modulfunktioner
Hvis du vil kalde en funktion, der er defineret i et modul, bruger du modulets navn efterfulgt af et punktum (.) og derefter funktionsnavnet med dets argumenter.
Dette tydelige navngivningsmønster hjælper dig med at forstå, hvor en funktion kommer fra.
defmodule Calculator do
def add(a, b), do: a + b
def subtract(a, b), do: a - b
end
IO.puts "10 + 5 = #{Calculator.add(10, 5)}"
IO.puts "10 - 5 = #{Calculator.subtract(10, 5)}"Introduktion til pipe-operatoren `|>`
Pipe-operatoren |> er en af Elixirs mest populære funktioner. Den gør sekvenser af funktionskald utroligt læsevenlige ved at føre data fra den ene funktion til den næste.
Tænk på den som at tage resultatet af udtrykket til venstre og sende det som det første argument til funktionskaldet til højre.
Pipelining i praksis
I stedet for at indlejre funktionskald som function_c(function_b(function_a(data))) lader pipe-operatoren dig skrive det som data |> function_a() |> function_b() |> function_c().
Det læses som en række trin og gør komplekse datatransformationer meget tydeligere.
defmodule DataProcessor do
def double(x), do: x * 2
def add_five(x), do: x + 5
def to_string(x), do: to_string(x)
end
result = 10
|> DataProcessor.double()
|> DataProcessor.add_five()
|> DataProcessor.to_string()
IO.puts "Processed result: #{result}"Tjek din forståelse
Hvilke af følgende udsagn om Elixir-funktioner, moduler og pipe-operatoren er sande?
Opsummering: Funktioner, moduler og pipes
Godt klaret! I denne lektion lærte du det grundlæggende om organisering og transformation af data i Elixir:
- Hvordan du definerer offentlige (`def`) og private (`defp`) funktioner.
- Hvorfor moduler (`defmodule`) er vigtige for strukturering af din kode.
- Hvordan pipe-operatoren (`|>`) forbedrer læsbarheden markant ved sekventielle datatransformationer.
Disse begreber er grundlæggende, når du skal skrive klare, vedligeholdelsesvenlige og funktionelle Elixir-apps. Bliv ved med at øve dig!
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
Ofte stillede spørgsmål
Er lektionen “Funktioner, moduler og pipelining” gratis?
Ja — hele teksten til “Funktioner, moduler og pipelining” 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 “Funktioner, moduler og pipelining”?
Lær at definere funktioner, organisere kode i moduler og bruge pipe-operatoren til tydelige datatransformationer. 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 1 af 4.
Hvor lang tid tager lektionen “Funktioner, moduler og pipelining”?
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
- Funktioner, moduler og pipelining
- Arbejde med Enumerable-samlinger
- Rekursion og højereordensfunktioner
- Doven evaluering med Stream-modulet