Szukaj…
Składnia
(zdefiniuj (nazwa argumentów ...) treść)
(argumenty funkcji ...)
Proste wywołania funkcji
Możesz wywołać funkcję w Racket, zawijając ją w nawiasach z argumentami po niej. Wygląda to na (function argument ...) .
> (define (f x) x)
> (f 1)
1
> (f "salmon")
"salmon"
> (define (g x y) (string-append x y))
> (g "large" "salmon")
"largesalmon"
> (g "large " "salmon")
"large salmon"
Operacje takie jak + i * są również funkcjami i używają tej samej składni, co wywoływanie f lub g .
> (+ 1 2)
3
> (* 3 4)
12
> (+ (* 3 3) (* 4 4))
25
Aby uzyskać więcej informacji i przykładów, zobacz Wywołania funkcji w Przewodniku po rakietach.
Argumenty słów kluczowych
Funkcje rakiety mogą także zawierać argumenty słów kluczowych , które są określone słowem kluczowym, po którym następuje wyrażenie argumentu. Słowo kluczowe zaczyna się od znaków #: więc argument słowa kluczowego wygląda jak #:keyword arg-expr . W wywołaniu funkcji wygląda to tak (function #:keyword arg-expr) .
> (define (hello #:name n)
(string-append "Hello " n))
> (hello #:name "John")
"Hello John"
> (hello #:name "Sarah")
"Hello Sarah"
> (define (kinetic-energy #:mass m #:velocity v)
(* 1/2 m (sqr v)))
> (kinetic-energy #:mass 2 #:velocity 1)
1
> (kinetic-energy #:mass 6 #:velocity 2)
12
Aby uzyskać więcej informacji i przykładów, zobacz Argumenty słów kluczowych w Przewodniku po rakietach.
Funkcja „zastosuj”
Jeśli masz listę i chcesz użyć jej elementów jako argumentów funkcji, apply :
> (apply string-append (list "hello" " " "and hi" " " "are both words"))
"hello and hi are both words"
> (apply + (list 1 2 3 4))
10
> (apply append (list (list "a" "b" "c") (list 1 2 3) (list "do" "re" "mi")))
(list "a" "b" "c" 1 2 3 "do" "re" "me")
apply wymaga dwóch argumentów. Pierwszy argument to funkcja do zastosowania, a drugi argument to lista zawierająca argumenty.
apply połączenie jak
(apply + (list 1 2 3 4))
Jest równa
(+ 1 2 3 4)
Główną zaletą apply jest to, że działa na dowolnych listach obliczeniowych, w tym na listach dołączonych i listach, które pochodzą z argumentów funkcji.
> (apply + (append (list 1 2 3 4) (list 2 3 4)))
19
> (define (sum lst)
(apply + lst))
> (sum (list 1 2 3 4))
10
> (sum (append (list 1 2 3 4) (list 2 3 4)))
19
Aby uzyskać więcej informacji i przykładów, zobacz apply funkcję w Przewodniku po rakietach.
Definicje funkcji
Funkcje w Racket można tworzyć za pomocą formularza lambda . Formularz przyjmuje listę argumentów i treść.
(lambda (x y) (* x y))
W powyższym przykładzie funkcja przyjmuje dwa argumenty i zwraca wynik ich pomnożenia.
> ((lambda (x y) (* x y)) 4 4)
16
> ((lambda (x y) (* x y)) 3 2)
6
Ponowne pisanie funkcji i jej ciała jest nudne za każdym razem, gdy chcemy pomnożyć dwie liczby, więc nadajmy jej nazwę. Aby nadać mu nazwę, użyj formularza define . Spowoduje to powiązanie funkcji z nazwą.
(define multiply (lambda (x y) (* x y)))
Teraz możemy odwoływać się do naszej funkcji, wywołując multiply
> (multiply 5 2)
10
Ponieważ powiązanie procedur z nazwami jest bardzo powszechne, Racket zapewnia skrót do definiowania funkcji za pomocą formularza definiowania.
(define (multiply x y) (* x y))
Aby uzyskać więcej informacji i przykładów, zobacz Funkcje: lambda w Przewodniku po rakietach.