espansione Swift
Si tratta di estendere una classe, struct, o il tipo di enumerazione esistente per aggiungere nuove funzionalità.
Le estensioni possono aggiungere nuove funzionalità a un tipo, ma non possono ignorare le funzionalità esistenti.
L'espansione Swift può:
- Aggiungere proprietà computazionali e le proprietà statiche computazionali
- metodi Esempi di metodi e tipi definiti
- Nuovo costruttore
- definizione standard
- Definizione e uso dei nuovi tipi nidificati
- Fare una linea esistente con un tipo di protocollo
grammatica
dichiarazioni di estensione utilizzanol'estensione parola chiave:
extension SomeType {
// 加到SomeType的新功能写到这里
}
Un'estensione può estendere un tipo esistente, può essere adattato per uno o più protocolli, sintassi è la seguente:
extension SomeType: SomeProtocol, AnotherProctocol {
// 协议实现写到这里
}
proprietà computazionali
Le estensioni possono aggiungere un esempio calcolato di il tipo di proprietà e le proprietà computazionali ai tipi esistenti.
Esempi
L'esempio seguente aggiunge cinque proprietà per l'esempio di calcolo del tipo Int ed estendere le sue funzionalità:
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)")
L'output sopra l'esecuzione del programma è il seguente:
加法运算后的值：103 减法运算后的值：110 乘法运算后的值：390 除法运算后的值: 11 混合运算结果：154
costruttore
Le estensioni possono aggiungere nuovi costruttori per tipi esistenti.
Ciò consente di estendere ad altri tipi, il proprio tipo personalizzato come un argomento del costruttore, o il tipo di opzioni di inizializzazione aggiuntive non incluse nella realizzazione originale fornito.
Le estensioni possono aggiungere nuove costruttore convenienza per l'init () della classe, ma non possono aggiungere nuove designato costruttore o distruttore deinit alla classe ().
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)")
L'output sopra l'esecuzione del programma è il seguente:
mult 模块内 (100, 200) mult 模块内 (200, 100) mult 模块内 (300, 500) mult 模块内 (300, 100) Sum 模块内:(100, 200) Diff 模块内: (200, 100)
modo
Le estensioni possono aggiungere nuovi metodi e metodi tipo di istanza di tipi esistenti.
L'esempio seguente aggiunge un nuovo metodo di istanza denominato argomenti di tipo Int:
extension Int {
func topics(summation: () -> ()) {
for _ in 0..<self {
summation()
}
}
}
4.topics({
print("扩展模块内")
})
3.topics({
print("内型转换模块内")
})
L'output sopra l'esecuzione del programma è il seguente:
扩展模块内 扩展模块内 扩展模块内 扩展模块内 内型转换模块内 内型转换模块内 内型转换模块内
La topics metodo utilizza una () -> () parametro singolo tipo, ad indicare che la funzione non ha parametri e non restituisce alcun valore.
Dopo aver definito l'estensione, è possibile chiamare per ogni intero topics metodi per raggiungere la funzione è quella di eseguire ripetutamente un compito:
metodo di istanza variabile
Esempi di metodi di estensioni che aggiungono possono anche modificare l'istanza stessa.
I tipi di struttura e enumerati modificare metodi di auto o di proprietà devono essere contrassegnati come metodo di mutare esempio, basta modificare l'implementazione originale del metodo stesso.
Esempi
L'esempio seguente aggiunge un nuovo metodo di modifica chiamato piazza per tipo Double di Swift per ottenere un calcolo del valore originale piazza:
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)")
L'output sopra l'esecuzione del programma è il seguente:
圆的面积为: 34.210935 圆的面积为: 105.68006 圆的面积为: 45464.070735
deponente
Le estensioni possono aggiungere nuovo indice di un tipo esistente.
Esempi
L'esempio seguente per Swift aggiunge un tipo di indice Int intero built-in. L'indice [n] Restituisce il numero decimale
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])
L'output sopra l'esecuzione del programma è il seguente:
2 6 5
tipi nidificati
È possibile espandere le classi, le strutture esistenti, e le enumerazioni aggiungere nuovi tipi nidificati:
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])
L'output sopra l'esecuzione del programma è il seguente:
10 20 30 40 50 50