Swift: Funkcje

Funkcje w Swift

Składania funkcji w Swift wygląda następująco:

func name() {
	...
}

Najpierw słowo kluczowe func, a następnie podajesz jej nazwę.

Wywołanie funkcji:

func helloWorld() {
	print("Hello World!)
}

helloWorld() // Hello World!

Parametry

Parametry funkcji są stałymi. To znaczy, że jeśli spróbujesz zmienić ich wartość, zostanie zgłoszony błąd.

Możesz zdefiniować parametry funkcji na różne sposoby:

Parametry z etykietą

func sayHello(name) {
	print("Hello \(name)!")
}

Jeśli tak deklarujesz parametry funkcji, musisz podać nazwę etykiety argumentu przy wywołaniu:

sayHello(name: "Anna")

Nie możesz napisać tak:

sayHello("Anna")

Parametry i typ danych

Możesz określić typ danych parametrów:

func calculate(a: Int, b: Int) {
	print(a + b)
}

Parametry bez etykiet

Jeśli nie chcesz używać etykiet dla argumentów, to przed nazwą parametru użyj _:

func sayHello(_ name: String) {
	print("Hello \(name)!")
}

sayHello("Anna") // Hello Anna!

Domyślne wartości parametrów

Do funkcji można przekazywać domyślne wartości:

func calculate(a: Int = 1, b: Int = 2) {
	print(a + b)
}

Wywołanie:

calculate() // 3

calculate(a: 9, b: 3) // 12

calculate(a: 8) // 10

Parametry typu in-out

Jak już wyżej wspomniałem: nie można zmieniać wartości parametrów w ciele funkcji. Jeśli spróbujesz to zrobić, zostanie zgłoszony błąd.

Jeśli jednak koniecznie potrzebujesz zmienić wartość parametru, oznacz go jako: inout. Dodatkowo w momencie wywołania funkcji przed nazwą argumentu należy użyć: &.

Przykład:

func increment(_ counter: inout Int) {
	counter += 1
}

var counter = 0

print(counter) // 0

increment(&counter)

print(counter) // 1

Parametr funkcja

Możesz do funkcji przekazać inną funkcję

func sum(_ a: Int, _ b: Int) {
	print(a + b)
}

func substract(_ a: Int, _ b: Int) {
	print(a - b)
}

func calculate(_ operation: (Int, Int) -> Void, _ a: Int, _ b: Int) {
	operation(a, b)
}

calculate(sum, 1, 1) // 2
calculate(substract, 1, 1) // 0

Zwracanie danych

Możesz określić typ danych, jaki zwraca funkcja za pomocą: return. Dzięki -> określasz typ zwracanych danych.

Zwracania jednej wartości

func calculate(a: Int, b: Int) -> Int {
	return a + b
}

let result: Int = calculate(a: 5, b: 7)

print(result) // 12

Zwracanie wielu wartości

Swift pozwala na zwrócenie wielu wartości. Taka funkcja zwróci krotkę (ang.: Tuple).

func prepare(_ name: String) -> (greet: String, goodbye: String) {
	let greet: String = "Hello \(name)!"
	let goodbye: String = "Bye \(name)!"
	
	return (greet, goodbye)
}

let result = prepare("Marcin")

print(result.greet) // Hello Marcin!
print(result.goodbye) // Bye Marcin!

Zwracanie funkcji

Możesz zwrócić funkcję jako wynik działania innej funkcji.

func sum(_ a: Int, _ b: Int) -> Int {
	return a + b
}

func substract(_ a: Int, _ b: Int) -> Int {
	return a - b
}
	
func defaultOperate(_ a: Int, _ b: Int) -> Int {
	return 0
}
	
func prepare(_ op: String) -> (Int, Int) -> Int {
	if op == "+" {
	    return sum
	} else if op == "-" {
	    return substract
	}
	
	return defaultOperate
}

let sumOperate = prepare("+")
print(sumOperate(0, 1)) // 1

let substractOperate = prepare("-")
print(substractOperate(0, 1)) // -1

Zagnieżdżone funkcje

Swift pozwala także na zagnieżdżone funkcje:

func calculate(_ a: Int, _ b: Int, _ op: String) -> Int {
  func sum(_ a: Int, _ b: Int) -> Int {
	  return a + b
  }

  func substract(_ a: Int, _ b: Int) -> Int {
	  return a - b
  }
	
  if op == "+" {
   return sum(a, b)
  } else if op == "-" {
    return substract(a, b)
  }
	
  return 0
}

print(calculate(0, 1, "+")) // 1

print(calculate(0, 1, "-")) // -1