Extension rapide
L'extension consiste à ajouter une nouvelle fonctionnalité à 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 remplacer les fonctionnalités existantes.
Les extensions dans Swift peuvent :
Ajouter des propriétés calculées et des propriétés statiques calculées
Définir des méthodes et des types d'instance Méthodes
fournir de nouveaux constructeurs
définir des indices
définir et utiliser de nouveaux types imbriqués
Rendre un type existant conforme à un protocole
Syntaxe
Déclaration d'extension à l'aide de mots-clésextension：
extension SomeType {
// 加到SomeType的新功能写到这里
} Une extension peut étendre un type existant afin qu'il puisse s'adapter à un ou plusieurs protocoles. Le format de syntaxe est le suivant :
extension SomeType: SomeProtocol, AnotherProctocol {
// 协议实现写到这里
}Attribut calculé
Les extensions peuvent ajouter des calculs. propriétés d'instance et propriétés de type calculées aux types existants.
Instance
L'exemple suivant ajoute 5 attributs d'instance calculés 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)")Le résultat de sortie de l'exécution du programme ci-dessus est :
加法运算后的值：103 减法运算后的值：110 乘法运算后的值：390 除法运算后的值: 11 混合运算结果：154
Constructeurs
Les extensions peuvent ajouter de nouveaux constructeurs aux types existants.
Cela vous permet d'étendre d'autres types, de transmettre vos propres types personnalisés en tant que paramètres de constructeur ou de fournir des options d'initialisation supplémentaires non incluses dans l'implémentation originale du type.
Les extensions peuvent ajouter un nouvel initialiseur pratique init() à une classe, mais elles ne peuvent pas ajouter un nouveau constructeur ou destructeur désigné deinit() à une 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)")Le résultat de l'exécution du programme ci-dessus est :
mult 模块内 (100, 200) mult 模块内 (200, 100) mult 模块内 (300, 500) mult 模块内 (300, 100) Sum 模块内:(100, 200) Diff 模块内: (200, 100)
Méthodes
Les extensions peuvent ajouter de nouvelles méthodes d'instance et des méthodes de type aux types existants.
L'exemple suivant ajoute une nouvelle méthode d'instance nommée sujets au type Int :
extension Int {
func topics(summation: () -> ()) {
for _ in 0..<self {
summation()
}
}
}
4.topics({
print("扩展模块内")
})
3.topics({
print("内型转换模块内")
})Le résultat de sortie de l'exécution du programme ci-dessus est :
扩展模块内 扩展模块内 扩展模块内 扩展模块内 内型转换模块内 内型转换模块内 内型转换模块内
This topics La méthode utilise Un seul paramètre de type () -> (), indiquant que la fonction n'a aucun paramètre ni aucune valeur de retour.
Après avoir défini cette extension, vous pouvez appeler la méthode topics sur n'importe quel entier pour effectuer une tâche plusieurs fois :
Méthode d'instance variable
Méthodes d'instance ajoutées par extension peut également modifier l'instance elle-même.
Les méthodes dans les structures et les types d'énumération qui modifient soi ou ses propriétés doivent marquer la méthode d'instance comme étant en mutation, tout comme la méthode de modification de l'implémentation d'origine.
Exemple
L'exemple suivant ajoute une nouvelle méthode de modification nommée square au type Double de Swift pour implémenter le calcul carré d'une valeur primitive :
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)")Ci-dessus Le résultat de sortie du programme l'exécution est :
圆的面积为: 34.210935 圆的面积为: 105.68006 圆的面积为: 45464.070735
Indice
L'extension peut ajouter un nouvel indice à un type existant.
Exemple
L'exemple suivant ajoute un indice entier au type intégré Swift Int. L'indice [n] renvoie un 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])Le résultat de l'exécution du programme ci-dessus est :
2 6 5
Le type imbriqué
peut être étendu aux classes existantes, Ajouter nouveaux types imbriqués dans les structures et les énumérations :
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])Le résultat de l'exécution du programme ci-dessus est :
10 20 30 40 50 50
