Extensions

Extensions means add additional functionality to existing types.
Extensions add new functionality to existing class, struct, enum or protocols.
Extensions are similar to categories in Objective-C.

Extension syntax
Declare Extension with "extension" keyword

extension Type {

    ///Additional functionality add hear

}

An Extension can extends one or more protocols.

extension Type : Protocol{

    ///protocols method hear

}

Example

extension String{

    ///Trim string value

    func toTrim() -> String{

        return self.trimmingCharacters(in: .whitespacesAndNewlines)

    }

}

///Simply use like below

let strName = " use of string extension "

print(strName)

print(strName.toTrim())

Output : 

 use of string extension 

use of string extension

Another example

extension UIView {

    func defaultRadius() {

        self.layer.cornerRadius = self.frame.size.width / 2

    }

}

let parentView = UIView.init(frame: CGRect.init(x: 0, y: 0, width: 50, height: 50))

parentView.backgroundColor = UIColor.red

parentView.defaultRadius()

Output: 

UIView Extension

Computed Properties

Extension can add computed instance property and computed type property to existing type.

Example

extension Int{

    var squareRoot : Int {

        return self * self

    }

}

let iValue = 5

print(iValue.squareRoot)

Output : 

25

Methods

Extensions add new instance method and type method to existence type.

Example

extension Int{

    func repeatValue(value : () -> Void) {

        for _ in 0..<self{

            value()

        }

    }

}

5.repeatValue {

    print("hello world")

}

Output :

hello world

hello world

hello world

hello world

hello world

For more about Extensions watch below video

Optional Types

Optional represents either wrapped value or nil.
Optionals are generic enum type that works as wrapper.

Basically wrapper allow variable have 2 states:

1. User define type
2. nil (that represent no value)

In swift nil value must be optional.
Optional can be created by appending either "?" or "!".

example :

var name : String? = nil

var lname : String! = nil

"?" must be explicitly unwrapped where as "!" automatically unwrapped.

Conditionally unwrapped use "?" optional binding where as force unwrapped use "!" operator. If you force unwrapped variable and value is nil then program will throw exception and crash so be careful.

example :

var lname : String! = nil

print(lname!)

Output :

fatal error: unexpectedly found nil while unwrapping an Optional value

Safe unwrapping :

Using if-let statement safe unwrap

example :

func safeUnwrap(withName name : String?){

    if let userName = name{

        print(userName)

    }else{

        print("name value is nil")

    }

}

safeUnwrap(withName: "Pratik")

Output :

Pratik

safeUnwrap(withName: nil)

Output :

name value is nil

Using guard-let statement safe unwrap

example :

func safeUnwrap(withName name : String?){

    guard let userName = name else{

        print("user name not found")

        return

    }

    print(userName)

}

safeUnwrap(withName: "Pratik")

Output :

Pratik

safeUnwrap(withName: nil)

Output :

user name not found

Using Coalescing operator safe unwrap

example :

var name : String? = nil

print(name ?? "name value is nil")

Output :

name value is nil

var name : String? = nil

name = "Pratik"

print(name ?? "name value is nil")

Output :

Pratik

You can also use Optional chaining in order to call method,property or subscript.

example : 

struct Family{

    func printName() {

        print("Hello friends")

    }

}

var objFamily : Family?

objFamily?.printName()

Output :

no print 

var objFamily : Family? = Family()

objFamily?.printName()

Output :

Hello friends

Optional types unwrapped