Swift-Erweiterungen

Erweiterungen fügen einer vorhandenen Klasse, Struktur oder einem Enumerationstyp neue Funktionalität hinzu.

Erweiterungen können einem Typ neue Funktionalität hinzufügen, aber vorhandene Funktionalität nicht überschreiben.

Erweiterungen in Swift können:

Berechnete Eigenschaften und berechnete statische Eigenschaften hinzufügen
Instanzmethoden und Typmethoden definieren
Neue Initialisierer bereitstellen
Subscripts definieren
Neue verschachtelte Typen definieren und verwenden
Einen vorhandenen Typ an ein Protokoll anpassen

Syntax

Erweiterungsdeklarationen verwenden das Schlüsselwortextension：

extension SomeType {
    // 加到SomeType的新功能写到这里
}

Eine Erweiterung kann einen vorhandenen Typ erweitern, damit er einem oder mehreren Protokollen entspricht, mit dem folgenden Syntaxformat:

extension SomeType: SomeProtocol, AnotherProctocol {
    // 协议实现写到这里
}

Berechnete Eigenschaften

Erweiterungen können vorhandenen Typen berechnete Instanzeigenschaften und berechnete Typ-Eigenschaften hinzufügen.

Beispiel

Das folgende Beispiel fügt dem Int-Typ 5 berechnete Instanzeigenschaften hinzu und erweitert seine Funktionalität:

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)")

Die Ausgabe der obigen Programmausführung ist:

加法运算后的值：103
减法运算后的值：110
乘法运算后的值：390
除法运算后的值: 11
混合运算结果：154

Initialisierer

Erweiterungen können vorhandenen Typen neue Initialisierer hinzufügen.

Dadurch können Sie andere Typen erweitern, Ihre eigenen benutzerdefinierten Typen als Initialisiererparameter verwenden oder zusätzliche Initialisierungsoptionen bereitstellen, die in der ursprünglichen Implementierung des Typs nicht enthalten sind.

Erweiterungen können Klassen neue Convenience-Initialisierer init() hinzufügen, aber sie können Klassen keine neuen designierten Initialisierer oder Deinitialisierer deinit() hinzufügen.

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)")

Die Ausgabe der obigen Programmausführung ist:

getMult sum(100, 200)
getMult diff(200, 100)

Methoden

Erweiterungen können vorhandenen Typen neue Instanzmethoden und Typmethoden hinzufügen.

Das folgende Beispiel fügt dem Int-Typ eine neue Instanzmethode namens topics hinzu:

extension Int {
   func topics(summation: () -> ()) {
      for _ in 0..<self {
         summation() 
      }
   }
}  

4.topics({
   print("扩展模块内")       
})    
    
3.topics({
   print("内型转换模块内")       
})

Die Ausgabe der obigen Programmausführung ist:

Within the extension module

DiestopicsMethode verwendet einen() -> ()einzelnen Parameter vom Typ, der angibt, dass die Funktion keine Parameter und keinen Rückgabewert hat.

Nach dem Definieren dieser Erweiterung können Sie für jede Ganzzahltopicsdie Methode aufrufen, die die Funktionalität implementiert, eine Aufgabe mehrmals auszuführen:

Mutierende Instanzmethoden

Durch Erweiterungen hinzugefügte Instanzmethoden können auch die Instanz selbst ändern.

In Strukturen und Aufzählungstypen müssen Methoden, die self oder dessen Eigenschaften ändern, die Instanzmethode als mutating kennzeichnen, genau wie es die Änderungsmethoden aus der ursprünglichen Implementierung tun.

Beispiel

Das folgende Beispiel fügt dem Double-Typ von Swift eine neue mutierende Methode namens square hinzu, um die Quadratberechnung des ursprünglichen Werts zu implementieren:

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)")

Die Ausgabe der obigen Programmausführung ist:

圆的面积为: 34.210935
圆的面积为: 105.68006
圆的面积为: 45464.070735

Subscripts

Erweiterungen können einem vorhandenen Typ neue Subscripts hinzufügen.

Beispiel

Das folgende Beispiel fügt dem integrierten Typ Int von Swift einen ganzzahligen Subscript hinzu. Der Subscript [n] gibt die Dezimalziffer zurück

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

Die Ausgabe der obigen Programmausführung ist:

2
6
5

Verschachtelte Typen

Erweiterungen können neue verschachtelte Typen zu vorhandenen Klassen, Strukturen und Aufzählungen hinzufügen:

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])

Die Ausgabe der obigen Programmausführung ist:

Andere Erweiterungen