Swift 초보자가 범하기 쉬운 실수와 해결책 🚀

안녕, Swift 개발에 관심 있는 친구들! 오늘은 우리가 Swift를 배우면서 자주 저지르는 실수들과 그 해결책에 대해 재미있게 얘기해볼 거야. 🎉 Swift는 정말 멋진 언어지만, 처음 배울 때는 좀 헷갈리는 부분들이 있지. 그래서 이 글에서는 그런 부분들을 하나하나 짚어가면서, 어떻게 하면 더 나은 Swift 개발자가 될 수 있는지 알아볼 거야!

그리고 말이야, 우리가 이렇게 Swift에 대해 배우다 보면 어느새 실력이 쑥쑥 늘어서 나중에는 재능넷같은 플랫폼에서 Swift 개발 재능을 공유할 수 있게 될지도 몰라! 😉 자, 그럼 시작해볼까?

1. 옵셔널(Optional) 다루기 😅

Swift를 처음 배우면 가장 먼저 만나게 되는 개념 중 하나가 바로 '옵셔널'이야. 옵셔널은 값이 있을 수도 있고 없을 수도 있는 상황을 표현하는 Swift의 특별한 기능이지. 근데 이게 은근히 헷갈리는 녀석이라 많은 초보자들이 실수를 하곤 해.

1.1 실수 1: 강제 언래핑 남용 🙅‍♂️

가장 흔한 실수 중 하나는 옵셔널 값을 강제로 언래핑하는 거야. 예를 들어 이런 코드를 봐봐:

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)!
print(convertedNumber + 1)  // 124 출력

이 코드는 지금은 잘 동작하지만, 만약 possibleNumber가 숫자로 변환될 수 없는 문자열이라면? 🤔 그럼 앱이 크래시 나버릴 거야!

해결책: 안전한 옵셔널 바인딩 사용하기 👍

대신에 이렇게 해보는 게 어때?

if let convertedNumber = Int(possibleNumber) {
    print(convertedNumber + 1)
} else {
    print("변환할 수 없는 숫자예요!")
}

이렇게 하면 숫자로 변환할 수 없는 경우에도 앱이 크래시 나지 않고 안전하게 처리할 수 있어.

🌟 Pro Tip: 옵셔널 체이닝을 사용하면 더 간결하게 코드를 작성할 수 있어!

let result = Int(possibleNumber).map { $0 + 1 }
print(result ?? "변환할 수 없는 숫자예요!")

1.2 실수 2: 옵셔널 체이닝 오용 🔗

옵셔널 체이닝은 정말 유용한 기능이지만, 때로는 이걸 잘못 사용해서 문제가 생기기도 해. 예를 들어:

struct Person {
    var name: String?
    var age: Int?
}

let someone = Person(name: "Kim", age: 25)
let uppercaseName = someone.name?.uppercased()
print(uppercaseName)  // Optional("KIM") 출력

이 코드에서 uppercaseName은 여전히 옵셔널이야. 그래서 이걸 그대로 사용하면 예상치 못한 결과가 나올 수 있어.

해결책: 옵셔널 바인딩과 함께 사용하기 🤝

이렇게 해보면 어떨까?

if let name = someone.name?.uppercased() {
    print("이름: \(name)")
} else {
    print("이름이 없어요!")
}

이렇게 하면 옵셔널 값을 안전하게 처리할 수 있고, 코드의 의도도 더 명확해져.

💡 알아두면 좋은 점: Swift 5.7부터는 if-let 구문을 더 간결하게 쓸 수 있어졌어!

if let name = someone.name?.uppercased() {
    print("이름: \(name)")
}

이렇게 하면 else 구문 없이도 옵셔널 바인딩을 할 수 있지.

2. 클로저(Closure) 사용하기 🎭

클로저는 Swift의 강력한 기능 중 하나야. 하지만 처음 접하면 좀 복잡해 보일 수 있지. 많은 초보자들이 클로저를 사용할 때 실수를 하곤 해.

2.1 실수 1: 캡처 리스트 미사용 🕸️

클로저 내에서 외부 변수를 사용할 때, 메모리 누수가 발생할 수 있어. 예를 들어:

class MyViewController: UIViewController {
    var counter = 0
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        someAsyncTask { [weak self] in
            self?.counter += 1
            print("Counter: \(self?.counter ?? 0)")
        }
    }
    
    func someAsyncTask(completion: @escaping () -> Void) {
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            completion()
        }
    }
}

이 코드에서 weak self를 사용하지 않으면, 뷰 컨트롤러가 해제되어야 할 때 해제되지 않고 메모리에 계속 남아있을 수 있어.

해결책: 캡처 리스트 사용하기 🎣

클로저에서 self를 사용할 때는 항상 캡처 리스트를 고려해봐야 해. 위의 코드를 이렇게 수정할 수 있어:

someAsyncTask { [weak self] in
    guard let self = self else { return }
    self.counter += 1
    print("Counter: \(self.counter)")
}

이렇게 하면 메모리 누수를 방지할 수 있고, 뷰 컨트롤러가 필요 없어졌을 때 적절히 해제될 수 있어.

🌟 Pro Tip: Swift 5.3부터는 weak self를 더 간단하게 사용할 수 있어!

someAsyncTask { [weak self] in
    self?.counter += 1
    print("Counter: \(self?.counter ?? 0)")
}

이렇게 하면 guard let 구문 없이도 옵셔널 체이닝을 통해 안전하게 self를 사용할 수 있지.

2.2 실수 2: 클로저의 강한 참조 순환 ♻️

클로저를 프로퍼티로 가지는 클래스에서 종종 강한 참조 순환 문제가 발생해. 예를 들어:

class Person {
    let name: String
    var introduceSelf: () -> Void
    
    init(name: String) {
        self.name = name
        self.introduceSelf = {
            print("안녕하세요, 저는 \(self.name)입니다.")
        }
    }
    
    deinit {
        print("\(name) 인스턴스가 해제되었습니다.")
    }
}

var person: Person? = Person(name: "Kim")
person?.introduceSelf()
person = nil  // deinit이 호출되지 않음!

이 코드에서 Person 클래스의 introduceSelf 클로저가 self를 강하게 참조하고 있어서, 인스턴스가 해제되지 않는 문제가 발생해.

해결책: 캡처 리스트와 약한 참조 사용하기 🔗

이 문제를 해결하려면 클로저에서 self를 약한 참조로 캡처해야 해:

class Person {
    let name: String
    var introduceSelf: () -> Void
    
    init(name: String) {
        self.name = name
        self.introduceSelf = { [weak self] in
            guard let self = self else { return }
            print("안녕하세요, 저는 \(self.name)입니다.")
        }
    }
    
    deinit {
        print("\(name) 인스턴스가 해제되었습니다.")
    }
}

var person: Person? = Person(name: "Kim")
person?.introduceSelf()
person = nil  // "Kim 인스턴스가 해제되었습니다." 출력

이렇게 하면 강한 참조 순환 문제를 해결할 수 있고, 인스턴스가 적절히 해제돼.

💡 알아두면 좋은 점: 클로저에서 self를 캡처할 때는 항상 강한 참조가 필요한지, 약한 참조로 충분한지 고민해봐야 해. 대부분의 경우 약한 참조(weak self)를 사용하는 것이 안전해.

3. 프로토콜(Protocol) 활용하기 📜

프로토콜은 Swift의 강력한 기능 중 하나야. 하지만 초보자들은 종종 프로토콜을 제대로 활용하지 못하거나 잘못 사용하곤 해. 어떤 실수들이 있는지 살펴볼까?

3.1 실수 1: 프로토콜 확장 미사용 🚫

많은 초보자들이 프로토콜을 정의할 때 모든 메서드에 대한 구현을 요구해. 이렇게 하면 코드 중복이 발생하고 유연성이 떨어질 수 있어. 예를 들어:

protocol Animal {
    var name: String { get }
    func makeSound()
    func eat()
    func sleep()
}

class Dog: Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func makeSound() {
        print("멍멍!")
    }
    
    func eat() {
        print("\(name)이(가) 먹이를 먹습니다.")
    }
    
    func sleep() {
        print("\(name)이(가) 잠을 잡니다.")
    }
}

class Cat: Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func makeSound() {
        print("야옹!")
    }
    
    func eat() {
        print("\(name)이(가) 먹이를 먹습니다.")
    }
    
    func sleep() {
        print("\(name)이(가) 잠을 잡니다.")
    }
}

이 코드에서 eat()과 sleep() 메서드의 구현이 Dog와 Cat 클래스에서 중복되고 있어.

해결책: 프로토콜 확장 사용하기 🔧

프로토콜 확장을 사용하면 중복 코드를 줄이고 기본 구현을 제공할 수 있어:

protocol Animal {
    var name: String { get }
    func makeSound()
}

extension Animal {
    func eat() {
        print("\(name)이(가) 먹이를 먹습니다.")
    }
    
    func sleep() {
        print("\(name)이(가) 잠을 잡니다.")
    }
}

class Dog: Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func makeSound() {
        print("멍멍!")
    }
}

class Cat: Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func makeSound() {
        print("야옹!")
    }
}

이렇게 하면 eat()과 sleep() 메서드의 구현을 각 클래스에서 반복하지 않아도 돼. 필요한 경우에만 오버라이드해서 사용할 수 있지.

🌟 Pro Tip: 프로토콜 확장을 사용하면 코드 재사용성을 높이고 유지보수를 쉽게 만들 수 있어. 특히 여러 타입에서 공통으로 사용되는 기능을 구현할 때 유용해!

3.2 실수 2: 프로토콜 합성 미사용 🔀

때로는 여러 프로토콜의 기능을 조합해야 할 때가 있어. 하지만 많은 초보자들이 이를 위해 새로운 프로토콜을 만들거나 클래스 상속을 사용해. 이건 유연성을 떨어뜨리고 코드를 복잡하게 만들 수 있어. 예를 들어:

protocol Eatable {
    func eat()
}

protocol Sleepable {
    func sleep()
}

protocol Animal: Eatable, Sleepable {
    var name: String { get }
    func makeSound()
}

class Dog: Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func makeSound() {
        print("멍멍!")
    }
    
    func eat() {
        print("\(name)이(가) 먹이를 먹습니다.")
    }
    
    func sleep() {
        print("\(name)이(가) 잠을 잡니다.")
    }
}

이 방식은 Animal 프로토콜이 Eatable과 Sleepable을 상속받아야 해서, 불필요하게 복잡해질 수 있어.

해결책: 프로토콜 합성 사용하기 🔗

프로토콜 합성을 사용하면 더 유연하게 타입을 정의할 수 있어:

protocol Eatable {
    func eat()
}

protocol Sleepable {
    func sleep()
}

protocol Animal {
    var name: String { get }
    func makeSound()
}

class Dog: Animal, Eatable, Sleepable {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func makeSound() {
        print("멍멍!")
    }
    
    func eat() {
        print("\(name)이(가) 먹이를 먹습니다.")
    }
    
    func sleep() {
        print("\(name)이(가) 잠을 잡니다.")
    }
}

func feedAndRest(pet: Animal & Eatable & Sleepable) {
    pet.eat()
    pet.sleep()
}

이렇게 하면 각 프로토콜의 기능을 독립적으로 유지하면서도 필요에 따라 조합해서 사용할 수 있어. feedAndRest 함수처럼 특정 기능들을 가진 타입만 받도록 제한할 수도 있지.

💡 알아두면 좋은 점: 프로토콜 합성을 사용하면 코드의 재사용성과 유연성을 크게 높일 수 있어. 특히 여러 기능을 조합해야 하는 복잡한 시스템을 설계할 때 매우 유용해!

4. 메모리 관리 실수 피하기 🧠

Swift는 ARC(Automatic Reference Counting)를 사용해서 메모리를 관리해. 하지만 이걸 제대로 이해하지 못하면 메모리 누수나 의도치 않은 동작이 발생할 수 있어. 어떤 실수들이 흔한지 살펴볼까?

4.1 실수 1: 강한 참조 순환 만들기 🔄

가장 흔한 메모리 관리 실수 중 하나는 강한 참조 순환을 만드는 거야. 예를 들어:

class Person {
    let name: String
    var apartment: Apartment?
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) is being deinitialized")
    }
}

class Apartment {
    let unit: String
    var tenant: Person?
    
    init(unit: String) {
        self.unit = unit
    }
    
    deinit {
        print("Apartment \(unit) is being deinitialized")
    }
}

var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")

john?.apartment = unit4A
unit4A?.tenant = john

john = nil
unit4A = nil

// 아무것도 출력되지 않음 - 메모리 누수 발생!

이 코드에서 Person과 Apartment 인스턴스가 서로를 강하게 참조하고 있어서, nil을 할당해도 메모리에서 해제되지 않아.

해결책: 약한 참조 또는 미소유 참조 사용하기 🔗

이런 문제를 해결하려면 약한 참조(weak) 또는 미소유 참조(unowned)를 사용해야 해:

class Person {
    let name: String
    var apartment: Apartment?
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) is being deinitialized")
    }
}

class Apartment {
    let unit: String
    weak var tenant: Person?
    
    init(unit: String) {
        self.unit = unit
    }
    
    deinit {
        print("Apartment \(unit) is being deinitialized")
    }
}

var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")

john?.apartment = unit4A
unit4A?.tenant = john

john = nil
unit4A = nil

// "John is being deinitialized"
// "Apartment 4A is being deinitialized" 출력

이렇게 Apartment 클래스의 tenant 프로퍼티를 weak로 선언하면 강한 참조 순환을 피할 수 있어.

🌟 Pro Tip: weak는 옵셔널 타입에만 사용할 수 있고, 참조하는 인스턴스가 메모리에서 해제되면 자동으로 nil이 할당돼. 반면 unowned는 non-optional 타입에 사용하며, 참조하는 인스턴스가 항상 존재한다고 가정해. 사용할 때 주의가 필요해!

4.2 실수 2: 클로저에서의 강한 참조 🔒

클로저 내에서 객체를 캡처할 때 강한 참조가 생길 수 있어. 이것도 메모리 누수의 원인이 될 수 있지. 예를 들어:

class NetworkManager {
    var onCompletion: (() -> Void)?
    
    func fetchData() {
        // 데이터 가져오는 로직
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            self.onCompletion?()
        }
    }
    
    deinit {
        print("NetworkManager is being deinitialized")
    }
}

class ViewController {
    var networkManager: NetworkManager?
    
    func viewDidLoad() {
        networkManager = NetworkManager()
        networkManager?.onCompletion = {
            self.updateUI()
        }
        networkManager?.fetchData()
    }
    
    func updateUI() {
        print("UI updated")
    }
    
    deinit {
        print("ViewController is being deinitialized")
    }
}

var viewController: ViewController? = ViewController()
viewController?.viewDidLoad()
viewController = nil

// "UI updated" 출력
// 아무것도 deinit되지 않음 - 메모리 누수 발생!

이 코드에서 NetworkManager의 onCompletion 클로저가 ViewController를 강하게 참조하고 있어서, 뷰 컨트롤러가 해제되지 않아.

해결책: 캡처 리스트 사용하기 📝

클로저에서 객체를 캡처할 때 약한 참조를 사용하면 이 문제를 해결할 수 있어:

class ViewController {
    var networkManager: NetworkManager?
    
    func viewDidLoad() {
        networkManager = NetworkManager()
        networkManager?.onCompletion = { [weak self] in
            self?.updateUI()
        }
        networkManager?.fetchData()
    }
    
    func updateUI() {
        print("UI updated")
    }
    
    deinit {
        print("ViewController is being deinitialized")
    }
}

var viewController: ViewController? = ViewController()
viewController?.viewDidLoad()
viewController = nil

// "ViewController is being deinitialized"
// "NetworkManager is being deinitialized" 출력

이렇게 클로저의 캡처 리스트에 [weak self]를 사용하면 강한 참조 순환을 피할 수 있어. 뷰 컨트롤러가 해제될 때 클로저도 함께 해제되기 때문에 메모리 누수가 발생하지 않아.

💡 알아두면 좋은 점: 클로저에서 self를 캡처할 때는 항상 강한 참조가 필요한지, 약한 참조로 충분한지 고민해봐야 해. 대부분의 경우 약한 참조(weak self)를 사용하는 것이 안전해. 하지만 클로저가 self보다 수명이 짧다는 것이 확실할 때는 강한 참조를 사용해도 돼.

5. 동시성(Concurrency) 다루기 ⚡

Swift 5.5부터 도입된 새로운 동시성 모델은 비동기 프로그래밍을 훨씬 쉽게 만들었어. 하지만 여전히 주의해야 할 점들이 있지. 어떤 실수들이 흔한지 살펴볼까?

5.1 실수 1: 잘못된 작업 그룹 사용 🚦

작업 그룹(Task Group)을 사용할 때 종종 실수가 발생해. 예를 들어, 모든 작업이 완료되기를 기다리지 않고 결과를 반환하는 경우가 있어:

func fetchUserData() async throws -> [User] {
    var users: [User] = []
    
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in 1...10 {
            group.addTask {
                try await fetchUser(id: id)
            }
        }
        
        return users  // 오류: 모든 작업이 완료되기 전에 반환
    }
}

func fetchUser(id: Int) async throws -> User {
    // 네트워크 요청 시뮬레이션
    try await Task.sleep(nanoseconds: UInt64.random(in: 1...3) * 1_000_000_000)
    return User(id: id, name: "User \(id)")
}

이 코드는 모든 사용자 데이터를 가져오기 전에 빈 배열을 반환해버려.

해결책: 모든 작업 결과 수집하기 🧩

작업 그룹의 모든 결과를 수집해야 해:

func fetchUserData() async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in 1...10 {
            group.addTask {
                try await fetchUser(id: id)
            }
        }
        
        var users: [User] = []
        for try await user in group {
            users.append(user)
        }
        return users
    }
}

이렇게 하면 모든 사용자 데이터를 가져온 후에 결과를 반환할 수 있어.

🌟 Pro Tip: 작업 그룹을 사용할 때는 항상 모든 작업이 완료되었는지 확인해야 해. for try await 루프를 사용하면 모든 결과를 쉽게 수집할 수 있어!

5.2 실수 2: 잘못된 액터(Actor) 사용 🎭

액터를 사용할 때 종종 데드락(deadlock)이 발생할 수 있어. 예를 들어, 액터 내부에서 다른 액터의 메서드를 동기적으로 호출하는 경우:

actor BankAccount {
    var balance: Double
    
    init(balance: Double) {
        self.balance = balance
    }
    
    func deposit(_ amount: Double) {
        balance += amount
    }
    
    func transfer(to other: BankAccount, amount: Double) {
        balance -= amount
        other.deposit(amount)  // 오류: 액터 내부에서 다른 액터의 메서드를 동기적으로 호출
    }
}

let account1 = BankAccount(balance: 100)
let account2 = BankAccount(balance: 50)

Task {
    await account1.transfer(to: account2, amount: 30)  // 데드락 발생!
}

이 코드는 transfer 메서드 내에서 다른 액터의 메서드를 동기적으로 호출하고 있어서 데드락이 발생할 수 있어.

해결책: 비동기 호출 사용하기 🔄

액터 간의 통신은 항상 비동기적으로 이루어져야 해:

actor BankAccount {
    var balance: Double
    
    init(balance: Double) {
        self.balance = balance
    }
    
    func deposit(_ amount: Double) {
        balance += amount
    }
    
    func withdraw(_ amount: Double) {
        balance -= amount
    }
}

func transfer(from: BankAccount, to: BankAccount, amount: Double) async {
    await from.withdraw(amount)
    await to.deposit(amount)
}

let account1 = BankAccount(balance: 100)
let account2 = BankAccount(balance: 50)

Task {
    await transfer(from: account1, to: account2, amount: 30)
}

이렇게 하면 각 액터의 메서드를 비동기적으로 호출하게 되어 데드락을 피할 수 있어.

💡 알아두면 좋은 점: 액터를 사용할 때는 항상 비동기 컨텍스트에서 작업해야 해. 액터의 메서드를 호출할 때는 await 키워드를 사용하고, 액터 간의 복잡한 상호작용은 별도의 함수로 분리하는 것이 좋아.