Extensions Swift
Les extensions ajoutent de nouvelles fonctionnalités à une classe, une structure ou un type d'énumération existant.
Les extensions peuvent ajouter de nouvelles fonctionnalités à un type, mais ne peuvent pas redéfinir les fonctionnalités existantes.
Les extensions en Swift peuvent :
- Ajouter des propriétés calculées et des propriétés statiques calculées
- Définir des méthodes d'instance et des méthodes de type
- Fournir de nouveaux initialiseurs
- Définir des indices
- Définir et utiliser de nouveaux types imbriqués
- Rendre un type existant conforme à un protocole
Syntaxe
Les déclarations d'extension utilisent le mot-cléextension：
extension SomeType {
// 加到SomeType的新功能写到这里
}
Une extension peut étendre un type existant pour le rendre conforme à un ou plusieurs protocoles, avec le format de syntaxe suivant :
extension SomeType: SomeProtocol, AnotherProctocol {
// 协议实现写到这里
}
Propriétés calculées
Les extensions peuvent ajouter des propriétés calculées d'instance et des propriétés calculées de type à des types existants.
Exemple
L'exemple suivant ajoute 5 propriétés calculées d'instance au type Int et étend 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 :
加法运算后的值：103 减法运算后的值：110 乘法运算后的值：390 除法运算后的值: 11 混合运算结果：154
Initialiseurs
Les extensions peuvent ajouter de nouveaux initialiseurs à des types existants.
Cela vous permet d'étendre d'autres types, d'utiliser vos propres types personnalisés comme paramètres d'initialiseur, ou de fournir des options d'initialisation supplémentaires non incluses dans l'implémentation d'origine du type.
Les extensions peuvent ajouter de nouveaux initialiseurs de commodité init() aux classes, mais elles ne peuvent pas ajouter de nouveaux initialiseurs désignés ni de désinitialiseurs deinit() aux classes.
struct sum {
var num1 = 100, num2 = 200
}
struct diff {
var no1 = 200, no2 = 100
}
struct mult {
var a = sum()
var b = diff()
}
extension mult {
init(x: sum, y: diff) {
_ = x.num1 + x.num2
_ = y.no1 + y.no2
}
}
let a = sum(num1: 100, num2: 200)
let b = diff(no1: 200, no2: 100)
let getMult = mult(x: a, y: b)
print("getMult sum\(getMult.a.num1, getMult.a.num2)")
print("getMult diff\(getMult.b.no1, getMult.b.no2)")
La sortie de l'exécution du programme ci-dessus est :
getMult sum(100, 200) getMult diff(200, 100)
Méthodes
Les extensions peuvent ajouter de nouvelles méthodes d'instance et des méthodes de type à des types existants.
L'exemple suivant ajoute une nouvelle méthode d'instance nommée topics au 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 :
Within the extension module
Cecitopicsla méthode utilise un() -> ()paramètre unique de type, indiquant que la fonction n'a aucun paramètre et aucune valeur de retour.
Après avoir défini cette extension, vous pouvez appeler sur n'importe quel entiertopicsla méthode, qui implémente la fonctionnalité d'exécuter une tâche plusieurs fois :
Méthodes d'instance mutating
Les méthodes d'instance ajoutées via des extensions peuvent également modifier l'instance elle-même.
Dans les structures et les types d'énumération, les méthodes qui modifient self ou ses propriétés doivent marquer la méthode d'instance comme mutating, tout comme le font les méthodes de modification de l'implémentation d'origine.
Exemple
L'exemple suivant ajoute une nouvelle méthode de mutation nommée square au type Double de Swift pour implémenter le calcul du 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 :
圆的面积为: 34.210935 圆的面积为: 105.68006 圆的面积为: 45464.070735
Indices
Les extensions peuvent ajouter de nouveaux indices à un type existant.
Exemple
L'exemple suivant ajoute un indice entier au type Int intégré de Swift. L'indice [n] renvoie le chiffre décimal
extension Int {
subscript(multtable: Int) -> Int {
var powerOf10 = 1
var index = multtable
while index > 0 {
powerOf10 *= 10
index -= 1
}
return (self / powerOf10) % 10
}
}
print(12[0]) // 输出：2
print(7869[1]) // 输出：6
print(786543[2]) // 输出：5
La sortie de l'exécution du programme ci-dessus est :
2 6 5
Types imbriqués
Les extensions peuvent ajouter de nouveaux types imbriqués à des classes, structures et énumérations existantes :
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 :
10 20 30 40 50 50Autres extensions