l'expansion Swift
Il est d'étendre une classe, struct ou type d'énumération existante pour ajouter de nouvelles fonctionnalités.
Les extensions peuvent ajouter de nouvelles fonctionnalités à un type, mais ne peuvent pas remplacer les fonctionnalités existantes.
L'expansion Swift peut:
- Ajouter des propriétés de calcul et des propriétés statiques de calcul
- méthodes Exemples de méthodes et types définis
- Nouveau constructeur
- définition standard
- Définition et utilisation des nouveaux types imbriqués
- Faire une ligne existante avec un type de protocole
grammaire
déclarations d'extension utilisentl'extension mot clé:
extension SomeType {
// 加到SomeType的新功能写到这里
}
Une extension peut s'étendre un type existant, il peut être adapté à un ou plusieurs protocoles, la syntaxe est la suivante:
extension SomeType: SomeProtocol, AnotherProctocol {
// 协议实现写到这里
}
propriétés Computational
Les extensions peuvent ajouter un exemple calculé le type de propriété et des propriétés de calcul à des types existants.
Exemples
L'exemple suivant ajoute cinq propriétés à l'exemple de calcul du type Int et étendre ses fonctionnalités:
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 sortie de l'exécution du programme ci-dessus est la suivante:
加法运算后的值：103 减法运算后的值：110 乘法运算后的值：390 除法运算后的值: 11 混合运算结果：154
constructeur
Les extensions peuvent ajouter de nouveaux constructeurs de types existants.
Cela vous permet d'étendre d'autres types, votre propre type personnalisé comme un argument du constructeur, ou le type d'options d'initialisation supplémentaires non incluses dans la mise en œuvre d'origine fourni.
Les extensions peuvent ajouter un nouveau constructeur de commodité à l'init classe (), mais ils ne peuvent pas ajouter de nouveaux constructeur ou destructeur deinit désigné à la 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)")
La sortie de l'exécution du programme ci-dessus est la suivante:
mult 模块内 (100, 200) mult 模块内 (200, 100) mult 模块内 (300, 500) mult 模块内 (300, 100) Sum 模块内:(100, 200) Diff 模块内: (200, 100)
manière
Les extensions peuvent ajouter de nouvelles méthodes et des méthodes de type d'instance pour les types existants.
L'exemple suivant ajoute une nouvelle méthode d'instance sujets nommés type Int:
extension Int {
func topics(summation: () -> ()) {
for _ in 0..<self {
summation()
}
}
}
4.topics({
print("扩展模块内")
})
3.topics({
print("内型转换模块内")
})
La sortie de l'exécution du programme ci-dessus est la suivante:
扩展模块内 扩展模块内 扩展模块内 扩展模块内 内型转换模块内 内型转换模块内 内型转换模块内
La topics méthode utilise un () -> () seul paramètre de type, indiquant que la fonction n'a pas de paramètres et aucune valeur de retour.
Après avoir défini l'extension, vous pouvez appeler pour tout entier topics méthodes pour atteindre la fonction est d'effectuer une tâche à plusieurs reprises:
méthode d'instance variable
Des exemples de méthodes par extensions ajoutant peuvent également modifier l'instance elle-même.
Les types de structure et énumérés modifient les méthodes d'auto ou de propriété doivent être marqués comme méthode d'instance de mutationniste, juste modifier la mise en œuvre initiale de la méthode de la même.
Exemples
L'exemple suivant ajoute une nouvelle méthode de modification appelée carré Double Type de Swift pour réaliser un calcul carré de la valeur d'origine:
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 sortie de l'exécution du programme ci-dessus est la suivante:
圆的面积为: 34.210935 圆的面积为: 105.68006 圆的面积为: 45464.070735
indice
Les extensions peuvent ajouter de nouveaux index pour un type existant.
Exemples
L'exemple suivant à Swift ajoute un type index Int entier intégré. L'indice [n] Renvoie le nombre décimal
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 sortie de l'exécution du programme ci-dessus est la suivante:
2 6 5
Les types imbriqués
Vous pouvez étendre les classes, les structures existantes, et énumérations ajouter de nouveaux types imbriqués:
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 sortie de l'exécution du programme ci-dessus est la suivante:
10 20 30 40 50 50