# Swift Data Types Explained: Int, String, Double, Bool, and More

Source: https://devdocs10.com/articles/swift/swift-data-types  
By Murat Bo · Updated 2026-05-10 · DevDocs10 (https://devdocs10.com)

Swift data types define what kind of value a variable or constant can store. If you want to write correct Swift code, you need to understand the basic built-in types such as `Int`, `String`, `Double`, `Bool`, `Float`, and `Character`. In this guide, you will learn what each type does, how to use them in real code, how Swift infers types automatically, and how to avoid common mistakes like type mismatch errors.

> **Quick answer:** Swift data types describe the kind of data a value represents, such as whole numbers, text, decimal numbers, or true/false values. The most common basic types are `Int` for whole numbers, `String` for text, `Double` for decimal numbers, and `Bool` for true or false values.

> **Difficulty:** Beginner
>
> **Helpful to know first:** You'll understand this better if you know basic Swift syntax, how to declare variables and constants, and how simple values are printed with `print()`.

## 1. What Is Swift Data Types?

A data type tells Swift what kind of value is being stored or passed around in code. This matters because Swift is a type-safe language, which means it checks that you use values in sensible ways.

For example, a name should be stored as text, an age is usually a whole number, and a price may need a decimal number. Swift uses types to make these differences clear.

- `Int` stores whole numbers like `5` or `-12`.
- `String` stores text like `"Hello"`.
- `Double` stores decimal numbers like `3.14`.
- `Bool` stores `true` or `false`.
- `Float` also stores decimal numbers, but with less precision than `Double`.
- `Character` stores a single character like `"A"`.

Beginners often compare `Double` and `Float`, or `Character` and `String`. Those comparisons matter because the values may look similar, but Swift treats them as different types with different purposes.

## 2. Why Swift Data Types Matters

Data types matter because they help Swift catch mistakes early, make your code easier to read, and ensure operations behave correctly.

If Swift did not care about types, you could accidentally add text to a number, compare unrelated values incorrectly, or lose numeric precision without noticing. By enforcing types, Swift helps prevent many bugs at compile time.

In real programs, data types are used everywhere:

- User ages, scores, and counters often use `Int`.
- Names, messages, and file paths use `String`.
- Measurements, prices, and percentages often use `Double`.
- On/off states, conditions, and checks use `Bool`.
- Single letters or symbols may use `Character`.

> Swift's type system is one of the reasons Swift code is usually safer and easier to maintain than loosely typed code.

## 3. Basic Syntax

In Swift, you can declare a variable or constant with an explicit type, or let Swift infer the type from the assigned value.

### Declaring values with explicit types

This example shows the main built-in data types written clearly with type annotations.

```swift
let age: Int = 25
let name: String = "Maya"
let temperature: Double = 21.5
let isOpen: Bool = true
let grade: Character = "A"
```

Each line tells Swift exactly what kind of value is being stored. This is useful when you want your code to be extra clear.

### Using type inference

Swift can often determine the type automatically based on the value you assign.

```swift
let count = 10
let city = "London"
let price = 19.99
let isReady = false
```

Here, Swift infers that `count` is an `Int`, `city` is a `String`, `price` is a `Double`, and `isReady` is a `Bool`.

### Reading the core idea

The main rule is simple: the value and the type must match. If they do not match, Swift usually gives a compile-time error instead of letting incorrect code run.

## 4. Step-by-Step Examples

### Example 1: Using Int for whole numbers

Use `Int` when you need numbers without decimal places, such as a score or quantity.

```swift
let apples = 4
let oranges = 6
let totalFruit = apples + oranges

print(totalFruit)
```

Output (tested with Swift 6.4):

```text
10
```

This prints `10`. Because all values are whole numbers, `Int` is the natural choice.

### Example 2: Using String for text

Use `String` when you need words, sentences, or other text data.

```swift
let firstName = "Sam"
let lastName = "Lee"
let fullName = firstName + " " + lastName

print(fullName)
```

Output (tested with Swift 6.4):

```text
Sam Lee
```

This prints `Sam Lee`. Swift uses `+` to join strings together.

### Example 3: Using Double for decimal values

Use `Double` for decimal values such as prices, distances, or averages.

```swift
let itemPrice = 12.5
let tax = 1.25
let totalPrice = itemPrice + tax

print(totalPrice)
```

Output (tested with Swift 6.4):

```text
13.75
```

This prints `13.75`. Because the numbers include decimal places, Swift infers `Double`.

### Example 4: Using Bool for conditions

Use `Bool` when something can be true or false.

```swift
let isLoggedIn = true

if isLoggedIn {
    print("Welcome back!")
} else {
    print("Please sign in.")
}
```

Output (tested with Swift 6.4):

```text
Welcome back!
```

A boolean value is commonly used in conditions because `if` statements expect a `Bool`.

### Example 5: Character vs String

A single letter may look like a short string, but Swift distinguishes `Character` from `String`.

```swift
let letter: Character = "Z"
let word: String = "Zebra"

print(letter)
print(word)
```

Output (tested with Swift 6.4):

```text
Z
Zebra
```

`letter` stores one character, while `word` stores a sequence of characters. Even though both use double quotes in Swift, they are still different types.

## 5. Practical Use Cases

- Use `Int` for item counts, page numbers, scores, IDs that are truly numeric, and loop counters.
- Use `String` for names, email addresses, search terms, messages, URLs, and labels.
- Use `Double` for prices, ratings, distances, percentages, durations, and scientific measurements.
- Use `Bool` for flags such as `isAdmin`, `isHidden`, or `hasPermission`.
- Use `Character` when you specifically need one symbol, such as a grade letter or menu shortcut key.
- Use `Float` mainly when working with APIs or performance-sensitive code that specifically requires it.

## 6. Common Mistakes

### Mistake 1: Mixing Int and Double without conversion

Swift does not automatically mix numeric types in arithmetic expressions. Even though `Int` and `Double` are both numbers, they are not interchangeable.

**Problem:** This code tries to add an `Int` and a `Double` directly, which causes a type mismatch error such as `Binary operator '+' cannot be applied to operands of type 'Int' and 'Double'`.

```swift
let items = 3
let pricePerItem = 4.99
let total = items + pricePerItem
```

**Fix:** Convert one value so both sides use the same numeric type.

```swift
let items = 3
let pricePerItem = 4.99
let total = Double(items) * pricePerItem
```

The corrected version works because both values are treated as `Double` before the calculation.

### Mistake 2: Treating a String like a number

Text that looks like a number is still text if it is stored in a `String`. Swift will not automatically treat it as numeric data.

**Problem:** This code tries to add a string and an integer, which leads to a compile-time error such as `Binary operator '+' cannot be applied to operands of type 'String' and 'Int'`.

```swift
let quantityText = "5"
let extraItems = 2
let totalItems = quantityText + extraItems
```

**Fix:** Convert the string to an integer first if it truly represents a number.

```swift
let quantityText = "5"
let extraItems = 2

if let quantity = Int(quantityText) {
    let totalItems = quantity + extraItems
    print(totalItems)
}
```

Output (tested with Swift 6.4):

```text
7
```

The corrected version works because the text is safely converted into an `Int` before arithmetic is performed.

### Mistake 3: Using text instead of Bool in conditions

In some languages, developers write values like `"true"` as text and expect them to behave like booleans. Swift does not allow that.

**Problem:** An `if` statement requires a `Bool`, not a `String`, so this code fails with an error such as `Cannot convert value of type 'String' to expected condition type 'Bool'`.

```swift
let isMember = "true"

if isMember {
    print("Discount applied")
}
```

**Fix:** Store true/false values using the `Bool` type.

```swift
let isMember = true

if isMember {
    print("Discount applied")
}
```

Output (tested with Swift 6.4):

```text
Discount applied
```

The corrected version works because the condition now uses an actual boolean value.

### Mistake 4: Confusing Character with String

A single letter and a piece of text may look similar, but Swift still treats them as separate types.

**Problem:** This code assigns a string value to a variable declared as `Character`, but the value contains more than one character.

```swift
let initial: Character = "AB"
```

**Fix:** Use a single-character value for `Character`, or change the type to `String`.

```swift
let initial: Character = "A"
let initials: String = "AB"
```

The corrected version works because each value now matches the declared type exactly.

## 7. Best Practices

### Use the most accurate type for the job

Choosing the right type makes your code easier to understand and helps prevent mistakes. Do not use text for values that should be numeric or boolean.

```swift
// Less preferred
let ageText = "30"

// Preferred
let age = 30
```

The preferred version is better because the data is stored in a form that matches how it will be used.

### Prefer type inference when the type is obvious

Swift's type inference keeps code shorter and cleaner. Use explicit types when they improve clarity, not by default everywhere.

```swift
// Less preferred when the type is already obvious
let username: String = "coder123"

// Preferred
let username = "coder123"
```

This keeps the code readable while still letting Swift know exactly what type to use.

### Use Double as the default decimal type

In standard Swift code, `Double` is usually the better default for decimal numbers because it offers more precision than `Float`.

```swift
// Less preferred unless an API specifically needs Float
let distance: Float = 5.75

// Preferred
let distance: Double = 5.75
```

This is a good default choice for most everyday calculations in Swift.

### Choose clear boolean names

Boolean values are easier to read when their names sound like yes/no questions or states.

```swift
// Less preferred
let status = true

// Preferred
let isAvailable = true
```

The second name makes conditions much easier to read later in the code.

## 8. Limitations and Edge Cases

- Swift does not automatically convert between most types. You must convert values explicitly when needed.
- `Double` and `Float` can store decimal values, but they can still have rounding behavior because they use binary floating-point representation.
- `Int` stores whole numbers only. If you divide integers, you may lose the fractional part unless you convert to `Double`.
- `Character` is not the same as a one-character `String`, even if the value looks similar.
- Type inference is helpful, but if a value's purpose is unclear, adding an explicit type can improve readability.
- Large numeric values can exceed the range of a type. For example, an `Int` cannot hold infinite-size numbers.

> A common "not working" situation is integer division. For example, `5 / 2` gives `2` with `Int` values, not `2.5`. Convert to `Double` if you need a fractional result.

## 9. Practical Mini Project

This small program uses several Swift data types together to represent a simple product summary. It shows how whole numbers, decimals, text, and booleans work together in one realistic example.

```swift
let productName: String = "Wireless Mouse"
let quantity: Int = 2
let pricePerItem: Double = 24.99
let isInStock: Bool = true
let categoryCode: Character = "E"

let totalCost = Double(quantity) * pricePerItem

print("Product:", productName)
print("Quantity:", quantity)
print("Price per item:", pricePerItem)
print("In stock:", isInStock)
print("Category code:", categoryCode)
print("Total cost:", totalCost)
```

Output (tested with Swift 6.4):

```text
Product: Wireless Mouse
Quantity: 2
Price per item: 24.99
In stock: true
Category code: E
Total cost: 49.98
```

This example is useful because each value uses a type that matches its meaning. The final line also shows explicit type conversion from `Int` to `Double` before multiplication.

## 10. Key Points

- `Int` stores whole numbers, while `Double` and `Float` store decimal numbers.
- `String` stores text, and `Character` stores a single character.
- `Bool` stores only `true` or `false`.
- Swift can infer types automatically from assigned values.
- Swift does not automatically convert between most types, so explicit conversion is often required.
- Using the correct data type makes code safer, clearer, and easier to maintain.

## 11. Practice Exercise

Build a small profile summary using multiple Swift data types.

- Create a `String` for a user's name.
- Create an `Int` for the user's age.
- Create a `Double` for the user's account balance.
- Create a `Bool` for whether the user is active.
- Print all four values in a readable format.

**Expected output:** A short summary showing the name, age, balance, and active status.

**Hint:** Choose the type that matches the meaning of each value, and use `print()` to display the result.

```swift
let name: String = "Ava"
let age: Int = 28
let balance: Double = 152.75
let isActive: Bool = true

print("Name:", name)
print("Age:", age)
print("Balance:", balance)
print("Active:", isActive)
```

Output (tested with Swift 6.4):

```text
Name: Ava
Age: 28
Balance: 152.75
Active: true
```

## 12. Final Summary

Swift data types are one of the first core ideas every Swift developer should understand. They tell Swift what kind of data a value contains and allow the compiler to catch mistakes early. The most common types you will use are `Int` for whole numbers, `String` for text, `Double` for decimal values, and `Bool` for true/false conditions.

You also saw that Swift supports type inference, which lets the compiler determine types automatically in many situations. At the same time, Swift remains strict about type safety, so you often need explicit conversions when working with different kinds of values. That strictness may feel limiting at first, but it helps you write safer and more predictable code.

A good next step is to learn about Swift variables and constants, operators, and type conversion in more detail. Those topics build directly on what you learned here and will help you use Swift data types more confidently in real programs.