expansión rápida
Es extender una clase, estructura o tipo de enumeración existente para agregar nuevas características.
Las extensiones pueden añadir nuevas características a un tipo, pero no pueden reemplazar la funcionalidad existente.
La expansión Swift puede:
- Añadir propiedades computacionales y propiedades estáticas computacionales
- métodos de los ejemplos de métodos y tipos definidos
- nueva constructor
- definición estándar
- Definición y uso de los nuevos tipos anidados
- Hacer una línea existente con un tipo de protocolo
gramática
declaraciones de extensión utilizan laextensión de lapalabraclave:
extension SomeType {
// 加到SomeType的新功能写到这里
}
Una extensión puede extender un tipo existente, que se puede adaptar a uno o más protocolos, sintaxis es la siguiente:
extension SomeType: SomeProtocol, AnotherProctocol {
// 协议实现写到这里
}
propiedades computacionales
Las extensiones pueden añadir un ejemplo calculado del tipo de propiedad y propiedades computacionales a los tipos existentes.
Ejemplos
En el siguiente ejemplo se agrega cinco propiedades que el ejemplo de cálculo del tipo int y extender su funcionalidad:
extension Int {
var add: Int {return self + 100 }
var sub: Int { return self - 10 }
var mul: Int { return self * 10 }
var div: Int { return self / 5 }
}
let addition = 3.add
print("加法运算后的值：\(addition)")
let subtraction = 120.sub
print("减法运算后的值：\(subtraction)")
let multiplication = 39.mul
print("乘法运算后的值：\(multiplication)")
let division = 55.div
print("除法运算后的值: \(division)")
let mix = 30.add + 34.sub
print("混合运算结果：\(mix)")
La salida por encima de la ejecución del programa es:
加法运算后的值：103 减法运算后的值：110 乘法运算后的值：390 除法运算后的值: 11 混合运算结果：154
constructor
Las extensiones pueden añadir nuevos constructores de tipos existentes.
Esto le permite ampliar otros tipos, su propio tipo personalizado como un argumento del constructor, o el tipo de opciones adicionales de inicialización no incluidos en la implementación original proporcionado.
Las extensiones pueden añadir constructor de conveniencia a la clase init (), pero no pueden añadir nuevos constructor o destructor deinit designado a la clase ().
struct sum {
var num1 = 100, num2 = 200
}
struct diff {
var no1 = 200, no2 = 100
}
struct mult {
var a = sum()
var b = diff()
}
let calc = mult()
print ("mult 模块内 \(calc.a.num1, calc.a.num2)")
print("mult 模块内 \(calc.b.no1, calc.b.no2)")
let memcalc = mult(a: sum(num1: 300, num2: 500),b: diff(no1: 300, no2: 100))
print("mult 模块内 \(memcalc.a.num1, memcalc.a.num2)")
print("mult 模块内 \(memcalc.b.no1, memcalc.b.no2)")
extension mult {
init(x: sum, y: diff) {
_ = x.num1 + x.num2
_ = y.no1 + y.no2
}
}
let a = sum(num1: 100, num2: 200)
print("Sum 模块内:\( a.num1, a.num2)")
let b = diff(no1: 200, no2: 100)
print("Diff 模块内: \(b.no1, b.no2)")
La salida por encima de la ejecución del programa es:
mult 模块内 (100, 200) mult 模块内 (200, 100) mult 模块内 (300, 500) mult 模块内 (300, 100) Sum 模块内:(100, 200) Diff 模块内: (200, 100)
camino
Las extensiones pueden añadir nuevos métodos y métodos de tipo de instancia a los tipos existentes.
El siguiente ejemplo añade un nuevo método de instancia para asuntos nombrados Int tipo:
extension Int {
func topics(summation: () -> ()) {
for _ in 0..<self {
summation()
}
}
}
4.topics({
print("扩展模块内")
})
3.topics({
print("内型转换模块内")
})
La salida por encima de la ejecución del programa es:
扩展模块内 扩展模块内 扩展模块内 扩展模块内 内型转换模块内 内型转换模块内 内型转换模块内
El topics método utiliza una () -> () solo parámetro de tipo, lo que indica que la función no tiene parámetros y no devuelve ningún valor.
Después de definir la extensión, puede llamar a cualquier número entero topics métodos para lograr la función es llevar a cabo una tarea en varias ocasiones:
método de instancia de variable
Ejemplos de métodos de extensiones añadiendo también pueden modificar la instancia en sí.
Estructura y tipos enumerados modificar métodos de auto o de propiedad deben estar marcados como el método de instancia de mutar, basta con variar la implementación original del método de la misma.
Ejemplos
El siguiente ejemplo añade un nuevo método de modificación de llamada plaza de tipo doble de Swift para lograr un cálculo de valor original cuadrado:
extension Double {
mutating func square() {
let pi = 3.1415
self = pi * self * self
}
}
var Trial1 = 3.3
Trial1.square()
print("圆的面积为: \(Trial1)")
var Trial2 = 5.8
Trial2.square()
print("圆的面积为: \(Trial2)")
var Trial3 = 120.3
Trial3.square()
print("圆的面积为: \(Trial3)")
La salida por encima de la ejecución del programa es:
圆的面积为: 34.210935 圆的面积为: 105.68006 圆的面积为: 45464.070735
subíndice
Las extensiones pueden añadir nuevo índice para un tipo existente.
Ejemplos
El siguiente ejemplo para Swift agrega un índice Int tipo entero incorporado. El índice [n] Devuelve el número decimal
extension Int {
subscript(var multtable: Int) -> Int {
var no1 = 1
while multtable > 0 {
no1 *= 10
--multtable
}
return (self / no1) % 10
}
}
print(12[0])
print(7869[1])
print(786543[2])
La salida por encima de la ejecución del programa es:
2 6 5
tipos anidados
Puede ampliar las clases, las estructuras existentes, y enumeraciones añadir nuevos tipos anidados:
extension Int {
enum calc
{
case add
case sub
case mult
case div
case anything
}
var print: calc {
switch self
{
case 0:
return .add
case 1:
return .sub
case 2:
return .mult
case 3:
return .div
default:
return .anything
}
}
}
func result(numb: [Int]) {
for i in numb {
switch i.print {
case .add:
print(" 10 ")
case .sub:
print(" 20 ")
case .mult:
print(" 30 ")
case .div:
print(" 40 ")
default:
print(" 50 ")
}
}
}
result([0, 1, 2, 3, 4, 7])
La salida por encima de la ejecución del programa es:
10 20 30 40 50 50