Swift Data Types: Syntax, Usage, and Examples

Swift data types define the kind of values a variable or constant can store. Swift provides a strong and type-safe system that helps catch errors at compile time. Understanding data types is essential for writing efficient and bug-free Swift programs.

How to Use Data Types in Swift

Swift has built-in data types that cover numbers, text, and more complex structures. Use var for variables that change and let for constants. Swift infers types automatically but allows explicit type annotations.

var age: Int = 30       // Integer type
let name: String = "Alice"  // String type
var isActive: Bool = true   // Boolean type

Swift also supports type inference, meaning you can omit explicit type declarations.

var temperature = 25.5  // Swift infers Double
let message = "Hello"   // Swift infers String

To check a variable’s type at runtime, use type(of:).

print(type(of: temperature)) // Output: Double

When to Use Data Types in Swift

Choosing the correct data type ensures efficiency, safety, and readability. Use Swift data types for:

1. Storing Numeric Values

Different number types handle integer and floating-point calculations.

var distance: Double = 42.195  // Marathon distance in kilometers
let maxScore: Int = 100

2. Working with Text

Use String to store user input, messages, and formatted text.

var greeting = "Hello, world!"
greeting += " How are you?"
print(greeting)

3. Managing True/False States

Use Bool for conditions, user settings, and logic checks.

var isLoggedIn = false
isLoggedIn = true

Examples of Swift Data Types

Swift data types are widely used in applications. Here are some examples:

Using Integers

Swift provides Int and UInt (unsigned integer).

var count: Int = -10
var positiveCount: UInt = 20  // Cannot store negative numbers

Use Int.max and Int.min to check type limits.

print(Int.max)  // Maximum value for an Int
print(Int.min)  // Minimum value for an Int

Working with Floating-Point Numbers

Float and Double store decimal values.

var price: Float = 19.99
var pi: Double = 3.1415926535

Strings and Characters

Use String for text and Character for single characters.

var initial: Character = "A"
var sentence: String = "Swift is powerful."

Boolean Values

Booleans store true or false values.

let hasPermission: Bool = true
if hasPermission {
    print("Access granted")
} else {
    print("Access denied")
}

Arrays and Dictionaries

Collections store multiple values.

var colors: [String] = ["Red", "Green", "Blue"]
var ages: [String: Int] = ["Alice": 30, "Bob": 25]

Access elements using indices or keys.

print(colors[0])  // Output: Red
print(ages["Alice"]!)  // Output: 30

Learn More About Data Types in Swift

Swift has additional features for handling data types efficiently.

Type Conversion

Convert between data types using explicit initialization.

let number = 42
let doubleValue = Double(number)  // Converts Int to Double
print(doubleValue)  // Output: 42.0

Use String() to convert numbers to text.

let score = 85
let scoreText = String(score)
print("Your score is " + scoreText)

Optionals

Optionals handle missing values. Use ? to declare an optional variable.

var username: String? = nil
username = "Charlie"
print(username ?? "Guest")  // Output: Charlie

Tuples

Tuples store multiple values in a single variable.

let coordinates = (x: 10, y: 20)
print(coordinates.x)  // Output: 10

Type Aliases

Define custom type names for better readability.

typealias Age = Int
var userAge: Age = 25

Checking Type at Runtime

Use is and as? to check and cast types.

let value: Any = "Hello"
if value is String {
    print("It's a string")
}

Best Practices for Using Data Types in Swift

• Use type inference when possible – Let Swift determine the type automatically.
• Choose the most efficient type – Use Float for less precision, Double for high accuracy.
• Use optionals wisely – Avoid force unwrapping (!) unless necessary.
• Convert types explicitly – Prevent unexpected crashes by handling conversions properly.
• Use collections for grouped data – Arrays and dictionaries improve data organization.