Swift - закрытие

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

Глобальные функции	Вложенные функции	Замыкающие выражения
Назови имя. Не фиксируйте никаких значений	Назови имя. Захват значений из включающей функции	Безымянные замыкания захватывают значения из соседних блоков

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

• Вывод типов параметров и возвращаемых значений из контекста.
• Неявный возврат из замыканий с одним выражением.
• Сокращенные имена аргументов и
• Синтаксис завершающего закрытия

Синтаксис

Ниже приведен общий синтаксис для определения закрытия, которое принимает параметры и возвращает тип данных.

{
   (parameters) −> return type in
   statements
}

Ниже приводится простой пример -

let studname = { print("Welcome to Swift Closures") }
studname()

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

Welcome to Swift Closures

Следующее закрытие принимает два параметра и возвращает значение типа Bool -

{     
   (Int, Int) −> Bool in
   Statement1
   Statement 2
   ---
   Statement n
}

Ниже приводится простой пример -

let divide = {
   (val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}

let result = divide(200, 20)
print (result)

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

10

Выражения в замыканиях

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

Программа возрастающего порядка

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

Внутри отсортированной функции представлены два аргумента -

• Значения типа Known представлены в виде массивов.

• Содержимое массива (Int, Int) и возвращает логическое значение (Bool), если массив отсортирован правильно, он вернет истинное значение, иначе он вернет ложь.

Обычная функция с входной строкой записывается и передается в сортированную функцию для сортировки строк в новый массив, который показан ниже -

func ascend(s1: String, s2: String) -> Bool {
   return s1 > s2
}

let stringcmp = ascend(s1: "Swift 4", s2: "great")
print (stringcmp)

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

true

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

Синтаксис выражения закрытия использует -

• постоянные параметры,
• переменные параметры и
• inout параметры.

Выражение закрытия не поддерживает значения по умолчанию. Параметры с переменными параметрами и кортежи также могут использоваться в качестве типов параметров и типов возвращаемых значений.

let sum = {
   (no1: Int, no2: Int) -> Int in 
   return no1 + no2 
}

let digits = sum(10, 20)
print(digits)

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

30

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

Неявный возврат одного выражения

Здесь тип функции второго аргумента отсортированной функции дает понять, что значение типа Bool должно быть возвращено замыканием. Поскольку тело замыкания содержит одно выражение (s1> s2), которое возвращает значение типа Bool, двусмысленности нет, и ключевое слово return можно опустить.

Чтобы вернуть оператор Single expression в закрытии выражений, ключевое слово return опускается в его части объявления.

var count:[Int] = [5, 10, -6, 75, 20]
let descending = count.sorted(by: { n1, n2 in n1 > n2 })
let ascending = count.sorted(by: { n1, n2 in n1 < n2 })

print(descending)
print(ascending)

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

[75, 20, 10, 5, -6]
[-6, 5, 10, 20, 75]

Сам оператор четко определяет, что, когда строка1 больше, чем строка 2, возвращает истину, в противном случае - ложь, поэтому оператор возврата здесь опускается.

Укупорочные средства известного типа

Рассмотрим сложение двух чисел. Мы знаем, что добавление вернет целочисленный тип данных. Следовательно, замыкания известных типов объявляются как -

let sub = {
   (no1: Int, no2: Int) -> Int in 
   return no1 - no2 
}

let digits = sub(10, 20)
print(digits)

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

-10

Объявление сокращенных имен аргументов как замыканий

Swift 4 автоматически предоставляет сокращенные имена аргументов для встроенных замыканий, которые можно использовать для ссылки на значения аргументов замыкания по именам $ 0, $ 1, $ 2 и так далее.

var shorthand: (String, String) -> String
shorthand = { $1 }
print(shorthand("100", "200"))

Здесь $ 0 и $ 1 относятся к первому и второму строковым аргументам замыкания.

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

200

Swift 4 упрощает пользователю представление встроенных замыканий в виде сокращенных имен аргументов, представляя $ 0, $ 1, $ 2 --- $ n.

Список аргументов замыкания опускается в разделе определения, когда мы представляем сокращенные имена аргументов внутри выражений замыкания. На основе типа функции будут производиться сокращенные имена аргументов. Поскольку сокращенный аргумент определен в теле выражения, ключевое слово in опущено.

Замыкания как операторские функции

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

Выражение стало еще проще с помощью операторной функции в замыкании как -

let numb = [98, -20, -30, 42, 18, 35]
var sortedNumbers = numb.sorted ({
   (left: Int, right: Int) -> Bool in
   return left < right
})

let asc = numb.sorted(<)
print(asc)

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

[-30, -20, 18, 35, 42, 98]

Закрытие как трейлеры

Передача последнего аргумента функции в выражение замыкания объявляется с помощью 'Trailing Closures'. Он написан вне функции () с помощью {}. Его использование необходимо, когда невозможно написать встроенную функцию в одной строке.

reversed = sorted(names) { $0 > $1}

где {$ 0> $ 1} представлены как завершающие замыкания, объявленные за пределами (имена).

import Foundation
var letters = ["North", "East", "West", "South"]

let twoletters = letters.map({ 
   (state: String) -> String in
   return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString
})

let stletters = letters.map() { 
   $0.substringToIndex(advance($0.startIndex, 2)).uppercaseString 
}
print(stletters)

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

[NO, EA, WE, SO]

Захват значений и ссылочных типов

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

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

Вложенная функция захватывает -

• Аргументы внешней функции.
• Захватите константы и переменные, определенные во внешней функции.

В Swift 4, когда константа или переменная объявляются внутри функции, ссылка на эти переменные также автоматически создается закрытием. Он также предоставляет возможность ссылаться на более чем две переменные как на одно и то же закрытие следующим образом:

let decrem = calcDecrement(forDecrement: 18)
decrem()

Вот oneDecrement и переменные Decrement будут указывать на один и тот же блок памяти в качестве ссылки на замыкание.

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

let decrem = calcDecrement(forDecrement: 18)
decrem()
decrem()
decrem()

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

82
64
46

Каждый раз, когда вызывается внешняя функция calcDecrement, она вызывает функцию Decmenter (), уменьшает значение на 18 и возвращает результат с помощью внешней функции calcDecrement. Здесь calcDecrement действует как закрытие.

Несмотря на то, что функция декрементер () не имеет аргументов, закрытие по умолчанию обращается к переменным 'totalDecrement' и 'total' путем захвата их существующих значений. Копии значений для указанных переменных сохраняются с помощью новой функции Decmenter (). Swift 4 обрабатывает функции управления памятью, выделяя и освобождая пространства памяти, когда переменные не используются.