Array creation and type inference in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is type inference in Swift when creating an array?

Type inference means Swift automatically figures out the type of the array based on the values you put inside it, so you don't have to write the type explicitly.

beginner

How do you create an empty array of integers in Swift?

You can create it by writing: var numbers: [Int] = [] or var numbers = [Int]().

beginner

What happens if you write <code>let fruits = ["Apple", "Banana", "Cherry"]</code> in Swift?

Swift infers that fruits is an array of strings: [String].

intermediate

Can Swift infer the type of an array if it contains mixed types like [1, "two", 3]?

No, Swift requires all elements in an array to be of the same type. Mixed types cause a compile error.

beginner

How do you create an array with repeated values in Swift?

Use Array(repeating: value, count: number). For example, Array(repeating: 0, count: 3) creates [0, 0, 0].

What type does Swift infer for let numbers = [1, 2, 3]?

A [Int]

B [Double]

C [String]

D [Any]

Swift sees all values are integers, so it infers the array type as [Int].

Which of these is a valid way to create an empty array of strings in Swift?

A var names = [String]

B var names = []

C var names = [1, 2, 3]

D var names: [String] = []

You must specify the type when creating an empty array, like var names: [String] = [].

What happens if you try to create let mixed = [1, "two", 3] in Swift?

A Swift infers [Any]

B Swift infers [String]

C Compile error due to mixed types

D Swift infers [Int]

Swift arrays must have elements of the same type; mixed types cause a compile error.

How do you create an array with five zeros in Swift?

A [0, 0, 0, 0, 0]

B Array(repeating: 0, count: 5)

C Array(0, 5)

D repeat(0, 5)

Use Array(repeating: 0, count: 5) to create an array with five zeros.

If you write var items = ["pen", "pencil"], what is the type of items?

A [String]

B [Character]

C [Any]

D [Int]

Swift infers the type as [String] because all elements are strings.

Explain how Swift uses type inference when you create an array with values.

Think about how Swift guesses the type based on what you put inside the array.

Describe two ways to create an empty array in Swift and why you might need to specify the type.

Remember empty arrays have no values, so Swift can't guess the type automatically.

Practice

1. What does Swift do when you create an array with values like [1, 2, 3] without specifying a type?

easy

A. Swift infers the array type as [Int] automatically.

B. Swift treats the array as [Any] type.

C. Swift throws a syntax error because type is missing.

D. Swift creates an empty array instead.

Solution

1. Step 1: Understand type inference with array literals

   When you write an array with values like [1, 2, 3], Swift looks at the values and guesses the type. Here, all values are integers.

2. Step 2: Determine the inferred type

   Since all values are integers, Swift infers the array type as [Int]. No explicit type declaration is needed.

3. Final Answer:

   Swift infers the array type as [Int] automatically. -> Option A

4. Quick Check:

   Array with integers = [Int] [OK]

Hint: Look at items; Swift guesses array type from them [OK]

Common Mistakes:

• Thinking Swift defaults to [Any]
• Assuming a syntax error without explicit type
• Believing empty array is created instead

2. Which of the following is the correct way to create an empty array of Strings in Swift?

easy

A. let names = []

B. let names = String[]

C. let names: [String] = []

D. let names = Array()

Solution

1. Step 1: Recognize empty array syntax with type annotation

   Empty arrays need a type so Swift knows what kind of items will be stored. let names: [String] = [] declares names as [String] and assigns an empty array.

2. Step 2: Check other options for correctness

   let names = [] lacks type info, so it's invalid. let names = String[] uses invalid syntax. let names = Array() creates an empty array but type is not specified, so it defaults to [Any].

3. Final Answer:

   let names: [String] = [] -> Option C

4. Quick Check:

   Empty array needs type annotation [OK]

Hint: Empty arrays must declare type explicitly [OK]

Common Mistakes:

• Omitting type for empty arrays
• Using Array() without type annotation
• Assuming [] alone is enough

3. What is the type of the array created by let numbers = [1, 2.5, 3] in Swift?

medium

A. [Int]

B. [Double]

C. [Float]

D. Error: mixed types not allowed

Solution

1. Step 1: Analyze the array elements' types

   The array contains 1 (Int), 2.5 (Double), and 3 (Int). Swift will promote Int values to Double to keep the array type consistent.

2. Step 2: Determine the inferred array type

   Because of the Double value 2.5, Swift infers the array type as [Double], converting Ints to Double.

3. Final Answer:

   [Double] -> Option B

4. Quick Check:

   Mixed Int and Double = [Double] [OK]

Hint: Mixed Int and Double become [Double] array [OK]

Common Mistakes:

• Assuming array is [Int]
• Expecting a syntax error for mixed types
• Thinking array becomes [Float]

4. Identify the error in this Swift code:

let items = []
items.append("apple")

medium

A. Cannot append to a constant array declared with let.

B. Array type cannot be inferred from empty array literal.

C. Appending a String to an array of Ints causes error.

D. No error; code runs fine.

Solution

1. Step 1: Check array declaration and type inference

   The array is declared as let items = [] with no type or initial values. Swift cannot guess the type from an empty array literal.

2. Step 2: Understand why append fails

   Because items is declared with let, it is immutable and cannot be appended to. To append, it must be declared with var.

3. Final Answer:

   Cannot append to a constant array declared with let. -> Option A

4. Quick Check:

   let arrays are immutable [OK]

Hint: let arrays cannot be modified after declaration [OK]

Common Mistakes:

• Thinking append fails because array type is unknown
• Assuming default array type is [Int]
• Believing code runs without error

5. You want to create an array that holds either integers or strings in Swift. Which approach correctly creates such an array?

hard

A. let mixed = Array()

B. let mixed = [1, "two", 3]

C. let mixed: [Int | String] = [1, "two", 3]

D. let mixed: [Any] = [1, "two", 3]

Solution

1. Step 1: Understand Swift's type system for mixed arrays

   Swift does not support union types like Int | String. To hold different types, use the type Any.

2. Step 2: Check each option for correctness

   let mixed: [Any] = [1, "two", 3] declares mixed as [Any] and initializes with Int and String values, which is valid. let mixed = [1, "two", 3] tries to infer type but fails due to mixed types. Options A and C use invalid syntax for union types.

3. Final Answer:

   let mixed: [Any] = [1, "two", 3] -> Option D

4. Quick Check:

   Mixed types array uses [Any] [OK]

Hint: Use [Any] for arrays with mixed types [OK]

Common Mistakes:

• Trying to infer mixed types without [Any]
• Using invalid union type syntax
• Assuming Swift allows Int | String type