Swift Language
расширения

замечания

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

Расширения могут содержать функции и вычисленные / константные переменные get. Они в формате

extension ExtensionOf {
    //new functions and get-variables
}

Чтобы ссылаться на экземпляр расширенного объекта, можно использовать self , так же, как его можно использовать

Чтобы создать расширение String которое добавляет функцию .length() которая возвращает длину строки, например

extension String {
    func length() -> Int {
        return self.characters.count
    }
}

"Hello, World!".length() // 13

Расширения также могут содержать переменные get . Например, добавив переменную .length в строку, которая возвращает длину строки

extension String {
    var length: Int {
        get {
            return self.characters.count
        }
    }
}

"Hello, World!".length // 13

Инициализаторы в расширениях

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

extension Int {
    init?(_ string: NSString) {
        self.init(string as String)  // delegate to the existing Int.init(String) initializer
    }
}

let str1: NSString = "42"
Int(str1) // 42

let str2: NSString = "abc"
Int(str2) // nil

Что такое расширения?

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

Предположим, вы хотите иметь возможность вычислить факториал Int . Вы можете добавить вычисленное свойство в расширение:

extension Int {
    var factorial: Int {
        return (1..<self+1).reduce(1, combine: *)
    }
}

Затем вы можете получить доступ к объекту так же, как если бы он был включен в оригинальный Int API.

let val1: Int = 10

val1.factorial  // returns 3628800

Расширения протокола

Очень полезной особенностью Swift 2.2 является возможность расширения протоколов.

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

protocol FooProtocol {
    func doSomething()
}

extension FooProtocol {
    func doSomething() {
        print("Hi")
    }
}

class Foo: FooProtocol {
    func myMethod() {
        doSomething() // By just implementing the protocol this method is available
    }
}

Это также возможно с помощью дженериков.

ограничения

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

extension Array where Element: StringLiteralConvertible {
  func toUpperCase() -> [String] {
      var result = [String]()
      for value in self {
          result.append(String(value).uppercaseString)
      }
      return result
    }        
}

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

let array = ["a","b","c"]
let resultado = array.toUpperCase()

Что такое расширения и когда их использовать

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

Расширения в Swift могут:

• Добавить вычисленные свойства и свойства вычисленного типа
• Определение методов экземпляра и методов типа
• Предоставить новые инициализаторы
• Определение индексов
• Определить и использовать новые вложенные типы
• Сделать существующий тип соответствующим протоколу

Когда использовать Swift Extensions:

• Дополнительная функциональность для Swift
• Дополнительные возможности для UIKit / Foundation
• Дополнительная функциональность без возиться с кодом других лиц
• Классы разбивки на: Данные / Функциональность / Делегат

Когда не использовать:

• Расширьте свои собственные классы из другого файла

Простой пример:

extension Bool {
    public mutating func toggle() -> Bool {
        self = !self
        return self
    }
}

var myBool: Bool = true
print(myBool.toggle()) // false

Источник

Нижние индексы

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

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

extension String {
    subscript(index: Int) -> Character {
        let newIndex = startIndex.advancedBy(index)
        return self[newIndex]
    }
}

var myString = "StackOverFlow"
print(myString[2]) // a
print(myString[3]) // c

extension String {
    subscript(offset: Int) -> Character {
        let newIndex = self.index(self.startIndex, offsetBy: offset)
        return self[newIndex]
    }
}

var myString = "StackOverFlow"
print(myString[2]) // a
print(myString[3]) // c