Swift - Функции

Функция - это набор операторов, организованных вместе для выполнения определенной задачи. Функция Swift 4 может быть настолько простой, как простая функция C, так и сложной, как функция языка Objective C. Это позволяет нам передавать значения локальных и глобальных параметров внутри вызовов функций.

Function Declaration - сообщает компилятору имя функции, возвращаемый тип и параметры.
Function Definition - Он обеспечивает собственное тело функции.

Функции Swift 4 содержат тип параметра и его возвращаемые типы.

Определение функции

В Swift 4 функция определяется ключевым словом func. Когда функция определяется заново, она может принимать одно или несколько значений в качестве входных «параметров» функции, и она будет обрабатывать функции в основном теле и передавать значения функциям в качестве выходных «возвращаемых типов».

У каждой функции есть имя, которое описывает задачу, которую выполняет функция. Чтобы использовать функцию, вы «вызываете» эту функцию с ее именем и передаете входные значения (известные как аргументы), которые соответствуют типам параметров функции. Параметры функции также называются «кортежами».

Аргументы функции всегда должны предоставляться в том же порядке, что и список параметров функции, а за возвращаемыми значениями следует знак →.

Синтаксис

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

Взгляните на следующий код. Имя студента объявляется как строковый тип данных, объявленный внутри функции «student», и при вызове функции она возвращает имя студента.

func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name: "About Functions"))

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

First Program
About Functions

Вызов функции

Предположим, мы определили функцию с именем 'display' для рассмотрения, например, для отображения чисел функция с именем функции 'display' инициализируется первой с аргументом 'no1', который содержит целочисленный тип данных. Затем аргумент «no1» присваивается аргументу «a», который в дальнейшем будет указывать на тот же тип данных целое число. Теперь в функцию возвращается аргумент «а». Здесь функция display () будет хранить целочисленное значение и возвращать целочисленные значения при каждом вызове функции.

func display(no1: Int) -> Int {
   let a = no1
   return a
}

print(display(no1: 100))
print(display(no1: 200))

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат -

100
200

Параметры и возвращаемые значения

Swift 4 предоставляет гибкие параметры функции и ее возвращаемые значения от простых до сложных значений. Подобно функциям C и Objective C, функции в Swift 4 также могут принимать несколько форм.

Функции с параметрами

Доступ к функции осуществляется путем передачи значений ее параметров в тело функции. Мы можем передавать одно или несколько значений параметров в виде кортежей внутри функции.

func mult(no1: Int, no2: Int) -> Int {
   return no1*no2
}

print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат -

40
45
120

Функции без параметров

У нас также могут быть функции без параметров.

Синтаксис

func funcname() -> datatype {
   return datatype
}

Ниже приведен пример функции без параметра -

func votersname() -> String {
   return "Alice"
}
print(votersname())

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Alice

Функции с возвращаемыми значениями

Функции также используются для возврата значений строковых, целочисленных и плавающих типов данных в качестве возвращаемых типов. Чтобы узнать наибольшее и наименьшее число в заданном массиве, объявляется функция ls с типами данных big и small целочисленные.

Массив инициализируется для хранения целочисленных значений. Затем массив обрабатывается, и каждое значение в массиве читается и сравнивается с его предыдущим значением. Когда значение меньше предыдущего, оно сохраняется в «маленьком» аргументе, в противном случае оно сохраняется в «большом» аргументе, и значения возвращаются путем вызова функции.

func ls(array: [Int]) -> (large: Int, small: Int) {
   var lar = array[0]
   var sma = array[0]

   for i in array[1..<array.count] {
      if i < sma {
         sma = i
      } else if i > lar {
         lar = i
      }
   }
   return (lar, sma)
}

let num = ls(array: [40,12,-5,78,98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Largest number is: 98 and smallest number is: -5

Функции без возвращаемых значений

Некоторые функции могут иметь аргументы, объявленные внутри функции, без каких-либо возвращаемых значений. Следующая программа объявляетa и bв качестве аргументов функции sum (). внутри самой функции значения аргументовa и b передаются путем вызова функции sum (), и ее значения печатаются, тем самым устраняя возвращаемые значения.

func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

30 20
50 40
30 24

Функции с дополнительными типами возврата

Swift 4 представляет «необязательную» функцию, позволяющую избавиться от проблем путем введения меры безопасности. Рассмотрим, например, что мы объявляем тип возвращаемого значения функции как целое число, но что произойдет, когда функция вернет строковое значение или либо нулевое значение. В этом случае компилятор вернет значение ошибки. «необязательные» вводятся, чтобы избавиться от этих проблем.

Необязательные функции могут принимать две формы: «значение» и «ноль». Мы будем упоминать «Опции» с ключевым зарезервированным символом «?» чтобы проверить, возвращает ли кортеж значение или нулевое значение.

func minMax(array: [Int]) -> (min: Int, max: Int)? {
   if array.isEmpty { return nil }
   var currentMin = array[0]
   var currentMax = array[0]
   
   for value in array[1..<array.count] {
      if value < currentMin {
         currentMin = value
      } else if value > currentMax {
         currentMax = value
      }
   }
   return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат -

min is -6 and max is 109

«Необязательные» используются для проверки значений «nil» или «мусора», отнимая много времени на отладку и делая код эффективным и читаемым для пользователя.

Функции Локальные и внешние имена параметров

Имена локальных параметров

Имена локальных параметров доступны только внутри функции.

func sample(number: Int) {
   print(number)
}

Здесь funcНомер аргумента sample объявлен как внутренняя переменная, поскольку к нему обращается внутренняя функция sample (). Здесь 'число' объявлено как локальная переменная, но ссылка на переменную делается вне функции с помощью следующего оператора:

func sample(number: Int) {
   print(number)
}

sample(number: 1)
sample(number: 2)
sample(number: 3)

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

1
2
3

Имена внешних параметров

Имена внешних параметров позволяют нам называть параметры функции, чтобы прояснить их назначение. Например, ниже вы можете назвать два параметра функции, а затем вызвать эту функцию следующим образом:

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}

pow(firstArg:5, secondArg:3)

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Вариативные параметры

Когда мы хотим определить функцию с несколькими аргументами, мы можем объявить члены как «вариативные» параметры. Параметры могут быть указаны как переменные с помощью (···) после имени параметра.

func vari<N>(members: N...){
   for i in members {
      print(i)
   }
}

vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

Постоянные, переменные и параметры ввода / вывода

Функции по умолчанию рассматривают параметры как «постоянные», тогда как пользователь может также объявлять аргументы функций как переменные. Мы уже обсуждали, что ключевое слово let используется для объявления постоянных параметров, а параметры переменных определяются с помощью ключевого слова var.

Параметры ввода-вывода в Swift 4 предоставляют функциональные возможности для сохранения значений параметров, даже если их значения изменяются после вызова функции. В начале определения параметра функции объявляется ключевое слово inout для сохранения значений членов.

Он выводит ключевое слово inout, так как его значения передаются в функцию, а его значения доступны и изменяются телом функции, и оно возвращается обратно из функции для изменения исходного аргумента.

Переменные передаются только в качестве аргумента для параметра in-out, поскольку только его значения изменяются внутри и вне функции. Следовательно, нет необходимости объявлять строки и литералы в качестве входных-выходных параметров. Знак «&» перед именем переменной указывает на то, что мы передаем аргумент параметру входа-выхода.

func temp(a1: inout Int, b1: inout Int) {
   let t = a1
   a1 = b1
   b1 = t
}

var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Swapped values are 10, 2

Типы функций и их использование

Каждая функция следует за конкретной функцией, учитывая входные параметры и выдает желаемый результат.

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

Ниже приведен пример -

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

2
6

Здесь функция инициализируется двумя аргументами no1 и no2 как целочисленные типы данных и его возвращаемый тип также объявлен как int

Func inputstr(name: String) -> String {
   return name
}

Здесь функция объявлена как string тип данных.

Функции также могут иметь void типы данных и такие функции ничего не вернут.

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Swift 4 Functions
Types and its Usage

Вышеупомянутая функция объявлена как функция void без аргументов и без возвращаемых значений.

Использование типов функций

Функции сначала передаются с аргументами целочисленного, плавающего или строкового типа, а затем передаются функции как константы или переменные, как указано ниже.

var addition: (Int, Int) -> Int = sum

Здесь sum - это имя функции, имеющее целочисленные переменные 'a' и 'b', которое теперь объявлено как переменная к добавлению имени функции. В дальнейшем обе функции сложения и суммирования имеют одинаковое количество аргументов, объявленных как целочисленный тип данных, а также возвращают целые значения в качестве ссылок.

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Result: 129

Типы функций как типы параметров и типы возврата

Мы также можем передать саму функцию как типы параметров другой функции.

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   print("Result: \(addition(a, b))")
}
another(sum, 10, 20)

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Result: 129
Result: 30

Вложенные функции

Вложенная функция предоставляет возможность вызвать внешнюю функцию путем вызова внутренней функции.

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 30)
print(decrem())

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

-30