Какие инициализаторы можно добавить в extension ?
Спросят с вероятностью 18%

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

1️⃣Структуры (Structs)
Обладают особенностью автоматически создавать "синтезированный" инициализатор, который требует, чтобы все свойства структуры были инициализированы. При добавлении новых инициализаторов через расширения:

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

struct Point {
    var x: Double
    var y: Double
}

extension Point {
    init() {
        self.init(x: 0, y: 0)
    }
}

2️⃣Классы (Classes)
Добавление инициализаторов к классам через расширения включает в себя более строгие ограничения:

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

class Person {
    var name: String
    var age: Int

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

extension Person {
    convenience init() {
        self.init(name: "Unknown", age: 0)
    }
}

3️⃣Перечисления (Enums)
Могут получать дополнительные инициализаторы через расширения:

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

enum TemperatureUnit {
    case celsius, fahrenheit, kelvin
}

extension TemperatureUnit {
    init?(symbol: Character) {
        switch symbol {
        case "C":
            self = .celsius
        case "F":
            self = .fahrenheit
        case "K":
            self = .kelvin
        default:
            return nil
        }
    }
}

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что в extension можно добавить, кроме функции ?
Спросят с вероятностью 18%

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

1️⃣Вычисляемые свойства
Расширения могут добавлять новые вычисляемые свойства к типам, но они не могут содержать хранимые свойства или добавлять свойства с наблюдателями за их изменениями.

extension Double {
    var km: Double { return self * 1_000.0 }
    var m: Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
}

let oneInch = 25.4.mm
print("One inch is \(oneInch) meters") // Вывод: "One inch is 0.0254 meters"

2️⃣Методы
Расширения могут добавлять новые методы экземпляра и новые методы типа к существующим типам.

extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0..<self {
            task()
        }
    }
}

3.repetitions {
    print("Hello!")
}
// Вывод: "Hello!" будет напечатано три раза

3️⃣Модифицирующие (mutating) методы экземпляра
Позволяет им изменять переменные экземпляра.

extension Int {
    mutating func square() {
        self = self * self
    }
}

var someInt = 3
someInt.square() // someInt теперь равен 9

4️⃣Инициализаторы
Позволяет создавать типы новыми способами.

struct Size {
    var width: Double
    var height: Double
}

extension Size {
    init(squareWithSide side: Double) {
        self.width = side
        self.height = side
    }
}

let squareSize = Size(squareWithSide: 5) // width и height будут равны 5

5️⃣Сабскрипты
Расширения могут добавлять новые сабскрипты к существующим типам.

extension Int {
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex {
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}

print(746381295[0]) // Выводит 5

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

extension Int {
    enum Kind {
        case negative, zero, positive
    }

    var kind: Kind {
        switch self {
        case 0:
            return .zero
        case let x where x > 0:
            return .positive
        default:
            return .negative
        }
    }
}

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое асинхронная задача ?
Спросят с вероятностью 45%

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

Принцип работы

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

Для работы с асинхронными задачами часто используются замыкания (closures) и различные API, такие как Grand Central Dispatch (GCD) и async/await. Вот пример использования async/await для асинхронной загрузки данных из сети:

func fetchDataAsync() async -> Data? {
    let url = URL(string: "https://example.com/data")!
    do {
        let (data, _) = try await URLSession.shared.data(from: url)
        return data
    } catch {
        print("Ошибка при загрузке данных: \(error)")
        return nil
    }
}

// Где-то в другом месте вашего кода
Task {
    if let data = await fetchDataAsync() {
        // Обработка данных
    }
}

В этом примере функция fetchDataAsync выполняет асинхронный запрос к серверу и возвращает данные, полученные в ответ. Благодаря использованию async/await, код остаётся читаемым и легко понимаемым, несмотря на асинхронность операции.

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

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

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

Как это работает

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

Пример:

protocol Printable {
    func printYourself()
}

extension Printable {
    func printYourself() {
        print("I am \(self)")
    }
}

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

let john = Person(name: "John Doe", age: 30)
john.printYourself()  // Вывод: "I am Person(name: "John Doe", age: 30)"

В этом примере, структура Person соответствует протоколу Printable и автоматически получает реализацию метода printYourself через расширение протокола. Метод выводит строковое представление экземпляра.

Преимущества:
1️⃣Код становится более DRY (Don't Repeat Yourself): Расширения протоколов позволяют определить общее поведение в одном месте, а не дублировать код во всех типах, соответствующих протоколу.

2️⃣Повышение гибкости: Можно легко изменять поведение всех типов, соответствующих протоколу, просто изменяя реализацию в расширении протокола.

3️⃣Улучшение тестируемости: Благодаря тому что конкретные реализации сосредоточены в расширениях протоколов, их легче тестировать и поддерживать.

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

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какие отличия MVC от MVP ?
Спросят с вероятностью 18%

MVC (Model-View-Controller) и MVP (Model-View-Presenter) — это два популярных архитектурных паттерна, используемых для создания веб- и настольных приложений. Оба паттерна предназначены для разделения ответственности между компонентами программы, что упрощает управление кодом, его тестирование и поддержку. Вот ключевые отличия между ними:

MVC (Model-View-Controller)

Компоненты:
✅Model: Содержит бизнес-логику и данные. Оповещает контроллер о изменениях, которые нужно отразить в представлении.
✅View: Отображает данные (модель) пользователю и отправляет действия пользователя контроллеру.
✅Controller: Мост между моделью и представлением. Обрабатывает входящие действия и данные от представления, изменяет модель и обновляет представление.

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

MVP (Model-View-Presenter)

Компоненты:
✅Model: Также содержит бизнес-логику и данные приложения.
✅View: Интерфейс, который отображает данные (модель) и делегирует все действия пользователя через интерфейс на Presenter.
✅Presenter: Получает действия от представления через интерфейс, работает с моделью и обновляет представление. Представление пассивно — оно не содержит никакой логики, кроме логики отображения.

Особенности:
✅Presenter в MVP не знает о конкретных реализациях представлений. Он работает через абстрактный интерфейс View, что упрощает тестирование.
✅Представление в MVP полностью пассивно, что значит, что вся логика управления UI переносится в Presenter. Это упрощает модульное тестирование, так как Presenter можно тестировать отдельно от пользовательского интерфейса.

Ключевые отличия:

✅Связь между компонентами: В MVC контроллер активно связывает модель и представление, в то время как в MVP Presenter обеспечивает двустороннюю связь между моделью и представлением через абстрактный интерфейс.
✅Роль View: В MVC представление может быть более активным участником (особенно в веб-разработке), принимая решения на основе данных модели. В MVP представление полностью пассивно и все решения по управлению данными и состоянием UI принимаются Presenter'ом.
✅Тестируемость: MVP часто считается более удобным для модульного тестирования, поскольку Presenter не зависит от конкретных реализаций View и может быть легко протестирован с моками или стабами представления.

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое диспетчеризация ?
Спросят с вероятностью 45%

Диспетчеризация (dispatch) относится к процессу определения того, какой блок кода (или функция) должен быть выполнен в ответ на вызов функции, особенно когда точный метод, который следует вызвать, не может быть определён на момент компиляции. Этот процесс тесно связан с концепцией полиморфизма и механизмами наследования в объектно-ориентированном программировании. Существует несколько ее типов.

Статическая диспетчеризация

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

Динамическая диспетчеризация

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

Множественная диспетчеризация

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

Swift использует как статическую, так и динамическую диспетчеризацию, в зависимости от контекста. Методы структур и перечислений обычно используют статическую диспетчеризацию, что делает их вызов очень быстрым. В то же время, методы классов могут использовать динамическую диспетчеризацию, особенно если они помечены как dynamic или происходят от классов, отмеченных @objc, для совместимости с Objective-C.


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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как будут реализованы опциональные функции в протоколах ?
Спросят с вероятностью 18%

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

Реализация:

1️⃣Расширения протоколов

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

protocol MyProtocol {
    func requiredMethod()
    func optionalMethod()
}

extension MyProtocol {
    func optionalMethod() {
        print("Default implementation of optionalMethod")
    }
}

class MyClass: MyProtocol {
    func requiredMethod() {
        print("Implementation of requiredMethod")
    }
}

let instance = MyClass()
instance.requiredMethod()  // Вывод: "Implementation of requiredMethod"
instance.optionalMethod()  // Вывод: "Default implementation of optionalMethod"

2️⃣Использование пустых реализаций

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

protocol MyProtocol {
    func requiredMethod()
    func optionalMethod()
}

extension MyProtocol {
    func optionalMethod() {}
}

class MyClass: MyProtocol {
    func requiredMethod() {
        print("Implementation of requiredMethod")
    }
}

let instance = MyClass()
instance.requiredMethod()  // Вывод: "Implementation of requiredMethod"
instance.optionalMethod()  // Ничего не выводится

Особенности:

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

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Могут ли быть в протоколах опциональные функции ?
Спросят с вероятностью 18%

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

Особенности:

1️⃣Использование `@objc`: Протокол должен быть объявлен с атрибутом @objc для того, чтобы поддерживать опциональные члены. Это делает протокол совместимым с Objective-C.

2️⃣Ограничение на типы: Только классы могут реализовывать такие протоколы с опциональными функциями, так как @objc протоколы не могут быть приняты структурами или перечислениями.

3️⃣Синтаксис: Опциональные методы в протоколе должны быть явно помечены как optional.

import Foundation

@objc protocol MyProtocol {
    @objc optional func optionalMethod()
    func requiredMethod()
}

class MyClass: MyProtocol {
    func requiredMethod() {
        print("Реализация обязательного метода")
    }

    func optionalMethod() {
        print("Реализация опционального метода")
    }
}

class MySecondClass: MyProtocol {
    func requiredMethod() {
        print("Реализация обязательного метода во втором классе")
    }
    // Опциональный метод не реализован
}

let myObject = MyClass()
myObject.optionalMethod?()  // Вывод: "Реализация опционального метода"
myObject.requiredMethod()  // Вывод: "Реализация обязательного метода"

let mySecondObject = MySecondClass()
mySecondObject.optionalMethod?()  // Ничего не происходит, метод не вызывается
mySecondObject.requiredMethod()  // Вывод: "Реализация обязательного метода во втором классе"

В этом примере MyClass реализует как опциональный, так и обязательный методы, тогда как MySecondClass реализует только обязательный метод. Вызов optionalMethod происходит с использованием синтаксиса опционального вызова (?()), что безопасно, даже если метод не реализован.
Альтернативы:

Если вы хотите избежать использования @objc и Objective-C совместимости, вы можете рассмотреть другие подходы, такие как:

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

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

Эти методы позволяют достичь похожей гибкости без необходимости совместимости с Objective-C.

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что используется для многопоточности в IOS ?
Спросят с вероятностью 27%

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

1️⃣Grand Central Dispatch (GCD)
Это низкоуровневый API для многозадачности, основанный на очередях. GCD позволяет выполнять задачи асинхронно или синхронно в различных очередях. Очереди могут быть последовательными (serial) или параллельными (concurrent). GCD автоматически управляет пулом потоков, что упрощает работу с многопоточностью.

DispatchQueue.global(qos: .background).async {
    // Выполнить тяжёлую операцию в фоновом потоке
    let result = performHeavyComputation()
    DispatchQueue.main.async {
        // Вернуться к главному потоку для обновления UI
        self.updateUI(with: result)
    }
}

2️⃣Operation и OperationQueue
Это абстрактный класс, который представляет собой одиночную задачу. Задачи, представленные операциями (Operation), могут быть добавлены в OperationQueue, который управляет их параллельным или последовательным выполнением. Operation и OperationQueue предоставляют больше контроля и гибкости по сравнению с GCD, позволяя устанавливать зависимости между операциями, приостанавливать и возобновлять их выполнение.

let operationQueue = OperationQueue()

let operation1 = BlockOperation {
    // Выполнить задачу 1
}

let operation2 = BlockOperation {
    // Выполнить задачу 2
}

operation2.addDependency(operation1) // Задача 2 не начнется, пока не завершится задача 1
operationQueue.addOperations([operation1, operation2], waitUntilFinished: false)

3️⃣async/await (Swift 5.5 и выше)
async/await упрощает асинхронное программирование, делая асинхронный код более читабельным и похожим на синхронный. Это существенно упрощает работу с асинхронными операциями, такими как сетевые запросы или долгие вычисления, и обеспечивает более безопасное и удобное управление потоками.

func fetchData() async throws -> Data {
    let url = URL(string: "https://example.com/data")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// Где-то в асинхронном контексте
Task {
    do {
        let data = try await fetchData()
        // Обработка данных
    } catch {
        // Обработка ошибки
    }
}

Для реализации многопоточности применяются Grand Central Dispatch (GCD), Operation и OperationQueue для управления асинхронными операциями и параллельным выполнением задач. С появлением Swift 5.5 добавился новый удобный способ работы с асинхронностью через async/await, который делает код более читабельным и упрощает работу с асинхронными операциями.

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Можно ли добавить структуру в extension ?
Спросят с вероятностью 18%

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

Что можно добавить через него:
1️⃣Методы экземпляра и типа
2️⃣Вычисляемые свойства экземпляра и типа
3️⃣Новые инициализаторы (только для структур и классов в том же файле)
4️⃣Определения протоколов
5️⃣Вложенные типы

Что нельзя добавить через него:
✅Хранимые свойства
✅Свойства свойства наблюдателя

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

Расширение структуры с новым методом:

struct Point {
    var x: Int
    var y: Int
}

extension Point {
    func isToTheRightOf(x: Int) -> Bool {
        return self.x > x
    }
}

let somePoint = Point(x: 10, y: 5)
print(somePoint.isToTheRightOf(x: 4))  // Вывод: true

Добавление вычисляемого свойства:

extension Point {
    var isOrigin: Bool {
        return x == 0 && y == 0
    }
}

let originPoint = Point(x: 0, y: 0)
print(originPoint.isOrigin)  // Вывод: true

Добавление нового инициализатора (только в том же файле для классов, для структур такое ограничение отсутствует):

extension Point {
    init() {
        self.init(x: 0, y: 0)
    }
}

let defaultPoint = Point()
print(defaultPoint)  // Вывод: Point(x: 0, y: 0)

Ответ на ваш вопрос
Можно определить вложенный тип внутри расширения.

Пример:

extension Array where Element: Numeric {
    struct Summary {
        var total: Element
        var count: Int
    }
    
    var summary: Summary {
        return Summary(total: self.reduce(0, +), count: self.count)
    }
}

let numbers = [1, 2, 3, 4, 5]
let numbersSummary = numbers.summary
print("Total: \(numbersSummary.total), Count: \(numbersSummary.count)")  // Вывод: Total: 15, Count: 5

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Можно ли добавить структуру в extension ?
Спросят с вероятностью 18%

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

Что можно добавить через него:
1️⃣Методы экземпляра и типа
2️⃣Вычисляемые свойства экземпляра и типа
3️⃣Новые инициализаторы (только для структур и классов в том же файле)
4️⃣Определения протоколов
5️⃣Вложенные типы

Что нельзя добавить через него:
✅Хранимые свойства
✅Свойства свойства наблюдателя

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

Расширение структуры с новым методом:

struct Point {
    var x: Int
    var y: Int
}

extension Point {
    func isToTheRightOf(x: Int) -> Bool {
        return self.x > x
    }
}

let somePoint = Point(x: 10, y: 5)
print(somePoint.isToTheRightOf(x: 4))  // Вывод: true

Добавление вычисляемого свойства:

extension Point {
    var isOrigin: Bool {
        return x == 0 && y == 0
    }
}

let originPoint = Point(x: 0, y: 0)
print(originPoint.isOrigin)  // Вывод: true

Добавление нового инициализатора (только в том же файле для классов, для структур такое ограничение отсутствует):

extension Point {
    init() {
        self.init(x: 0, y: 0)
    }
}

let defaultPoint = Point()
print(defaultPoint)  // Вывод: Point(x: 0, y: 0)

Ответ на ваш вопрос
Можно определить вложенный тип внутри расширения.

Пример:

extension Array where Element: Numeric {
    struct Summary {
        var total: Element
        var count: Int
    }
    
    var summary: Summary {
        return Summary(total: self.reduce(0, +), count: self.count)
    }
}

let numbers = [1, 2, 3, 4, 5]
let numbersSummary = numbers.summary
print("Total: \(numbersSummary.total), Count: \(numbersSummary.count)")  // Вывод: Total: 15, Count: 5

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какие можно выделить главные принципы ООП ?
Спросят с вероятностью 27%

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

1️⃣Инкапсуляция
Механизм ООП, который объединяет данные (атрибуты) и код (методы), манипулирующий этими данными, внутри одного объекта и скрывает детали реализации от внешнего использования. Это позволяет защитить внутреннее состояние объекта от прямого доступа извне и обеспечить контролируемый интерфейс для работы с этим объектом.

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

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

4️⃣Абстракция
Позволяет скрыть сложность системы, представляя её ключевые аспекты и скрывая детали реализации. Это достигается за счёт использования абстрактных классов и интерфейсов, которые определяют шаблон для классов-наследников. Абстракция помогает сосредоточиться на взаимодействии объектов на более высоком уровне, игнорируя ненужные детали.

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

👉 Можно посмотреть примеры как отвечают люди на этот вопрос, или перейти к списку 823 вопросов на IOS разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых