Swift

### Аннотации типов

``swift
var greeting: String = "Hello"
var NumberOfToys: Int = 8
var isMorning: Bool = true
var price: Double = 8.99

----

- `+=` Складывает и присваивает суммы
- `-=` Вычитание и присваивание разности
- `*=` Умножение и присваивание
- `/=` Деление и присваивание делителя
- `%=` Деление и присваивание остатка
{.marker-none}



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

``swift
var numberOfDogs = 100
numberOfDogs += 1
print("Есть \(numberOfDogs) далматинцев!")

// print: 101 далматинец!

### Многострочная строка

``swift
let myLongString = """
Swift?
Это мой любимый язык!
Да!
"""

### Формируем кортеж {.col-span-2}

``swift
let player = ("Maya", 5, 150)

print(player) // ("Maya", 5, 150)
print("\(player.0): уровень \(player.1), \(player.2) pts") // Майя: уровень 5, 150 pts

### Специальный синтаксис комментария (MARK)

``swift''
// MARK: - настройки вида

`TODO` используется для отображения напоминаний о том, что необходимо сделать



### Синтаксис специальных комментариев (FIXME)

``swift''
// FIXME: Исправление ошибок при внесении изменений в существующие записи

Для наглядности объявления переменных могут содержать аннотации типов:

``swift
var greeting: String = "Hello"
var NumberOfToys: Int = 8
var isMorning: Bool = true

### Константы

Константы объявляются с помощью `let`:

``swift
let greeting = "Hello"
let numberOfToys = 8
let isMorning = true

Константы являются неизменяемыми. Их значения не могут быть изменены:

``swift
let NumberOfToys: Int = 8
numberOfToys += 1
// Ошибка: numberOfToys является неизменяемым

В приведенном ниже примере у distanceInFeet есть `getter` и `setter`. Из-за наличия `setter`, для `getter` требуется ключевое слово `get`:

``swift
var distanceInMeters: Float = 100

var distanceInFeet: Float {
  get {
    distanceInMeters *3.28
  }
  set(newDistance) {
    distanceInMeters = newDistance /3.28
  }
}

print(distanceInMeters) // 100.0
print(distanceInFeet) // 328.0

distanceInFeet = 250
print(distanceInMeters) // 76.21951
print(distanceInFeet) // 250.0

distanceInMeters = 800
print(distanceInMeters) // 800.0
print(distanceInFeet) // 2624.0

Доступ к новому значению можно получить в `willSet`:

``swift
var distance = 5 {
  willSet(newDistance) {
    print("Расстояние будет установлено \(newDistance)")
  }
}

distance = 10 // print: расстояние будет установлено равным 10

### willSet и didSet

``сдвиг
var distance = 5 {
  willSet(newDistance) {
    print("Расстояние будет установлено в \(newDistance)")
  }
  didSet {
    print("Расстояние установлено в \(расстояние)")
    print("Его старое значение равно: \(oldValue)")
  }
}
distance = 10

### else statement

``swift
var turbulence = false

if turbulence {
  print("Пожалуйста, сядьте.")
} else {
  print("Вы можете свободно передвигаться.")
}
// print: Вы можете свободно передвигаться.

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

``swift
5 > 1 // true
6 < 10 // true
2 >= 3 // false
3 <= 5 // true
"A" == "a" // false
"B" != "b" // true

### оператор switch

``swift
var secondaryColor = "зеленый"

switch secondaryColor {
  case "orange":
    print("Смесь красного и желтого")
  case "purple":
    print("Смесь красного и синего")
  default:
    print("Это не может быть вторичным цветом")
}
// print: смесь синего и желтого

### оператор switch: составной случай

``swift
let service = "Seamless"

switch service {
case "Uber", "Lyft":
    print("travel")
  case "DoorDash", "Seamless", "GrubHub":
    print("Доставка ресторанов")
  case "Instacart", "FreshDirect":
    print("Доставка продуктов")
  default:
    print("Неизвестный сервис")
}
// print: ресторан на вынос

### Логические операторы

``сдвиг
!true // false
!false //true

### Логические операторы ||

``сдвиг
true || true // true
true || false // true
false || true // true
false || false // false

Сначала `!false && true` оценивает и возвращает `true` Затем выражение `true` || `false` оценивает и возвращает конечный результат `true`.

``сдвиг
false || true && false // false

### Простые охранники

``swift
func greet(name: String?) {
  guard let unwrapped = name else {
    print("Hello guest!")
    return
  }
  print("Привет \(unwrapped)!")
}
greet(name: "Asma") // output: Hello Asma!
greet(name: nil) // output: Hello guest!

### функция stride()

``swift
for oddNum in stride(from: 1, to: 5, by: 2) {
  print(oddNum)
}
// print: 1
// print: 3

### продолжить ключевое слово

``swift
for num in 0...5 {
  if num % 2 == 0 {
    продолжить
  }
  print(num)
}
// print: 1
// print: 3
// print: 5

### Используйте символы подчеркивания

``swift
for _ in 1...3 {
  print("Ole")
}
// print: Ole
// print: Ole
// print: Ole

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

Массивы и коллекции
----



### Массив

``swift
var scores = [Int]()
// массив пуст: []

### индекс {.row-span-2}

Индекс обозначает позицию элемента в упорядоченном списке, а одиночный элемент извлекается из массива с помощью подстрочного синтаксиса `array[index]`.

``swift
var vowels = ["a", "e", "i", "o", "u"]

print(vowels[0]) // печатает: a
print(vowels[1]) // печатает: e
print(vowels[2]) // print: i
print(vowels[3]) // prints: o
print(vowels[4]) // prints: u

### Метод .append() и оператор +=

``swift
var gymBadges = ["Boulder", "Cascade"]
gymBadges.append("Thunder")
gymBadges += ["Радуга", "Душа"]
// ["Валун", "Каскад", "Гром",
// "Rainbow", "Soul"]

### Обход массива

``swift
var employees = ["Peter", "Denial", "Jame"]
for person in employees {
  print(person)
}
// print: Питер
// print: Отказ
// print: Jam

Мы можем использовать коллекцию (`Set`) для хранения `уникальных` элементов одного и того же типа данных



### Пустая коллекция (Set)

``swift
var team = Set<String>()

print(team)
// print: []

Чтобы создать набор, заполненный значениями, используйте ключевое слово `Set` перед оператором присваивания.



### .insert()

``swift
var cookieJar: Набор = [
  "Шоколадная крошка",
  "Овсяный изюм"
]
// добавляем новый элемент
cookieJar.insert("Peanut Butter Chip")

### .contains()

```swift
var names: Set = ["Rosa", "Doug", "Waldo"]
print(names.contains("Lola")) // print: false

if names.contains("Waldo"){
  print("Вот и Уолдо!")
} else {
  print("Где Уолдо?")
}
// print: There's Waldo!

### Свойство .isEmpty

``swift
var emptySet = Set<String>()
print(emptySet.isEmpty) // print: true

var populatedSet: Set = [1, 2, 3]
print(populatedSet.isEmpty) // print: false

var band: Set = ["Peter", "Denial", "Jame"]

print("В группе \(band.count) игроков.")
// print: В группе 4 игрока.

### .union()

```swift
var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

var setC = setA.union(setB)
print(setC)
// print: ["B", "A", "D", "F", "C", "E"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

var setC = setA.symmetricDifference(setB)
print(setC)
// print: ["B", "E", "F", "A"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D"]

var setC = setA.subtracting(setB)
print(setC)
// print: ["B", "A"]

Неупорядоченная коллекция пар данных или пар ключ-значение



### Ключи

``swift
var fruitStand = [
  "Кокосы": 12,
  "Ананасы": 12,
  "Папайя": 12
]

Содержит только ключи `String` и значения `Int`.



### Инициализация и заполнение словаря

``swift
var employeeID = [
  "Гамлет": 1367,
  "Горацио": 8261,
  "Офелия": 9318
]

// Синтаксис инициализатора:
var yearlyFishPopulation = [Int: Int]()

// Синтаксис литерала пустого словаря:
var yearlyBirdPopulation: [Int: Int] = [:]

### Удалить пару ключ-значение {.row-span-2}

``swift
var bookShelf = [
  "Спокойной ночи": "Маргарет Уайз Браун",
  "The BFG": "Roald Dahl",
  "Falling Up": "Шел Сильверстайн",
  "Нет, Дэвид!": "David Shannon"
]
// удалить значение, установив ключ в nil
bookShelf["The BFG"] = nil

// удаляем значение с помощью функции .removeValue()
bookShelf. removeValue(forKey: "Goodnight")

// удалить все значения
bookShelf. removeAll()

Для изменения значения пары ключ-значение можно воспользоваться методом `.updateValue()` или синтаксисом subscript, добавив к имени словаря скобки `[ ]` с существующими внутри ключами, затем оператор присваивания _(`= `)_, за которым следует измененное значение



### Свойство .isEmpty

``swift
var bakery = [String:Int]()

// проверяем, пуст ли словарь
print(bakery.isEmpty) // печатает true
bakery["Cupcakes"] = 12
// проверяем, пуст ли словарь
print(bakery.isEmpty) // выводит false

var fruitStand = [
  "Яблоки": 12,
  "Апельсины": 17
]
print(fruitStand.count) // print: 2

Присвоение переменной значения пары ключ-значение возвращает опциональное значение. Для извлечения значений используйте расширение optional



### Обход словаря

``swift
var emojiMeaning = [
  "🤔": "Задумчивое лицо",
  "😪": "Сонное лицо",
  "😵": "Головокружение"
]
// перебор ключей и значений
for (emoji, meaning) in emojiMeaning {
  print("\(emoji) называется '\(meaning)Emoji'")
}
// итерация только по ключам
for emoji in emojiMeaning. keys {
  print(emoji)
}
// итерация только по значениям
for meaning in emojiMeaning. values {
  print(meaning)
}

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

``swift
func greetLearner() {
 print("Добро пожаловать на CheatSheets.zip!")
}
// вызов функции:
greetLearner()
// print: Welcome to CheatSheets.zip!

### Множественные параметры {.col-span-2}

``swift
func convertFracToDec(numerator: Double, denominator: Double) -> Double {
  return numerator / denominator
}

let decimal = convertFracToDec(numerator: 1.0, denominator: 2.0)
print(decimal) // prints: 0.5

### возвращает несколько значений {.col-span-2}

``swift
func smartphoneModel() -> (name: String, version: String, yearReleased: Int) {
  return ("iPhone", "8 Plus", 2017)
}
let phone = smartphoneModel()

print(phone.name) // print: iPhone
print(phone.version) // print: 8 Plus
print(phone.yearReleased) // print: 2017

### Неявный возврат
``swift
func nextTotalSolarEclipse() -> String {
  "8 апреля 2024 🌎"
}

print(nextTotalSolarEclipse())
// print: 8 апреля 2024 года 🌎

func greet(person: String = "guest") {
  print("Привет \(person)")
}
greet() // Здравствуй гость
greet(person: "Aliya") // Hello Aliya

### переменная параметр

``swift
func totalStudent(data: String...) -> Int {
  let numStudents = data.count
  return numStudents
}

print(totalStudent(data: "Отказ", "Петр"))
// print: 2

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

структура
----



### Создание структуры

``swift
struct Building {
  var адрес: String
  var этажи: Int
  init(address: String, floors: Int) {
    self.address = address
    self.floors = floors
  }
}

### Создание структурного экземпляра

``swift
struct Person {
  var name: String
  var возраст: Int

  init(name: String, age: Int) {
    self.name = name
    self.age = age
  }
}

// Экземпляр Person:
var morty = Person(name: "Peter", age: 14)

Использование класса `TV`

``swift
var newTV = TV(size: 65, type: "LED")

### Метод мутации (mutating) {.row-span-2}

``сдвиг
struct Menu {
  var menuItems = ["Картофель фри", "Бургеры"]
  mutating func addToMenu(dish: String) {
    self.menuItems.append(dish)
  }
}

### Структурные методы

``свифт
struct Dog {
  func bark() {
    print("Гав")
  }
}
let fido = Dog()
fido.bark() // prints: Гав

### экземпляр класса

``swift
class Person {
  var name = ""
  var age = 0
}

var sonny = Person()
// sonny теперь является экземпляром Person

Использование класса Fruit

``swift
let apple = Fruit(color: "red")

### Наследуем {.row-span-2}

Предположим, что у нас есть класс BankAccount:

``swift
class BankAccount {
  var balance = 0.0
  func deposit(amount: Double) {
    balance += amount
  }
  func withdraw(amount: Double) {
    баланс -= сумма
  }
}

Новый класс `SavingsAccount` (подкласс) автоматически получает все характеристики класса `BankAccount` (суперкласс). Кроме того, класс `SavingsAccount` определяет свойство `.interest` и метод `.addInterest()`.



### Пример

использовать тип данных

``swift
класс Студент {
  var name: String
  var year: Int
  var gpa: Double
  var honors: Bool
}

### Это пример определения структуры и класса

``swift
struct Resolution {
  var width = 0
  var height = 0
}
class VideoMode {
  var resolution = Resolution()
  var interlaced = false
  var frameRate = 0.0
  var name: String?
}

Перечислить
----



### Определите перечисление

``swift
enum Day {
  случай понедельник
  случай вторник
  случай среда
  четверг
  случай пятница
  суббота
  случай воскресенья
}

let casualWorkday: Day = .friday

### CaseIterable

``swift
enum Season: CaseIterable {
  случай зима
  случай весна
  лето
  случай осень
}

for season in Season.allCases {
  print(season)
}

### Связанные значения

``swift
enum Dessert {
  case cake(flavor: String)
  case vanillaIceCream(scoops: Int)
  case brownie
}

let order: Dessert = .cake(flavor: "Red Velvet")

Как и классы и структуры, перечисления могут иметь методы экземпляра. Если метод экземпляра изменяет значение перечисления, то он должен быть помечен как `mutating`.



### Инициализация из примитивного значения

``swift
enum Hello: String {
  case english = "Hello"
  case japanese = "Hello!"
  case emoji = "👋"
}
let hello1 = Hello(rawValue: "Привет!")
let hello2 = Hello(rawValue: "Привет")
print(hello1) // Optional(Hello.japanese)
print(hello2) // nil

Также см.
----

- [Swift Documentation (Official)](https://www.swift.org/documentation/) _(swift.or)_
- [Язык программирования Swift (официальный)](https://docs.swift.org/swift-book/) _(swift.or)_
- [One-Stop Quick Reference for Swift Developers](https://swiftly.dev/) _(swiftly.dev)_