Swift Tutorial
Swift Useful Resources
Selected Reading
- Swift - Access Control
- Swift - Generics
- Swift - Protocols
- Swift - Extensions
- Swift - Type Casting
- Swift - Optional Chaining
- Swift - ARC Overview
- Swift - Deinitialization
- Swift - Initialization
- Swift - Inheritance
- Swift - Subscripts
- Swift - Methods
- Swift - Properties
- Swift - Classes
- Swift - Structures
- Swift - Enumerations
- Swift - Closures
- Swift - Functions
- Swift - Dictionaries
- Swift - Sets
- Swift - Arrays
- Swift - Characters
- Swift - Strings
- Swift - Loops
- Swift - Decision Making
- Swift - Operators
- Swift - Literals
- Swift - Constants
- Swift - Tuples
- Swift - Optionals
- Swift - Variables
- Swift - Data Types
- Swift - Basic Syntax
- Swift - Environment
- Swift - Overview
- Swift - Home
Swift Useful Resources
Selected Reading
- Who is Who
- Computer Glossary
- HR Interview Questions
- Effective Resume Writing
- Questions and Answers
- UPSC IAS Exams Notes
Swift - Extensions
Swift - Extensions
Functionapty of an existing class, structure or enumeration type can be added with the help of extensions. Type functionapty can be added with extensions but overriding the functionapty is not possible with extensions.
Swift Extension Functionapties −
Adding computed properties and computed type properties
Defining instance and type methods.
Providing new initiapzers.
Defining subscripts
Defining and using new nested types
Making an existing type conform to a protocol
Extensions are declared with the keyword extension
Syntax
extension SomeType {
// new functionapty can be added here
}
Existing type can also be added with extensions to make it as a protocol standard and its syntax is similar to that of classes or structures.
extension SomeType: SomeProtocol, AnotherProtocol {
// protocol requirements is described here
}
Computed Properties
Computed 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 span: Int { return self / 5 }
}
let addition = 3.add
print("Addition is (addition)")
let subtraction = 120.sub
print("Subtraction is (subtraction)")
let multippcation = 39.mul
print("Multippcation is (multippcation)")
let spanision = 55.span
print("Division is (spanision)")
let mix = 30.add + 34.sub
print("Mixed Type is (mix)")
When we run the above program using playground, we get the following result −
Addition is 103 Subtraction is 110 Multippcation is 390 Division is 11 Mixed Type is 154
Initiapzers
Swift 4 provides the flexibipty to add new initiapzers to an existing type by extensions. The user can add their own custom types to extend the types already defined and additional initiapzation options are also possible. Extensions supports only init(). deinit() is not supported by the extensions.
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 ("Inside mult block (calc.a.num1, calc.a.num2)")
print("Inside mult block (calc.b.no1, calc.b.no2)")
let memcalc = mult(a: sum(num1: 300, num2: 500),b: diff(no1: 300, no2: 100))
print("Inside mult block (memcalc.a.num1, memcalc.a.num2)")
print("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)
print("Inside Sum Block:( a.num1, a.num2)")
let b = diff(no1: 200, no2: 100)
print("Inside Diff Block: (b.no1, b.no2)")
When we run the above program using playground, we get the following result −
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 type methods can be added further to the subclass with the help of extensions.
extension Int {
func topics(summation: () -> ()) {
for _ in 0..<self {
summation()
}
}
}
4.topics(summation: {
print("Inside Extensions Block")
})
3.topics(summation: {
print("Inside Type Casting Block")
})
When we run the above program using playground, we get the following result −
Inside Extensions Block Inside Extensions Block Inside Extensions Block Inside Extensions Block Inside Type Casting Block Inside Type Casting Block Inside Type Casting Block
topics() function takes argument of type (summation: () → ()) to indicate the function does not take any arguments and it won t return any values. To call that function multiple number of times, for block is initiapzed and call to the method with topic() is initiapzed.
Mutating Instance Methods
Instance methods can also be mutated when declared as extensions.
Structure and enumeration methods that modify self or its properties must mark the instance method as mutating, just pke mutating methods from an original implementation.
extension Double {
mutating func square() {
let pi = 3.1415
self = pi * self * self
}
}
var Trial1 = 3.3
Trial1.square()
print("Area of circle is: (Trial1)")
var Trial2 = 5.8
Trial2.square()
print("Area of circle is: (Trial2)")
var Trial3 = 120.3
Trial3.square()
print("Area of circle is: (Trial3)")
When we run the above program using playground, we get the following result −
Area of circle is: 34.210935 Area of circle is: 105.68006 Area of circle is: 45464.070735
Subscripts
Adding new subscripts to already declared instances can also be possible with extensions.
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])
When we run the above program using playground, we get the following result −
2 6 5
Nested Types
Nested types for class, structure and enumeration instances can also be extended with the help of extensions.
extension Int {
enum calc {
case add
case sub
case mult
case span
case anything
}
var print: calc {
switch self {
case 0:
return .add
case 1:
return .sub
case 2:
return .mult
case 3:
return .span
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 .span:
print(" 40 ")
default:
print(" 50 ")
}
}
}
result(numb: [0, 1, 2, 3, 4, 7])
When we run the above program using playground, we get the following result −
10 20 30 40 50 50Advertisements