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

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

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

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("변환할 수 없는 숫자예요!")
}

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

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("이름이 없어요!")
}

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

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

클로저는 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)")
}

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

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

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 인스턴스가 해제되었습니다." 출력

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

프로토콜은 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() 메서드의 구현을 각 클래스에서 반복하지 않아도 돼. 필요한 경우에만 오버라이드해서 사용할 수 있지.

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 함수처럼 특정 기능들을 가진 타입만 받도록 제한할 수도 있지.

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로 선언하면 강한 참조 순환을 피할 수 있어.

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]를 사용하면 강한 참조 순환을 피할 수 있어. 뷰 컨트롤러가 해제될 때 클로저도 함께 해제되기 때문에 메모리 누수가 발생하지 않아.

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
    }
}

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

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)
}

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

자, 이렇게 Swift 초보자들이 자주 범하는 실수들과 그 해결책에 대해 알아봤어. 이런 실수들을 피하고 더 나은 Swift 개발자가 되기 위해서는 다음과 같은 점들을 기억하면 좋아:

• 옵셔널을 안전하게 다루는 방법을 익히고, 강제 언래핑은 정말 필요한 경우에만 사용해.
• 클로저 사용 시 메모리 관리에 주의를 기울이고, 필요한 경우 캡처 리스트를 활용해.
• 프로토콜을 활용해 코드의 유연성과 재사용성을 높여.
• ARC와 메모리 관리 개념을 잘 이해하고, 강한 참조 순환을 피해.
• 새로운 동시성 모델을 적극 활용하되, 데드락과 같은 함정에 빠지지 않도록 주의해.

Swift는 정말 강력하고 아름다운 언어야. 이런 실수들을 피하고 Swift의 장점을 잘 활용한다면, 더욱 안전하고 효율적인 코드를 작성할 수 있을 거야. 계속해서 공부하고 실험해보면서 Swift의 매력에 빠져보는 건 어때? 🚀

그리고 기억해, 프로그래밍은 실수를 통해 배우는 과정이기도 해. 실수를 두려워하지 말고, 그것을 통해 배우고 성장하는 기회로 삼아봐. 화이팅! 👍