Swift difference between var arr:[String] = [] and var arr = [String]() - ios

Question

I want to create an empty array that will contain strings.
What are differences between the following two approaches and which one is better to use?
var arr:[String] = []
// versus
var arr = [String]()

Answer 1

AFAIU, the first approach is essentially equivalent to Array<String>(arrayLiteral: ...) with empty set of literals. The second one is just Array<String>(). Despite same end result, the latter should be more preferable just because it takes less to execute. You can explore this for yourself by debugging both options with stepping into instructions.

Answer 2

The first one, var arr:[String] = [] is usually used for adding values upon initialisation. You could create an empty array like this, but usually you would do the second one to create the empty array: var are = [String]().
Either one is acceptable, but usually you would use the first for adding values on initialisation, just like you would with normal variables: you would normally write something like this:
var exampleVariable:String = "Example String"
and to compare the second, it would be like writing:
var exampleVariable = String()
Simply, you are adding the square brackets to show you are making an array.

Answer 3

I'm answering very late this question because it's missing, in my opinion they key words Type Annotation & Type Inference.
var arr: [String] = []
You are declaring a variable arr of type [String] (array of String), with the : [String] part. It's the Type Annotation
Then you assign its value with [], ie create an empty array, and since the compiler knows it's an array of String, it will create an empty array of string.
var arr = [String]()
You are creating a variable arr without specifying its type. Then, you intialize that variable, with an array of String ([String](), which is short for [String].init()).
Then, the compiler knows what's the type of arr with its initialization.
That's the Type Inference.
But if you write:
var arr = []
Compiler won't know what's arr, you need to tell it when declaring the variable with myVar: ItsType, or upon the initialization, if with = [String]().
So you'll get compiler error: Empty collection literal requires an explicit type.
Usually, using both is overkill, too verbose.
You could then also write:
// Using Type Annotation:
// Declaring the variable type, the initialization doesn't need to specify it
var arr: [String] = []
var arr: Array<String> = []
// Using Type inference:
// Initialization is expliciting the type, the type is then "guessed".
var arr = [String]()
var arr = [String].init()
var arr = Array<String>()
var arr = Array<String>.init()
// Using Type Annotation & Type Inference:
// Declaring the variable type, AND also the on the initialization
var arr: [String] = [String]()
var arr: [String] = [String].init()
var arr: Array<String> = [String]()
var arr: Array<String> = [String].init()
In my case, I prefer var arr: [String] = []. But that's my opinion.