Учебники

Свифт – Закрытие

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

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

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

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

Синтаксис

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

{
   (parameters) −> return type in
   statements
}

Ниже приведен простой пример –

Live Demo

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

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

Welcome to Swift Closures

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

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

Ниже приведен простой пример –

Live Demo

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

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

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

10

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

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

Программа по возрастанию

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

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

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

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

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

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

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

Live Demo

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

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

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

true

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

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

  • постоянные параметры,
  • переменные параметры и
  • входные параметры.

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

Live Demo

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 в его части объявления опущено.

Live Demo

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]

Сам оператор ясно определяет, что когда string1 больше, чем строка 2, возвращают true, в противном случае false, поэтому здесь возвращаемый оператор опускается.

Закрытия известного типа

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

Live Demo

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

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

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

-10

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

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

Live Demo

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

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

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

200

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

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

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

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

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

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 захват значений констант и переменных осуществляется с помощью замыканий. Кроме того, он ссылается и изменяет значения этих констант и переменных внутри тела замыкания, даже если эти переменные больше не существуют.

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

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

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

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

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

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

Live Demo

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 действует как замыкание.

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