Variables, Constants, and Data Types in Swift

# CHAPTER 4

Variables, Constants, and Data Types in Swift #

1. Introduction #

2. Learning Objectives #

• Clearly define the architectural difference between let and var.

• Understand Swift's powerful "Type Inference" engine.

• Explicitly annotate data types (Int, Double, Float, String, Bool).

• Understand the difference between Double and Float.

• Perform Type Conversion (Casting) to mix different data types safely.

• Use String Interpolation to inject variables into text.

3. let vs var (Immutability) #

• var (Variable): Mutable data. It can be changed.

• let (Constant): Immutable data. Once assigned, it is locked in memory forever.

Why use let? If you define let maxPlayers = 4, and a junior developer tries to write code later that accidentally sets maxPlayers = 5, the compiler will block them. It prevents human error and optimizes memory!

4. Type Inference (Swift is Smart) #

var username = "Alice" // Swift infers this is a String
username = "Bob"       // Allowed! It's still a String.
// username = 42       // ERROR! You cannot put an Integer into a String variable.

5. Explicit Data Types #

// Syntax: var name: Type = Value

var age: Int = 25
var pi: Double = 3.14159
var message: String = "Hello"
var isLoggedIn: Bool = true

6. The Core Data Types Explained #

• Int (Integer): Whole numbers only. Positives and negatives. (10, -5, 0).

• Double: High-precision decimal numbers. (3.14159265...). This is the default in Swift!

• Float: Low-precision decimal numbers. Takes up less memory, but less accurate. Rarely used today unless a specific game engine requires it.

• String: Text. Surrounded by " ".

• Bool (Boolean): Strictly true or false.

7. String Interpolation (Injecting Variables) #

let playerName = "Zelda"
let level = 50

// Injecting variables directly into the text!
print("Welcome back, \(playerName)! You are currently on Level \(level).")

8. Type Conversion (Casting) #

let wholeNumber: Int = 10
let decimalNumber: Double = 4.5

// let result = wholeNumber + decimalNumber // ERROR! Int + Double not allowed!

// Solution: Convert the Int into a Double for the math calculation!
let result = Double(wholeNumber) + decimalNumber
print(result) // Prints 14.5

Converting Strings to Integers (e.g., getting a phone number from a text box):

let stringAge = "25"
// Convert String to Int!
let realAge = Int(stringAge) 

9. Common Mistakes #

• Type Changing: JavaScript allows let data = 10; data = "Hello";. Swift does NOT. Once a variable is inferred as an Int, it is an Int for the rest of its life. Trying to assign a String to it later will crash the compiler.

• Float vs Double: If you write var math = 3.14, Swift infers it as a Double by default. If you try to pass that to a function that explicitly requires a Float, it will fail. Always rely on Double in iOS unless forced otherwise.

10. Best Practices #

• Let the Compiler Infer: You do not need to write var name: String = "Alice". Writing var name = "Alice" is cleaner and is the standard practice among Apple engineers. Only use explicit types (: String) when the variable starts off empty.

11. Exercises #

1. 1. Explicitly declare a variable named temperature of type Double and assign it 72.5.

1. 2. Use String Interpolation to print a sentence containing the temperature variable.

12. Coding Challenges #

13. MCQ Quiz with Answers #

14. Interview Questions #

• Q: Explain the concept of "Type Safety" in Swift. Provide an example of an operation that JavaScript would allow, but Swift's type-safety architecture would explicitly reject during compilation.

• Q: Contrast the Double and Float data types. Why does Swift's type inference engine default to Double when processing a decimal literal?

• Q: A developer attempts to add a String representing a number ("5") to an Int (10). Explain the explicit Type Conversion steps required to successfully execute this mathematical operation.

15. FAQs #

16. Summary #

17. Next Chapter Recommendation #