Ich lerne Clojure und versuche, eine Funktion zu definieren, die eine variable Anzahl von Parametern (eine variable Funktion) akzeptiert und zusammenfasst (yep, genau wie die + -Prozedur). Ich weiß jedoch nicht, wie ich eine solche Funktion implementieren soll
Alles was ich tun kann ist:
(defn sum [n1, n2] (+ n1 n2))
Natürlich akzeptiert diese Funktion nur zwei Parameter und zwei Parameter. Bitte bringen Sie mir bei, wie es eine undefinierte Anzahl von Parametern akzeptiert (und verarbeitet).
Antworten:
Im Allgemeinen nichtkommutative Fall können Sie verwenden , gelten :
(defn sum [& args] (apply + args))
Da Addition kommutativ ist, sollte so etwas auch funktionieren:
(defn sum [& args] (reduce + args))
& bewirkt args, dass an den Rest der Argumentliste gebunden wird (in diesem Fall die gesamte Liste, da links davon nichts steht &).
Offensichtlich macht es keinen Sinn, eine solche Summe zu definieren, da anstelle von:
(sum a b c d e ...)
Sie können einfach schreiben:
(+ a b c d e ....)
seqan Ihre Summenfunktion zu übergeben? Zum Beispiel: (Summe '(1 2 3)) und das Ergebnis ist 6?
&aus jeder Version entfernen
def fn(*args): pass), kann ich sie aufrufen, indem ich eine Liste wie fn (* list_of_args) gebe. Kann ich das Gleiche in Clojure tun?
def fn(*args): passwäre nicht fn([1,2,3])aber fn(1,2,3)(offensichtlich abhängig davon, was Sie genau tun möchten, aber ich versuche, dem Geist hier zu folgen)
Yehoanathan erwähnt die Überlastung der Arität, liefert jedoch kein direktes Beispiel. Hier ist, wovon er spricht:
(defn special-sum
([] (+ 10 10))
([x] (+ 10 x))
([x y] (+ x y)))
(special-sum) => 20
(special-sum 50) => 60
(special-sum 50 25) => 75
(fn ([] (+ 10 10)) ([x] (+ 10 x)) ([x y] (+ x y)))
(defn my-sum
([] 0) ; no parameter
([x] x) ; one parameter
([x y] (+ x y)) ; two parameters
([x y & more] ; more than two parameters
(reduce + (my-sum x y) more))
)
defnist ein Makro, das das Definieren von Funktionen etwas vereinfacht. Clojure unterstützt die Arity-Überladung in einem einzelnen Funktionsobjekt, Selbstreferenz- und Variable-Arity-Funktionen mithilfe von&
(defn sum [& args]
(print "sum of" args ":" (apply + args)))
Dies nimmt eine beliebige Anzahl von Argumenten und addiert sie.