Boost Swift Code Quality: Practical Tips for Faster, Safer iOS Development

1. Introduction

Jingxi APP introduced Swift in 2019, using it for the first order module. Over a year of internal promotion has led to Swift now supporting more than 70% of business code, improving development efficiency and reducing crash rates to less than 1%.

2. Swift Features

Before discussing code‑quality improvements, we review why Swift outperforms Objective‑C and other languages. Its three core strengths are expressiveness, safety, and speed.

Expressiveness

Rich basic types – tuples, enum associated values

Method overloading

Protocols – default implementations, class‑only protocols

Generics – associated types, where clauses, generic extensions

Optionals – declaration, optional chaining, implicitly unwrapped

Properties – let, lazy, computed, willSet/didSet, property wrappers

Functional programming – filter/map/reduce, extensive standard‑library functions

Concurrency – async/await, actors

Standard‑library frameworks – Combine, SwiftUI, Codable

Result builders – DSL capabilities

Dynamic features – dynamicCallable, dynamicMemberLookup

Other – extensions, subscripts, operator overloading, nested types, ranges

Swift Package Manager – native package handling in Xcode

Structs – automatic initializer synthesis

Type inference – reduces explicit type declarations

Tip: Strong type inference can increase compile time, but the Swift team continuously improves compilation speed.

Safety

Code Safety

let constants – prevent unintended mutation

Value types – avoid accidental state changes during parameter passing

Access control – public/final restricts external subclassing and overriding

Mandatory error handling – throw methods must be caught, preventing uncaught crashes

Pattern matching – exhaustive switch cases catch unhandled branches

Type Safety

Explicit casts – disallow implicit conversions, eliminating runtime type errors

When writing Objective‑C, developers often add manual type checks to avoid crashes.

KeyPath – provides compile‑time checked property names and types

Generics – enable compile‑time type safety compared with Any

Enum associated values – replace Any with strongly typed cases

Memory Safety

Optional safety – prevents nil‑pointer crashes

ARC – automatic reference counting avoids manual memory bugs

Mandatory initialization – variables must be initialized before use

Exclusive memory access – compiler checks for potential data races

Thread Safety

Prefer value types – reduce data‑race scenarios

async/await – structured concurrency avoids callback‑related memory cycles

Actor model – eliminates data‑sharing races and lock‑related deadlocks

Speed

Value types – avoid heap allocation and reduce memory usage

Static dispatch – faster than Objective‑C message forwarding

Compiler optimizations – whole‑module analysis enables dead‑code elimination, method inlining, generic specialization, copy‑on‑write, etc.

Objective‑C message dispatch prevents the compiler from removing unused methods.

ARC optimizations – Swift’s compiler can generate faster reference‑count handling than Objective‑C’s autorelease pool.

Swift does not need autorelease, leading to fewer runtime operations.

3. Code‑Quality Metrics

The goal is to write Swift code that meets these quality indicators.

4. Good Practices

Leverage Compiler Checks

Reduce Any/AnyObject

Using Any/AnyObject hides type information, preventing the compiler from performing type safety checks and leading to numerous as? casts, missed optimizations, and potential logic errors.

func do(data: Any?) {
    guard let string = data as? String else {
        return
    }
    // ...
}

do(1)

do("")

These bugs are often harder to detect than crashes.

Replace Dictionary with Custom Types

Large dictionaries increase maintenance cost and introduce bugs such as hard‑coded keys, missing type constraints, and loss of optional safety.

let dic: [String: Any]
let num = dic["value"] as? Int
dic["name"] = "name"

Recommended:

struct Data {
    let num: Int
    var name: String?
}
let num = data.num
data.name = "name"

Use dictionaries only for data transport or decoupling between components.

Replace Any with Enum Associated Values

Transform APIs that accept Any into type‑safe enums.

enum NSAttributedStringKey {
    case foregroundColor(UIColor)
}
let string = NSMutableAttributedString()
string.addAttribute(.foregroundColor(UIColor.red), range: range) // compile‑time error if type mismatched

Replace Any with Generics / Protocol Associated Types

Generics and associated types let the compiler enforce stricter checks.

Replace Hard‑coded Strings with Enums or Constants

Hard‑coded literals cause synchronization bugs; use enums or constants instead.

Replace String Keys with KeyPath

KeyPath provides compile‑time checked property names and types.

class SomeClass: NSObject {
    @objc dynamic var someProperty: Int
    init(someProperty: Int) { self.someProperty = someProperty }
}
let object = SomeClass(someProperty: 10)
object.observe(\.​someProperty) { obj, change in
    // safe observation
}

Reduce Forced Unwrapping (!)

Using ! can cause runtime crashes when a value is nil.

class ViewController: UIViewController {
    @IBOutlet private var label: UILabel!
}

Prefer safe optional handling or limited use of ! in small, well‑controlled scopes.

Avoid try! for Error Handling

try! method() // crashes if method throws

Use weak/unowned to Prevent Retain Cycles

resource.request().onComplete { [weak self] response in
    guard let self = self else { return }
    let model = self.updateModel(response)
    self.updateUI(model)
}

Use unowned only when you are certain the captured self will outlive the closure.

Control Flow Improvements

Prefer higher‑order functions over explicit loops.

let nums = [1, 2, 3]
let result = nums.filter { $0 < 3 }.map { String($0) }

Use guard for early returns and avoid deep nested if‑else structures.

String Literals

Use multi‑line string literals (""") to keep formatting without escaping.

let quotation = """
The White Rabbit ...
"""

String Interpolation

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"

Standard Library High‑Order Functions

Prefer isEmpty, first, etc., over manual count checks.

Access Control

Default internal visibility; reduce it where possible (private, fileprivate) to aid compiler optimizations.

Parameter Default Values

func test(a: Int, b: String? = nil, c: Int? = nil) { }

test(1)

Limit Parameter Count

Group many parameters into a custom struct.

struct Params { let a, b, c, d, e, f: Int }
func f(params: Params) { }

Use @discardableResult

@discardableResult func report(id: String) -> Bool { }
report("1") // no warning

Prefer Enums over Long Tuples

Tuples lack named fields; replace them with structs or enums for clarity.

KVO / Notification Block APIs

Block‑based observers automatically deregister when deallocated.

class Object: NSObject {
    private var observer: Any?
    private var kvoObserver: NSKeyValueObservation?
    override init() {
        super.init()
        observer = NotificationCenter.default.addObserver(forName: NSNotification.Name(""), object: nil, queue: nil) { _ in }
        kvoObserver = foo.observe(\.​value, options: [.new]) { foo, change in }
    }
}

Prefer Protocols over Inheritance

Protocols provide default implementations, associated types, and value‑type support, reducing class hierarchy complexity.

Organize Code with Extensions

class MyViewController: UIViewController { /* class stuff */ }
// MARK: - Private
extension MyViewController { private func method() {} }
// MARK: - UITableViewDataSource
extension MyViewController: UITableViewDataSource { /* data source methods */ }

5. Performance Optimization

Whole Module Optimization (WMO)

Enabling WMO lets the compiler treat the whole app as a single module, enabling static dispatch, dead‑code elimination, and other aggressive optimizations.

Source‑code Packaging

When using componentized builds, static libraries limit WMO to internal scopes. Packaging the entire Swift codebase together gives the compiler more global information for optimization.

Reduce Dynamic Dispatch

Mark classes, methods, and properties as final.

Use private visibility to enable static dispatch.

Avoid dynamic keyword.

Leverage WMO to infer finality automatically.

Slice Sharing for Arrays/Strings

Slices reference the original collection without copying, but should not be held indefinitely to avoid memory leaks.

Protocol with AnyObject

Class‑only protocols (inherit AnyObject) let the compiler skip value‑type handling, improving runtime performance.

@inlinable for Method Inlining

// Original
let label = UILabel().then { $0.textAlignment = .center; $0.textColor = .black; $0.text = "Hello, World!" }
// After inlining
let label = UILabel()
label.textAlignment = .center
label.textColor = .black
label.text = "Hello, World!"

Lazy Properties

Use lazy initialization for expensive or rarely used objects, but be aware of thread‑safety concerns.

Prefer let over var

Immutable collections allow the compiler to perform more aggressive optimizations and reduce heap allocations for captured variables.

Avoid Large Structs When Not Needed

Large structs generate extensive copy‑related code; replace them with classes if reference semantics are acceptable.

Prefer Encodable/Decodable Over Codable When Possible

Implement only the needed side (encoding or decoding) to reduce generated code size.

Minimize Equatable Conformance

Only adopt Equatable when equality checks are required, and limit comparisons to essential fields to keep binary size low.

4. Conclusion

Since Swift 3.0, the author has used Swift as the primary language. Writing Swift is more than translating Objective‑C; it requires deep understanding of Swift’s safety, value semantics, concurrency model, functional programming, and protocol‑oriented design. Keeping up with each Swift release’s new features and optimizations not only improves code quality but also strengthens overall programming concepts that translate to other modern languages such as Dart, TypeScript, Kotlin, and Rust.

For further reading, follow Swift Evolution proposals, which detail motivations, use‑cases, and future directions for each language feature.

Additional Links

The Swift Programming Language

Swift Advanced Topics

SwiftLint Rules

Optimization Tips

Deep Dive into Swift Performance Optimization

Google Swift Style Guide

Swift Evolution

Dictionary

Array

String

Struct

-end-