expansão Swift

É para estender uma classe, struct, ou tipo de enumeração existente para adicionar novos recursos.

As extensões podem adicionar novas funcionalidades a um tipo, mas não pode substituir a funcionalidade existente.

A expansão Swift pode:

• Adicione propriedades computacionais e propriedades estáticas computacionais
• Exemplos de métodos e métodos tipos definidos
• New construtor
• definição padrão
• Definição e à utilização dos novos tipos aninhados
• Faça uma linha existente com um tipo de protocolo

gramática

declarações de extensão usar a palavra-chavede extensão:

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

Uma extensão pode estender um tipo existente, ele pode ser adaptado a um ou mais protocolos, sintaxe é a seguinte:

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

propriedades computacionais

As extensões podem adicionar um exemplo calculada do tipo de propriedade e propriedades computacionais para tipos existentes.

Exemplos

O exemplo a seguir adiciona cinco propriedades para o exemplo de cálculo do tipo Int e estender sua funcionalidade:

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

A saída de execução de programa acima é:

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

construtor

As extensões podem adicionar novos construtores para tipos existentes.

Isso permite que você estenda outros tipos, o seu próprio tipo personalizado como um argumento do construtor, ou o tipo de opções de inicialização adicionais não incluídos na implementação original fornecido.

As extensões podem adicionar novos construtor conveniência para a inicialização de classe (), mas não podem adicionar novos designado construtor ou destrutor deinit à 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)")

A saída de execução de programa acima é:

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

caminho

As extensões podem adicionar novos métodos e métodos de tipo de instância para tipos existentes.

O exemplo a seguir adiciona um novo método da ocorrência temas nomeados para o tipo int:

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

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

A saída de execução de programa acima é:

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

O topics método usa um () -> () parâmetro único tipo, indicando que a função não tem parâmetros e nenhum valor de retorno.

Depois de definir a extensão, você pode chamar para qualquer inteiro topics métodos para atingir a função é executar uma tarefa repetidamente:

método de instância variável

Exemplos de métodos de extensões acrescentando também pode modificar a instância própria.

Estrutura e enumerados tipos modificar métodos de auto ou de propriedade deve ser marcado como o método de instância de mutação, basta modificar a implementação original do método a partir do mesmo.

Exemplos

O exemplo a seguir adiciona um novo método de modificação chamado quadrado para tipo Double do Swift para alcançar um cálculo valor original quadrado:

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

A saída de execução de programa acima é:

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

subscrito

As extensões podem adicionar novo índice para um tipo existente.

Exemplos

O exemplo a seguir para Swift adiciona um tipo de índice Int inteiro embutido. O índice [n] Retorna o número decimal

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

A saída de execução de programa acima é:

2
6
5

tipos aninhados

Pode expandir as classes, estruturas existentes e enumerações adicionar novos tipos aninhados:

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

A saída de execução de programa acima é:

 10 
 20 
 30 
 40 
 50 
 50