Suche…
Funktionen definieren
Funktionen werden mit fünf Komponenten definiert:
Der Header, der das Schlüsselwort defn , ist der Name der Funktion.
(defn welcome ....)
Ein optionaler Docstring, der die Funktion der Funktion erläutert und dokumentiert.
(defn welcome
"Return a welcome message to the world"
...)
In Klammern aufgeführte Parameter.
(defn welcome
"Return a welcome message"
[name]
...)
Der Körper, der die Prozeduren beschreibt, die die Funktion ausführt.
(defn welcome
"Return a welcome message"
[name]
(str "Hello, " name "!"))
Es nennen:
=> (welcome "World")
"Hello, World!"
Parameter und Arity
Clojure-Funktionen können mit null oder mehr Parametern definiert werden.
(defn welcome
"Without parameters"
[]
"Hello!")
(defn square
"Take one parameter"
[x]
(* x x))
(defn multiplier
"Two parameters"
[x y]
(* x y))
Liebe
Die Anzahl der Argumente, die eine Funktion benötigt. Funktionen unterstützen das Überladen von Arity , was bedeutet, dass Funktionen in Clojure mehr als eine "Menge" von Argumenten zulassen.
(defn sum-args
;; 3 arguments
([x y z]
(+ x y z))
;; 2 arguments
([x y]
(+ x y))
;; 1 argument
([x]
(+ x 1)))
Die Arities müssen nicht die gleiche Arbeit machen, jede Arity kann etwas tun, das nichts miteinander zu tun hat:
(defn do-something
;; 2 arguments
([first second]
(str first " " second))
;; 1 argument
([x]
(* x x x)))
Variadische Funktionen definieren
Eine Clojure-Funktion kann definiert werden, um eine beliebige Anzahl von Argumenten aufzunehmen, wobei das Symbol & in der Argumentliste verwendet wird. Alle übrigen Argumente werden als Sequenz gesammelt.
(defn sum [& args]
(apply + args))
(defn sum-and-multiply [x & args]
(* x (apply + args)))
Berufung:
=> (sum 1 11 23 42)
77
=> (sum-and-multiply 2 1 2 3) ;; 2*(1+2+3)
12
Definieren anonymer Funktionen
Es gibt zwei Möglichkeiten, eine anonyme Funktion zu definieren: die vollständige Syntax und eine Abkürzung.
Vollständige anonyme Funktionssyntax
(fn [x y] (+ x y))
Dieser Ausdruck wertet eine Funktion aus. Jede Syntax, die Sie mit einer mit defn definierten Funktion verwenden defn ( & , Argument-Destructuring usw.), können Sie auch mit dem Formular fn verwenden. defn ist eigentlich ein Makro, das genau das tut (def (fn ...)) .
Abkürzung Anonyme Funktionssyntax
#(+ %1 %2)
Dies ist die Kurzschreibweise. Bei Verwendung der Kurzschreibweise müssen Sie Argumente nicht explizit benennen. Sie erhalten die Namen %1 , %2 , %3 usw. in der Reihenfolge, in der sie übergeben werden. Wenn die Funktion nur ein Argument enthält, wird ihr Argument nur % .
Wann jeweils verwendet werden
Die Kurzschreibweise hat einige Einschränkungen. Sie können ein Argument nicht zerstören, und Sie können keine anonymen Kurzschriftfunktionen verschachteln. Der folgende Code gibt einen Fehler aus:
(def f #(map #(+ %1 2) %1))
Unterstützte Syntax
Sie können varargs mit anonymen Kurzwahlfunktionen verwenden. Das ist völlig legal:
#(every? even? %&)
Es nimmt eine variable Anzahl von Argumenten und gibt true zurück, wenn alle Argumente gerade sind:
(#(every? even? %&) 2 4 6 8)
;; true
(#(every? even? %&) 1 2 4 6)
;; false
Trotz des offensichtlichen Widerspruchs ist es möglich, eine benannte anonyme Funktion durch Einfügen eines Namens zu schreiben, wie im folgenden Beispiel dargestellt. Dies ist besonders nützlich, wenn die Funktion sich selbst aber auch in Stack-Traces aufrufen muss.
(fn addition [& addends] (apply + addends))