Swift USES some of the basic extension features of extension
- 2020-05-14 05:00:26
- OfStack
The functionality of existing classes, structures, or enumerated types can be added with the help of extensions. Types of functionality can be added with extensions, but overridden functionality cannot be added with extensions.
Swift extension features:
Add the calculated property and calculate the type property Methods that define instances and types New initialization is provided Define the subscript Define and use new nested types Make the existing type conform to the protocolThe extension is declared with the keyword extension
grammar
extension SomeType {
// new functionality can be added here
}
An existing type can also be added as an extension 1 Two protocol standards and their syntax are similar to classes or structures.
extension SomeType: SomeProtocol, AnotherProtocol {
// protocol requirements is described here
}
Calculate attribute
Calculating the "instance" and "type" properties can also be extended with the help of extensions.
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
println("Addition is \(addition)")
let subtraction = 120.sub
println("Subtraction is \(subtraction)")
let multiplication = 39.mul
println("Multiplication is \(multiplication)")
let division = 55.div
println("Division is \(division)")
let mix = 30.add + 34.sub
println("Mixed Type is \(mix)")
When we run the above program using playground, we get the following results.
Addition is 103
Subtraction is 110
Multiplication is 390
Division is 11
Mixed Type is 154
The initializer
Swift has the flexibility to add to existing types by extending new initializations. Users can add their own custom types to extend defined types, as well as additional initialization options. The extension only supports init(). deinit() is not supported by the extension.
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()
println ("Inside mult block \(calc.a.num1, calc.a.num2)")
println("Inside mult block \(calc.b.no1, calc.b.no2)")
let memcalc = mult(a: sum(num1: 300, num2: 500),b: diff(no1: 300, no2: 100))
println("Inside mult block \(memcalc.a.num1, memcalc.a.num2)")
println("Inside mult block \(memcalc.b.no1, memcalc.b.no2)")
extension mult {
init(x: sum, y: diff) {
let X = x.num1 + x.num2
let Y = y.no1 + y.no2
}
}
let a = sum(num1: 100, num2: 200)
println("Inside Sum Block:\( a.num1, a.num2)")
let b = diff(no1: 200, no2: 100)
println("Inside Diff Block: \(b.no1, b.no2)")
When we run the above program using playground, we get the following results.
Inside mult block (100, 200)
Inside mult block (200, 100)
Inside mult block (300, 500)
Inside mult block (300, 100)
Inside Sum Block:(100, 200)
Inside Diff Block: (200, 100)
methods
New instance methods and types of methods can be added to subclasses one step further with the help of extensions.
extension Int {
func topics(summation: () -> ()) {
for _ in 0..<self {
summation()
}
}
}
4.topics({
println("Inside Extensions Block")
})
3.topics({
println("Inside Type Casting Block")
})
When we run the above program using playground, we get the following results.
Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Type Casting Block
Inside Type Casting Block
Inside Type Casting Block
The topics() function takes the summation: () - argument > The type of ()) indicates that the function takes no arguments and that it does not return any values. The function is called multiple times, the block is initialized, and the topic() method is called for initialization.
Deform different instance methods
An instance method can also be used as a variant of an extension declaration.
Modifying its own structure and counting methods or its properties must be annotated with instance method deformations, as if from an original implementation of the deformations method.
extension Double {
mutating func square() {
let pi = 3.1415
self = pi * self * self
}
}
var Trial1 = 3.3
Trial1.square()
println("Area of circle is: \(Trial1)")
var Trial2 = 5.8
Trial2.square()
println("Area of circle is: \(Trial2)")
var Trial3 = 120.3
Trial3.square()
println("Area of circle is: \(Trial3)")
When we run the above program using playground, we get the following results.
Area of circle is: 34.210935
Area of circle is: 105.68006
Area of circle is: 45464.070735
The subscript
Adding new label declared instances can also be extended.
extension Int {
subscript(var multtable: Int) -> Int {
var no1 = 1
while multtable > 0 {
no1 *= 10
--multtable
}
return (self / no1) % 10
}
}
println(12[0])
println(7869[1])
println(786543[2])
When we run the above program using playground, we get the following results.
2
6
5
Nested types
Nested types are classes, structures, and enumerated instances, which can also be extended with the help of extensions.
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:
println(" 10 ")
case .sub:
println(" 20 ")
case .mult:
println(" 30 ")
case .div:
println(" 40 ")
default:
println(" 50 ")
}
}
}
result([0, 1, 2, 3, 4, 7])
When we run the above program using playground, we get the following results.
10
20
30
40
50
50