common-lisp
Funktionen

Bemerkungen

Erforderliche Parameter

(defun foobar (x y)
  (format t "X: ~s~@
             Y: ~s~%"
          x y))

(foobar 10 20)
; X: 10
; Y: 20
;=> NIL

Optionale Parameter

Optionale Parameter können nach den erforderlichen Parametern mit &OPTIONAL Schlüsselwort &OPTIONAL . Danach können mehrere optionale Parameter vorhanden sein.

(defun foobar (x y &optional z)
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is optional.~%"
          x y z))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z (NIL) is optional.
;=> NIL
(foobar 10 20 30)
; X (10) and Y (20) are required.
; Z (30) is optional.
;=> NIL

Standardwert

Für optionale Parameter kann ein Standardwert angegeben werden, indem der Parameter mit einer Liste angegeben wird. Der zweite Wert ist der Standardwert. Das Standardwertformular wird nur ausgewertet, wenn das Argument angegeben wurde. Es kann daher für Nebeneffekte verwendet werden, z. B. für das Melden eines Fehlers.

(defun foobar (x y &optional (z "Default"))
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is optional.~%"
          x y z))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z ("Default") is optional.
;=> NIL
(foobar 10 20 30)
; X (10) and Y (20) are required.
; Z (30) is optional.
;=> NIL

Prüfen Sie, ob ein optionales Argument angegeben wurde

Ein drittes Mitglied kann der Liste nach dem Standardwert hinzugefügt werden. Ein Variablenname, der wahr ist, wenn das Argument angegeben wurde, oder NIL wenn es nicht angegeben wurde (und der Standardwert verwendet wird).

(defun foobar (x y &optional (z "Default" zp))
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is optional. It ~:[wasn't~;was~] given.~%"
          x y z zp))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z ("Default") is optional. It wasn't given.
;=> NIL
(foobar 10 20 30)
; X (10) and Y (20) are required.
; Z (30) is optional. It was given.
;=> NIL

Funktion ohne Parameter

Globale benannte Funktionen werden mit DEFUN definiert.

(defun foobar ()
  "Optional documentation string. Can contain line breaks.

Must be at the beginning of the function body. Some will format the
docstring so that lines are indented to match the first line, although
the built-in DESCRIBE-function will print it badly indented that way.

Ensure no line starts with an opening parenthesis by escaping them
\(like this), otherwise your editor may have problems identifying
toplevel forms."
  (format t "No parameters.~%"))

(foobar)
; No parameters.
;=> NIL

(describe #'foobar) ; The output is implementation dependant.
; #<FUNCTION FOOBAR>
;   [compiled function]
;
; Lambda-list: ()
; Derived type: (FUNCTION NIL (VALUES NULL &OPTIONAL))
; Documentation:
;   Optional documentation string. Can contain line breaks.
;   
;   Must be at the beginning of the function body. Some will format the
;   docstring so that lines are indented to match the first line, although
;   the built-in DESCRIBE-function will print it badly indented that way.
; Source file: /tmp/fileInaZ1P
;=> No values

Der Funktionskörper kann eine beliebige Anzahl von Formularen enthalten. Die Werte des letzten Formulars werden von der Funktion zurückgegeben.

Restparameter

Nach den erforderlichen Argumenten kann mit dem Schlüsselwort &REST ein einzelner Rest-Parameter angegeben werden. Wenn ein solcher Parameter vorhanden ist, kann die Funktion eine Reihe von Argumenten annehmen, die in einer Liste im rest-Parameter zusammengefasst werden. Beachten Sie, dass die Variable CALL-ARGUMENTS-LIMIT die maximale Anzahl von Argumenten bestimmt, die in einem Funktionsaufruf verwendet werden können. CALL-ARGUMENTS-LIMIT die Anzahl der Argumente auf einen implementierungsspezifischen Wert von mindestens 50 Argumenten begrenzt.

(defun foobar (x y &rest rest)
  (format t "X (~s) and Y (~s) are required.~@
             The function was also given following arguments: ~s~%"
          x y rest))

(foobar 10 20)
; X (10) and Y (20) are required.
; The function was also given following arguments: NIL
;=> NIL
(foobar 10 20 30 40 50 60 70 80)
; X (10) and Y (20) are required.
; The function was also given following arguments: (30 40 50 60 70 80)
;=> NIL

Rest und Keyword-Parameter zusammen

Der rest-Parameter kann vor Schlüsselwortparametern liegen. In diesem Fall enthält es die vom Benutzer angegebene Eigenschaftsliste. Die Schlüsselwortwerte sind weiterhin an den entsprechenden Schlüsselwortparameter gebunden.

(defun foobar (x y &rest rest &key (z 10 zp))
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is a keyword argument. It ~:[wasn't~;was~] given.~@
             The function was also given following arguments: ~s~%"
          x y z zp rest))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z (10) is a keyword argument. It wasn't given.
; The function was also given following arguments: NIL
;=> NIL
(foobar 10 20 :z 30)
; X (10) and Y (20) are required.
; Z (30) is a keyword argument. It was given.
; The function was also given following arguments: (:Z 30)
;=> NIL

Das Schlüsselwort &ALLOW-OTHER-KEYS kann am Ende der Lambda-Liste hinzugefügt werden, damit der Benutzer Schlüsselwortargumente &ALLOW-OTHER-KEYS kann, die nicht als Parameter definiert sind. Sie werden in die Restliste aufgenommen.

(defun foobar (x y &rest rest &key (z 10 zp) &allow-other-keys)
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is a keyword argument. It ~:[wasn't~;was~] given.~@
             The function was also given following arguments: ~s~%"
          x y z zp rest))

(foobar 10 20 :z 30 :q 40)
; X (10) and Y (20) are required.
; Z (30) is a keyword argument. It was given.
; The function was also given following arguments: (:Z 30 :Q 40)
;=> NIL

Hilfsvariablen

Mit dem Schlüsselwort &AUX können lokale Variablen für die Funktion definiert werden. Sie sind keine Parameter; der Benutzer kann sie nicht liefern.

&AUX Variablen werden selten verwendet. Sie können stattdessen immer LET oder eine andere Möglichkeit verwenden, lokale Variablen im Funktionskörper zu definieren.

&AUX Variablen haben den Vorteil, dass lokale Variablen des gesamten Funktionskörpers nach oben verschoben werden und eine Einrückungsebene (z. B. durch ein LET eingeführt) nicht erforderlich ist.

(defun foobar (x y &aux (z (+ x y)))
  (format t "X (~d) and Y (~d) are required.~@
             Their sum is ~d."
          x y z))

(foobar 10 20)
; X (10) and Y (20) are required.
; Their sum is 30.
;=> NIL

Eine typische Verwendung kann das Auflösen von "Bezeichner" -Parametern sein. Wieder brauchen Sie es nicht so zu tun; Mit let ist genauso idiomatisch.

(defun foo (a b &aux (as (string a)))
  "Combines A and B in a funny way.  A is a string designator, B a string."
  (concatenate 'string as " is funnier than " b))

RETURN-FROM, um einen Block oder eine Funktion zu verlassen

Funktionen bilden immer einen Block um den Körper. Dieser Block hat den gleichen Namen wie der Funktionsname. Das bedeutet, dass Sie RETURN-FROM mit diesem Blocknamen verwenden können, um von der Funktion zurückzukehren und Werte zurückzugeben.

Sie sollten es vermeiden, so früh wie möglich zurückzukehren.

(defun foobar (x y)
  (when (oddp x)
    (format t "X (~d) is odd. Returning immediately.~%" x)
    (return-from foobar "return value"))
  (format t "X: ~s~@
             Y: ~s~%"
          x y))

(foobar 10 20)
; X: 10
; Y: 20
;=> NIL
(foobar 9 20)
; X (9) is odd. Returning immediately.
;=> "return value"

Schlüsselwortparameter

Schlüsselwortparameter können mit dem Schlüsselwort &KEY definiert werden. Sie sind immer optional (Details zur Definition finden Sie im Beispiel Optionale Parameter). Es können mehrere Schlüsselwortparameter vorhanden sein.

(defun foobar (x y &key (z "Default" zp))
  (format t "X (~s) and Y (~s) are required.~@
             Z (~s) is a keyword argument. It ~:[wasn't~;was~] given.~%"
          x y z zp))

(foobar 10 20)
; X (10) and Y (20) are required.
; Z ("Default") is a keyword argument. It wasn't given.
;=> NIL
(foobar 10 20 :z 30)
; X (10) and Y (20) are required.
; Z (30) is a keyword argument. It was given.
;=> NIL