Swift ekspansji

To jest rozszerzenie istniejącej klasy, struct lub typu wyliczenia, aby dodać nowe funkcje.

Rozszerzenia mogą dodawać nowe funkcje do typu, ale nie może zastąpić istniejące funkcje.

Swift ekspansja może:

• Dodaj ogłoszenie obliczeniowych i obliczeniowe właściwości statycznych
• Przykłady metod i typy zdefiniowane metody
• Nowy konstruktor
• standardowa rozdzielczość
• Definicja i zastosowanie nowych typów zagnieżdżonych
• Złóż istniejącą linię z typem protokołu

gramatyka

Deklaracje rozszerzeń używaćrozszerzenia słów kluczowych:

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

Przedłużenie może rozciągać istniejącego typu, może być dostosowany do jednego lub większej liczby protokołów, składni jest następujący:

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

właściwości obliczeniowe

Rozszerzenia mogą dodać obliczoną przykład od rodzaju własności i właściwości obliczeniowych istniejących typów.

Przykłady

Poniższy przykład dodaje pięć właściwości na przykład obliczeniowy typu int i rozszerzyć jego funkcjonalność:

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

Wyjście powyżej wykonywanie programu jest:

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

konstruktor

Rozszerzenia mogą dodawać nowe konstruktorów do istniejących typów.

Pozwala to na przedłużenie inne typy, swój własny typ jako argument konstruktora lub rodzaju dodatkowych opcji inicjalizacji nie ujęte w pierwotnym realizacji usług.

Rozszerzenia mogą dodawać nowe konstruktora wygody klasy init (), ale nie mogą dodawać nowe wyznaczony konstruktora lub destruktora deinit z klasą ().

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

Wyjście powyżej wykonywanie programu jest:

mult 模块内 (100, 200)
mult 模块内 (200, 100)
mult 模块内 (300, 500)
mult 模块内 (300, 100)
Sum 模块内:(100, 200)
Diff 模块内: (200, 100)

sposób

Rozszerzenia mogą dodawać nowe sposoby i metody instancji typu do istniejących typów.

Poniższy przykład dodaje nową metodę instancji o nazwie tematy do typu int:

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

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

Wyjście powyżej wykonywanie programu jest:

扩展模块内
扩展模块内
扩展模块内
扩展模块内
内型转换模块内
内型转换模块内
内型转换模块内

topics Metoda wykorzystuje () -> () jeden parametr typu, co wskazuje, że funkcja nie posiada parametrów i nie zwraca wartości.

Po zdefiniowaniu rozszerzenie, możesz zadzwonić do dowolnej liczby całkowitej topics metod osiągnięcia tej funkcji jest do wykonania zadania wielokrotnie:

Zmienny metody instancji

Przykłady metod przez dodanie rozszerzeń można również modyfikować samej instancji.

Struktura i wymienione rodzaje modyfikacji własny lub własności metody muszą być oznaczone jako metody instancji mutowania, wystarczy zmodyfikować oryginalny wdrożenie metody z tego samego.

Przykłady

Poniższy przykład dodaje nową metodę modyfikacji o nazwie square do typu Double Swifta osiągnąć kwadratowy obliczenie pierwotnej wartości:

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

Wyjście powyżej wykonywanie programu jest:

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

indeks

Rozszerzenia można dodać nowy indeks do istniejącego typu.

Przykłady

Poniższy przykład SWIFT dodaje wbudowany typ indeksu Int całkowitą. Indeks [n] Zwraca liczbę dziesiętną

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

Wyjście powyżej wykonywanie programu jest:

2
6
5

zagnieżdżone typy

Można rozszerzyć istniejących klas, struktur i wyliczenia dodać nowe typy zagnieżdżone:

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

Wyjście powyżej wykonywanie programu jest:

 10 
 20 
 30 
 40 
 50 
 50