common-lisp
Funkcje

Uwagi

Wymagane parametry

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

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

Parametry opcjonalne

Parametry opcjonalne można określić po wymaganych parametrach, używając słowa kluczowego &OPTIONAL . Po nim może być wiele opcjonalnych parametrów.

(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

Domyślny alue

Domyślną wartość można podać dla parametrów opcjonalnych, określając parametr za pomocą listy; druga wartość jest domyślna. Domyślny formularz wartości zostanie oceniony tylko wtedy, gdy podany zostanie argument, więc można go użyć do efektów ubocznych, takich jak sygnalizowanie błędu.

(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

Sprawdź, czy podano opcjonalny argument

Trzeci element członkowski może zostać dodany do listy po wartości domyślnej; nazwa zmiennej, która jest prawdziwa, jeśli podano argument lub NIL jeśli nie został podany (i używana jest wartość domyślna).

(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

Funkcja bez parametrów

Globalne funkcje nazwane są definiowane za pomocą DEFUN .

(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

Treść funkcji może zawierać dowolną liczbę form. Wartości z ostatniego formularza zostaną zwrócone z funkcji.

Parametr odpoczynku

Pojedynczy parametr odpoczynku można podać za pomocą słowa kluczowego &REST po wymaganych argumentach. Jeśli taki parametr istnieje, funkcja może przyjąć wiele argumentów, które zostaną pogrupowane w listę w parametrze rest. Zauważ, że zmienna CALL-ARGUMENTS-LIMIT określa maksymalną liczbę argumentów, które mogą być użyte w wywołaniu funkcji, dlatego liczba argumentów jest ograniczona do konkretnej implementacji wynoszącej co najmniej 50 lub więcej argumentów.

(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

Odpoczynek i parametry słów kluczowych razem

Reszta parametru może znajdować się przed parametrami słowa kluczowego. W takim przypadku będzie zawierać listę właściwości podaną przez użytkownika. Wartości słów kluczowych nadal będą powiązane z odpowiednim parametrem słowa kluczowego.

(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

Słowo kluczowe &ALLOW-OTHER-KEYS można dodać na końcu listy lambda, aby umożliwić użytkownikowi podawanie argumentów słów kluczowych niezdefiniowanych jako parametry. Pójdą na listę pozostałych.

(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

Zmienne pomocnicze

&AUX kluczowe &AUX można użyć do zdefiniowania zmiennych lokalnych dla funkcji. Nie są parametrami; użytkownik nie może ich dostarczyć.

Zmienne &AUX są rzadko używane. Zawsze możesz zamiast tego użyć LET lub innego sposobu definiowania zmiennych lokalnych w treści funkcji.

&AUX Zmienne &AUX mają tę zaletę, że zmienne lokalne całego ciała funkcji przenoszą się na górę i sprawiają, że jeden poziom wcięcia (na przykład wprowadzony przez LET) jest niepotrzebny.

(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

Jednym typowym zastosowaniem może być rozwiązywanie parametrów „desygnatora”. Znowu nie musisz tego robić; używanie let jest tak samo idiomatyczne.

(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, wyjście z bloku lub funkcji

Funkcje zawsze tworzą blok wokół ciała. Ten blok ma taką samą nazwę jak nazwa funkcji. Oznacza to, że możesz użyć RETURN-FROM z tą nazwą bloku, aby powrócić z funkcji i zwrócić wartości.

W miarę możliwości należy unikać powrotu wcześniej.

(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"

Parametry słowa kluczowego

Parametry słowa kluczowego można zdefiniować za pomocą słowa kluczowego &KEY . Są zawsze opcjonalne (szczegółowe informacje na temat definicji zawiera przykład parametrów opcjonalnych). Może istnieć wiele parametrów słów kluczowych.

(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