Funktionel programmering i Clojure og backendudvikling på JVM · Lektion

Førsteklasses funktioner og højereordensfunktioner

Forstå funktioner som værdier, hvordan De sender dem rundt, og hvordan De opretter kraftfulde højereordensfunktioner.

Lektion 1 af 411 trin

Førsteklasses funktioner og højereordensfunktioner er en gratis Funktionel programmering i Clojure og backendudvikling på JVM-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 Funktionel programmering i Clojure og backendudvikling på JVM, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Funktionel programmering i Clojure og backendudvikling på JVM-kurset indeholder 4 lektioner i alt.

Funktioner: førsteklasses værdier

I Clojure er funktioner "førsteklasses værdier". Det betyder, at de behandles ligesom alle andre værdier, f.eks. tal eller strenge.

Du kan:

Tildele dem til variabler.
Give dem som argumenter til andre funktioner.
Returnere dem som resultater fra andre funktioner.

Dette stærke koncept er grundlæggende for funktionel programmering!

Tildel funktioner til navne

Lad os se, hvordan vi kan behandle funktioner som værdier ved at tildele dem et navn med def eller let. Tænk på det som at give en funktion et kælenavn.

Prøv at køre dette eksempel:

(ns coddykit.core
  (:gen-class))

(defn greet [name]
  (str "Hello, " name "!"))

(defn -main [& args]
  (println "--- Output ---")
  (def my-greeting greet) ; Assign 'greet' function to 'my-greeting'
  (println (my-greeting "Alice")))

Giv funktioner som argumenter

Et centralt aspekt ved førsteklasses funktioner er muligheden for at give dem som argumenter til andre funktioner. Det gør koden meget fleksibel og genanvendelig.

Forestil dig en funktion, der udfører en operation, men at det er en anden funktion, du giver den, der bestemmer hvilken operation den udfører!

Prøv at køre dette eksempel:

(ns coddykit.core
  (:gen-class))

(defn operate [f x y]
  (f x y)) ; Call the function 'f' with arguments 'x' and 'y'

(defn -main [& args]
  (println "--- Output ---")
  (println (operate + 5 3)) ; Pass the '+' function
  (println (operate * 5 3))) ; Pass the '*' function

Funktioner, der returnerer funktioner

Funktioner kan også oprette og returnere nye funktioner. Det er nyttigt til at bygge "funktionsfabrikker", som producerer specialiserede funktioner ud fra et bestemt input.

Her tager make-adder et tal og returnerer en ny funktion, der lægger tallet til sit input.

Prøv at køre dette eksempel:

(ns coddykit.core
  (:gen-class))

(defn make-adder [x]
  (fn [y] (+ x y))) ; Returns an anonymous function

(defn -main [& args]
  (println "--- Output ---")
  (def add-five (make-adder 5))
  (def add-ten (make-adder 10))
  (println (add-five 2))
  (println (add-ten 2)))

Hvad er funktioner af højere orden?

Når en funktion enten tager en eller flere funktioner som argumenter eller returnerer en funktion som resultat, kaldes den en funktion af højere orden (HOF).

HOF'er er utroligt kraftfulde, fordi de lader dig:

Abstrahere almindelige mønstre.
Skrive mere kortfattet og udtryksfuld kode.
Oprette fleksible og genanvendelige programkomponenter.

Lad os se på nogle almindelige HOF'er i Clojure!

Transformér med `map`

map er en grundlæggende funktion af højere orden. Den anvender en given funktion på hvert element i en samling (f.eks. en liste eller vektor) og returnerer en ny samling med resultaterne.

Den er perfekt til at transformere data uden at ændre den oprindelige samling.

Prøv at køre dette eksempel:

(ns coddykit.core
  (:gen-class))

(defn square [x] (* x x))

(defn -main [& args]
  (println "--- Output ---")
  (def numbers [1 2 3 4])
  (def squared-numbers (map square numbers))
  (println "Original numbers:" numbers)
  (println "Squared numbers:" squared-numbers))

Filtrér samlinger med `filter`

HOF'en filter tager en "prædikatfunktion" (en funktion, der returnerer true eller false) og en samling. Den returnerer en ny samling, der kun indeholder de elementer, som prædikatfunktionen returnerer true for.

Det er velegnet til at vælge bestemte elementer fra en liste.

Prøv at køre dette eksempel:

(ns coddykit.core
  (:gen-class))

(defn is-even? [n]
  (= (mod n 2) 0))

(defn -main [& args]
  (println "--- Output ---")
  (def numbers (range 1 11)) ; Numbers from 1 to 10
  (def even-numbers (filter is-even? numbers))
  (println "All numbers:" numbers)
  (println "Even numbers:" even-numbers))

Kombinér med `reduce`

reduce er endnu en effektiv HOF, der kombinerer alle elementer i en samling til ét resultat. Den tager en kombinerende funktion, en valgfri startværdi og en samling.

Funktionen anvendes kumulativt på hvert element og bruges ofte til at summere, finde maksimum eller minimum eller sammenkæde.

Prøv at køre dette eksempel:

(ns coddykit.core
  (:gen-class))

(defn -main [& args]
  (println "--- Output ---")
  (def numbers [1 2 3 4 5])
  (def sum (reduce + numbers)) ; Sums all numbers
  (def product (reduce * numbers)) ; Multiplies all numbers
  (println "Numbers:" numbers)
  (println "Sum:" sum)
  (println "Product:" product))

Hurtige funktioner: lambdaer

De funktioner, vi giver til HOF'er, er ofte små og bruges kun én gang. Til dette tilbyder Clojure anonyme funktioner, også kaldet lambdaer.

De bruger den korte syntaks #(...), hvor % henviser til det første argument, %1 til det første, %2 til det andet og så videre.

Prøv at køre dette eksempel:

(ns coddykit.core
  (:gen-class))

(defn -main [& args]
  (println "--- Output ---")
  (def numbers [1 2 3 4])
  (def doubled-numbers (map #(* % 2) numbers)) ; Anonymous function
  (def greater-than-two (filter #(> % 2) numbers)) ; Another anonymous function
  (println "Doubled:" doubled-numbers)
  (println "Greater than 2:" greater-than-two))

HOF'er i praksis

Du har lært om førsteklasses funktioner og funktioner af højere orden. Nu skal du teste, om du forstår, hvordan de kan kombineres for at opnå bestemte datatransformationer.

Betragt talrækken (range 1 6), som evalueres til (1 2 3 4 5).

Hvilket Clojure-udtryk bruger funktioner af højere orden korrekt til at hente en liste med kvadrerede lige tal fra denne række?

Besvar den i den interaktive lektion

Opsummering: funktioner som superkræfter

Tillykke! Du har låst op for styrken ved førsteklasses funktioner og funktioner af højere orden i Clojure!

Her er det, vi har gennemgået:

Førsteklasses funktioner: Funktioner kan behandles som alle andre datatyper – tildeles til variabler, gives som argumenter og returneres fra andre funktioner.
Funktioner af højere orden: Funktioner, der arbejder med andre funktioner (ved at tage imod dem som argumenter eller returnere dem).
Vigtige HOF'er: Vi undersøgte map til transformation, filter til udvælgelse og reduce til sammenlægning.
Anonyme funktioner: Syntaksen #(...) til korte, indlejrede funktionsdefinitioner.

Disse begreber er centrale, når du skriver udtryksfuld og fleksibel Clojure-kode. Bliv ved med at øve dig!

Gratis at komme i gang

Lær Clojure 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 “Førsteklasses funktioner og højereordensfunktioner” gratis?

Ja — hele teksten til “Førsteklasses funktioner og højereordensfunktioner” 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 Funktionel programmering i Clojure og backendudvikling på JVM-kurset, skal du opgradere til CoddyKit PRO. Funktionel programmering i Clojure og backendudvikling på JVM-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Førsteklasses funktioner og højereordensfunktioner”?

Forstå funktioner som værdier, hvordan De sender dem rundt, og hvordan De opretter kraftfulde højereordensfunktioner. Du øver dig i Funktionel programmering i Clojure og backendudvikling på JVM 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å Funktionel programmering i Clojure og backendudvikling på JVM?

Der kræves ingen tidligere erfaring. Funktionel programmering i Clojure og backendudvikling på JVM 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 “Førsteklasses funktioner og højereordensfunktioner”?

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 Funktionel programmering i Clojure og backendudvikling på JVM-lektion?

Ja. Alle Funktionel programmering i Clojure og backendudvikling på JVM-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

Førsteklasses funktioner og højereordensfunktioner
Uforanderlighed og persistente data
Lazy sequences og performance
Transducers til komponerbare transformationer

← Tilbage til Funktionel programmering i Clojure og backendudvikling på JVM