Swift Enums

So far in this series we've stored data using strings, integers, arrays, dictionaries, and sets. But what happens when you want to store a value that can only ever be one of a fixed list of options? 🤔

That's exactly what enums are for.

---

😬 The Problem — Strings Are Dangerous

Let's say you're building an app that tracks which arc a user is currently watching in Naruto. You might start with a simple string:

var currentArc = "Chunin Exams"

Later in the code you update it:

currentArc = "Pain Invasion"

That looks fine. But what about this?

currentArc = "pain invasion" // lowercase — different string!
currentArc = "Pain Invasoin" // typo — Swift won't catch this
currentArc = "Chunin Exams " // trailing space — silently wrong

Swift won't complain about any of these. They're all valid strings. But your app logic will break in confusing, hard-to-debug ways because you made a tiny human mistake.

And beyond safety, strings are also inefficient. Do you really need to store all 13 characters of "Pain Invasion" just to track which arc someone is on? There has to be a better way. 🧐

---

✅ Enter Enums

An enum (short for enumeration) lets you define a brand new data type with a fixed list of possible values — called cases. You decide exactly what's allowed, and Swift enforces it for you.

Here's the arc tracker rewritten as an enum:

enum NarutoArc {
    case chuninExams
    case invasion
    case painInvasion
    case fourthGreatWar
    case boruto
}

Now instead of a freeform string, you use one of those exact cases:

var currentArc = NarutoArc.chuninExams
currentArc = NarutoArc.painInvasion

Try to use something that doesn't exist:

currentArc = NarutoArc.randomMadeUpArc // ❌ ERROR — Swift refuses to compile

Swift catches the mistake before your app even runs. That's the power of enums. 🔒

---

🧹 Cleaner Syntax

When you have lots of cases, you don't need to write case on every line — just separate them with commas:

enum NarutoArc {
    case chuninExams, invasion, painInvasion, fourthGreatWar, boruto
}

And once Swift knows the type of your variable, you can drop the enum name entirely in future assignments:

var currentArc = NarutoArc.chuninExams  // Swift now knows this is a NarutoArc
currentArc = .painInvasion              // ✅ No need to repeat NarutoArc
currentArc = .fourthGreatWar            // ✅ Clean and readable

Swift knows that .painInvasion must mean NarutoArc.painInvasion because currentArc can only ever be a NarutoArc. Less typing, same safety 🌸

---

⚡ Enums Are More Efficient Than Strings

Here's something that isn't immediately obvious — enums are actually much faster and lighter than strings under the hood.

When you write NarutoArc.painInvasion, Swift stores that as a simple number internally — something like 2. Compare that to storing the actual string "painInvasion" — that's 12 characters taking up real memory.

So enums give you:

• ✅ Human-readable names in your code
• ✅ Tiny, efficient storage behind the scenes
• ✅ Zero chance of typos or invalid values

---

🗺️ Another Example — Directions

A classic enum example that makes the benefit super clear:

enum Direction {
    case north
    case south
    case east
    case west
}

Without enums you might use integers — 1 for north, 2 for south, and so on. But who remembers what 3 means? And what stops someone from typing 5 by mistake?

var heading = Direction.north
heading = .west
heading = .south

This is instantly readable. No magic numbers. No guessing. Swift knows exactly what's valid and what isn't. 🧭

---

🎮 A Real-World Example

Let's build something more practical — a simple battle system for an RPG:

enum AttackType {
    case physical
    case magic
    case ranged
    case ultimate
}

var sasukesAttack = AttackType.magic
sasukesAttack = .ultimate

var narutosAttack = AttackType.physical
narutosAttack = .ultimate // He saved his Rasengan for last 😤

Now imagine if this was strings:

var sasukesAttack = "Magic"
sasukesAttack = "Ultimte" // Typo — Swift won't catch it, but your game will break

Enums make this kind of logic bulletproof. Your IDE (Xcode) will even show you a list of all valid cases the moment you type the dot — no documentation needed. 🎯

---

🆚 String vs Enum — Side by Side

	String	Enum
Typo protection	❌ None	✅ Compile-time error
Autocomplete in Xcode	❌ No	✅ Yes
Storage efficiency	❌ Stores every character	✅ Stored as a simple number
Fixed set of options	❌ Anything goes	✅ Only your defined cases
Readability	⚠️ Okay	✅ Crystal clear

---

🧩 Putting It All Together

Here's a mini example combining everything:

enum ChidoriVariant {
    case standard
    case chidoriSharp
    case chidoriStream
    case chidoriSenbon
}

var sasukesCurrentMove = ChidoriVariant.standard

print("Sasuke is using: \(sasukesCurrentMove)")

sasukesCurrentMove = .chidoriStream
print("Sasuke switched to: \(sasukesCurrentMove)")

// Try to use an invalid case
// sasukesCurrentMove = .rasengan ❌ — Swift won't allow it

Output:

Sasuke is using: standard
Sasuke switched to: chidoriStream

Clean, safe, and impossible to break with a typo 🔥

---

🌟 Wrap Up

Enums solve a real problem — they stop you from making subtle, hard-to-catch mistakes with freeform values like strings or magic numbers.

Here's what to remember:

• Enums define a fixed list of valid values — nothing outside that list is allowed
• Swift catches invalid cases at compile time — before your app even runs
• You can skip the enum name after the first assignment — just use .caseName
• Behind the scenes, enums are stored as simple numbers — fast and memory-efficient
• Xcode gives you full autocomplete on enum cases — no typos possible

And this is just the beginning — as you go deeper into Swift you'll discover that enums can do far more than what we've covered here. They are arguably one of Swift's most powerful features, and you'll see them absolutely everywhere in real iOS codebases. 💪

Next up, we'll look at type annotations — telling Swift explicitly what type a variable should be. See you there! 👋