Swift Language
Extensiones

Observaciones

Variables y funciones

Las extensiones pueden contener funciones y variables de obtención calculadas / constantes. Están en el formato.

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

Para hacer referencia a la instancia del objeto extendido, self puede usar self , tal como podría usarse

Para crear una extensión de String que agregue una función .length() que devuelva la longitud de la cadena, por ejemplo

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

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

Las extensiones también pueden contener variables get . Por ejemplo, agregar una variable .length a la cadena que devuelve la longitud de la cadena

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

"Hello, World!".length // 13

Inicializadores en extensiones

Las extensiones pueden contener inicializadores de conveniencia. Por ejemplo, un inicializador failable para Int que acepta un 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

¿Qué son las extensiones?

Las extensiones se utilizan para ampliar la funcionalidad de los tipos existentes en Swift. Las extensiones pueden agregar subíndices, funciones, inicializadores y propiedades computadas. También pueden hacer que los tipos se ajusten a los protocolos .

Supongamos que desea poder calcular el factorial de un Int . Puedes agregar una propiedad computada en una extensión:

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

Luego puede acceder a la propiedad como si se hubiera incluido en la API Int original.

let val1: Int = 10

val1.factorial  // returns 3628800

Extensiones de protocolo

Una característica muy útil de Swift 2.2 es tener la capacidad de extender protocolos.

Funciona casi como clases abstractas cuando se trata de una funcionalidad que desea que esté disponible en todas las clases que implementan algún protocolo (sin tener que heredar de una clase común básica).

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
    }
}

Esto también es posible usando genéricos.

Restricciones

Es posible escribir un método en un tipo genérico que sea más restrictivo usando la oración where.

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

Ejemplo de uso

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

Qué son las extensiones y cuándo usarlas.

Las extensiones agregan nueva funcionalidad a una clase, estructura, enumeración o tipo de protocolo existente. Esto incluye la capacidad de extender tipos para los que no tiene acceso al código fuente original.

Extensiones en Swift pueden:

• Añadir propiedades computadas y propiedades de tipo computadas
• Definir métodos de instancia y métodos de tipo.
• Proporcionar nuevos inicializadores
• Definir subíndices
• Definir y utilizar nuevos tipos anidados.
• Hacer que un tipo existente se ajuste a un protocolo.

Cuándo usar Swift Extensions:

• Funcionalidad adicional para Swift
• Funcionalidad adicional a UIKit / Foundation
• Funcionalidad adicional sin alterar el código de otras personas.
• Clases de desglose en: Datos / Funcionalidad / Delegado

Cuando no usar:

• Extiende tus propias clases desde otro archivo

Ejemplo simple:

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

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

Fuente

Subíndices

Las extensiones pueden agregar nuevos subíndices a un tipo existente.

Este ejemplo obtiene el carácter dentro de una cadena usando el índice dado:

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