Difference between various type of Variable declaration in swift

Question

I am quite a confused when and how to declare variables in particular points in Swift and its causing a headache for a new guy like me in SWIFT.

What is the difference between the following type of declarations? I have given my thoughts and understanding on them. Please rectify me with your solution if I am wrong and be a bit explanatory so that I can know the actual and exact answer.

  Array - 
   1) var arr = NSArray()//I think its an instance of immutable NSArray type
   2) var arr = NSMutableArray()
   3) var arr = Array()//I have no idea of difference between NSArray and Array type. Might be both are same
   4) var arr : NSMutableArray?//Creates an optional type but how is it different from line no.2
   5) var arr : NSMutableArray = []//creates an empty array NSMutableArray type and again how is it different from line no.2 & 3

Please clarify a bit clearly so that my confusion level would be a bit clear. Thanks

Answer 1

@G.Abhisek at first about you question. var arr: NSMutableArray = [] and var arr = NSMutableArray() means the same. the first one means, i ask the compiler to create a variable of type NSMutableArray and initialize it as an empty NSMutableArray. the second one means, i ask the compiler to create a variable and assign to it an empty initialized NSMutableArray. in the second case the compiler has to infer the right type of the variable, in the first case i did it by myself. still, the result will be the same. var arr1: Array<AnyObject> = [] and var arr2: NSMutableArray = [] are totally different things!. arr1 srores value type Array, arr2 stores reference to the instance of an empty NSMutableArray class. you can write let arr2: NSMutableArray = [] and next you can add an object there ... but you are not able to do thinks like arr2 = ["a","b"]. arr2 is constant, not variable, so the value stored there is imutable.

i am again close to my computer ... in the code below, you can see the main differences between swift and foundation arrays

import Foundation

let arr1: NSMutableArray = []
arr1.addObject("a")
arr1.addObject(10)
arr1.forEach {
    print($0, $0.dynamicType)
    /*
        a _NSContiguousString
        10 __NSCFNumber
    */
}

var arr2: Array<Any> = []
arr2.append("a")
arr2.append(10)
arr2.forEach {
    print($0, $0.dynamicType)
    /*
        a String
        10 Int
    */
}

var arr3: Array<AnyObject> = []
arr3.append("a")
arr3.append(10)
arr3.forEach {
    print($0, $0.dynamicType)
    /*
    a _NSContiguousString
    10 __NSCFNumber
    */
}

print(arr1.dynamicType, arr2.dynamicType, arr3.dynamicType)
// __NSArrayM Array<protocol<>> Array<AnyObject>

Answer 2

Array is a swift type where as NSArray is an objective C type. NS classes support dynamic-dispatch and technically are slightly slower to access than pure swift classes.

1) var arr = NSArray()

arr is an NSArray() here - you can re-assign things to arr but you can't change the contents of the NSArray() - this is a bad choice to use IMO because you've put an unusable array into the variable. I really can't think of a reason you would want to make this call.

2) var arr = NSMutableArray()

Here you have something usable. because the array is mutable you can add and remove items from it

3) var arr = Array()

This won't compile - but var arr = Array<Int>() will.

Array takes a generic element type ( as seen below)

public struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
    /// Always zero, which is the index of the first element when non-empty.
    public var startIndex: Int { get }
    /// A "past-the-end" element index; the successor of the last valid
    /// subscript argument.
    public var endIndex: Int { get }
    public subscript (index: Int) -> Element
    public subscript (subRange: Range<Int>) -> ArraySlice<Element>
}

4) var arr : NSMutableArray?

You are defining an optional array here. This means that arr starts out with a value of nil and you an assign an array to it if you want later - or just keep it as nil. The advantage here is that in your class/struct you won't actually have to set a value for arr in your initializer

5) var arr : NSMutableArray = []

It sounds like you are hung up on confusion about Optional values.

Optional means it could be nil or it could not

When you type something as type? that means it is nil unless you assign it something, and as such you have to unwrap it to access the values and work with it.