Функции swift: Функции — SwiftBook

Содержание

Функции — SwiftBook

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

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

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

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

возвращаемый тип).

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

В приведенном ниже примере функция называется greet(person:), потому что это отражает ее задачу – получить имя пользователя и вежливо поздороваться. Для этого задается один входной параметр типа String под названием person, а возвращается тоже значение типа String, но уже содержащее приветствие:

func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

Вся эта информация указана в объявлении функции, перед которым стоит ключевое слово func. Тип возвращаемого значения функции ставится после результирующей стрелки -> (это дефис и правая угловая скобка).

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

print(greet(person: "Anna"))
// Prints "Hello, Anna!"
print(greet(person: "Brian"))
// Prints "Hello, Brian!"

Функция greet(person:) вызывается, принимая значение типа String, которое стоит после имени person, например вот так — greet(person: «Anna»). Поскольку функция возвращает значение типа String, вызов функции greet(person:) может быть завернут в вызов для функции print(_:separator:terminator:), чтобы напечатать полученную строку и увидеть возвращаемое значение (см. выше).

Тело функции greet(person:) начинается с объявления новой константы типа String под названием greeting, и устанавливается простое сообщение-приветствие. Затем это приветствие возвращается в точку вызова функции с помощью ключевого слова return. После выполнения оператора return greeting функция завершает свою работу и возвращает текущее значение greeting.

Функцию greet(person:) можно вызывать многократно и с разными входными значениями. В примере выше показано, что будет, если функцию вызвать с аргументом «Anna» и со значением «Brian». В каждом случае функция возвратит персональное приветствие.

Чтобы упростить код этой функции, можно записать создание сообщения и его возврат в одну строку:

func greetAgain(person: String) -> String {
    return "Hello again, " + person + "!"
}
print(greetAgain(person: "Anna"))
// Выведет "Hello again, Anna!"

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

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

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

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())
// Выведет "hello, world"

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

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

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

Эта функция принимает два параметра: имя человека и булево значение, приветствовали ли его уже, и возвращает соответствующее приветствие для этого человека:

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return greetAgain(person: person)
    } else {
        return greet(person: person)
    }
}
print(greet(person: "Tim", alreadyGreeted: true))
// Выведет "Hello again, Tim!"

Вы вызываете функцию greet(person:alreadyGreeted:), передавая значение типа String параметру с ярлыком person и булево значение с ярлыком alreadyGreeted, взятое в скобки через запятую. Обратите внимание, что эта функция отличается от функции greet(person:), которую вы видели в предыдущем разделе. Хотя имена обеих функций начинаются с greet, функция greet(person:alreadyGreeted:) принимает два аргумента, а greet(person:) принимает только один.

Функции, не возвращающие значения

В некоторых случаях функции могут не иметь возвращаемого типа. Вот другая реализация функции greet(person:), которая выводит свое собственное значение типа String, но не возвращает его:

func greet(person: String) {
    print("Hello, \(person)!")
}
greet(person: "Dave")
// Выведет "Hello, Dave!"

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

Заметка

Строго говоря, функция greet(person:) все же возвращает значение, хотя оно нигде и не указано. Функции, для которых не задан возвращаемый тип, получают специальный тип Void. По сути, это просто пустой кортеж, т. е. кортеж с нулем элементов, который записывается как ().

Выходное значение функции может быть игнорировано:

func printAndCount(string: String) -> Int {
    print(string)
    return string. count
}
func printWithoutCounting(string: String) {
    let _ = printAndCount(string: string)
}
printAndCount(string: "hello, world")
// Выведет "hello, world" и возвращает значение 12
printWithoutCounting(string: "hello, world")
// Выведет "hello, world", но не возвращает значения

Первая функция, printAndCount(string:) выводит строку, а затем возвращает подсчет символов в виде целого (Int). Вторая функция, printWithoutCounting(string:) вызывает первую, но игнорирует ее возвращаемое значение. При вызове второй функции первая функция по-прежнему печатает сообщение, но ее возвращаемое значение не используется.

Заметка

Хотя возвращаемые значения можно игнорировать, функция все же должна возвратить то, что задано в ее объявлении. Функция, для которой указан возвращаемый тип, не может заканчиваться оператором, который ничего не возвращает, иначе произойдет ошибка во время компиляции.

Функции, возвращающие несколько значений

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

В следующем примере объявлена функция minMax(array:), которая ищет минимальный и максимальный элементы в массиве типа Int:

func minMax(array: [Int]) -> (min: Int, max: Int) {
    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)
}

Функция minMax(array:) возвращает кортеж из двух значений типа Int. Этим значениям присвоены имена min и max, чтобы к ним можно было обращаться при запросе возвращаемого типа функции.

Тело функции minMax(array:) начинается с инициализации двух рабочих переменных currentMin и currentMax значением первого целого элемента в массиве. Затем функция последовательно проходит по всем остальным значениям в массиве и сравнивает их со значениями currentMin и currentMax соответственно. И наконец, самое маленькое и самое большое значения возвращаются внутри кортежа типа Int.

Так как имена элементов кортежа указаны в возвращаемом типе функции, к ним можно обращаться через точку и считывать значения:

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. Чтобы сделать возвращаемый кортеж опциональным, нужно поставить вопросительный знак после закрывающей скобки:(Int, Int)? или (String, Int, Bool)?.

Заметка

Кортеж-опционал вида (Int, Int)? это не то же самое, что кортеж, содержащий опционалы: (Int?, Int?). Кортеж-опционал сам является опционалом, но не обязан состоять из опциональных значений.

Функция minMax(array:) выше возвращает кортеж из двух значений типа Int, однако не проверяет корректность передаваемого массива. Если аргумент array содержит пустой массив, для которого count равно 0, функция minMax в том виде, в каком она приведена выше, выдаст ошибку выполнения, когда попытается обратиться к элементу array[0].

Для устранения этого недочета перепишем функцию minMax(array:) так, чтобы она возвращала кортеж-опционал, который в случае пустого массива примет значение nil:

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)
}

Чтобы проверить, возвращает ли эта версия функции minMax(array:) фактическое значение кортежа или nil, можно использовать привязку опционала:

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"

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

func someFunction(firstParameterName: Int, secondParameterName: Int) {
    // Внутри тела функции firstParameterName и secondParameterName
    // ссылаются на значения аргументов, первого и второго параметров.
}
someFunction(firstParameterName: 1, secondParameterName: 2)

Все параметры должны иметь уникальные имена. Несмотря на то, что несколько параметров могут иметь один ярлык аргумента, уникальные ярлыки аргумента метки помогают сделать ваш код более читабельным.

Указываем ярлыки аргументов

Вы пишете ярлык аргумента перед именем параметра через пробел:

func someFunction(argumentLabel parameterName: Int) {
    // В теле функции parameterName относится к значению аргумента
    // для этого параметра. 
}

Вот вариант функции greet(person:), которая принимает имя человека и его родной город, затем возвращает приветствие:

func greet(person: String, from hometown: String) -> String {
    return "Hello \(person)!  Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// Выводит "Hello Bill!  Glad you could visit from Cupertino."

Использование ярлыков аргументов позволяет функции вызываться в более выразительной манере, в виде предложения, при этом все же предоставляя тело функции в более читаемом виде и с б

Swift — Основные операторы

Оператор является специальным символом или фразы , которую вы используете , чтобы проверить, изменить или скомбинировать значение. Например, оператор сложения ( +) добавляет два числа, как в , а логический оператор И ( ) объединяет два логических значения, как в .let i = 1 + 2&&if enteredDoorCode && passedRetinaScan

Swift поддерживает большинство стандартных операторов C и улучшает некоторые возможности для устранения распространенных ошибок кодирования.  Оператор присваивания ( =) не возвращает значение, чтобы предотвратить его ошибочное использование, когда ==предполагается, что равно operator ( ). Арифметические операторы ( +-*/%и т.д.) обнаружить и запретить переполнение значения, чтобы избежать неожиданных результатов при работе с числами , которые становятся больше или меньше , чем диапазон допустимого значения типа , который хранит их. Вы можете выбрать поведение переполнения, используя операторы переполнения Swift, как описано в разделе «Операторы переполнения» .

Swift также предоставляет операторы диапазона, которых нет в C, такие как a..<bи a...b, в качестве ярлыка для выражения диапазона значений.

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

Терминология

Операторы унарные, двоичные или троичные:

  • Унарные операторы работают на одну цель (например, -a). Унарные префиксныеоператоры появляются непосредственно перед их целью (например !b), а унарные постфиксные операторы появляются сразу после их цели (например c!).
  • Бинарные операторы работают с двумя целями (такими как ) и являются инфиксными, потому что они появляются между двумя целями.2 + 3
  • Тернарные операторы работают на три цели. Как и C, Swift имеет только один троичный оператор — троичный условный оператор ( ).a ? b : c

Значения, на которые влияют операторы, являются операндами . В выражении , то символ является бинарным оператором и его два операнда являются значениями и .1 + 2+12

Оператор присваивания

Оператор присваивания ( ) инициализирует или обновляет значение со значением :a = bab


let b = 10

var a = 5

a = b

// a is now equal to 10

Если правая часть присваивания представляет собой кортеж с несколькими значениями, его элементы можно разложить на несколько констант или переменных одновременно:


let (x, y) = (1, 2)

// x is equal to 1, and y is equal to 2

В отличие от оператора присваивания в C и Objective-C, оператор присваивания в Swift сам по себе не возвращает значение. Следующее утверждение недопустимо:


if x = y {

// This is not valid, because x = y does not return a value.

}

Эта функция предотвращает =случайное использование оператора присваивания ( ), когда ==фактически предполагается равенство с оператором ( ). Делая недействительным, Swift помогает вам избежать подобных ошибок в вашем коде.if x = y

Арифметические операторы

Swift поддерживает четыре стандартных арифметических оператора для всех типов чисел:

  • Дополнение ( +)
  • Вычитание ( -)
  • Умножение ( *)
  • Отдел ( /)

1 + 2 // equals 3

5 - 3 // equals 2

2 * 3 // equals 6

10.0 / 2.5 // equals 4.0

В отличие от арифметических операторов в C и Objective-C, арифметические операторы Swift не допускают переполнения значений по умолчанию. Вы можете выбрать поведение переполнения, используя операторы переполнения Swift (например, ). Смотрите Операторы переполнения .a &+ b

Оператор сложения также поддерживается для Stringобъединения:


"hello, " + "world" // equals "hello, world"

Оставшийся оператор

Оператор remainder ( ) определяет, сколько крат будет помещаться внутри, и возвращает оставшееся значение (известное как остаток ).a % bba

ЗАМЕТКА

Оператор остатка ( %) также известен как оператор по модулю в других языках. Однако его поведение в Swift для отрицательных чисел означает, что, строго говоря, это остаток, а не операция по модулю.

Вот как работает оператор остатка. Чтобы рассчитать , вы сначала определите, сколько s поместится внутри :9 % 449

Вы можете поместить два 4s внутри 9, а остальное 1(показано оранжевым цветом).

В Swift это будет записано как:


9 % 4 // equals 1

Чтобы определить ответ для , оператор вычисляет следующее уравнение и возвращает его результат:a % b%remainder

a= ( bх ) +some multiplierremainder

где наибольшее число, кратное тому, что поместится внутри .some multiplierba

Вставка 9и 4в это уравнение дает:

9= ( 4х 2) +1

Тот же метод применяется при расчете остатка для отрицательного значения a:


-9 % 4 // equals -1

Вставка -9и 4в уравнение дает:

-9= ( 4х -2) +-1

давая остаток стоимости -1.

Знак bигнорируется для отрицательных значений b. Это значит, что и всегда дают один и тот же ответ.a % ba % -b

Унарный минус оператор

Знак числового значения можно переключать с помощью префикса -, известного как унарный оператор минус :


let three = 3

let minusThree = -three // minusThree equals -3

let plusThree = -minusThree // plusThree equals 3, or "minus minus three"

Оператор унарного минуса ( -) добавляется непосредственно перед значением, с которым он работает, без пробелов.

Унар Плюс Оператор

Унарный плюс ( +) просто возвращает значение, которое действует на, без каких — либо изменений:


let minusSix = -6

let alsoMinusSix = +minusSix // alsoMinusSix equals -6

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

Составные операторы присваивания

Как и C, Swift предоставляет составные операторы присваивания, которые комбинируют метод assign ( =) с другой операцией. Одним из примеров является оператор присваивания ( +=):


var a = 1

a += 2

// a is now equal to 3

Выражение является сокращением для . По сути, сложение и назначение объединяются в одного оператора, который выполняет обе задачи одновременно.a += 2a = a + 2

ЗАМЕТКА

Составные операторы присваивания не возвращают значение. Например, вы не можете писать .let b = a += 2

Для получения информации об операторах, предоставляемых стандартной библиотекой Swift, см. Объявления операторов .

Операторы сравнения

Swift поддерживает все стандартные операторы сравнения C :

  • Равно ( )a == b
  • Не равно ( )a != b
  • Больше чем ( )a > b
  • Меньше чем ( )a < b
  • Больше или равно ( )a >= b
  • Меньше или равно ( )a <= b

ЗАМЕТКА

Swift также предоставляет два идентификатора оператора ( ===и !==), которые вы используете, чтобы проверить, ссылаются ли обе ссылки на один и тот же экземпляр объекта. Для получения дополнительной информации см. Identity Operators .

Каждый из операторов сравнения возвращает Boolзначение, чтобы указать, верно ли утверждение:


1 == 1 // true because 1 is equal to 1

2 != 1 // true because 2 is not equal to 1

2 > 1 // true because 2 is greater than 1

1 < 2 // true because 1 is less than 2

1 >= 1 // true because 1 is greater than or equal to 1

2 <= 1 // false because 2 is not less than or equal to 1

Операторы сравнения часто используются в условных выражениях, таких как if:


let name = "world"

if name == "world" {

print("hello, world")

} else {

print("I'm sorry \(name), but I don't recognize you")

}

// Prints "hello, world", because name is indeed equal to "world".

Для получения дополнительной информации об ifоператоре см. Поток управления .

Вы можете сравнить два кортежа, если они имеют одинаковый тип и одинаковое количество значений. Кортежи сравниваются слева направо, по одному значению за раз, пока сравнение не обнаружит два значения, которые не равны. Эти два значения сравниваются, и результат этого сравнения определяет общий результат сравнения кортежей. Если все элементы равны, то сами кортежи равны. Например:


(1, "zebra") < (2, "apple") // true because 1 is less than 2; "zebra" and "apple" are not compared

(3, "apple") < (3, "bird") // true because 3 is equal to 3, and "apple" is less than "bird"

(4, "dog") == (4, "dog") // true because 4 is equal to 4, and "dog" is equal to "dog"

В приведенном выше примере вы можете увидеть поведение сравнения слева направо в первой строке. Потому 1что меньше чем 2, считается меньше чем , независимо от любых других значений в кортежах. Неважно, что это не меньше , потому что сравнение уже определяется первыми элементами кортежей. Однако, когда первые элементы кортежей являются одинаковыми, их вторые элементы имеют по сравнению, это то , что происходит на второй и третьей линии.(1, "zebra")(2, "apple")"zebra""apple"

Кортежи можно сравнивать с данным оператором, только если оператор можно применить к каждому значению в соответствующих кортежах. Например, как показано в приведенном ниже коде, вы можете сравнить два кортежа типа, так как и значения, и значения можно сравнить с помощью оператора. Напротив, два кортежа типа не могут сравниваться с оператором, потому что оператор не может быть применен к значениям.(String, Int)StringInt<(String, Bool)<<Bool


("blue", -1) < ("purple", 1) // OK, evaluates to true

("blue", false) < ("purple", true) // Error because < can't compare Boolean values

ЗАМЕТКА

Стандартная библиотека Swift включает в себя операторы сравнения кортежей для кортежей, содержащих менее семи элементов. Чтобы сравнить кортежи с семью или более элементами, вы должны самостоятельно реализовать операторы сравнения.

Тернарный условный оператор

Тройной условный оператор является специальным оператором с тремя частями, который принимает форму . Это ярлык для оценки одного из двух выражений в зависимости от того, является ли оно истинным или ложным. Если это правда, он оценивает и возвращает свое значение; в противном случае он оценивает и возвращает свое значение.question ? answer1 : answer2questionquestionanswer1answer2

Тернарный условный оператор является сокращением для кода ниже:


if question {

answer1

} else {

answer2

}

Вот пример, который вычисляет высоту строки таблицы. Высота строки должна быть на 50 пунктов выше, чем высота содержимого, если строка имеет заголовок, и на 20 пунктов выше, если строка не имеет заголовка:


let contentHeight = 40

let hasHeader = true

let rowHeight = contentHeight + (hasHeader ? 50 : 20)

// rowHeight is equal to 90

Пример выше является сокращением для кода ниже:


let contentHeight = 40

let hasHeader = true

let rowHeight: Int

if hasHeader {

rowHeight = contentHeight + 50

} else {

rowHeight = contentHeight + 20

}

// rowHeight is equal to 90

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

Тернарный условный оператор обеспечивает эффективную стенограмму для решения, какое из двух выражений следует рассмотреть. Однако используйте троичный условный оператор с осторожностью. Его краткость может привести к сложному для чтения коду при чрезмерном использовании. Избегайте объединения нескольких экземпляров тернарного условного оператора в один составной оператор.

Ноль-коалесцирующий оператор

Оператор nil- coalescing ( ) разворачивает необязательное значение, если оно содержит значение, или возвращает значение по умолчанию, если оно есть . Выражение всегда имеет необязательный тип. Выражение должно соответствовать типу, который хранится внутри .a ?? babanilaba

Оператор nil-coalescing является сокращением для кода ниже:


a != nil ? a! : b

Приведенный выше код использует троичный условный оператор и принудительный unwrapping ( a!) для доступа к значению, заключенному внутри, aкогда aего нет nil, и для возврата в bпротивном случае. Оператор nil-coalescing предоставляет более элегантный способ инкапсулировать эту условную проверку и развертывание в сжатой и читаемой форме.

ЗАМЕТКА

Если значение не aявляется nil, значение bне оценивается. Это известно как оценка короткого замыкания .

В приведенном ниже примере оператор nil-coalescing выбирает имя цвета по умолчанию и необязательное имя цвета, определяемое пользователем:


let defaultColorName = "red"

var userDefinedColorName: String? // defaults to nil



var colorNameToUse = userDefinedColorName ?? defaultColorName

// userDefinedColorName is nil, so colorNameToUse is set to the default of 

iOS с нуля с Swift: больше Swift в двух словах

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

Несколько месяцев назад я написал серию по языку программирования Swift, в которой подробно рассмотрел функции и замыкания. Эта статья суммирует то, что я написал в этих уроках. Если вам нужна дополнительная информация о функциях и замыканиях, я рекомендую прочитать статьи этой серии:

Прежде чем мы углубимся в тему функций и замыканий, пора запустить Xcode и создать новую игровую площадку. Готов? Давайте напишем некоторый код.

1. Функции

Что такое функция?

Функция — это не что иное, как блок кода, который может быть выполнен, когда это необходимо. Я хотел бы начать с примера, чтобы обсудить базовую анатомию функции в Swift. Добавьте следующее определение функции на вашу игровую площадку.

1

2

3

func printHelloWorld() {

    print(«Hello World!»)

}

Функция начинается с ключевого слова func , за которым следует имя функции printHelloWorld в приведенном выше примере. Как и во многих других языках, за именем функции следует пара круглых скобок, которые содержат параметры функции, входные данные функции.

Тело функции заключено в пару фигурных скобок. Тело функции printHelloWorld() содержит один оператор, в котором мы печатаем строку "Hello World!" в стандартном выводе. Вот как выглядит основная функция в Swift. Чтобы вызвать функцию, мы вводим ее имя и пару круглых скобок.

параметры

Давайте сделаем приведенный выше пример более сложным, добавив параметры в определение функции. Добавляя параметры, мы предоставляем функции входные значения, которые она может использовать в своем теле. В следующем примере мы определяем printMessage(_:) , которая принимает один параметр, типа message , типа String .

1

2

3

func printMessage(message: String) {

    print(message)

}

Функция может принимать несколько параметров или входных значений. Параметры заключены в круглые скобки, которые следуют за именем функции. За именем параметра следует двоеточие и его тип. Как вы помните, это очень похоже на объявление переменной или константы. Это просто говорит о том, что параметр message имеет тип String .

Вызов функции похож на то, что мы видели ранее. Разница в том, что мы передаем аргумент.

1

printMessage(«Hello World!»)

Следующий пример выглядит аналогично. Единственное отличие состоит в том, что функция определяет два параметра: message типа String и times типа Int .

1

2

3

4

5

func printMessage(message: String, times: Int) {

    for i in 0..<times {

        print(«\(i) \(message)»)

    }

}

Хотя имя функции совпадает с printMessage(_:) исходной функции printMessage(_:) , тип функции отличается. Важно, чтобы вы поняли эту разницу. Каждая функция имеет тип, состоящий из типов параметров и возвращаемого типа. Мы рассмотрим типы возврата через минуту. Функции могут иметь одинаковое имя, если их тип отличается от предыдущих двух определений функций.

Тип первой функции (String) -> () а тип второй функции (String, Int) -> () . Название обеих функций одинаково. Не беспокойтесь о символе -> . Его значение станет ясным через несколько минут, когда мы обсудим типы возвращаемых данных.

Вторая printMessage(_:times:) определяет два параметра: message типа String и times типа Int . Эта сигнатура функции иллюстрирует одну из функций, которые Swift использует в Objective-C, — читаемые имена функций и методов.

1

printMessage(«Hello World!», times: 3)

Типы возврата

Функции, которые мы видели до сих пор, ничего не возвращают нам, когда мы их вызываем. Давайте создадим функцию, которая форматирует дату. Функция принимает два аргумента: дату типа NSDate и строку формата типа String . Поскольку NSDate и NSDateFormatter определены в платформе Foundation, нам необходимо импортировать Foundation вверху игровой площадки.

1

2

3

4

5

6

7

import Foundation

 

func formatDate(date: NSDate, format: String = «YY/MM/dd») -> String {

    let dateFormatter = NSDateFormatter()

    dateFormatter.dateFormat = format

    return dateFormatter.stringFromDate(date)

}

Есть несколько вещей, которые требуют некоторого объяснения. Символ -> указывает, что функция возвращает значение. Тип значения определяется после символа -> String .

Функция принимает два аргумента, а второй аргумент имеет значение по умолчанию. На это указывает присвоение, следующее за типом второго аргумента. Значением по умолчанию для format является "YY/MM/dd" . Это означает, что мы можем вызвать функцию только с одним аргументом. Автодополнение XCode иллюстрирует это.

Если функция не имеет возвращаемого типа, символ -> опускается. Вот почему printHelloWorld() не имеет символа -> в своем определении метода.

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

Ранее в этом уроке мы определили printMessage(_:) . Несмотря на то, что мы дали параметру имя, message , мы не используем это имя при вызове функции. Вместо этого мы передаем только значение для параметра message .

1

2

3

4

5

func printMessage(message: String) {

    print(message)

}

 

printMessage(«Hello World!»)

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

Objective-C известен своими длинными именами методов. Хотя это может показаться неуклюжим и не элегантным для посторонних, это делает методы простыми для понимания и, если их правильно выбрать, очень описательными. Если вы думаете, что потеряли это преимущество при переходе на Swift, то вас ждет сюрприз.

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

01

02

03

04

05

06

07

08

09

10

11

func power(a: Int, b: Int) -> Int {

    var result = a

     

    for _ in 1..<b {

        result = result * a

    }

     

    return result

}

 

power(2, 3)

Функция power(_:b:) увеличивает значение a на показатель степени b . Оба параметра имеют тип Int . Хотя большинство людей интуитивно передают базовое значение в качестве первого аргумента и экспоненту в качестве второго аргумента, это не ясно из типа, имени или сигнатуры функции.

Чтобы избежать путаницы, мы можем присвоить параметрам функции внешние имена. Затем мы можем использовать эти внешние имена при вызове функции, чтобы однозначно указать, какой аргумент соответствует какому параметру. Посмотрите на обновленный пример ниже.

1

2

3

4

5

6

7

8

9

func power(base a: Int, exponent b: Int) -> Int {

    var result = a

     

    for _ in 1..<b {

        result = result * a

    }

     

    return result

}

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

1

power(base: 2, exponent: 3)

Хотя типы обеих функций одинаковы (Int, Int) -> Int , функции разные. Другими словами, вторая функция не является переопределением первой функции. Синтаксис для вызова второй функции может напоминать некоторым из вас о Objective-C. Мало того, что аргументы четко описаны, комбинация имен функций и параметров описывает назначение функции.

В Swift первый параметр по умолчанию не имеет имени внешнего параметра. Вот почему сигнатура функции printMessage(_:) включает в себя _ для первого параметра. Если мы хотим определить имя внешнего параметра для первого параметра, то определение метода будет выглядеть немного иначе.

1

2

3

4

5

func printMessage(message message: String) {

    print(message)

}

 

printMessage(message: «Hello World!»)

Глобальные и вложенные функции

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

1

2

3

4

5

6

7

func printMessage(message: String) {

    let a = «hello world»

     

    func printHelloWorld() {

        print(a)

    }

}

2. Закрытия

Что такое закрытие?

Если вы работали с блоками в C и Objective-C или с замыканиями в JavaScript, у вас не возникнет трудностей, когда вы будете думать о замыканиях. В этой статье мы уже работали с замыканиями, потому что функции тоже являются замыканиями. Давайте начнем с основ и рассмотрим анатомию замыкания.

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

Закрытие имени намекает на одну из ключевых характеристик замыканий. Закрытие захватывает переменные и константы контекста, в котором оно определено. Это иногда называют закрытием по этим переменным и константам.

Синтаксис

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

1

2

3

let a = {(a: Int) -> Int in

    return a + 1

}

Первое, что вы заметите, это то, что все закрытие заключено в пару фигурных скобок. Параметры замыкания заключены в пару круглых скобок, отделенных от возвращаемого типа символом -> . Вышеупомянутое замыкание принимает один аргумент a типа Int и возвращает Int . Тело замыкания начинается после ключевого слова in .

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

1

2

3

func increment(a: Int) -> Int {

    return a + 1

}

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

Замыкания как параметры

Замыкания являются мощными, и следующий пример показывает, насколько они могут быть полезны. В примере мы создаем массив состояний. Мы вызываем функцию map() для массива, чтобы создать новый массив, который содержит только первые две буквы каждого состояния в виде заглавной строки.

1

2

3

4

5

6

7

8

var states = [«California», «New York», «Texas», «Alaska»]

 

let abbreviatedStates = states.map({ (state: String) -> String in

    let index = state.startIndex.advancedBy(2)

    return state.substringToIndex(index).uppercaseString

})

 

print(abbreviatedStates)

В приведенном выше примере функция map() вызывается для массива states , преобразует его содержимое и возвращает новый массив, содержащий преобразованные значения. В примере также показана сила вывода типа Swift. Поскольку мы вызываем функцию map() для массива строк, Swift знает, что аргумент state имеет тип String . Это означает, что мы можем опустить тип, как показано в обновленном примере ниже.

1

2

3

let abbreviations = states.map({ (state) -> String in

    return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString

})

Есть еще несколько вещей, которые мы можем опустить в приведенном выше примере, что приводит к следующей однострочной.

1

let abbreviations = states.map({ state in state.substringToIndex(state.startIndex.advancedBy(2)).uppercaseString })

Позвольте мне объяснить, что происходит. Компилятор может сделать вывод, что мы возвращаем строку из замыкания, которое передаем в функцию map() , что означает, что нет причин включать тип возвращаемого значения в определение выражения замыкания. Однако мы можем сделать это только в том случае, если тело замыкания содержит единственное утверждение. В этом случае мы можем поместить это утверждение в ту же строку, что и определение замыкания, как показано в приведенном выше примере. Поскольку в определении нет возвращаемого типа и символа -> предшествующего возвращаемому типу, мы можем опустить круглые скобки, содержащие параметры замыкания.

Сокращенные имена аргументов

Это не останавливается здесь, все же. Мы можем использовать сокращенные имена аргументов, чтобы еще больше упростить приведенное выше выражение замыкания. При использовании встроенного выражения замыкания, как в приведенном выше примере, мы можем опустить список параметров, включая ключевое слово in которое отделяет параметры от тела замыкания.

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

В обновленном примере ниже я опустил список параметров и ключевое слово in и заменил аргумент state в теле замыкания сокращенным именем аргумента $0 . Результирующее утверждение является более кратким без ущерба для читаемости.

1

let abbreviations = states.map({ $0.substringToIndex($0.startIndex.advancedBy(2)).uppercaseString })

Замыкающие затворы

Язык программирования Swift также определяет концепцию, известную как замыкающие замыкания. Если вы передаете замыкание как последний аргумент функции, вы можете поместить это замыкание за скобки вызова функции. Следующий пример демонстрирует, как это работает.

1

let abbreviations = states.map() { $0.substringToIndex($0.startIndex.advancedBy(2)).uppercaseString }

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

1

let abbreviations = states.map { $0.substringToIndex($0.startIndex.advancedBy(2)).uppercaseString }

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

1

2

3

4

5

let abbreviations = states.map { (state: String) -> String in

    let toIndex = state.startIndex.advancedBy(2)

    let newState = state.substringToIndex(toIndex)

    return newState.uppercaseString

}

3. Протоколы

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

Определение протокола выглядит аналогично определению класса или структуры. В следующем примере мы определяем протокол Repairable . Протокол определяет два свойства: time и cost , а также метод repair() . Свойство time доступно только для чтения, а свойство cost — только для чтения .

1

2

3

4

5

6

protocol Repairable {

    var time: Float { get }

    var cost: Float { get set }

     

    func repair()

}

Класс или структура могут принять протокол, следуя ему. Это означает, что требуется реализовать свойства и методы, определенные протоколом. Давайте обновим класс Boat мы реализовали в предыдущем уроке .

01

02

03

04

05

06

07

08

09

10

11

12

13

14

15

16

17

class Boat: Repairable {

     

    var speed: Float = 0

    var lifeboats: Int = 2

     

    var time: Float = 10.0

    var cost: Float = 100.0

     

    func deployLifeboats() {

        // …

    }

     

    func repair() {

        // …

    }

     

}

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

1

2

3

4

5

6

7

func bringInForRepairs(toBeRepaired: Repairable) {

    // …

}

 

let myDamagedBoat = Boat()

 

bringInForRepairs(myDamagedBoat)

Дэвис Элли недавно написал отличную статью о протоколно-ориентированном программировании в Swift. Если вам интересно узнать больше о протоколах и их возможностях в Swift, тогда я призываю вас прочитать статью Дэвиса.

4. Контроль доступа

Я хотел бы завершить это введение в Swift, поговорив об управлении доступом. Как следует из названия, контроль доступа определяет, какой код имеет доступ к какому коду. Уровни контроля доступа применяются к методам, функциям, типам и т. Д. Apple просто ссылается на объекты . Существует три уровня контроля доступа: публичный, внутренний и частный.

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

Взгляните на следующий пример, в котором я обновил класс Boat . Сам класс помечен как открытый, что означает, что он доступен из любого места. Свойство cost неявно помечается как внутреннее, поскольку мы не указали уровень контроля доступа. То же самое верно для deployLifeboats() .

01

02

03

04

05

06

07

08

09

10

11

12

13

14

15

public class Boat {

     

    public var speed: Float = 0

    public var lifeboats: Int = 2

     

    var cost: UInt = 100

     

    func deployLifeboats() {

        // …

    }

     

    private func scheduleMaintenance() {

         

    }

}

Метод scheduleMaintenance() помечен как закрытый , что означает, что он может быть вызван только сущностями, определенными в исходном файле, в котором определен класс Boat . Это важно понимать, потому что это немного отличается от того, что другие языки программирования считают закрытым методом или свойством.

Если мы отметим класс Boat как внутренний, удалив ключевое слово public , компилятор покажет нам предупреждение. Это говорит нам о том, что мы не можем пометить speed и lifeboats как общедоступные, если Boat помечена как внутренняя. Компилятор прав конечно. Не имеет смысла отмечать свойства внутреннего класса как публичные.

Вывод

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

Если у вас есть какие-либо вопросы или комментарии, вы можете оставить их в комментариях ниже или обратиться ко мне в Twitter .

Функции в Swift — Start iOS

Ознакомившись с переменными, настало время научиться писать свои методы и функции в Swift. Для этого откроем наш плейграунд, в котором мы работали в предыдущем уроки, и приступим.

По-традиции, на мгновение окунёмся в теорию и посмотрим как Wikipedia описывает методы и функции:

Фу́нкция — фрагмент программного кода (подпрограмма), к которому можно обратиться из другого места программы. В большинстве случаев с функцией связывается идентификатор, но многие языки допускают и безымянные функции.

Ме́тод — это функция или процедура, принадлежащая какому-то классу или объекту.

По сути, методы и функции — это одно и тоже. Разница заключается лишь в том, к какому объекту они принадлежат и где были объявлены.

Функции

Для объявления функции используется оператор func. Шаблон создания функции выглядит следующим образом:

Объявление функции в Swift

На примере кода, функция выглядит следующим образом:

func sayHello(name: String) -> Void { print(«Hello, \(name)») }

func sayHello(name: String) -> Void {

    print(«Hello, \(name)»)

}

Здесь мы объявили функцию под именем sayHello, которая принимает в качестве аргумента (параметра) строковую переменную name и ничего не возвращает в ответ (Void). В теле функции мы использовали уже знакомую нам функцию print. Попробуем использовать то что мы написали, добавив следующий код:

Вот так всё просто — достаточно сослаться на имя функции и указать необходимые параметры.

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

Если Вам нужно получить что-либо в результате работы функции в Swift, достаточно заменить return type с Void на необходимый класс. Рассмотрим следующий пример:

// Создаём 3 переменных let a: Float = 22.5 let b: Float = 30 var c: Float = 0 // Объявляем функцию, которая принимает 2 параметра типа Float, // суммирует их и возвращает результат func sum(a: Float, b: Float) -> Float { return a + b } // Задаём переменной «с» значение суммы переменных «a» и «b» c = sum(a, b: b)

// Создаём 3 переменных

let a: Float = 22.5

let b: Float = 30

var c: Float = 0

 

// Объявляем функцию, которая принимает 2 параметра типа Float,

// суммирует их и возвращает результат

func sum(a: Float, b: Float) -> Float

{

    return a + b

}

 

// Задаём переменной «с» значение суммы переменных «a» и «b»

c = sum(a, b: b)

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

В качестве эксперимента самостоятельно напишите еще 3 функции: вычитание, деление и умножение.

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

Рассмотрим более сложный пример — создадим 2 функции. Одна будет печатать переданное ей значение в лог, а с помощью второй мы будем рассчитывать площадь круга по формуле «S = π * r2«.  При этом, мы создадим переменную внутри второй функции и будем вызывать первую функцию при необходимости:

/* Функция, которая просто печатает значение переменной */ func printValue(value: Float) { print(«Value = \(value)») } /* Функция «calculateCircleSquare» для расчета площади круга по формуле «S = π * r2″ Параметры: radius — радиус нашего круга. printResult — булева переменная, с помощью которой мы говорим функции печатать промежуточный результат или нет. Результат: площадь круга */ func calculateCircleSquare(radius: Float, printResult: Bool) -> Float { // Создаём переменную внутри фнукции // Она будет использоваться в качестве возвращаемого аргумента var square: Float = 0 // Расчитываем площадь круга. // Здесь мы используем: // 1. Gеременную «pi», которую мы объявляли в уроке «Переменные в Swift» // 2. аргумент функции «radius», а также стандартную функцию «pow(lhs: Float, _ rhs: Float)» для возведения в степень. square = Float(pi) * pow(radius, 2) // Проверяем значение булевой переменный if printResult { // Если равна true — печатаем в лог значение площади // вызвав ранее созданную функцию «printValue» printValue(square) } // Возвращаем результат return square } // Объявляем переменную с радиусом, а также — две переменные, которые принимают значение результата функции «calculateCircleSquare» let radius: Float = 22 let squareWithPrint = calculateCircleSquare(radius, printResult: true) let square = calculateCircleSquare(radius, printResult: false)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

/* Функция, которая просто печатает значение переменной */

 

func printValue(value: Float)

{

    print(«Value = \(value)»)

}

 

/*  

    Функция «calculateCircleSquare» для расчета площади круга по формуле «S = π * r2»

    Параметры:

    radius — радиус нашего круга.

    printResult — булева переменная, с помощью которой мы

    говорим функции печатать промежуточный результат или нет.

    Результат: площадь круга

*/

func calculateCircleSquare(radius: Float, printResult: Bool) -> Float

{

    // Создаём переменную внутри фнукции

    // Она будет использоваться в качестве возвращаемого аргумента

    var square: Float = 0

    

    // Расчитываем площадь круга.

    // Здесь мы используем:

    // 1. Gеременную «pi», которую мы объявляли в уроке «Переменные в Swift»

    // 2. аргумент функции «radius», а также стандартную функцию «pow(lhs: Float, _ rhs: Float)» для возведения в степень.

    square = Float(pi) * pow(radius, 2)

Xcode уроки. Урок 2. Язык Swift. Playgroung проект – 2compa.ru

Xcode уроки. Урок 2. Язык Swift. Playgroung проект

В этом уроке будут кратко описаны некоторые особенности данного языка, разберём, что такое язык Swift и каков его синтаксис.

Цель урока: Знакомство с синтаксисом языка Swift: с его основными функциями, типами данных и структурами.

Содержание статьи:

Что такое язык Swift?

Язык Swift – язык программирования для разработчиков iOS и macOS. Его разработка началась в июле 2010 года Крисом Лэттнером с возможным сотрудничеством многих других программистов в Apple, но основа была заложена еще в 1989–1995 годах на платформе NeXT.

Язык представляет собой альтернативу языка Objective-C и использует современные понятия теории языка программирования и стремится представить более простой синтаксис. С помощью данного языка процесс создания программ становится очень гибким и продуктивным, так как Swift вобрал в себя лучшие черты различных языков программирования (Objective–C, C, Java, Rust, Haskell, Ruby, Python, C#, и ещё множество языков). Swift по производительности разрабатываемых программ приближается (а в некоторых случаях уже и обгоняет) к известному языку программирования C++ . Последняя версия этого языка (на момент написания урока) – Swift 4 (https://developer.apple.com/swift). Он до сих пор активно развивается и используется разработчиками, ввиду наличия огромного потенциала.

Язык Swift разработан с нуля со следующими отличительными особенностями:

  1. Скорость. Swift предназначен в качестве замены для Си языков (C, C++ и Objective-C). Как таковой, Swift должен быть сопоставим с этими языками в производительности для большинства задач, а в чем-то превосходить их.
  2. Ясность. Язык Swift легко читается, а код легко пишется. Его синтаксис довольно простой, понятный и последовательный.
  3. Безопасность. Swift был разработан с самого начала, чтобы быть более безопасным, чем Cи языки, и устраняет целые классы небезопасного кода. Переменные всегда инициализируются перед использованием, массивы и целые числа проверяются на переполнение, а память управляется автоматически. Синтаксис настроен так, чтобы было легко определить ваши намерения, например, простые три символа ключевые слова определяют переменную (var) или константу (let).
  4. Экономичность. Swift – небольшой язык, предоставляющий некоторые базовые операции и функциональные возможности и не более того. Остальное должно быть обеспечено вашим кодом или библиотеками кода, которые можно использовать – например, Cocoa.

Эти особенности делают использование языка Swift в разработке мобильных приложений приоритетнее. Для понимания основ программирования Swift – это гораздо более простой язык для работы. Мобильный разработчик Denis Mikan утверждает: «Swift ликвидирует трудности, которые скопились за много лет в языке Objective-C. Он призван, в первую очередь, облегчить ситуацию тех разработчиков, которые не имеют желания разбираться с огромными, сложными конструкциями Objective-C. Язык Swift так же откроет новую эру для непрофессиональных разработчиков, которые сейчас кроме разработки маленьких игр на JavaScript, так же смогут выбирать и этот язык»

Синтаксис SWIFT

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

Комментарии

Хорошо написанный программный код должен быть подкреплен комментариями, чтобы человек, впервые работающий с этим кодом, мог легко разобраться в нём. В языке Swift также, как и в языке Си, одиночные комментарии начинаются с двух косых черт. Многострочный комментарий начинается с «/*», после чего пишется какая-либо заметка, а заканчивается символами «*/». Пример комментариев:

1
//Это ваш одиночный комментарий

//Это ваш одиночный комментарий

1
2
3
/*А это ваш 
многострочный 
комментарий */

/*А это ваш многострочный комментарий */

Переменные

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

Объявление любой переменной выглядит следующим образом:

1
var имя_переменой = значение_переменной

var имя_переменой = значение_переменной

После ключевого слова «var» идёт название переменной, а после оператора присваивания «=» идёт значение переменной. В языке Swift указание типа данных переменной не требуется. Swift проводит анализ заданного значения и присваивает переменной тип данных (например, числовое или строчное).

Основные типы данных: Int, Float, Double, String, bool. Чтобы изменить значение переменной достаточно обратится к переменной по её имени и, используя оператор присваивания «=» изменить значение. Повторно использовать ключевое слово «var» для уже созданной переменной не требуется.

Константа

Константа является той же переменной, но за исключением того, что изменять её значение в будущем невозможно. Объявление константы ничем не отличается от объявления любой переменной, за исключением того, что используется ключевое слово «let». Объявление константы выглядит следующим образом:

1
let имя_константы = значение_константы

let имя_константы = значение_константы

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

В ходе разработки приложений очень часто требуется отследить изменения в переменной для ускорения процесса поиска ошибок. Для этой цели может использоваться встроенная глобальная функция print(), которая выводит сообщение в консоли Xcode.

Пример использования функции print(): print(a). Консоль выведет значение некой переменной «a». Для вывода определенного сообщения в консоли достаточно его заключить в кавычках внутри функции (print(«Hello, world! «)).

Арифметические действия

С числами, которые хранятся в переменных, можно производить арифметические действия (это можно делать и в других языках программирования). В языке Swift арифметические операции можно производить с числами любого типа данных (целые или дробные). Список доступных арифметический операций в Swift отображен в таблице:

ОперацияОписание
+Бинарный оператор сложения, который складывает операнд a с операндом b и выводит результат a+b.
Бинарный оператор вычитания, который вычитает из первого операнда a, операнд b и выводит результат a-b.
*Бинарный оператор умножения, который перемножает операнд a с операндом b и выводит результат a*b.
/Бинарный оператор деления, который выполняет деление операнда a с операндом b и выводит результат a/b.
%Бинарный оператор остатка от деления, который делит первый операнд a на второй операнд b и возвращает остаток от деления a%b.
++Унарный оператор инкремента, увеличивающий значение операнда на единицу.
— —Унарный оператор декремента, уменьшающий значение операнда на единицу.

Кортежи

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

Кортеж хранится в константах или в переменных. Объявление кортежа выглядит следующим образом:

1
let имя_константы = (Значение1, Значение2, …)

let имя_константы = (Значение1, Значение2, …)

1
var имя_переменной = (Значение1, Значение2, …)

var имя_переменной = (Значение1, Значение2, …)

Например, объявим кортеж с тремя разными типами данных:

1
var cortege = (false, 256,"World")

var cortege = (false, 256,»World»)

В данном случае false – логическое значение типа Bool, 256 – целочисленное значение типа Int, «World» – строковое значение типа String. В результате данный кортеж группирует вместе значения трех различных типов данных, позволяя хранить их в пределах одной переменной.

Для доступа к элементам кортежа используется числовой индекс, указываемый через точку после названия кортежа:

1
2
3
4
var cortege = (false, 256,"World") 
print ("Значение bool: \(cortege.0)") 
print ("Значение Int: \(cortege.1)") 
print ("Значение String: \(cortege.2)")

var cortege = (false, 256,»World») print («Значение bool: \(cortege.0)») print («Значение Int: \(cortege.1)») print («Значение String: \(cortege.2)»)

В консоли отобразится:

1
2
3
Значение bool: false 
Значение Int: 256  
Значение String: World

Значение bool: false Значение Int: 256 Значение String: World

Оператор ветвления if

Как и в других языках программирования, в Swift есть оператор ветвления if. Его синтаксис:

1
2
3
4
5
6
if условие_которое_проверяется {  
//действие, выполняемое при выполнении условия 
}  
else {  
//действие, выполняемое при невыполнении условия  
}

if условие_которое_проверяется { //действие, выполняемое при выполнении условия } else { //действие, выполняемое при невыполнении условия }

Массивы

Массивы хранятся в переменных или в константах, поэтому для объявления массива в языке Swift используются ключевые слова «let» или «var»:

1
let название_изменяемого_массива = ["Значение1","Значение2", …]

let название_изменяемого_массива = [«Значение1″,»Значение2», …]

1
var название_незменяемого_массива = ["Значение1","Значение2", …]

var название_незменяемого_массива = [«Значение1″,»Значение2», …]

Доступ к элементам массива осуществляется с помощью индекса, заключенного в скобках после названия массива (massive[2]). В языке Swift массивы имеют базовые свойства и некоторые методы для добавления, очистки, проверки на пустоту массива. Существует возможность создания многомерных массивов.

Словари

Ещё одна возможность Swift – Словари. Словари – неупорядоченные коллекции элементов одного типа, обратится к которым можно через специальные ключи. Каждый элемент словаря состоит из своего уникального ключа, который устанавливает разработчик. Синтаксис словаря выглядит следующим образом:

1
var название_словаря = ["Ключ1":"Значение1", "Ключ2":"Значение2", "Ключ3":"Значение3"]

var название_словаря = [«Ключ1″:»Значение1», «Ключ2″:»Значение2», «Ключ3″:»Значение3»]

Здесь Ключ1, Ключ2, Ключ3 – это уникальные ключи, которые служат для доступа к значениям словаря. Тип данных ключа – String, но такой тип данных не обязателен для ключа. Главное правило: ключ должен быть уникальным и не должен повторяться.

Пример объявления словаря и действий с ним:

1
2
3
4
5
6
7
8
9
var Country = ["Rus":"Russia", "USA":"America", "Ger":"Germany"] 
//получение значение элемента  
print(Country["Rus"])  
//изменение значения элемента  
Country["USA"] = "The United States of America" 
//добавление нового ключа и значения в словарь   
Country["Ita"] = "Italy"  
//удаление пары ключ-значение  
Country.removeValueForKey("Ger")

var Country = [«Rus»:»Russia», «USA»:»America», «Ger»:»Germany»] //получение значение элемента print(Country[«Rus»]) //изменение значения элемента Country[«USA»] = «The United States of America» //добавление нового ключа и значения в словарь Country[«Ita»] = «Italy» //удаление пары ключ-значение Country.removeValueForKey(«Ger»)

В результате в словаре появится измененное значение элемента с ключём USA, добавление нового ключа Ita и значения, а также удаление элемента с ключем Ger.

Циклы Swift

Как и другие языки программирования, Swift работает с циклами. Цикличное выполнение кода осуществляется операторами for, for-in, while и repeat while. Механизм работы циклов разный. Описание различных типов циклов, синтаксиса и их механизма работы приведены в таблице:

Оператор повторенияМеханизм работыСинтаксис
for1. Инициализация начального значения, в котором объявляется некоторая начальная переменная. 2. Проверка условия окончания, если оно возвращает false, цикл завершает работу. Если возвращается значение true, цикл продолжает работу и выполняет блок кода. 3.После выполнения блока кода, начальное выражение меняет своё значение в зависимости от заданного действия. 4. Новая итерация и повторение действий с шага 2.for начальное_выражение; условие_окончания; действие { блок кода }
for-inЦикл выполняет блок кода для каждого элемента в последовательности. Перед каждой итерацией последующий элемент из последовательности присваивается объявленной переменной, которая доступна в блоке кода. После перебора всех элементов последовательности цикл завершает свою работу.for переменная in последовательность { блок кода }
WhileЦикл выполняется до тех пор, пока условие истинно. Когда условие возвращает false, цикл завершает свою работу.while условие { блок кода }
repeat whileТакой цикл является циклом с последующей проверкой условия. Сначала происходит выполнение блока кода, а затем проверяется условие. Если условие возвращает true, цикл повторяется, если false – цикл завершает работу.repeat { блок кода } while условие

Playgroung проект

Playgroung проект – уникальное встроенное приложение, позволяющее изучать язык Swift интерактивно. Это среда для изучения основ программирования, созданная компанией Apple. Код, написанный пользователем, мгновенно компилируется, а результат тут же отображается.

Для создания нового playground проекта в первоначальном диалоговом окне создания проектов Xcode необходимо выбрать пункт «Get Started with a playground»:

Далее необходимо выбрать пустой шаблон «Blank» и нажать кнопку «Next»:

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

На экране отобразится первоначальный проект, в котором есть одна переменная str с текстом «Hello, playground» и сразу рядом в области результатов видно содержимое переменной.

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

Вопросы для проверки себя

  1. Назовите основные базовые операторы языка Swift.
  2. Как объявляются переменные и константы?
  3. Зачем необходимо использовать комментарии в программном коде?
  4. С помощью какой встроенной функции можно выводить сообщения в консоль?
  5. В чём различие между переменными, кортежами, массивами и словарями?
  6. Назовите виды циклов в языке Swift.
  7. Что такое playground проект?

функций Swift (с примерами)

Что такое функция?

Функция — это группа операторов, которая определяет действие, которое необходимо выполнить. Основное использование функции — сделать код многоразовым.

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


Типы функций

В зависимости от того, предопределена функция или создана программистом; есть два типа функций:

  1. Библиотечные функции — Функции, которые уже определены в Swift Framework.
  2. Пользовательские функции — функции, созданные самим программистом.

Библиотечные функции

Библиотечные функции — это встроенные функции, которые уже определены в платформе Swift. Эти функции используются в Swift для решения общих проблем, поэтому вам не нужно решать их самостоятельно. Это простые операции, такие как печать, поиск минимума и максимума и т. Д.

Вы можете использовать библиотечную функцию напрямую, вызвав (вызвав) ее. Если хотите, вы можете увидеть все функции внутри фреймворка Swift.Просто напишите import Swift, нажмите Cmd и щелкните по нему. Вы перейдете на новую страницу. Искать все операторы, начинающиеся с ключевого слова func .

Пример 1: Библиотека или встроенная функция
  print («Hello, World!»)  

Когда вы запустите вышеуказанную программу, вывод будет:

  Привет, мир!  

В приведенной выше программе мы вызвали встроенную функцию print , определенную в Swift Framework. Функция используется для вывода вывода на консоль.

Мы можем вызвать функцию print () , потому что инфраструктура Swift автоматически импортируется в нашу игровую площадку. В противном случае мы должны были импортировать его сами, написав import Swift .


Пользовательские функции

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


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


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

func имя_функции (аргументы ...) -> ReturnType {
    //заявления
    возвращаемое значение
}
 

Давайте кратко опишем каждый компонент:

  • func — ключевое слово, которое вы должны написать для создания функции
  • имя_функции — это имя функции.Вы можете дать ему любое имя, определяющее, что делает функция.
  • args… определяет ввод, который принимает функция.
  • -> Этот оператор используется для указания типа возвращаемого значения функции.
  • ReturnType определяет тип значения, которое вы можете вернуть из функции. Например. Int , Строка и т. Д.
  • return Ключевое слово используется для передачи управления программой вызову функции, а также для возврата значения из функции.
    Даже если вы не укажете ключевое слово return , функция автоматически вернется после выполнения последнего оператора.
  • значение представляет фактические данные, возвращаемые функцией. Тип значения должен соответствовать ReturnType .

Как работает функция?

На приведенной выше диаграмме оператор имя_функции (аргументы) вызывает / вызывает функцию со значениями аргументов args , которая затем оставляет текущий раздел кода (т.е.е. прекращает выполнение операторов под ним) и начинает выполнять первую строку внутри функции.

  1. Программа переходит к строке кода func имя_функции (аргументы ...) и принимает значения args , переданные во время вызова функции имя_функции (аргументы) .
  2. Затем программа выполняет операторы statementInsideFunction , определенные внутри функции.
  3. Операторы внутри функции выполняются в порядке сверху вниз, один за другим.
  4. После выполнения последнего оператора программа покидает функцию и возвращается туда, откуда она была запущена, т.е. имя_функции (аргументы) .
  5. let val = сохраняет значение, возвращаемое функцией, в константе val . Точно так же вы можете сохранить в переменной как var val = .
  6. После этого выполняются операторы statementOutsideFunction .

Пример 2: Как определить функцию в Swift?

  func greet (user: String) {
    print ("Доброе утро! \ (пользователь)")
}
  

Выше показано определение функции, которое состоит из следующих компонентов:

  1. Ключевое слово func отмечает начало заголовка функции.
  2. greet — это имя функции для однозначной идентификации и вызова функции в программе.
  3. (пользователь: String) отмечает конец заголовка функции и принимает параметр типа String . См. Статью Типы параметров функций Swift и возвращаемые типы, в которой определяется функция с параметрами.
  4. Функция состоит из оператора print внутри тела, который выполняется после вызова функции.

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

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

greet (пользователь: "Isac") 

Пример 3: Вызов функции в Swift

  func greet (user: String) {
    print ("Доброе утро! \ (пользователь)")
}

привет (пользователь: "Isac")
  

Когда вы запустите вышеуказанную программу, вывод будет:

  Доброе утро! Исак  

В приведенном выше коде greet (пользователь: "Isac") вызывает функцию и передает значение Isac типа String .После этого выполняется print внутри функции.


Заявление о возврате

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

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

Пример 3: Функция с ключевым словом return

  func greet (user: String) -> String {
    return "Доброе утро! \ (пользователь)"
}

let welcome = greet (пользователь: "Isac")
Распечатать("""
     У вас новое сообщение
     \(приветствие)
     "" ")
  

Когда вы запустите вышеуказанную программу, вывод будет:

  У вас есть новое сообщение
Доброе утро! Исак
  

В приведенном выше коде greet (пользователь: "Isac") вызывает функцию и передает значение Isac типа String . return «Доброе утро! \ (Пользователь)» Оператор возвращает значение типа String и передает программу вызову функции.

let welcome = сохраняет значение, возвращаемое функцией. После возврата из функции выполняется инструкция print под вызовом функции.


Что нужно помнить

  • Присвойте функции имя, которое отражает цель функции.
  • Функция должна выполнять только одну задачу.Если функция выполняет несколько задач, разбейте ее на несколько функций.
  • Попробуйте подумать заранее и сгруппировать операторы внутри функции, которая делает код многоразовым и модульным.

Вложенные функции в Swift (с примерами)

Если функция существует внутри тела другой функции, она называется вложенной функцией.

Синтаксис вложенной функции

func funcname () {
    // операторы внешней функции
    func anotherFuncname () {
        // операторы внутренней функции
    }
}
 

Здесь функция anotherFuncname находится внутри тела другой функции funcname .

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


Пример 1: Вложенная функция без возвращаемых значений

  func outputMessageByGreeting (_ message: String) {
    
    func addGreetingAndPrint () {
        print ("Привет! \ (сообщение)")
    }
    addGreetingAndPrint ()
}
outputMessageByGreeting ("Джек")
  

Когда вы запустите программу, вывод будет:

  Здравствуйте! Джек  

В приведенной выше программе вложенная функция addGreetingAndPrint () вызывается из включающей функции outputMessageByGreeting () .

Оператор outputMessageByGreeting ("Jack") вызывает внешнюю функцию. И оператор addGreetingAndPrint () внутри внешней функции вызывает метод, который выводит Hello! Джек в консоли.

Вы не можете вызвать функцию addGreetingAndPrint вне функции outputMessageByGreeting .


Пример 2: Вложенная функция с параметрами и возвращаемыми значениями

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

  func работает (с символом: String) -> (Int, Int) -> Int {
    
    func add (num1: Int, num2: Int) -> Int {
        вернуть num1 + num2
    }
    
    func subtract (num1: Int, num2: Int) -> Int {
        вернуть num1 - num2
    }
    пусть операция = (символ == "+")? добавить: вычесть
    возвратная операция
}

пусть операция = работа (с: "+")
пусть результат = операция (2, 3)
печать (результат)
  

Когда вы запустите программу, вывод будет:

  5  

В вышеуказанной программе

  • внешняя функция — operation () с возвращаемым значением типа Function (Int, Int) -> Int .
  • , а внутренние (вложенные) функции — add () и subtract () .

Вложенные функции add (), и subtract () в некотором смысле используются вне функции-контейнера Operating () . Это возможно, потому что внешняя функция возвращает одну из этих функций.

Мы использовали внутреннюю функцию вне охватывающей функции Operating () как operation (2, 3) . Программа внутренне вызывает add (2, 3) , который выводит 5 в консоли.

функций Swift — Tutlane

В swift функции — это блок операторов для выполнения указанных задач и возврата значений на основе определенных нами условий.

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

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

Синтаксис функций Swift

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

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

Ниже приводится синтаксис определения или объявления функций на быстром языке программирования.

func functionName (параметры) -> Тип возврата {

// Заявления

возвращаемые параметры

}

Если вы заметили выше синтаксис быстрых функций, мы определили несколько параметров, это

func — это ключевое слово, которое используется для определения функции на быстром языке программирования.

functionName — Имя функции, которую мы собираемся создать в приложении.

параметры — это входные параметры для передачи данных в функции и их необязательные.

-> — Дефис, за которым следует правая угловая скобка, указывает тип возврата функции в swift.

Тип возврата — указывает тип возвращаемого значения функции.

Теперь мы посмотрим, как использовать функции в быстром языке программирования с примерами.

Пример функции Swift

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

func helloworld (x: String, y: String) -> String {

возврат x + «» + y

}

print (helloworld («Добро пожаловать», «В Тутлейн»))

Если вы заметили вышеуказанную функцию, это простая функция на быстром языке программирования с возвращаемым типом.

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

Добро пожаловать в Тутлейн

Теперь мы увидим, как передавать параметры и возвращаемые типы функции на быстром языке программирования с примерами.

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

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

Теперь мы увидим, как использовать параметры и возвращаемые типы в быстром языке программирования на основе наших требований с примерами.

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

Обычно в быстрых функциях определять входные параметры не обязательно.Ниже приведен пример определения функции без каких-либо параметров на быстром языке программирования.

func helloworld () {

print («Добро пожаловать в Тутлейн»)

}

helloworld ()

Если вы посмотрите на приведенный выше пример, мы определили функцию без каких-либо входных параметров и типов возврата на быстром языке программирования.

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

Добро пожаловать в Тутлейн

Теперь мы увидим, как использовать функции с несколькими параметрами в быстром языке программирования.

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

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

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

сложение функций (a: Int) {

print («\ (a) + 50 = \ (a + 50)»)

}

сложение (120)

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

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

120 + 50 = 170

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

func Умножение (x: Int, y: Int) {

print («\ (x) * \ (y) = \ (x * y)»)

}

Умножение (100, 50)

Если вы посмотрите на пример выше, мы определили несколько параметров (x, y) в функции.

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

100 * 50 = 5000

Теперь посмотрим, как использовать возвращаемые типы в быстрых функциях в соответствии с нашими требованиями.

Быстрая функция без возвращаемых значений

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

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

func helloworld (x: строка, y: строка) {

отпечаток (x + «» + y)

}

helloworld («Добро пожаловать», «В Тутлейн»)

Если вы посмотрите на пример выше, мы определили функцию без каких-либо возвращаемых типов.

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

Добро пожаловать в Тутлейн

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

Быстрая функция с несколькими возвращаемыми значениями

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

Ниже приводится синтаксис объявления функции с несколькими возвращаемыми значениями в swift.

func funcName () -> (Тип данных, Тип данных) {

возврат (имя_аргумента1, имя_аргумента2)

}

В приведенном выше синтаксисе мы определили несколько типов возврата в функции и возвращаем эти значения в соответствии с нашими требованиями.

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

func getFullName () -> (Строка, Строка) {

var FirstName = «Добро пожаловать в»

var LastName = «Тутлейн»

возврат (Имя, Фамилия)

}

var vals = getFullName ()

печать (vals.0 + «» + vals.1)

Если вы видите пример выше, мы возвращаем несколько значений из функции « getFullName » и сохраняем эти значения в одной переменной с именем « vals » и получаем доступ к этим значениям с помощью переменной « vals »

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

Добро пожаловать в Тутлейн

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

Функция Swift со значениями параметров по умолчанию

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

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

Ниже приводится синтаксис объявления функции со значениями параметров по умолчанию в swift.

func funcName (param1: Datatype, param2: Datatype = defaultValue) -> Datatype {

возврат param1 + param2

}

Если вы заметили синтаксис выше, мы присвоили значение по умолчанию параметру « param2 » после типа параметра.

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

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

сложение функций (num1: Int, num2: Int = 45) -> Int {

return num1 + num2

}

print («23 + 45 = \ (сложение (23))»)

Если вы видите пример выше, мы присвоили значение по умолчанию « 45 » параметру « num2 » и получили доступ к этим значениям, вызвав функцию « сложение » с одним параметром.

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

23 + 45 = 68

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

Обработка параметров функций Swift

В Swift, когда мы определяем параметр в функции, компилятор будет рассматривать параметры как константы и не позволит нам вносить какие-либо изменения в значения параметров.В случае, если мы попытаемся выполнить операцию увеличения или уменьшения значений параметров функции, мы получим ошибку.

Ниже приведен пример изменения значения параметра функции в быстром языке программирования.

приращение функции (значение: Int) {

значение ++

печать (val)

}

отпечаток (инкремент (10, 90))

Если вы наблюдаете за примером выше, мы пытаемся увеличить функциональный параметр « val ».

Когда мы запустим указанную выше программу, мы получим ошибку, как показано ниже

Ошибка

: унарный оператор ++ не может применяться к операнду типа Int

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

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

приращение функции (var val: Int) {

значение ++

печать (val)

}

шаг (2)

Если вы посмотрите на пример выше, мы определили функциональный параметр « val » с ключевым словом « var » для изменения значения параметра в быстрых функциях.

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

3

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

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

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

Мы можем использовать вариативные параметры, вставив три символа точек (…) после имени типа параметра.

Ниже приведен пример использования вариативных параметров в объявлении функции на языке программирования Swift.

функция сложение числа (_ числа: Int …) -> Int {

var sum: Int = 0

для числа в цифрах {

сумма + = число

}

сумма возврата

}

отпечаток (сложение номера (21, 23, 23, 34, 45,55,66))

Если вы посмотрите на пример выше, мы определили вариативный параметр « чисел » с тремя точками и символами (…) для отправки нескольких значений в качестве входных данных.

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

267

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

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

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

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

Ниже приведен пример отправки значений функции с именами меток аргументов на языке программирования Swift.

сложение функций (param1 num1: Int, param2 num2: Int = 45) -> Int {

var sum = num1 + num2

сумма возврата

}

print («23 + 45 = \ (сложение (param1: 23, param2: 45))»)

Если вы наблюдаете приведенный выше пример, мы определили меток аргументов (param1, param2) непосредственно перед именами параметров в определении функции, и мы используем меток аргументов имен для отправки значений в функцию.

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

23 + 45 = 68

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

Функции Swift пропускают метки аргументов

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

Ниже приведен пример отправки значений функции с именами меток аргументов на языке программирования Swift.

сложение функций (_ num1: Int, num2: Int = 45) -> Int {

var sum = num1 + num2

сумма возврата

}

print («23 + 45 = \ (сложение (23, num2: 45))»)

Если вы наблюдаете приведенный выше пример, мы определили подчеркивание непосредственно перед параметром num1 name, чтобы игнорировать метку аргумента для этого параметра в определении функции, и мы отправляем значения в функцию без метки аргумента name.

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

23 + 45 = 68

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

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

Swift Назначить функцию переменной

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

Ниже приводится синтаксис присвоения функции переменной в быстром языке программирования.

func funcName (param1: Datatype, param2: Datatype) -> Datatype {

возврат param1, param2

}

var имя переменной: (Datatype, Datatype) -> Datatype = funcName

имя переменной (значение1, значение2)

Если вы заметили вышеупомянутый синтаксис, мы определили функцию « funcName » и назначили функцию « funcName » переменной имя_переменной, определив параметры и типы данных так же, как function.

Ниже приведен пример присвоения функции переменной в быстром языке программирования.

func add (a: Int, b: Int) -> Int {

возврат a + b

}

var сложение: (Int, Int) -> Int = добавить

print («10 + 90 = \ (сложение (10, 90))»)

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

10 + 90 = 100

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

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

В быстром темпе — функции, которые находятся внутри тела других функций, известных как вложенные функции.

В swift по умолчанию вложенные функции скрыты от внешнего мира, но мы можем использовать эти вложенные функции с помощью их включающих функций.

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

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

func addoperation (str: String) -> (Int, Int) -> Int {

)

func sum (a: Int, b: Int) -> Int

{

возврат a + b;

}

, если str == «+»

{

возвратная сумма;

}

сумма возврата

}

let nestedVal = addoperation («+»)

печать (nestedVal (10,30))

Если вы посмотрите на пример выше, мы определили функцию « sum » внутри другой функции « addoperation » и выполнили операцию суммирования путем передачи значений в основную функцию addoperation () .

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

40

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

Swift — разработчик Apple

Модерн

Swift — это результат последних исследований языков программирования в сочетании с многолетним опытом создания платформ Apple. Именованные параметры выражаются в чистом синтаксисе, что делает API в Swift еще проще для чтения и поддержки.Более того, вам даже не нужно вводить точку с запятой. Предполагаемые типы делают код более чистым и менее подверженным ошибкам, а модули устраняют заголовки и предоставляют пространства имен. Для наилучшей поддержки международных языков и эмодзи строки корректны для Юникода и используют кодировку на основе UTF-8 для оптимизации производительности в самых разных случаях использования. Память управляется автоматически с использованием точного детерминированного подсчета ссылок, что сводит использование памяти к минимуму без накладных расходов на сборку мусора.

  struct Player {
    имя переменной: Строка
    var highScore: Int = 0
    var history: [Int] = []

    init (_ имя: String) {
        я.name = имя
    }
}

var player = Player ("Томас")  

Объявите новые типы с помощью современного простого синтаксиса. Задайте значения по умолчанию для свойств экземпляра и определите настраиваемые инициализаторы.

  extension Player {
    мутирующая функция updateScore (_ newScore: Int) {
        history.append (newScore)
        если highScore  

Добавьте функциональность к существующим типам с помощью расширений и сократите количество шаблонов с помощью пользовательских интерполяций строк.

  extension Player: Codable, Equatable {}

импортный фундамент
пусть кодировщик = JSONEncoder ()
попробуйте encoder.encode (player)

печать (игрок)
  

Быстро расширяйте свои пользовательские типы, чтобы воспользоваться преимуществами мощных языковых функций, таких как автоматическое кодирование и декодирование JSON.

  let Players = getPlayers ()


let ranked = Players.sorted (по: {player1, player2 в
    player1.highScore> player2.highScore
})


let rankedNames = ranked.map {$ 0.name}
  

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

Эти дальновидные концепции привели к созданию веселого и простого в использовании языка.

Swift имеет много других функций, которые делают ваш код более выразительным:

  • Мощные и простые в использовании универсальные шаблоны
  • Расширения протокола, упрощающие написание универсального кода
  • Функции первого класса и упрощенный синтаксис закрытия
  • Быстрая и лаконичная итерация по диапазону или коллекции
  • Кортежи и несколько возвращаемых значений
  • Структуры, поддерживающие методы, расширения и протоколы
  • Перечисления могут иметь полезные данные и поддерживать сопоставление с образцом
  • Шаблоны функционального программирования, e.г., карта и фильтр
  • Собственная обработка ошибок с помощью try / catch / throw

Безопасность

Swift устраняет целые классы небезопасного кода. Переменные всегда инициализируются перед использованием, массивы и целые числа проверяются на переполнение, память управляется автоматически, а принудительный монопольный доступ к памяти защищает от многих ошибок программирования. Синтаксис настроен так, чтобы упростить определение вашего намерения - например, простые трехсимвольные ключевые слова определяют переменную (var) или константу (let).И Swift сильно использует типы значений, особенно для часто используемых типов, таких как массивы и словари. Это означает, что когда вы делаете копию чего-либо с этим типом, вы знаете, что это не будет изменено где-либо еще.

Еще одна функция безопасности заключается в том, что по умолчанию объекты Swift никогда не могут быть нулевыми. Фактически, компилятор Swift не даст вам попытаться создать или использовать объект nil с ошибкой времени компиляции. Это делает написание кода намного чище и безопаснее, а также предотвращает огромную категорию сбоев времени выполнения в ваших приложениях.Однако бывают случаи, когда значение nil является допустимым и подходящим. Для таких ситуаций в Swift есть инновационная функция, известная как optionals. Необязательный параметр может содержать nil, но синтаксис Swift заставляет вас безопасно работать с ним, используя? синтаксис, чтобы указать компилятору, что вы понимаете поведение и будете обрабатывать его безопасно.

  extension Collection, где Element == Player {
    
    func highScoringPlayer () -> Игрок? {
        return self.max (by: {$ 0.highScore <$ 1.highScore})
    }
}  

Используйте опции, когда у вас может быть экземпляр для возврата из функции, а может и нет.

  if let bestPlayer = Players.highestScoringPlayer () {
    recordHolder = "" "
        Рекордсмен - \ (bestPlayer.name), \
        с высоким баллом \ (bestPlayer.highScore)!
        "" "
} else {
    recordHolder = "В игры еще не играли.")
}
печать (recordHolder)


let highScore = player.highestScoringPlayer () ?. highScore ?? 0
  

Такие функции, как дополнительное связывание, дополнительное связывание и объединение с нулевым значением, позволяют безопасно и эффективно работать с необязательными значениями.

Быстрый и мощный

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

Swift является преемником языков C и Objective-C.Он включает низкоуровневые примитивы, такие как типы, управление потоком и операторы. Он также предоставляет объектно-ориентированные функции, такие как классы, протоколы и универсальные шаблоны, предоставляя разработчикам Cocoa и Cocoa Touch требуемую производительность и мощность.

Великий первый язык

Swift может открыть двери в мир программирования. Фактически, он был разработан, чтобы стать первым языком программирования, независимо от того, учитесь ли вы в школе или исследуете новые пути карьеры. Для преподавателей Apple создала бесплатную программу обучения Swift как в классе, так и вне его.Начинающие программисты могут загрузить Swift Playgrounds - приложение для iPad, которое делает начало работы с кодом Swift интерактивным и увлекательным.

Начинающие разработчики приложений могут получить доступ к бесплатным курсам, чтобы научиться создавать свои первые приложения в Xcode. А магазины Apple по всему миру проводят сеансы Today at Apple Coding & Apps, на которых вы можете получить практический опыт работы с кодом Swift.

Узнайте больше об образовательных ресурсах Swift от Apple

Исходная и двоичная совместимость

В Swift 5 вам не нужно изменять какой-либо код Swift 4 для использования новой версии компилятора.Вместо этого вы можете начать использовать новый компилятор и выполнять миграцию в своем собственном темпе, используя преимущества новых функций Swift 5, по одному модулю за раз. А Swift 5 теперь представляет двоичную совместимость для приложений. Это означает, что вам больше не нужно включать библиотеки Swift в приложения, предназначенные для текущих и будущих выпусков ОС, потому что библиотеки Swift будут включены в каждый выпуск ОС в будущем. Ваши приложения будут использовать последнюю версию библиотеки в ОС, и ваш код будет продолжать работать без перекомпиляции.Это не только упрощает разработку вашего приложения, но также уменьшает размер вашего приложения и время его запуска.

Открытый исходный код

Swift разрабатывается открыто на Swift.org, с исходным кодом, системой отслеживания ошибок, форумами и регулярными сборками для разработки, доступными для всех. Это широкое сообщество разработчиков, как внутри Apple, так и сотни сторонних разработчиков, работают вместе, чтобы сделать Swift еще более удивительным. Существует еще более широкий спектр блогов, подкастов, конференций и встреч, где разработчики из сообщества делятся своим опытом о том, как реализовать огромный потенциал Swift.

Кросс-платформенный

Swift уже поддерживает все платформы Apple и Linux, и члены сообщества активно работают над переносом на еще большее количество платформ. Сообщество SourceKit-LSP также работает над интеграцией поддержки Swift в широкий спектр инструментов разработчика. Мы рады видеть больше способов, с помощью которых Swift делает программное обеспечение более безопасным и быстрым, а также делает программирование более увлекательным.

Swift для сервера

Хотя Swift поддерживает многие новые приложения на платформах Apple, он также используется для нового класса современных серверных приложений.Swift идеально подходит для использования в серверных приложениях, которым требуется безопасность во время выполнения, производительность компиляции и небольшой объем памяти. Чтобы направить Swift в сторону разработки и развертывания серверных приложений, сообщество сформировало рабочую группу Swift Server. Первым продуктом этой работы стал SwiftNIO, кроссплатформенная платформа асинхронных событийно-управляемых сетевых приложений для высокопроизводительных протокольных серверов и клиентов. Он служит основой для создания дополнительных ориентированных на сервер инструментов и технологий, включая ведение журналов, метрики и драйверы баз данных, которые все находятся в активной разработке.

Чтобы узнать больше о сообществе Swift с открытым исходным кодом и рабочей группе Swift Server, посетите Swift.org

Детские площадки и цикл чтения-оценки-печати (REPL)

Как и Swift Playgrounds для iPad, игровые площадки в Xcode делают написание кода Swift невероятно простым и увлекательным. Введите строку кода, и результат появится немедленно. Затем вы можете быстро просмотреть результат со стороны вашего кода или закрепить результат прямо ниже. В представлении результатов могут отображаться графики, списки результатов или графики значений с течением времени.Вы можете открыть Помощник по временной шкале, чтобы наблюдать за развитием и анимацией сложного представления, что отлично подходит для экспериментов с новым кодом пользовательского интерфейса или для воспроизведения анимированной сцены SpriteKit по мере ее написания. Когда вы усовершенствовали свой код на игровой площадке, просто переместите этот код в свой проект. Swift также интерактивен, когда вы используете его в терминале или в консоли отладки LLDB Xcode. Используйте синтаксис Swift для оценки и взаимодействия с вашим запущенным приложением или напишите новый код, чтобы увидеть, как оно работает в среде, подобной сценарию.

Менеджер пакетов

Swift Package Manager - это единый кроссплатформенный инструмент для создания, запуска, тестирования и упаковки ваших библиотек и исполняемых файлов Swift.Пакеты Swift - лучший способ распространять библиотеки и исходный код среди сообщества Swift. Конфигурация пакетов написана на самом Swift, что упрощает настройку целей, объявление продуктов и управление зависимостями пакетов. Впервые в Swift 5 команда быстрого запуска теперь включает возможность импорта библиотек в REPL без необходимости создания исполняемого файла. Сам Swift Package Manager построен на Swift и включен в проект с открытым исходным кодом Swift как пакет.

Взаимодействие с Objective-C

Вы можете создать совершенно новое приложение с помощью Swift сегодня или начать использовать код Swift для реализации новых функций и возможностей в своем приложении.Код Swift сосуществует вместе с вашими существующими файлами Objective-C в одном проекте с полным доступом к API Objective-C, что упрощает внедрение.

Swift Function - JournalDev

В этом руководстве по быстрым функциям мы рассмотрим, как функции определяются и используются в Swift. Мы рассмотрим все концепции, которые дадут вам более глубокое понимание, и, надеюсь, к концу этого руководства вы усвоите концепцию функции в быстром программировании.

Swift Function

Согласно документации Apple, «Функции Swift - это автономные фрагменты кода, которые выполняют определенную задачу.Вы даете функции имя, которое идентифицирует то, что она делает, и это имя используется для «вызова» функции для выполнения ее задачи при необходимости ».

В этом руководстве мы рассмотрим следующие концепции.

  1. Именованные и неназванные параметры
  2. Значение параметра по умолчанию
  3. Несколько типов возврата
  4. Входные параметры
  5. Вариативные параметры
  6. Вложенные функции
  7. Функции как типы, параметры и тип возвращаемого значения

Давайте откроем нашу игровую площадку в XCode и нырни прямо внутрь!

Определение и вызов функции Swift

Чтобы определить функцию Swift, нам нужно начать с ключевого слова func , за которым следует имя функции, как показано ниже.

 
func helloFunction ()
{
 print ("Привет, функции Swift)
}
  

Функции Swift с параметрами и типами возвращаемых значений

Давайте определим функцию Swift с параметрами и посмотрим, как она выглядит.

 
func display (websiteName w: String, withTutorial t: String)
{
   печать (w + "" + t)
}
  

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

Параметры внутри вышеупомянутой функции состоят из двух частей.Внешний параметр , за которым следует внутренний параметр . Такой тип параметров, состоящий из двух меток, известен как с именем параметров.

  1. Тип параметра следует после двоеточия : .
  2. websiteName и withTutorial являются внешними параметрами и должны использоваться только при вызове функции. Внешние параметры также известны как метки аргументов.
  3. w и t - это внутренние параметры, которые будут использоваться внутри тела функции.Внутренние параметры также известны как локальные параметры.

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

 
display (websiteName: "JournalDev", withTutorial: "Функции в Swift")
  

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

Другой способ определения функции приведен ниже.

 
func appendStrings (a: строка, b: строка)
{
    печать (a + "" + b)
}

appendStrings (a: «Привет», b: «Swift»)
  

В приведенном выше коде мы не указали явно внешние и внутренние параметры. Swift рассматривает их как оба в приведенном выше случае.

Чтобы явно опустить внешний параметр (метку аргумента), нам нужно добавить подчеркивание _ .

Следующий фрагмент кода демонстрирует пример, в котором первый параметр не имеет имени.

 
func appendString (_ a: String, с b: String)
{
  печать (a + "" + b)
}

appendString ("Привет", с: "Swift")
  

Примечание : Мы не можем изменить значение параметра внутри функции (по крайней мере, не с помощью вышеупомянутого подхода).

Затем давайте создадим функцию с возвращаемым типом.

 
func sumOfTwo (_ a: Int, _ b: Int) -> Int
{
  вернуть a + b
}
печать (sumOfTwo (2,3))
  

Чтобы установить тип возвращаемого значения, мы добавили оператор -> , за которым следует тип возвращаемых данных.

Значение по умолчанию для любого параметра функции может быть присвоено после типа параметра. Если определено значение по умолчанию, мы можем опустить этот параметр при вызове функции.

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

 
func sum (_ a: Int, _ b: Int = 2) -> Int
{
   вернуть a + b
}
print (sum (5)) // выводит 7
print (sum (5, 3)) // выводит 8

  

Входящие параметры функции Swift

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

 
var i = 3
print (i) // выводит 3
приращение функции (_ i: inout Int, по x: Int) -> Int
{
    я = я + х
    вернуть я
}
приращение (& i, на: 3)
print (i) // выводит 6
  

Константы не могут быть переданы как быстрые функции inout параметров.

Примечание : параметры inout аналогичны передаче по ссылке в C.

Вариативные параметры функции Swift

Вариативный параметр функции Swift принимает ноль или более значений указанного типа.Для каждой функции разрешен только один вариативный параметр. Вариативный параметр обозначается ... после типа параметра, как показано ниже.

 
func makeSentence (слова: String ...) -> String
{
    var предложение = ""
    за слово в словах
    {
     предложение = предложение + "" + слово
    }
    вернуть приговор
}

makeSentence (слова: «Функция», «наличие», «Параметры с переменным числом параметров», «Добавьте сюда столько строк, сколько захотите», «Можно использовать один параметр с переменным числом на одну функцию», «Использовать в полной мере»)
  

Функция Swift, возвращающая несколько значений

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

 
func returnSentenceAndWordCount (_ strings: String ...) -> (предложение: String, wordCount: Int)
{
    var предложение = ""
    для s в строках
    {
        предложение = предложение + "" + s
    }
    возврат (предложение, strings.count)
}

let data = returnSentenceAndWordCount («Функция», «возвращает кортеж», «содержащий», «предложение и количество строк и количество слов»)
                                      
print (data.sentence + "\ n \ (data.wordCount)")
  

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

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

Swift позволяет нам определять функцию внутри функции, как показано ниже.

 
func sayHello (на имя: String) {
    let s = "Привет" + имя
    func printString () {
        печать (и)
    }
}
sayHello (to: "Anupam") // выводит Hello Anupam
  

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

Функции Swift как типы, параметры и типы возвращаемых данных

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

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

Начнем с создания двух основных функций, как показано ниже.

 
// Функция для вычисления квадрата целого числа.
func square (_ num: Int) -> Int
{
     вернуть число * число
}
square (4) // возвращает 16

// Функция для вычисления куба целого числа.
func cube (_ num: Int) -> Int
{
    вернуть число * число * число
}
cube (4) // возвращает 64
  

Мы можем назначить функцию переменной / константе, как показано ниже.

 
var exponentialFunction = квадрат
  

exponentialFunction определяется как переменная типа функции, которая принимает параметр Int и возвращает параметр Int.

Теперь мы можем вызвать переменную exponentialFunction , как показано в приведенном ниже фрагменте кода.

 
exponentialFunction (4) // Это будет работать так же, как square (4)

square (exponentialFunction (5)) // Это вернет 625

exponentialFunction (exponentialFunction (5)) // То же, что и выше
  

Мы можем изменить тип exponentialFunction на функцию cube , как показано ниже.

 
экспоненциальная функция = куб (_ :)
square (exponentialFunction (5)) // квадрат куба 5 возвращает 15625
  

Давайте создадим функцию, которая принимает указанные выше функции square и cube в качестве параметров.

 
целые числа var = [1,2,3,4,5]

func sumOfExponentialsOf (массив a: [Int], с функцией: (Int) -> Int) -> Int
{
    var result = 0
    для x в
    {
        результат = результат + функция (x)
    }
    вернуть результат
}
  

Вышеупомянутая функция вычисляет сумму возвращаемых функцией значений для всех элементов массива.

Подсказка : Swift достаточно умен, чтобы вывести тип переменной / константы из значения.

Примечание : Второй параметр принимает тип (Int) -> Int , который является тем же типом, что и для exponentialFunction .

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

 
экспоненциальная функция = квадрат (_ :)
// сумма квадратов всех элементов массива
sumOfExponentialsOf (массив: целые числа, with: exponentialFunction) // возвращает 55
экспоненциальная функция = куб (_ :)
// сумма кубов всех элементов массива
sumOfExponentialsOf (массив: целые числа, with: exponentialFunction) // возвращает 225
  

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

 
func chooseComputation (isSquared b: Bool) -> (Int) -> Int {

    func square (_ num: Int) -> Int
    {
        вернуть число * число
    }
    
    func cube (_ num: Int) -> Int
    {
        вернуть число * число * число
    }
    
    if b {
        площадь возврата
    }
    else {
        возвратный куб
    }

}

var result = chooseComputation (isSquared: true)
result (2) // возвращает 4

результат = selectComputation (isSquared: false)
result (2) // возвращает 8

  

Функция chooseComputation состоит из двух функций с тем же типом, что и return.

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

Попробуйте описанные выше сценарии на игровой площадке. Ниже скриншот с моей детской площадки.

На этом мы завершаем данное руководство. Мы рассмотрели все основные случаи использования функций в Swift.

Функции первого класса в Swift

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

Хотя Swift вряд ли является первым языком, поддерживающим такой способ обработки функций, обычно это функция, которую вы видите в более динамичных языках, таких как JavaScript или Lua. Таким образом, сочетание надежной системы статических типов Swift с функциями первого класса становится довольно интересной комбинацией и может позволить нам делать некоторые довольно творческие вещи 😀.

На этой неделе давайте рассмотрим несколько различных способов использования функций первого класса в Swift!

Это объявление делает Swift от Sundell бесплатным для всех. Если можете, проверьте этого спонсора, так как он напрямую помогает поддерживать этот сайт:

Архитектура приложений SwiftUI с помощью MVC и MVVM: Хотя вы, , можете создать приложение , просто собрав вместе некоторый код, без передовых практик и надежная архитектура, вы скоро получите неуправляемый спагетти-код.Узнайте, как создавать надежные и удобные в обслуживании приложения с меньшим количеством ошибок, используя это бесплатное руководство.

Начнем с основ. Поскольку функции могут использоваться как значения, это означает, что мы можем передавать их как аргументы. Например, предположим, что мы хотим добавить в представление массив подпредставлений. Обычно мы можем сделать что-то вроде этого:

  let subviews = [button, label, imageView]

subviews.forEach {subview in
    view.addSubview (подвид)
}  

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

Что мы можем сделать, так это обработать метод addSubview как закрытие типа (UIView) -> Void (поскольку он принимает представление для добавления и ничего не возвращает). Это полностью соответствует типу аргумента, который принимает forEach (закрытие типа (Element) -> Void , и в этом случае тип Element - это UIView ). В результате мы можем передать просмотров.addSubview непосредственно в качестве аргумента к нашему вызову forEach , например:

  subviews.forEach (view.addSubview)  

Это довольно круто! 😎 Однако следует иметь в виду, что при использовании методов экземпляра в качестве замыканий, подобных этому, вы автоматически сохраняете экземпляр до тех пор, пока сохраняете замыкание.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa