Clean Code in Swift: Principles and Examples for iOS/macOS

Clean Code in Swift: Principles and Practical Examples

Clean Code is not just a trendy term, but a fundamental skill for every developer working with Swift for iOS and macOS. In the Apple ecosystem, where projects often live for years and are maintained by different teams, the ability to write understandable, predictable, and easily modifiable code directly impacts development speed and the number of bugs. In this article, we will break down the key principles of Clean Code in Swift with specific examples that you can apply in your projects today.

Why is Clean Code Important for a Swift Developer?

Swift is a powerful and expressive language, but its flexibility can lead to chaos if discipline is not maintained. Clean Code solves three main problems:

• Readability: Another developer (or you in a month) should understand the code without effort.
• Maintainability: Adding new features should not break old logic.
• Testability: Clean code is easily covered by unit tests.

Let's move from theory to practice and look at the main principles.

Principle 1: Naming — The Foundation of Cleanliness

A good name for a variable, function, or class speaks for itself. In Swift, with its strong typing, this is especially important. Avoid abbreviations and single-letter names (except in loops).

Bad:

func calc(a: Int, b: Int) -> Int {    return a * b}

Good:

func calculateArea(width: Int, height: Int) -> Int {    return width * height}

Rule for Swift: Use CamelCase for variables and functions. Names should answer the questions "What is this?" or "What does it do?".

• Variable: userName, maxRetryCount
• Function: fetchData(), validateEmail()
• Class/Struct: UserProfile, NetworkService

Principle 2: Small Functions (Single Responsibility)

Each function should do only one thing. If a function takes more than 10-15 lines or has comments explaining blocks of code — this is a signal for refactoring. In Swift, this is especially relevant due to the use of closures and the functional approach.

Example of violation (one large method):

func processUserData(user: User) {    // Validation    guard user.email.contains("@") else { return }    // Save to DB    Database.shared.save(user)    // Send notification    NotificationCenter.default.post(name: .userSaved, object: nil)}

Clean Code (separation of concerns):

func processUserData(user: User) {    guard validateUser(user) else { return }    saveUser(user)    notifyUserSaved()}

private func validateUser(_ user: User) -> Bool {    return user.email.contains("@")}

private func saveUser(_ user: User) {    Database.shared.save(user)}

private func notifyUserSaved() {    NotificationCenter.default.post(name: .userSaved, object: nil)}

Now each function is easy to test, modify, and reuse.

Principle 3: Avoid Magic Numbers and Strings

Hardcoded values ("magic numbers") are the enemy of readability. In Swift, use constants and enumerations (enum).

Bad:

if user.age > 18 {    grantAccess()}

Good:

private let minimumAgeForAccess = 18

if user.age > minimumAgeForAccess {    grantAccess()}

For more complex cases, use enum:

enum HTTPStatusCode: Int {    case ok = 200    case notFound = 404    case internalError = 500}

func handleResponse(code: Int) {    sw