---
title: 4.2. Функции и области видимости. Замыкания
tags: Templates, Talk
description: View the slide with "Slide Mode".
---
# 4.2. Функции и области видимости. Замыкания
# План занятия
1. Области видимости
- open и public
- internal
- fileprivate
- private
2. Функции
- Определение
- Параметры функции
- Параметры функций по умолчанию
3. Замыкания
- Замыкания как аргументы функций
- Доступ к контексту
- Захват значений
## Области видимости
Начиная с Swift 3.0.1 существует 4 уровня доступа, описанный ниже с наивысшего (наименее ограничивающего) до самого низкого (наиболее ограничительного).
1. open и public
Включить сущность, которая будет использоваться вне определяющего модуля (цели). Обычно вы используете доступ к ```open``` или ```public``` при указании открытого интерфейса на фреймворк.
Однако доступ ```open``` применяется только к классам и членам класса, и он отличается от доступа ```public``` следующим образом:
- ```public``` классы и члены класса могут быть только подклассифицированы и переопределены в определяющем модуле (цели).
- ```open``` классы и члены класса могут быть подклассифицированы и переопределены как внутри, так и вне определяющего модуля (цели).
```javascript=
// First.framework – A.swift
open class A {}
```
```javascript=
// First.framework – B.swift
public class B: A {} // ok
```
```javascript=
// Second.framework – C.swift
import First
internal class C: A {} // ok
```
```javascript=
// Second.framework – D.swift
import First
internal class D: B {} // error: B cannot be subclassed
```
2. internal
Позволяет использовать объект в определяющем модуле (цели). Обычно вы используете доступ ```internal``` при определении приложений или внутренней структуры фреймворка.
```javascript=
// First.framework – A.swift
internal struct A {}
```
```javascript=
// First.framework – B.swift
A() // ok
```
```javascript=
// Second.framework – C.swift
import First
A() // error: A is unavailable
```
3. fileprivate
Ограничивает использование сущности в определяющем исходном файле. Обычно вы используете ```fileprivate``` доступ, чтобы скрыть детали реализации определенной функциональности, когда эти данные используются во всем файле.
```javascript=
// First.framework – A.swift
internal struct A {
fileprivate static let x: Int
}
A.x // ok
```
```javascript=
// First.framework – B.swift
A.x // error: x is not available
```
4. private
Ограничивает использование объекта в его объявлении. Обычно вы используете ```private``` доступ, чтобы скрыть детали реализации определенной части функциональности, когда эти данные используются только в пределах одного объявления.
```javascript=
// First.framework – A.swift
internal struct A {
private static let x: Int
internal static func doSomethingWithX() {
x // ok
}
}
A.x // error: x is unavailable
```
---
## Функции
Функция представляет набор инструкций, который имеет имя (имя функции) и может использоваться повторно в различных местах программы. Функция имеет следующее формальное определение:
```javascript=
func имя_функции (параметры) -> тип_возвращаемого_значения {
// набор инструкций
}
```
Сначала идет ключевое слово ```func```, после которого идет имя функции. Для именования функции применяются в принципе те же правила, что и при именовании переменных. Для имени функции используется режим camel case.
После имени функции в скобках указываются параметры. Если параметров нет, то просто идут пустые скобки.
Если функция возвращает какое-либо значение, то после параметров в скобках идет стрелка и тип возвращаемого значения. И в конце в фигурных скобках собственно идет блок кода, который и представляет функцию.
Определим простейшую функцию:
```javascript=
func printName(){
print("Меня зовут Вадим")
}
```
Здесь функция называется printName. Эта функция ничего не возвращает, поэтому тут после скобок сразу идут фигурные скобки с набором операторов. Данная функция просто выводит строку "Меня зовут Вадим".
Далее по имени функции мы можем ее вызвать многократно. Для вызова функции указывается ее имя, после которого в скобках перечисляются значения для ее параметров:
```javascript=
func printName(){
print("Меня зовут Вадим")
}
printName()
printName()
printName()
```
В частности, здесь функция вызывается три раза.
### Параметры функции
Теперь используем параметры:
```javascript=
func printInfo(name: String, age: Int){
print("Имя: \(name) ; возраст: \(age)")
}
printInfo(name: "Tom", age: 18) // Имя: Tom ; возраст: 18
printInfo(name: "Bob", age: 35) // Имя: Bob ; возраст: 35
```
Количество параметров может быть произвольным. В данном случае мы используем два параметра: для передачи имени и возраста. Для каждого параметра определено имя и тип. Например, первый параметр называется name и имеет тип String.
При вызове функции нам надо учитывать имя и тип параметров. При вызове функции ей необходимо передать значения для всех ее параметров по имени. То есть указывается имя параметра и через двоеточие его значение: name: "Tom", причем передаваемое значение должно соответствовать параметру по типу:
```javascript=
printInfo(name: "Tom", age: 18)
```
Хотя мы можем указать, что при вызове функции не надо указывать имена параметров при ее вызове. Для этого перед именем параметра нужно поставить подчеркивание. Между подчеркиванием и названием параметра должен идти пробел:
```javascript=
func printInfo(_ name: String, _ age: Int){
print("Имя: \(name) ; возраст: \(age)")
}
printInfo("Tom", 18) // Имя: Tom ; возраст: 18
```
При вызове подобной функции значения параметрам передаются по позиции. При этом опять же передаваемое значение должно соответствовать параметру по типу.
### Значения параметров по умолчанию
Если мы определили два параметра в функции, то соответственно при ее вызове мы также должны передать ей два значения для параметров. Однако мы также можем установить для параметров значения по умолчанию:
```javascript=
func printInfo(name: String = "Tom", age: Int = 22){
print("Имя: \(name) ; возраст: \(age)")
}
printInfo(name: "Bob", age: 18) // Имя: Bob ; возраст: 18
printInfo(name: "Alice") // Имя: Alice ; возраст: 22
printInfo() // Имя: Tom ; возраст: 22
```
И если при вызове функции мы не передадим для какого-то параметра значение, то этот параметр будет использовать значение по умолчанию.
## Замыкание
Замыкания (сlosures) представляют самодостаточные блоки кода, которые могут использоваться многократно в различных частях программы, в том числе в виде параметров в функциях.
По сути функции являются частным случаем замыканий. Замыкания могут иметь одну из трех форм:
- глобальные функции, которые имеют имя и которые не сохраняют значения внешних переменных и констант
- вложенные функции, которые имеют имя и которые сохраняют значения внешних переменных и констант
- замыкающие выражения (closure expressions), которые не имеют имени и которые могут сохранять значения внешних переменных и констант
В прошлых темах были рассмотрены глобальные и вложенные функции, поэтому в данной теме рассмотрим только замыкающие выражения.
Замыкающие выражения в общем случае имеют следующий синтаксис:
```javascript=
{ (параметры) -> тип_возвращаемого_значения in
инструкции
}
```
Если замыкания не имеют параметров или не возвращают никакого значения, то соответствующие элементы при определении замыкания могут опускаться.
Подобно тому, как переменная или константа могут представлять ссылку на функцию, они также могут представлять ссылку на замыкание:
```javascript=
let hello = { print("Hello world")}
hello()
hello()
```
В данном случае константе hello присваивается анонимная функция, которая состоит из блока кода, в котором выполняются некоторые действия. Эта функция не имеет никакого имени, мы ее можем вызывать только через константу hello.
Фактически константа hello в данном случае имеет тип ()->() или ()-gt;Void:
```javascript=
let hello: ()->Void = { print("Hello world")}
```
Дополнительно можно определить список параметров с помощью ключевого слова in:
```javascript=
let hello = {
(message: String) in
print(message)
}
hello("Hello")
hello("Salut")
hello("Ni hao")
```
В данном случае замыкание принимает один параметр - message, который представляет тип String. Список параметров указывается до ключевого слова in, а после идут инструкции функции.
Также можно определить возвращаемое значение:
```javascript=
let sum = {
(x: Int, y: Int) -> Int in
return x + y
}
print(sum(2, 5)) // 7
print(sum(12, 15)) // 27
print(sum(5, 3)) // 8
```
### Замыкания как аргументы функций
Как правило, анонимные функции используются в том месте, где они определены. Нередко анонимные функции передаются в другие функции в качестве параметра, если параметр представляет функцию:
```javascript=
func operation(_ a: Int, _ b: Int, _ action: (Int, Int) -> Int) -> Int{
return action(a, b)
}
let x = 10
let y = 12
let result1 = operation(x, y, {(a: Int, b: Int) -> Int in
return a + b
})
print(result1) // 22
var result2 = operation(x, y, {(a: Int, b: Int) -> Int in return a - b})
print(result2) // -2
```
Здесь функция operation() в качестве третьего параметра принимает другую функцию, которой передаются значения первого и второго параметров. Но нам необязательно определять дополнительные функции, поскольку в operation мы можем передать замыкающее выражение.
В первом случае это выражение производит сложение параметров, а во втором случае - их вычитание.
Таким образом, замыкающие выражения позволяют нам сократить объем кода, поскольку не надо определять дополнительную функцию для передачи ее в качестве параметра. Но мы можем сократить код еще больше. Система может самостоятельно выводить тип параметров и тип возвращаемого значения, поэтому мы можем определение этих типов опускать:
```javascript=
let x = 10
let y = 12
let result1 = operation(x, y, {(a, b) in a + b })
print(result1) // 22
let result2 = operation(x, y, {(a, b) in a - b })
print(result2) // -2
```
Компилятор видит, замыкающее выражение передается в качестве значения для параметра типа (Int, Int) -> Int, то есть в качестве функции, которая принимает параметры типа Int. Поэтому можно не указывать тип параметров a и b. Также компилятор определяет, что функция возвращает значение типа Int, поэтому выражение после ключевого слова in воспринимается как возвращаемое значение, и явным образом можно не использовать оператор return.
Но мы можем еще больше сократить замыкание, используя сокращения для параметров:
```javascript=
let x = 10
let y = 12
let result1 = operation(x, y, {$0 + $1})
print(result1) // 22
let result2 = operation(x, y, {$0 - $1})
print(result2) // -2
```
$0 представляет первый переданный в функцию параметр, а $1 - второй параметр. Система автоматически распознает их и поймет, что они представляют числа.
Однако поскольку здесь выполняются примитивные операции - сложение и вычитание двух чисел, то мы можем сократить замыкания еще больше:
```javascript=
let x = 10
let y = 12
let result1 = operation(x, y, +)
print(result1) // 22
let result2 = operation(x, y, -)
print(result2) // -2
```
Система автоматически распознает,что должны выполняться операции сложения и вычитания двух переданных параметров, и поэтому результат будет тот же.
### Доступ к контексту
Замыкания имеют полный доступ к контексту, в котором они определены. Кроме того, замыкания могут использовать внешние переменные и константы как состояние, которое может храниться на всем протяжении жизни замыкания:
```javascript=
func action() -> (()->Int){
var val = 0
return {
val = val+1
return val
}
}
let inc = action()
print(inc()) // 1
print(inc()) // 2
```
Здесь определена функция action, которая, в свою очередь, сама возвращает функцию. По факту она возвращает замыкающее выражение, которое увеличивает внешнюю переменную val на единицу и затем возвращает ее значение. Но при вызове мы видим, что переменная val сохраняет свое значение после увеличения, оно не сбрасывается обратно к нулю при каждом вызове функции. То есть переменная val представляет состояние, где замыкание может хранить данные.
### Захват значений
Замыкающие выражения обладают способностью сохранять начальные значения переданных в них переменных. Например, рассмотрим следующую ситуацию:
```javascript=
var a = 14
var b = 2
let myClosure: () -> Int = {return a + b}
print(myClosure()) // 16
a = 5
b = 6
print(myClosure()) // 11
```
Замыкающее выражение, на которое указывает константа myClosure, складывает значения переменных a и b. С изменением значений переменных также меняется результат замыкания myClosure. Однако мы можем зафиксировать начальные значения переменных:
```javascript=
var a = 14
var b = 2
let myClosure: () -> Int = {[a, b] in return a + b}
print(myClosure()) // 16
a = 5
b = 6
print(myClosure()) // 16
```
Передав переменные в квадратные скобки: [a, b], мы тем самым фиксируем их начальные значения. И даже если значения этих переменных в какой-то момент изменятся, замыкание будет оперировать прежними значениями.
## Домашнее задание:
Написать функцию которая принимает 3 значения A B C. И рассчитывает значение переменной D по формуле D = B * B - 4AC.
Так же написать подобное замыкание для переменной D!
Вывести в консоль результат функции и результат замыкания каждое на новой строке.
Задание выполнить в PlayGround.
Google Drive
Gist
Clipboard
Sign in with Wallet
