Пример

var strings = ["FOO", "BAR"] 

strings.reverse()

strings[0]

Общее между JS и Swift

• Синтаксис;
• REPL;
• Ощущение того, что код – интерпретируемый.

Отличия между JS и Swift

• Компилируемый язык (LLVM);
• Функциональные концепты;
• Пока ещё не работает в браузере;

• Функциональность, которой нет в JS 😂

Опционал / Optional

Опционал

var x : Int?

x = Int("abc")           // не Int, получим nil
x = Int("123")           // 123

Опционал имеет свой собственный тип

var y = Int("123")

var x = 123                    // Int
var y = Int("123")             // Int?

Int() возвращает тип Int?, почему y Int?, а не Int

Получение значения

var str : String = "Первый"
var str2 : String? = "пример"

var fullStr = str + " " + str2

var fullStr = str + " " + str2!

if let tmp = str2
{
   fullStr = str + " " + str2!
}
else
{
   fullStr = str
}

Правильное получение

Сказать компилятору явно

Использовать связывание

Кортежи / Tuples

var coordinates = (10, 20)
print("Координаты x:\(coordinates.0) y:\(coordinates.1)")

Кортежи

Обращение по индексу

var coordinates = (x: 10, y: 20)
print("Координаты x:\(coordinates.x) y:\(coordinates.y)")

Именование при создании

var (x, y) = (10, 20)
print("Координаты \(x), \(y)")

Декомпозиция в переменные

var (_, _, z) = (10, 20, "Мир")
print("Привет, \(z)")

Можно игнорировать переменные при декомпозиции

Switch

var tasksNum = 6

switch (tasksNum)
{
case 0, 1:
    print("достаточно")
case 2..<5:
    print("нормально")
case 5..<10:
    print("много")
case 10...100:
    print("слишком много")
default:
    print("я же не робот!")
}

Switch

var person = ("Иван", 23, "Россия")

switch (person)
{
case (let name, _, "Россия"):
    print("Привет, \(name)")
case (_, let age, _) where age > 60:
    print("Добрый день, господин")
case let (name, age, country):
    print("Привет, я \(name), мне \(age), \(country)")
}

Switch с кортежами

Functions

func functionName(param1: Type, param2: Type) -> ReturnType {
    // тело
}

Синтаксис

func add(x: Int, y: Int) -> Int {
    return x + y
}

add(5, y:10)

/******/

func add(x: Int, _ y: Int) -> Int {
    return x + y
}

add(5, 10)

/******/

func add(thisNumber x: Int, andThisNumber y: Int) -> Int {
    return x + y
}

add(thisNumber: 5, andThisNumber:10)

Параметры

func add(a:Int, _ b:Int) -> Int {
    return a + b
}

var addingFunction = add

addingFunction(1, 2)

Функции – это значения

add, addingFunction имеет тип (Int, Int) -> Int

А значения имеют тип

Closures

var add = { (x:Int, y:Int) -> (Int) in
    x + y
}

add(1,2)

Функции – это именованные замыкания

func add(x: Int, y: Int) -> Int {
    return x + y
}

add(5, y:10)

func doMath(c : (Int, Int) -> Int) -> Int {
    return c(1,2)
}

doMath({ (x:Int, y:Int) -> Int in return x + y })
doMath() { (x:Int, y:Int) -> Int in return x + y }
doMath { (x:Int, y:Int) -> Int in return x + y }

Замыкания можем передавать в параметры

Перечисления

Особенности

• Могут иметь вычисляемые поля
• Могут иметь методы конструкторы/инициализаторы
• Могут быть расширяемыми

enum Size {
    case Small, Medium, Large
}

var x = Size.Small
var y = .Small       

print(y)              // напечатает "Small"

Синтаксис

enum Response {
    case Success
    case Error(Int, String)
}

var r1 = Response.Success
var r2 = Response.Error(404, "Not Found")

switch (r2)
{
case .Success:
    print("Всё супер!")
case .Error(let code, let msg):
    print("Ошибка \(code): \(msg)")
}

Хранение кастомных значений

Структуры и классы

Структура

• Свойства
• Методы
• Расширяемая
• Может принимать протокол
• Метод инициализатор
• По значению

Класс

• Свойства
• Методы
• Расширяемый
• Может принимать протокол
• Метод инициализатор
• По ссылке
• Наследование
• Приведение типа во время выполнения
• Метод деструктор

Массивы, словари и строки – структуры и ссылаются по значению

Generic
Protocol
OOП...

Swift не JS,

но бояться его не стоит