Eksplorowanie funkcji

  • 4 min

Zazwyczaj znajdujesz się w sytuacji, w której kod wygląda powtarzalnie. Robi to samo w wielu miejscach lub istnieją tylko drobne różnice. W takich sytuacjach pomyśl o sposobie ponownego wykorzystania kodu. Sposobem rozwiązania tej sytuacji jest wyodrębnienie tych wyrażeń i utworzenie jednej lub więcej funkcji. Funkcja jest podstawowym blokiem konstrukcyjnym w wielu językach programowania, a język F# nie różni się.

Funkcja

Funkcja jest nazwanym odwołaniem z treścią składającą się z co najmniej jednego wyrażenia. Może również mieć parametry. Funkcja rozpoczyna się od słowa kluczowego let i nazwy funkcji. Następnie jest operator przypisania, a po prawej stronie tego operatora jest treść funkcji.

Oto składnia funkcji:

let <function name> <parameters> = <function body>

Rzeczywisty przykład funkcji, jak pokazano w poprzedniej przykładowej składni, wygląda następująco:

let add a b = a + b

W tym przykładzie nazwa funkcji to add , a parametry to a i b. Treść funkcji dodaje dwa parametry razem , a+bi zwraca wynik.

Wartości zwracane

Jak widzieliście w pierwszym przykładzie, nie ma return słowa kluczowego do wskazania, co jest zwracane. W języku F# informacje w ostatnim wierszu funkcji są zwracane. Rozważmy tę funkcję wielowierszową:

let addAndMultiply a b c = 
    let sum = a + b
    let product = sum * c
    product

Umieszczając product w ostatnim wierszu, pokazuje, co jest zwracane. Jak więc wywołać funkcję podobną do tej?

Wywoływanie funkcji

Aby wywołać funkcję, użyj jej nazwy i dodaj wszystkie parametry, których chcesz użyć, oddzielając je spacją. Aby na przykład wywołać addAndMultiply() funkcję, wprowadź następujący kod:

addAndMultiply 2 3 3 // 15

Aby wyświetlić wyniki funkcji, możesz przypisać ją do zmiennej lub wydrukować ją bezpośrednio, w następujący sposób:

let sum = addAndMultiply 2 3 3
printfn "%i" sum
// OR
printfn "%i" (addAndMultiply 2 3 3)

Wnioskowane typy

Weźmy następujący kod:

let add a b = a + b
let sum = add 2 2 
let concat = add "hello" "world" // will give compilation error

Ten kod kończy się niepowodzeniem w ostatnim wierszu z następującym komunikatem:

error FS0001: This expression was expected to have type
    'int'    
but here has type
    'string'

Przyczyną niepowodzenia jest to, że język F# już ustalił, jakiego typu parametru należy użyć, i zdecydował się na liczbę całkowitą. Powodem, dla którego zdecydowano się na liczbę całkowitą, były informacje w drugim wierszu let sum = add 2 2. Funkcja add() została użyta w sposób, który stwierdził, że typ parametru był zdecydowanie liczbą całkowitą.

Jeśli drugi wiersz nie istnieje, kod działa:

let add a b = a + b
// let sum = add 2 2 
let concat = add "hello" "world" // will work

Kompilator widzi, że pierwsze użycie funkcji jest wykonywane z ciągami i stwierdza, że typ parametru jest ciągiem. Tak więc kontekst i pierwsze użycie pozwalają wywnioskować typ.

Typy jawne

Istnieją sytuacje, w których chcesz być jawny w kwestii zarówno tego, jaki typ parametrów przyjąć, jak i tego, co zwraca funkcja. Ułatwia to czytelność, będąc skonkretyzowanym, nawet jeśli kompilator najprawdopodobniej tego nie potrzebuje.

Weź na przykład następującą funkcję:

let convert a =
    int a

Aby dodać do niego typy, należy dodać :<type> element w następujący sposób:

let convert (a:string) =
    int a

Parametr ma teraz typ string za pomocą kodu let convert (a:string). Teraz możesz być jeszcze bardziej precyzyjny, przez dodanie typu zwracanego. W tym celu dodaj kolejny parametr :<type> bezpośrednio po parametrze:

let convert (a:string) :int =
    int a

Teraz nawiasy otaczają parametr, jak pokazano w (a:string). Zwracany typ to ostatnia :<type> adnotacja, która ma się zdarzyć, czyli :int. Język F# jest wystarczająco sprytny, aby ustalić większość scenariuszy, ale czasami trzeba pomóc kodowi, będąc bardziej wyraźnym. Kolejną zaletą dodawania typów jest to, że ułatwia innym deweloperom ustalenie, co się dzieje.