🤔 Что знаешь про Array?

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

🚩Основные аспекты

🟠Создание массива
Пустой массив

var emptyArray: [Int] = []
var anotherEmptyArray = [Int]()     

Массив с начальными значениями

var numbers: [Int] = [1, 2, 3, 4, 5]
var moreNumbers = [1, 2, 3, 4, 5]     

🟠Доступ к элементам
По индексу

let firstNumber = numbers[0]  // 1     

Изменение элемента

numbers[0] = 10  // теперь numbers = [10, 2, 3, 4, 5]     

🟠Добавление элементов
В конец массива

numbers.append(6)  // теперь numbers = [10, 2, 3, 4, 5, 6]     

Вставка по индексу

numbers.insert(7, at: 1)  // теперь numbers = [10, 7, 2, 3, 4, 5, 6]     

🟠Удаление элементов
По индексу

numbers.remove(at: 1)  // теперь numbers = [10, 2, 3, 4, 5, 6]     

Последний элемент

numbers.removeLast()  // теперь numbers = [10, 2, 3, 4, 5]     

Все элементы

numbers.removeAll()  // теперь numbers = []     

🟠Итерация по массиву
С использованием цикла for

for number in numbers {
    print(number)
}     

С использованием метода forEach

numbers.forEach { print($0) }     

🟠Методы массивов
Фильтрация

let evenNumbers = numbers.filter { $0 % 2 == 0 }     

Преобразование

     let stringNumbers = numbers.map { String($0) }
     

➕ Сокращение:

let sum = numbers.reduce(0, +)     

🚩Плюсы использования

➕Упорядоченность
Элементы хранятся в определенном порядке и доступ к ним возможен по индексу.
➕Гибкость
Легко добавлять и удалять элементы, изменять их порядок.
➕Богатый набор методов
Массивы предоставляют множество методов для обработки данных, таких как фильтрация, сортировка, преобразование и т.д.

🚩Важные особенности

🟠Тип безопасности
Все элементы массива должны быть одного типа, что обеспечивает безопасность типов.
🟠Производительность
Доступ по индексу выполняется за постоянное время O(1), но вставка и удаление элементов могут иметь сложность O(n), если они происходят не в конце массива.
🟠Неизменяемые массивы
Если массив объявлен с использованием let, он становится неизменяемым, и его элементы нельзя добавлять или удалять.

let immutableNumbers = [1, 2, 3]
// immutableNumbers.append(4) // Ошибка: Невозможно изменить неизменяемый массив

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие есть паттерны в объектном проектировании

Среди паттернов объектного проектирования выделяются: порождающие паттерны (например, Singleton, Factory, Builder), структурные паттерны (Adapter, Composite, Decorator) и поведенческие паттерны (Observer, Strategy, Command). Порождающие паттерны помогают создавать объекты, структурные организуют отношения между объектами, а поведенческие управляют взаимодействиями и обязанностями объектов. Эти паттерны способствуют созданию гибкого и поддерживаемого кода.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое notification центр?

Это механизм в iOS и macOS для обмена сообщениями между различными частями приложения. Он позволяет объектам отправлять и получать уведомления без необходимости напрямую ссылаться друг на друга, что способствует более гибкому и модульному дизайну.

🚩Основные аспекты

🟠Отправка уведомлений
Любой объект может отправить уведомление с помощью Notification Center. Уведомления идентифицируются по имени (Notification.Name). Можно передать дополнительную информацию в виде словаря (userInfo).

NotificationCenter.default.post(name: .myNotification, object: nil)   

🟠Получение уведомлений
Объекты могут регистрироваться для получения уведомлений с определенным именем. Для обработки уведомлений используется метод, который будет вызван при получении уведомления.

NotificationCenter.default.addObserver(self, selector: #selector(handleNotification), name: .myNotification, object: nil)
   
@objc func handleNotification(notification: Notification) {
    print("Received notification")
}   

🟠Удаление наблюдателей
Важно удалять наблюдателей, когда они больше не нужны, чтобы избежать утечек памяти. Обычно это делается в методе deinit или перед уничтожением объекта.

NotificationCenter.default.removeObserver(self, name: .myNotification, object: nil)   

🚩Плюсы

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

🚩Примеры использования

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

NotificationCenter.default.post(name: .dataDidUpdate, object: nil)   

2⃣Реакция на системные события
Например, можно подписаться на уведомление о смене состояния сети.

NotificationCenter.default.addObserver(self, selector: #selector(handleNetworkChange), name: .reachabilityChanged, object: nil)   

3⃣Межмодульное взаимодействие
Различные модули приложения могут общаться друг с другом через Notification Center, не создавая сильных зависимостей.

NotificationCenter.default.post(name: .userDidLogin, object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(updateUI), name: .userDidLogin, object: nil)   

Ставь 👍 и забирай 📚 Базу знаний

🤔 Расскажи о самом главном различии между UI Vue и CLI Vue

UI Vue предоставляет графический интерфейс для работы с проектами Vue, управляя настройками и сборками через визуальный интерфейс. CLI Vue — это командная строка, с помощью которой разработчики могут создавать и управлять проектами Vue через текстовые команды, имея более детальный контроль над конфигурацией. Основное различие — способ взаимодействия: UI Vue удобен для новичков, а CLI Vue подходит для более гибкой и точной настройки.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Когда нужно изменять метод loadview?

Метод loadView() в UIViewController отвечает за создание и инициализацию основного представления (view) контроллера. Обычно этот метод используется в специфических случаях, когда требуется полное управление процессом создания представления.

🚩Основные случаи, когда нужно переопределять `loadView()`

🟠Полное управление созданием представления
Когда необходимо создать и настроить представление программно без использования Interface Builder (storyboards или xibs).

override func loadView() {
    let view = UIView()
    view.backgroundColor = .white
         
    let label = UILabel()
    label.text = "Hello, World!"
    label.textAlignment = .center
    label.translatesAutoresizingMaskIntoConstraints = false
         
    view.addSubview(label)
         
    NSLayoutConstraint.activate([
        label.centerXAnchor.constraint(equalTo: view.centerXAnchor),
        label.centerYAnchor.constraint(equalTo: view.centerYAnchor)
   ])
         
    self.view = view
}     

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

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

🟠Индивидуальный подход к инициализации view
Когда требуется специфическая настройка представления, которая не может быть выполнена через Interface Builder. Например, создание представлений с использованием сторонних библиотек или компонентов, которые требуют программного конфигурирования.

🚩Важные моменты при переопределении `loadView()`

🟠Не забывайте назначать свойство `self.view`
В методе loadView() обязательно должно быть присвоено значение свойству self.view, иначе возникнет ошибка и контроллер не будет иметь основного представления.

override func loadView() {
    self.view = UIView()
}  

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

🟠Избегайте тяжелых операций
Не выполняйте ресурсоемкие операции в loadView(), чтобы не замедлять создание представления. Это может негативно повлиять на производительность.

Ставь 👍 и забирай 📚 Базу знаний

🤔 За счёт чего стек быстрее кучи?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 В каких ситуациях можно применять MVC?

🟠Простые приложения
Минимальная логика и количество экранов. Одностраничные приложения. Быстрая разработка.

🟠Быстрое прототипирование
Быстрое создание прототипов. Демонстрация идей заказчику. Легкость реализации.

🟠Минимальная сложность
Приложения с простой функциональностью. Калькуляторы, справочники. Простота поддержки.

🟠Обучение
Изучение основ iOS-разработки. Учебные проекты. Понятность для новичков.

🟠Поддержка старых проектов
Работа с существующими проектами на MVC. Доработка старого кода. Сохранение целостности архитектуры.

🚩Компоненты MVC

🟠Model
Данные и бизнес-логика.

struct User {
    let name: String
}   

🟠View
Отображение данных (Storyboards, xibs).

@IBOutlet weak var nameLabel: UILabel!   

🟠Controller
Управление взаимодействием между Model и View.

class ViewController: UIViewController {
    var user: User?

    override func viewDidLoad() {
        super.viewDidLoad()
        user = User(name: "Alice")
        updateView()
    }

    func updateView() {
        nameLabel.text = user?.name
    }
}   

🚩Плюсы и минусы

➕Простота и ясность.
➕Четкое разделение ответственности.
➕Подходит для небольших проектов.
➖Сложность масштабирования.
➖Возможная перегрузка контроллеров.
➖Тесная связь между компонентами.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Чем отличается rebase от merge?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что относится к типам данных?

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

🤔 Основные типы данных

🟠Примитивные типы данных
Представляют целые числа. Int, UIn

       let age: Int = 25
       

Представляют дробные числа. Float, Double

       let pi: Double = 3.14159
       

Представляют логические значения true или false. Bool

       let isActive: Bool = true
       

Представляют отдельные символы. Character

       let letter: Character = "A"
       

🟠Составные типы данных (Composite data types)
Представляют последовательности символов. String

       let greeting: String = "Hello, World!"
       

Представляют упорядоченные коллекции элементов одного типа. Array<T>

       let numbers: [Int] = [1, 2, 3, 4, 5]
       

Представляют коллекции пар ключ-значение. Dictionary<Key, Value>

       let user: [String: String] = ["name": "Alice", "age": "30"]
       

Представляют коллекции уникальных элементов. Set<T>

       let uniqueNumbers: Set<Int> = [1, 2, 3, 4, 5]
       

🟠Пользовательские типы данных (User-defined data types)
Представляют тип данных с набором связанных значений. enum

       enum CompassPoint {
           case north
           case south
           case east
           case west
       }
       

Представляют группы связанных значений. struct

       struct Person {
           var name: String
           var age: Int
       }
       let person = Person(name: "Alice", age: 30)
       

Представляют объекты с состоянием и поведением. class

       class Car {
           var model: String
           var year: Int
           
           init(model: String, year: Int) {
               self.model = model
               self.year = year
           }
       }
       let car = Car(model: "Tesla", year: 2021)
       

🟠Специальные типы данных
Представляют группы нескольких значений различных типов. (Type1, Type2, ...)

       let coordinates: (Int, Int) = (10, 20)
       

Представляют значение, которое может быть либо некоторым значением, либо nil. Optional<T>

       var optionalName: String? = "Alice"
       

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем отличие классов и структур?

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

🚩Основные отличия

🟠Тип данных
Классы: Ссылочный тип.
Структуры: Значимый тип.

🟠Передача по значению и по ссылке
Классы: Передаются по ссылке. При присваивании переменной другого объекта, оба объекта указывают на одну и ту же область памяти.
Структуры: Передаются по значению. При присваивании переменной другой структуры, создается копия структуры.

   // Класс
   class PersonClass {
       var name: String
       init(name: String) {
           self.name = name
       }
   }

   let person1 = PersonClass(name: "Alice")
   let person2 = person1
   person2.name = "Bob"
   print(person1.name) // "Bob" (оба объекта указывают на одну и ту же память)

   // Структура
   struct PersonStruct {
       var name: String
   }

   var person3 = PersonStruct(name: "Alice")
   var person4 = person3
   person4.name = "Bob"
   print(person3.name) // "Alice" (создана копия структуры)
   

🟠Наследование
Классы: Поддерживают наследование, то есть один класс может наследовать свойства и методы другого класса.
Структуры: Не поддерживают наследование.

   // Класс с наследованием
   class Vehicle {
       var speed: Int = 0
       func description() -> String {
           return "Moving at \(speed) km/h"
       }
   }

   class Car: Vehicle {
       var hasSunroof: Bool = false
   }

   let myCar = Car()
   myCar.speed = 120
   myCar.hasSunroof = true
   print(myCar.description()) // "Moving at 120 km/h"
   

🟠Деинициализаторы
Классы: Могут иметь деинициализаторы (deinitializers), которые вызываются перед освобождением экземпляра класса.
Структуры: Не имеют деинициализаторов.

   class MyClass {
       deinit {
           print("MyClass is being deinitialized")
       }
   }
   

🟠Сборка мусора и управление памятью
Классы: Используют автоматическое управление памятью с подсчетом ссылок (ARC). Объекты удаляются, когда на них больше нет сильных ссылок.
Структуры: Удаляются автоматически, когда выходят из области видимости.

🟠Расширяемость (Extensions)
Оба: Поддерживают расширения (extensions), что позволяет добавлять новые функциональности к существующим классам или структурам.

🟠Протоколы (Protocols)
Оба: Поддерживают соответствие протоколам.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Можно ли имитировать множественное наследование?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какой механизм работы у структур при копировании?

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

🚩Основные аспекты

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

     struct Person {
         var name: String
         var age: Int
     }

     var person1 = Person(name: "Alice", age: 30)
     var person2 = person1  // Создается копия person1
     person2.name = "Bob"
     
     print(person1.name)  // "Alice" (оригинал не изменился)
     print(person2.name)  // "Bob" (копия изменена)
     

🟠Неявное копирование
Копирование происходит автоматически при присваивании или передаче структур. Это делает работу со структурами безопасной и предсказуемой.

     func updateName(person: Person) -> Person {
         var updatedPerson = person
         updatedPerson.name = "Charlie"
         return updatedPerson
     }

     let person = Person(name: "Alice", age: 30)
     let updatedPerson = updateName(person: person)
     
     print(person.name)  // "Alice"
     print(updatedPerson.name)  // "Charlie"
     

🟠Изменение свойств
Изменения, сделанные в одной копии структуры, не влияют на другие копии.

     var person1 = Person(name: "Alice", age: 30)
     var person2 = person1
     person2.age = 35
     
     print(person1.age)  // 30
     print(person2.age)  // 35
     

🟠Копирование вложенных структур
При копировании структуры копируются также все ее вложенные структуры.

     struct Address {
         var city: String
     }

     struct Person {
         var name: String
         var address: Address
     }

     var person1 = Person(name: "Alice", address: Address(city: "New York"))
     var person2 = person1
     person2.address.city = "San Francisco"
     
     print(person1.address.city)  // "New York"
     print(person2.address.city)  // "San Francisco"
     

🚩Оптимизации копирования

🟠Copy-on-write (COW)
Swift использует оптимизацию copy-on-write для некоторых стандартных типов данных (например, массивов). Это означает, что фактическое копирование происходит только тогда, когда одна из копий изменяется.

     var array1 = [1, 2, 3]
     var array2 = array1  // array1 и array2 указывают на один и тот же массив
     array2.append(4)  // array2 создает свою копию и модифицирует ее
     
     print(array1)  // [1, 2, 3]
     print(array2)  // [1, 2, 3, 4]
     

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

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое чистый код?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 У множества любые могут быть элементы или какого-то типа определенного?

В языке Swift множества (sets) могут содержать только элементы одного типа. Это обусловлено тем, что множества реализованы как обобщённые (generic) коллекции.

🚩Почему множества в Swift содержат элементы одного типа

🟠Обобщённые коллекции
Swift использует обобщения (generics) для своих коллекций, таких как массивы (arrays), множества (sets) и словари (dictionaries). Это означает, что при создании множества вы указываете тип элементов, которые оно будет содержать, и все элементы должны быть этого типа.
🟠Типобезопасность
Это помогает обеспечить типобезопасность (type safety). Когда тип элементов известен, компилятор может проверять правильность операций с элементами во время компиляции, предотвращая множество потенциальных ошибок на этапе исполнения.

🚩Как создаются множества

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

var stringSet: Set<String> = ["Apple", "Banana", "Cherry"]

Если мы попробуем добавить в это множество элемент другого типа, компилятор выдаст ошибку

// Ошибка: Cannot convert value of type 'Int' to expected argument type 'String'
stringSet.insert(42)

🚩Пример с множествами различных типов

Множество целых чисел

var intSet: Set<Int> = [1, 2, 3, 4, 5]
intSet.insert(6) // Это допустимо

Множество строк

var stringSet: Set<String> = ["Red", "Green", "Blue"]
stringSet.insert("Yellow") // Это допустимо

Множество пользовательских объектов

struct Person: Hashable {
    let name: String
    let age: Int
}

var peopleSet: Set<Person> = [Person(name: "John", age: 30), Person(name: "Jane", age: 25)]
peopleSet.insert(Person(name: "Doe", age: 40)) // Это допустимо

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие принципы программирования бывают?

1. SOLID: набор принципов ООП для создания гибкого и масштабируемого кода (единственная ответственность, открытость/закрытость, подстановка Лисков, разделение интерфейсов, инверсия зависимостей).
2. DRY (Don't Repeat Yourself): избегание повторения кода.
3. KISS (Keep It Simple, Stupid): упрощение структуры и логики программ.
4. YAGNI (You Aren't Gonna Need It): не добавляйте функционал, пока он не нужен.
5. Separation of Concerns: разделение логики программы на модули с отдельной ответственностью.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Язык программирования на IOS типизированный?

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

🚩Что значит "строго типизированный язык"?

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

var explicitString: String = "Hello, World!" // Явное указание типа
var inferredInt = 42 // Неявное указание типа, Swift выводит тип как Int    

🟠Проверка типов во время компиляции
Компилятор Swift проверяет правильность типов во время компиляции. Это позволяет обнаруживать многие ошибки на ранних этапах разработки, до выполнения программы.

var number: Int = 10
// number = "Ten" // Ошибка: Невозможно присвоить значение типа 'String' переменной типа 'Int'    

🟠Безопасное преобразование типов
Swift требует явного преобразования типов, что предотвращает случайные ошибки.

let integer: Int = 42
let doubleValue: Double = Double(integer) // Явное преобразование Int в Double    

🚩Почему типизация важна?

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

🟠Оптимизация производительности
Знание типов на этапе компиляции позволяет компилятору лучше оптимизировать код.

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

🚩Примеры работы с типами

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

let name: String = "Alice"
let age: Int = 30
let height: Double = 5.9

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

let city = "New York" // Swift выводит тип как String
let population = 8_000_000 // Swift выводит тип как Int

Ошибка из-за несовместимости типов

let isOpen: Bool = true
// isOpen = 1 // Ошибка: Невозможно присвоить значение типа 'Int' переменной типа 'Bool'

Ставь 👍 и забирай 📚 Базу знаний

🤔 Можно совершить реализацию функции в протоколе?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Могут ли разные типы данных лежать в массиве?

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

🚩Массивы одного типа

Обычно массивы в Swift содержат элементы одного типа. Это помогает компилятору проверять правильность типов и предотвращает множество ошибок.

var intArray: [Int] = [1, 2, 3, 4, 5]
var stringArray: [String] = ["Apple", "Banana", "Cherry"]

Попытка добавить элемент другого типа приведет к ошибке компиляции

// Ошибка: Cannot convert value of type 'String' to expected element type 'Int'
// intArray.append("Six")

🚩Хранение элементов разных типов

🟠Использование типа `Any`
Тип Any может представлять любой тип данных в Swift. Однако, использование Any убирает преимущества типобезопасности.

var mixedArray: [Any] = [1, "Two", 3.0, true]

for item in mixedArray {
    if let intValue = item as? Int {
        print("Integer value: \(intValue)")
    } else if let stringValue = item as? String {
        print("String value: \(stringValue)")
    } else if let doubleValue = item as? Double {
        print("Double value: \(doubleValue)")
    } else if let boolValue = item as? Bool {
        print("Boolean value: \(boolValue)")
    }
}

🟠Использование объединённых типов (enums)
Можно определить перечисление с ассоциированными значениями для хранения различных типов данных в массиве.

enum MixedType {
    case intValue(Int)
    case stringValue(String)
    case doubleValue(Double)
    case boolValue(Bool)
}

var mixedArray: [MixedType] = [
    .intValue(1),
    .stringValue("Two"),
    .doubleValue(3.0),
    .boolValue(true)
]

for item in mixedArray {
    switch item {
    case .intValue(let intValue):
        print("Integer value: \(intValue)")
    case .stringValue(let stringValue):
        print("String value: \(stringValue)")
    case .doubleValue(let doubleValue):
        print("Double value: \(doubleValue)")
    case .boolValue(let boolValue):
        print("Boolean value: \(boolValue)")
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Могут быть в протоколах опциональные функции?

Да, опциональные функции могут быть в протоколах, но только если протокол поддерживает Objective-C, что требует использования атрибута @objc. Они доступны для классов, так как зависят от Objective-C runtime.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний