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

Generics in iOS Swift

The main use of Generic is avoid code duplication.
Generic placeholder is defined within angle brackets <>.

For example there are two array with different type.

let arrayOfInt = [5,10,15,20]

let arrayOfString = ["Karan","Ankur","Bunty"]

For print this array of value you can create two function like

func printInt(fromArrayOfInt arrayOfInt:[Int]){

    arrayOfInt.map({print($0)})

}

func printString(fromArrayOfString arrayOfString:[String]){

    arrayOfString.map({print($0)})

}

And use

printInt(fromArrayOfInt: arrayOfInt)

printString(fromArrayOfString: arrayOfString)

Output:

5

10

15

20

Karan

Ankur

Bunty

Now using Generic no need to create two function. We can print all type of array using single function like 

func printArray<T>(fromArray arrayOfValue: [T]){

    arrayOfValue.map({print($0)})

}

and calling is same

printArray(fromArray: arrayOfInt)

printArray(fromArray: arrayOfString)

In order to use Generic with struct, class or enum, you can define the Generic placeholder after the name. 

Github link : Generics

You can also watch video :