clojure
funktioner

Definiera funktioner

Funktioner definieras med fem komponenter:

Sidhuvudet, som innehåller defn nyckelordet, namnet på funktionen.

(defn welcome ....)

En valfri dokstring som förklarar och dokumenterar vad funktionen gör.

(defn welcome 
    "Return a welcome message to the world"
     ...)

Parametrar som anges inom parentes.

(defn welcome 
    "Return a welcome message"
    [name]
    ...)

Kroppen, som beskriver de procedurer som funktionen utför.

(defn welcome 
    "Return a welcome message"
    [name]
    (str "Hello, " name "!"))

Kallar det:

=> (welcome "World")

"Hello, World!"

Parametrar och Arity

Clojure-funktioner kan definieras med noll eller fler parametrar.

(defn welcome
    "Without parameters"
    []
    "Hello!")

(defn square
    "Take one parameter"
    [x]
    (* x x))

(defn multiplier
    "Two parameters"
    [x y]
    (* x y))

ställighet

Antalet argument som en funktion tar. Funktioner stöder överbelastning av arity , vilket innebär att funktioner i Clojure möjliggör mer än en "uppsättning" av argument.

(defn sum-args
  ;; 3 arguments
  ([x y z]
     (+ x y z))
  ;; 2 arguments
  ([x y]
     (+ x y))
  ;; 1 argument 
  ([x]
     (+ x 1)))

Aritiesna behöver inte göra samma jobb, varje arity kan göra något som inte är relaterat:

(defn do-something
  ;; 2 arguments
  ([first second]
     (str first " " second))
  ;; 1 argument 
  ([x]
     (* x x x)))

Definiera Variadic-funktioner

En Clojure-funktion kan definieras för att ta ett godtyckligt antal argument med symbolen & i dess argumentlista. Alla återstående argument samlas som en sekvens.

(defn sum [& args]
  (apply + args))

(defn sum-and-multiply [x & args]
  (* x (apply + args)))

Kallelse:

=> (sum 1 11 23 42)
77

=> (sum-and-multiply 2 1 2 3)  ;; 2*(1+2+3)
12

Definiera anonyma funktioner

Det finns två sätt att definiera en anonym funktion: den fullständiga syntaxen och en korthet.

Synonym för fullständig anonym funktion

(fn [x y] (+ x y))

Detta uttryck utvärderar till en funktion. Alla syntaxer du kan använda med en funktion definierad med defn ( & , argumentdestrukturering, etc.), du kan också göra med fn formen. defn är faktiskt ett makro som bara gör (def (fn ...)) .

Kortfattad synonym för anonym funktion

#(+ %1 %2)

Detta är den korta notationen. Med hjälp av den korta notationen behöver du inte namnge argument uttryckligen; de kommer att tilldelas namnen %1 , %2 , %3 och så vidare i enlighet med den ordning de ges i. Om funktionen bara har ett argument kallas dess argument bara % .

När du ska använda varje

Den korta notationen har vissa begränsningar. Du kan inte förstöra ett argument och du kan inte lägga till korta anonyma funktioner. Följande kod kastar ett fel:

(def f #(map #(+ %1 2) %1))

Syntax som stöds

Du kan använda varargs med korta anonyma funktioner. Detta är helt lagligt:

#(every? even? %&)

Det tar ett variabelt antal argument och återgår sant om var och en av dem är jämn:

(#(every? even? %&) 2 4 6 8)
;; true
(#(every? even? %&) 1 2 4 6)
;; false

Trots den uppenbara motsägelsen är det möjligt att skriva en namngiven anonym funktion genom att inkludera ett namn, som i följande exempel. Detta är särskilt användbart om funktionen måste ringa sig själv men också i stapelspår.

(fn addition [& addends] (apply + addends))