Swift

Google Swift Style Guide

Official Google Swift coding standards for consistent, maintainable iOS/macOS code.

Golden Rules

1. Clear, descriptive names — readability at the call site
2. Prefer let over var — immutability by default
3. Use optionals properly — avoid force unwrapping (!)
4. Protocol-oriented programming — prefer protocols over inheritance
5. guard for early returns — reduce nesting with early exits
6. Use type inference — let Swift infer types when obvious
7. SwiftLint for consistency — automate style enforcement

Quick Reference

Naming Conventions

Variables and Constants

// ✓ CORRECT - prefer let (immutable)
let userName = "Alice"
let maxRetries = 3

// ✓ CORRECT - var only when value changes
var retryCount = 0
retryCount += 1

// ✓ CORRECT - type inference (no need to repeat type)
let users: [User] = []        // OK: collection type is clear
let count = users.count       // inferred as Int

Optionals

// ✓ CORRECT - if let for optional binding
if let user = getUser(id: 42) {
  print(user.name)
}

// ✓ CORRECT - guard for early return
func processUser(id: Int) {
  guard let user = getUser(id: id) else {
    print("User not found")
    return
  }
  // user is non-optional here
  display(user)
}

// ✓ CORRECT - nil coalescing
let name = user?.name ?? "Unknown"

// ✗ INCORRECT - force unwrap
let user = getUser(id: 42)!  // crashes if nil

Structs and Classes

// ✓ CORRECT - prefer struct for value types
struct User {
  let id: Int
  var name: String
  var email: String
}

// ✓ CORRECT - class for reference semantics / inheritance
final class UserService {
  private let repository: UserRepository

  init(repository: UserRepository) {
    self.repository = repository
  }

  func getUser(id: Int) async throws -> User {
    return try await repository.find(id: id)
  }
}

Protocols

// ✓ CORRECT - protocol for abstraction
protocol UserRepository {
  func find(id: Int) async throws -> User
  func save(_ user: User) async throws
}

// ✓ CORRECT - protocol extension for default behavior
extension UserRepository {
  func findAll() async throws -> [User] {
    return []
  }
}

// ✓ CORRECT - composing protocols
typealias UserStore = UserRepository & Codable

Error Handling

// ✓ CORRECT - typed errors with enum
enum UserError: Error {
  case notFound(id: Int)
  case invalidData(String)
  case networkFailure(underlying: Error)
}

// ✓ CORRECT - throw and catch
func fetchUser(id: Int) throws -> User {
  guard let user = database[id] else {
    throw UserError.notFound(id: id)
  }
  return user
}

// ✓ CORRECT - do-catch
do {
  let user = try fetchUser(id: 42)
  display(user)
} catch UserError.notFound(let id) {
  print("User \(id) not found")
} catch {
  print("Unexpected error: \(error)")
}

Async/Await

// ✓ CORRECT - async/await (Swift 5.5+)
func loadUsers() async throws -> [User] {
  let data = try await networkClient.get("/api/users")
  return try JSONDecoder().decode([User].self, from: data)
}

// ✓ CORRECT - task for concurrent work
Task {
  do {
    let users = try await loadUsers()
    await MainActor.run { self.users = users }
  } catch {
    await MainActor.run { self.error = error }
  }
}

Access Control

// ✓ CORRECT - explicit access control
public struct User {
  public let id: Int
  public var name: String
  internal var metadata: [String: String]
  private var _internalState: Bool
}

// ✓ CORRECT - use final to prevent subclassing
public final class AuthService {
  // ...
}

Formatting

// ✓ CORRECT - trailing closures
users.forEach { user in
  print(user.name)
}

let activeUsers = users.filter { $0.isActive }
let names = users.map { $0.name }

// ✓ CORRECT - 2-space indentation, opening brace on same line
func process() {
  if condition {
    doSomething()
  }
}

Common Mistakes

When to Use This Guide

• Writing new Swift code
• Refactoring existing Swift
• Code reviews
• Setting up SwiftLint rules
• Onboarding new team members

Install

npx skills add testdino-hq/google-styleguides-skills/swift

Full Guide

See swift.md for complete details, examples, and edge cases.