이 글은 독자가 Generic Type, URLSession, 클로져와 Callback, UIKit 혹은 SwiftUI 의 View LifeCycle 에 대해서 이미 알고 있음을 전제하고 있습니다.

Combine 이란?

Combine 은 앱 내에서 일어나는 이벤트들의 진행 경과들을 선언적으로 코딩할 수 있게끔 도와주는 Apple 의 프레임워크입니다.

어떠한 이벤트를 추적할 때 Delegate 패턴 을 사용하거나, Completion 클로져 를 사용하는 대신 Combine 을 활용해볼 수 있습니다.

이 프레임워크는 Swift API 에 해당하기에 Swift 언어를 사용한다면 UIKit 이나 SwiftUI 둘 다 사용할 수 있습니다.

더 쉽게 말하자면 URLSession.shared.dataTask { } 쓰면 completion() 써야하고 모시깽이 클래스 - 모시깽이 Delegate 를 적용하는 상황들이

직관적이지 않고, 조금만 복잡해져도 스파게티 코드가 되니 이걸 간단하게 해결해보자

라는 취지

Combine 개요

Combine 은 결국 Publisher 라는 이벤트 반응 전송기계 Subscriber 라는 이벤트 수집기계

이 두개를 연결해주는 프레임워크입니다.

Subscriber 는 Publisher 에게 데이터를 받기만 하는 일방향적 관계이며, Subscriber 가 Publisher 에게 요청할 수 있는것은 데이터를 달라는 요청만 할 수 있습니다.

Publisher 는 Subscriber 에게 데이터를 전달할 때, 바로 전달할 수도 있지만 Operator 를 활용해서, 데이터를 가공해서 줄 수 있습니다.

Operator 는 Swift 에서 일상적으로 쓰는 메소드들인 map, flatMap, compactMap, filter 등의 이름을 따서 만든 메소드들로, 이름과 유사한 기능들을 제공합니다.

더 쉽게 말하자면 Publisher 는 데이터를 전송만 담당, Subscriber 는 데이터 수신만 담당 Operator 는 Publisher 가 데이터 전송할 때, 중간에 수정하는 역할

Subscriber 와 Publisher 의 타입

Publisher 와 Subscriber 는 각각 실제 데이터에 해당하는 Output 과 Input, 각각 오류에 해당하는 Failure 과 Failure 를 갖고 있습니다.

서로 연결되어있는 Publisher 와 Subscriber 는 OutPut 과 Input 이 같아야하며, 같은 Failure 를 갖고 있어야 합니다.

더 쉽게 말하자면 Publisher 랑 Subscriber 는 같은 타입이여야해용

Publisher 와 Subscriber 연결하는 방법

연결은 Publiser 에 Subscriber 를 붙이는 형태로 동작합니다.

SomePublisher
    .sink(receiverCompletion:receiveValue:)`
    .assign(to:on:)

/*
 Publisher 에 sink() 혹은 assign() 을 사용하면
 새로운 Subscriber 를 만들 수 있습니다.
*/

Subscriber 는 새로운 Subscriber 를 생성할 수 있습니다.

SomeSubscriber
    .sink(receiverCompletion:receiveValue:)`
    .assign(to:on:)

/*

Subscriber 에 또 sink, 혹은 assign 을 붙여서
새로운 subscriber 를 선언할 수 있다.

*/

더 쉽게 말하자면 Publisher 에 sink() 혹은 assign() 쓰면 새로운 Subscriber 를 선언할 수 있어요.

Class 에는 Observable 프로토콜 (옛날 이름 BindableObject) 을 사용할 수 있는데, Class 내부 변수에 @Published 만 붙이면, 자동으로 Publisher 로 만들어요. @Published var posts = [T]()

Operators

Operator 는 Publisher 에 붙여서 사용할 수 있는 메소드입니다. Publisher 가 뿜어주는 데이터들을 원하는대로 가공할 때 사용합니다.

let sub = NotificationCenter.default
    .publisher(for: NSControl.textDidChangeNotification, object: filterField)
    .map( { ($0.object as! NSTextField).stringValue } )
    .sink(receiveCompletion: { print ($0) },
          receiveValue: { print ($0) })

/*

TextField 의 변화를 감지하는 NotificationCenter 를 만들어서, 
해당 이벤트 (입력 감지) 기반으로 Publisher 를 만들고,
Publisher 가 뿜는 이벤트 기반 데이터 중, 실제 입력값인 String 값만 받도록 Map 해서
sink 를 통해 Subscriber 를 만든 후, 받은 이벤트 상태 (receiveCompletion) 과 값 (receiveValue) 를 출력하는 중 입니다.

*/

Operator 에는 다양한 종류가 있어, 필요에 따라 사용할 수 있습니다. 자주 사용될법한 Operator 들은 다음과 같이 있습니다.

    .map { }
    .flatMap { } // 이벤트가 1회 요청에 여러번 돌아올 때, 해당 값들을 모두 한번에 받습니다. (URLRequest 를 사용하는 시나리오가 대표적)
    .compactMap { } // nil 값은 제외하고 이벤트 값들을 방출합니다.
    .tryMap { } // 에러를 발생시키는 작업을 할 때, 에러가 발생하면 바로 Publisher 를 종료시킵니다.

    .filter { } // 이벤트 값들을 특정 조건에 따라 거릅니다.
    .tryFilter { } // 이벤트 값들을 특정 조건에 따라 거를 때, 에러가 발생하면 바로 Publisher 를 종료시킵니다.

    .setFailureType(to: Error.self) // 해당 에러를 Publisher 가 방출하는 Error 로 바꿉니다. 

    .decode(type: T.self, decoder: JSONDecoder()) // JSON 등의 데이터를 T 자료형으로 디코딩합니다. 실패하면 Publisher 를 종료시킵니다.

    .retry() // Publisher 의 흐름에 따라 내려올 때, 오류가 발생하면 retry의 횟수만큼 처음부터 다시 시도합니다. (URLRequest 를 실패했을 때, 1번 더 시도 하게 하는 등으로 사용할 수 있습니다.)
    .debounce(for: .milliseconds(500), scheduler: RunLoop.main) // 얼마나 자주 이벤트를 요청할 건지 debounce 를 통해 지정할 수 있습니다.

    .eraseToAnyPublisher() // Publisher 의 Operator 들을 거치며 생성된 중첩 상태의 OutPut 들 중 가장 마지막 타입을 기반으로 Publisher 로 1개의 타입으로 만듭니다.

Cancellabel

Subscriber 를 한번 만들면, 특정 이유에 의해서 종료되지 않는 이상 메모리에 계속해서 남아서 이벤트를 요청하게 됩니다. 이러한 Publisher 들은 필요 없을 때 해제해주지 않으면 메모리 누수로 이어지기 때문에 적절한 시점에서 해제하는 것이 필요합니다.

해제를 하는 방법에는 두가지 방법이 있습니다.

• Subscriber.cancel() 을 호출해서 직접 해제하는 방법
• Set<AnyCancellabel>() 에 Publisher 들을 모아서 해제하는 방법

Subscriber.cancel()

let sub = NotificationCenter.default
    .publisher(for: NSControl.textDidChangeNotification, object: filterField)
    .map( { ($0.object as! NSTextField).stringValue } )
    .filter( { $0.unicodeScalars.allSatisfy({CharacterSet.alphanumerics.contains($0)}) } )
    .debounce(for: .milliseconds(500), scheduler: RunLoop.main)
    .receive(on: RunLoop.main)
    .assign(to:\MyViewModel.filterString, on: myViewModel)
    // 어떤 Subscriber

sub?.cancel() // << 원하는 시점에서 Cancel()

Publisher 에서 sink() 혹은 assign() 을 통해 만들어진 Subscriber 들을, 원하는 시점에서 직접 Cancel() 을 호출해서 메모리에서 해제할 수 있습니다.

대표적인 시점은 UIKit 에서는 viewDidDisapeear() SwiftUI 에서는 OnDisAppear() 가 될 수 있습니다.

Set<AnyCancellabel>()

Subscriber 들이 다수 존재하고, 특이점이 없는 LifeCycle 을 가진다면 (즉, View가 사라질 때 함께 사라지면 된다면) Set<AnyCancellabel> 를 사용할 수 있습니다.

private var cancellabels = Set<AnyCancellable>() // Subscriber 들을 저장해놓은 Set


let sub = NotificationCenter.default
    .publisher(for: NSControl.textDidChangeNotification, object: filterField)
    .map( { ($0.object as! NSTextField).stringValue } )
    .filter( { $0.unicodeScalars.allSatisfy({CharacterSet.alphanumerics.contains($0)}) } )
    .debounce(for: .milliseconds(500), scheduler: RunLoop.main)
    .receive(on: RunLoop.main)
    .assign(to:\MyViewModel.filterString, on: myViewModel)
    .store(in: &cancellabels) // << Subscriber 의 마지막에 store() 를 통해 해당 Subscriber 를 Set<Cancellabel> 에 저장한다.


// 이후 Cancellabels 가 사라질 때, 
// Cancellabels 에 저장된 Subscriber 들도 모두 함께 메모리에서 해제됩니다.

더 쉽게 말하자면 Subscriber 는 한번 만들면 메모리 해제해줘야해요. Subscriber.cancel() 쓰거나, Set<AnyCancellabel> - Subscriber.store() 를 통해 메모리에서 해제할 수 있어요.

읽어주셔서 감사합니당 :)

출처

Combine from Apple Combine in Practice from Apple URLSession dataTask Vs Combine dataTaskPublisher from Medium by PTeng

주니어 개발자로, SwiftUI 를 통해 MVVM 에 대한 설명 후 SwiftUI 가 MVVM 에 찰떡이라고 느꼈던 주관을 풀어낸 글 입니다.

인스턴스는 다양하게 사용할 수 있는 단어이지만, 여기서는 메모리에 적재되어 실재하는 데이터 덩어리 라는 의미로만 사용됩니다.

독자는 SwiftUI 를 통해 UI 를 작성하는 방법을 알고 있으며, Modifier 와 Property Wrapper 가 무엇인지 알고 있다고 가정한 글 입니다.

디자인패턴이란?

모바일 개발을 진행하다보면 흔히들 MVC, MVP, MVVM 이라는 디자인 패턴을 보게 된다. 하지만 어떤 글을 보더라도, 뭐라카는데? 라는 느낌이 들 것이다. 왜 그럴까?

What's a design pattern? / Refactoring Guru 에서는 디자인 패턴을 다음과 같이 설명하고 있다.

디자인 패턴은 소프트웨어 개발 중 흔하게 발생하는 문제들을 해결할 수 있는 일반론들을 모아 놓은 것이다. 디자인 패턴은 미리 만들어진 청사진과 같아서, 현재 발생하고 있는 설계 (*design) 문제들을 자신의 코드에 맞게 커스터마이징해서 적용하여 사용하는 것이다.

따라서 특정 디자인 패턴을 찾았다고 해서, 코드에 복붙을 할 수는 없다. 디자인 패턴은 함수나 라이브러리가 아니라서, 특정 코드 블럭을 복붙한다고 해서 적용할 수 있는 것이 아니기 때문이다.

대신 디자인 패턴은 특정 문제를 풀기 위한 넓은 의미로서의 개념과 같다. 디자인 패턴을 사용하되, 세밀하게 현재 코드에 맞도록 적용함으로서 이 개념을 적용할 수 있다.

요약하자면 특정 문제를 해결하기 위한 일반적인 개념 으로 볼 수 있겠다. 그래서 디자인 패턴은 실제 코드와 실제 문제가 있어야만 적용할 수 있는 것이다.

현재 적용한 MVVM 구조

그러니까 바로 실제 MVVM 을 그냥 바로 봐보자. 원래 모르면 맞아야 한다. ㅎ

현재 진행하고 있는 프로젝트의 구조이다. 파란색은 MVVM 의 필수 요소이고, 초록색은 내가 임의로 사용하는 요소이다.

• Model: 데이터 구조 그 자체
• viewModel: 비즈니스 로직 모음집
• view: UI 모음집
• APIs, Utils: Singleton 을 보장해야 하는 API 이거나, 서버 등으로부터 복잡하게 데이터를 처리해야하는 API 모음집 API 는 서버, Util 은 로컬 (안드로이드에서 Repository 역할 / 목차: 데이터 가져오기)
  

예?

MVVM 디자인 패턴은 구조를 해결하기 위한 문제이다. 마이크로소프트 의 MVVM 을 설명을 빌리자면 다음과 같이 이야기할 수 있다.

MVVM(Model-View-ViewModel)은 UI 및 비 UI 코드(이하 비즈니스 로직) 를 분리하기 위한 UI 아키텍처 디자인 패턴입니다.

MVVM을 사용하여

1) UI를 선언적으로 정의하여 UI 와 관련된 내용만 깔끔하게 정리할 수 있으며, 2) 비즈니스 로직만 모아놓은 파일을 따로 정리할 수 있으며, 3) UI 와 비즈니스 로직을 거친 데이터를 동기화 상태를 유지할 수 있고, 4) 적절한 명령으로 UI 와 비즈니스 로직을 라우팅하여, 느슨할 결합을 제공할 수 있습니다.

*이 내용은 임의로 변형 & 요약한 내용입니다. 원본은 링크에서 확인해주세요.

1번과 2번 항목은 직관적이다. UI 코드들만 모아서 정리하고 싶고, 비즈니스 로직만 모아서 정리하고 싶다.

1. 1번을 실제 구조와 비교해보자. 구조의 사진을 다시 보면 Viwe 안에 폴더를 다시 나눠서 메인 화면, 스플래쉬 화면, 로그인 화면, 등등으로 나누어놓고, 펼쳐놓지 않았지만 ㅎ 내부에는 폴더 제목에 해당하는 UI 만 있을 것이라고 쉽게 예상할 수 있다. 실제로 내부에는 UI 와 관련된 내용 + List 등 아이템이 관련된 UI 파일만 있다.
2. 2번을 실제구조와 비교해보자. _참고로 Wassup 은 기획에서 나온 UI 컨셉 이름 중 하나이다. _ User 와 관련된 viewModel, Wassup 과 관련된 viewModel, Wassup 에서도 Poster, Video 관련된 viewModel 이 각각 있다. 각 파일들은 해당 개념, 즉 User / Wassup / Wassup 중에서도 Poster / Wassup 중에서도 Video 와 관련된 비즈니스 로직만 작성했다.

3번과 4번은 의미가 묘하니, 조금 더 살펴보자.

3번, UI 와 비즈니스 로직을 거친 데이터 를 동기화를 한다는 이야기를 풀어보면 비즈니스 로직 은 결국 로직일 뿐, 실제로 UI 에 들어가는 것은 데이터라는 것을 집중하면 쉽게 이해할 수 있다. UI 에서 참여하기 버튼 등을 클릭했을 때, 그것을 특정 비즈니스 로직 (실제로 참여할 수 있는가? 없는가? 등을 해결한 후) 데이터적으로 반응해야 하는데 MVVM 은 이를 쉽게 해결할 수 있다는 이야기다.

4번, 적절한 명령 으로 UI 와 비즈니스 로직 을 라우팅하여, 느슨한 결합 을 제공한다는 이야기를 풀어보면, 얼핏 보면 3번의 내용이 코드적으로 너무 복잡하고, 또 까딱하면 데이터가 서로 엮여서 수정하려면 대규모 리팩토링이 될 것 같은데 MVVM 은 적절한 명령 을 통해 느슨하게 연결해서, 코드가 종속적이지 않고 수정을 쉽게끔 할 수 있다는 이야기이다.

곰곰히 생각해보면 3번과 4번은 하나의 행동, UI 와 데이터 를 연결에 대해서만 이야기 하고 있다. 적절한 명령 을 쓰면 UI 와 비즈니스 로직을 처리한 데이터 를 동기화 하면서도 느슨한 결합 을 제공할 수 있다는 것이다.

애플은 마이크로소프트만큼 좋은 회사여서 그런지, SwiftUI 역시 적절한 명령 을 가지고 있다. 다음 실제 코드를 살펴보며 3번 내용 먼저 확인해보자.

@StateObject private var viewModel: UserViewModel 코드는 UserViewModel 자료형을 가진 변수에, @StateObject 라는 미리 SwiftUI 가 선언한 속성을 부여하고 있다.

공식문서 가라사대, @StateObject 는 SwiftUI View 의 파라미터에 쓸 수 있는 속성이다. 입력값이 ObservableObject, 관측 가능한 오브젝트, 이며 view 가 ObservableObject 의 속성이 변경될 때 마다 Publish, 출력하기를 바란다면 사용하기를 권장하고 있다.

Publish 가 강조된 이유는 단순히 출력, 출판을 한다는 의미가 아니라 Combine 에서 사용된 Publish 의 개념이기 때문이다.

이 글에서 Combine 개념은 필요없지만 궁금하다면 Introducing Combine 를 확인하면 알 수 있다.

쉽게말하면 값이 바뀔 때 마다 view 에 적용하고 싶으면 @StateObject 를 붙여서 사용하라고 할 수 있다. 단, 값 또한 관측이 가능해야 한다고 한다.

값의 관측은 viewModel 의 이야기이니, 이미 처리했다라고 생각하고 우선 UI 에 집중하며 계속해서 코드를 다시 정리해보자.

@StateObject private var viewModel: UserViewModel = UserViewModel() // 선언

var body: some Scene {
    windowGroupd {
        SplashView()
            .environmentObject(viewModel) 
            // 원하는 뷰에 적절한 명령을 통하여
            // 똑같은 인스턴스를 제공해주고 있다.
    }
}

이 코드에서 viewModel 을 초기화하였고, 이를 SplashView 에 .environmentObject() Modifier 를 사용하여 viewModel 을 전달하고 있다.

@StateObject 는 ObservableObject 를 선언할 때 사용하며, @ObservedObject 가 하나의 파일에서, 전달받아서 사용할 때, @environmentObject 는 인스턴스된 ObservableObject 를 상위뷰로부터 전달받을 때 사용된다.

주석

@ObservedObject 와 @EnvironmentObject 의 차이는 파라미터로 전달해야 하는가, Modifier 로 전달해야 하는가의 차이라고 생각한다.

코드로 보자면

struct MyView: View {
    @StateObject private var model = DataModel() // @State 로 선언
>
    var body: some View {
        Text(model.name)
        MySubView(model: model) // @ObervedObject 를 파라미터로 전달
        YourSubView()
            .environmentObject(model: model) 
            // @EnvironmentObject 를 Modifier 로 전달
    }
}
>
struct MySubView: View {
    @ObservedObject var model: DataModel
>
    var body: some View {
        Toggle("Enabled", isOn: $model.isEnabled)
    }
}
>
struct YourSubView: View {
    @EnvironmentObject var model: DataModel
>
    var body: some View {
        Toggle("Enabled", isOn: $model.isEnabled)
    }
}

공식문서에서는 @ObservedObject - for Subview @EnvironmentObject - for descendant 로 구분하였는데, 큰 설명은 없기에 취사선택 하면 되는 것 같다.

단 선언은 반드시 @StateObject 를 사용하며 외부에서 쓰지 못하도록 private 를 쓸 것을 권장하고 있다.

이를 무시하면 내부적으로 SwiftUI 프레임워크의 메모리 관리에 충돌을 일으키고 예상치 못한 결과를 야기한다고 한다.

전달된 EnvironmentObject 는 다음과 같이 사용할 수 있다.

참고

_Auth.auth().currentUser?.uid == nil 은 비즈니스 로직이니, viewModel 안에 있어야 하는게 맞고 그에 따라 전달받은 viewModel 내부에서 동기화된 데이터를 처리하는 것이 여태까지의 흐름으로는 맞다. _

_그럼에도 불구하고 Auth.auth().currentUser?.uid 를 직접 사용한 이유는 해당 속성은 Firebase 라는 라이브러리에서 직접 온 속성이자, 싱글턴 속성이기에 다이렉트로 작성하는 것이 가독성면에서 더 좋다고 판단하여 밖으로 꺼내었다. _

_ 디자인 패턴은 결국 특정 문제를 해결하고자 하는 것이니, 크게 어긋나지 않는 선에서 적절하게 맞추어도 괜찮다고 생각한다. _ 사실 혼자 하는 프로젝트라서 마음대로 한 것도 없지 않아 있긴 있다. 근데 파이어베이스는 저렇게 빼놓는게 더 직관적이지 않나? ..

정리하자면 UI 에서 적절한 명령 은 @ObservedObject 와 @EnvironmentObject 로, 인스턴스 여부에 따라 취사선택하여 비즈니스 로직을 처리한 데이터 를 UI 에 동기화 할 수 있다.

이제 4번 내용을 viewModel 과 함께 살펴보자. UI 의 적절한 명령 인 @ObservedObject 를 살펴볼 때, 이 입력값은 관측 가능한 오브젝트이어야 하며, 이는 viewModel 이 내부에서 처리를 해주어야 한다.

이 내용을 실제 코드와 함께 살펴보자.

UserViewModel 이라는 class 는 ObservableObject 프로토콜을 따르면서, viewModel 이라는 이름의 class 가 관측 가능한 오브젝트가 될 수 있도록 해주고 있다.

관측 가능한 오브젝트 가 된 viewModel 은 비즈니스 로직을 잔뜩 담고 있다. 크게 @Published 변수 와 이를 변경하는 함수들로 구분할 수 있다. login(), signUp() 등의 유저와 관련된 함수들은 내부에서 각각 자신이 담당하는 @Published 변수 를 변경하는 내용을 담고 있다.

함수 내용은 공개 불가능합니다.

놀랍게도 4번의 내용은 이렇게 끝이다. 그저 클래스가 ObservableObject 프로토콜을 따르며 (이 프로토콜은 바라는 내용도 없다!), 입력값에 따라 view 가 반응하기를 원하는 변수 앞에 @Published 를 붙임으로써 UI 와 비즈니스 로직을 처리한 데이터 를 라우팅하고 있다.

느슨한 결합 은 어떨까? 지금의 MVVM 구조를 통해 비즈니스 로직 내부에서도 서로 연관된 내용이 아니면 풀려있으며, 비즈니스 로직도 개발자가 원하는 크기와 단위, 개념으로 나눌 수 있게 된다. 이미 현재 적용한 MVVM 구조에서 살펴보았듯 User 와 Wassup 의 비즈니스 로직이 분리되어 있고, Wassup 내부에서 사용되는 Poster 와 Video 도 필요에 따라 분리되어 있는 것을 볼 수 있다.

viewModel 에게 ObervableObject 와 @Published 라는 적절한 명령 을 통해 UI 와 비즈니스 로직을 연결한 것이다.

그러면 현재 구조에서 사용되었던 Model 은 언제 쓰일까?

class UserModel: ObservableObject {
    @Published var user: UserModel = UserModel()
    ...
}

struct UserModel {
   .....
}

바로 유저 와 같이 큰 개념을 담아야 하는 변수의 커스텀한 자료형을 만들 때 사용된다. User 에는 프로필 사진, 이름 등 다양한 정보가 들어가야 하는데 이를 일일히 @Pubslih 를 사용하기보다 필요한 데이터만 모아서 깔끔하게 정리하고, 이후 초기화가 필요할 때도 Model 만 불러서 초기화할 수 있게 되었다.

무엇을 해결할 수 있었는가? (주관적 내용)

위에서 MVVM 의 설명을 이렇게 설명하였다.

MVVM(Model-View-ViewModel)은 UI 및 비 UI 코드(이하 비즈니스 로직) 를 분리하기 위한 UI 아키텍처 디자인 패턴입니다.

MVVM을 사용하여

1) UI를 선언적으로 정의하여 UI 와 관련된 내용만 깔끔하게 정리할 수 있으며, 2) 비즈니스 로직만 모아놓은 파일을 따로 정리할 수 있으며, 3) UI 와 비즈니스 로직을 거친 데이터를 동기화 상태를 유지할 수 있고, 4) 적절한 명령으로 UI 와 비즈니스 로직을 라우팅하여, 느슨할 결합을 제공할 수 있습니다.

*이 내용은 임의로 변형 & 요약한 내용입니다. 원본은 링크에서 확인해주세요.

이제 이걸 다시 정리해보자면 MVVM 디자인 패턴은 결국 코드를 어떻게 정리하면 이해하기 쉬울까? 에 대한 답변 중 하나라고 말할 수 있다.

하나의 파일에 UI 와 비즈니스 로직 을 몽땅 함께 담아버리면 나와 신만이 아는 코드에서 신만이 아는 코드가 될 수도 있고, 그렇다고 어설프게 나누면 뭐가 무엇이였는지 까먹어서 마찬가지로 신만이 아는 코드가 될 수도 있다.

MVVM 디자인 패턴은 코드를 UI 와 비즈니스 로직 으로 크게 나누고, 이 두개를 적절한 명령 을 통해 동기화 및 느슨한 결합 이라는 이점을 제공해주고 있다.

기나긴 글을 지나 MVVM 구조에 대해서 이야기를 나누어보았다. 이제는 실제 사례에서 어떤 점이 편하게 작용할 수 있었는지만 간편하게 살펴보자 :)

첫번째. UI 와 비즈니스 로직 코드가 분리되었기에, 테스트 하기 쉬워졌다. UI 를 먼저 작업하여 원하는 만큼 Preview 로 확인하고, 이후 비즈니스 로직을 넣어볼 수 있게 되어 개발할 때 API 호출 횟수 등에 신경쓰지 않고 미리 다 확인해 볼 수 있게 된 것이다. 이 이점은 다른 개발자와 함께 할 때 더욱 크게 다가오는데, 연결할 API 가 준비 안되어 있으면 다른 UI 작업을 하면 되고, UI 를 분업할 때도 어느 파트를 맡을 지 더욱 직관적으로 정리할 수 있게 된다.

두번째. MVVM 구조에 SwiftUI 에 적절한 명령 을 섞으니 마음이 편안한 선언형 프로그래밍이 가능해졌다. 이름, 개념 단위로 파일명을 작성하니 구조만 보더라도 무엇을 담당하는 파일인지 쉽게 알 수 있게되고, 무엇보다 재활용성이 높아졌다. 반복적으로 나오는 UI 혹은 두번 이상 쓰이는 비즈니스 로직들을 호출만으로 처리할 수 있게 되니 그 자체만으로 생산성 자체가 높아졌다.

세번째. 더욱 복잡한 구조를 설계할 수 있게 되었다.

이처럼 복잡한 화면을 처리해야할 때, 비즈니스 로직을 담당하는 viewModel 자체가 느슨한 결합 상태이니 핸들링이 쉬워졌다. 무엇보다도 위의 화면처럼 여러 리스트가 있을 때, 리스트 아이템에게도 viewModel 을 만들어줌으로써 코드들을 분리하여 관리할 수 있었고, 또 손 쉽게 리스트에게 데이터를 전달해줄 수 있었다.

응용하면 이런 내용도 해결할 수 있게 되었다.

해당 내용은 리스트를 생성하고 삭제해야하는 상황으로,

1. 리스트 아이템의 내용이 바로바로 반영될 것.
2. 삭제가 가능해야할 것.

이라는 문제를 해결해야 했던 상황이였다.

문제는 리스트를 위한 viewModel, 리스트 아이템을 위한 viewModel 로 구분하다보니 리스트를 삭제하기 꽤나 번거로운 상황이였다.

UI 코드 상으로는 리스트의 아이템을 표시할 때 아이템의 viewModel 만 사용하게 되는데, 막상 삭제할때는 UI 는 아이템 뷰에 있고, 메소드는 부모가 필요한 상황이라는 아이러니한 조건이었다. 이때 아이템의 viewModel 를 초기화할 때, 리스트 그 자체의 접근을 위한 viewModel 을 parent 로 함께 보내주어 직관적으로 아이템이 부모를 호출하여 스스로를 삭제할 수 있게 된 것이다.

결론

MVVM 구조를 SwiftUI 와 함께 알아보았다. MVVM 이 View(UI) - ViewModel(비즈니스 로직) - Model 의 축약어일 뿐이므로, 지금의 MVVM 구조가 진리도 아니고 개발자마다, 문제마다 다른 MVVM 구조를 가질 수 있다.

또적절한 방법 이라는 워딩을 사용하였지만, 이는 마이크로소프트가 제시할 때의 이야기이고, 애플과 SwiftUI 가 직접 MVVM 을 지원한다고 명시한 것은 아니다.

MVVM 이라는 단어는 애플 공식문서에서 공식적으로 언급이 된 적이 없다고 한다. SwiftUI에서 MVVM 사용을 멈추자"라고 생각이 들었던 이유

그럼에도 불구하고, 이번 구조는 MVVM 이 이루고자 했던 가장 큰 틀 : UI 와 비즈니스 로직을 구분하는 아키텍처 패턴 를 따랐다고 생각한다.

선언형 UI 를 사용하는 개발자가 늘어나면서 MVVM 이 꼭 필요한가? 에 대해서도 많은 논의가 있는 것으로 알고 있다.

개인적으로도 안드로이드의 Jetpack compose 를 사용할때는 워낙 자유롭기도 하고, by remember { }, LaunchedEffect 등의 코드를 UI 단에서 사용해야 하다보니 이렇게까지 비즈니스 로직을 UI 에서 섞을거라면 MVVM 을 왜 써야하지? 라는 의문도 있었다.

하지만 SwiftUI 를 기준으로는

• UI 내부에서 비즈니스 로직을 처리하기 까다롭다는 점
• 버튼이나 onAppear{} 등을 사용하지 않으면 body 내에서는 모든 코드가 View 프로토콜을 따라야 한다.

• Combine 을 비롯한 다수의 비즈니스 로직을 viewModel 이라는 레이어를 만들면 한 곳에서 직관적으로 풀 수 있다는 점

• PropertyWrapper 를 활용해서 Model 과 View 가 직접적으로 연결될 수 있다고 하더라도, MVC 패턴처럼 모델이 직접 상태를 관리할 것이 아니라면, 결국 누군가는 상태를 관리하고 관련된 메소드를 품고 있어야 한다는 점(Flux 패턴 등)

와 같은 문제를 속 시원하게 까지는 아니지만, 해결한다는 점에서 여전히 괜찮은 옵션 중 하나라고 생각이 든다.

출처

What's a design pattern? from Refactoring Guru 데이터 바인딩 및 MVVM from 마이크로소프트 @StateObject, @ObservedObject, Introducing Combine 등의 공식문서 from Apple

구조체(struct)와 클래스(class)는 범용적인 목적을 위해, 프로그래머의 코드를 유연하게 블록처럼 구성하는 것을 의미합니다. 프로그래머는 속성(properties) 과 메소드(methods) 기존에 사용했던 문법과 동일하게 변수, 상수, 함수 문법을 사용하여 구조체나 클래스 내부에 정의할 수 있습니다.

다른 프로그래밍 언어들과 달리, 스위프트는 구조체와 클래스를 위해 별도의 인터페이스나 구현을 위한 별도의 파일을 요구하지 않습니다. 스위프트에서는 프로그래머가 구조체나 클래스를 하나의 파일 안에 정의하고나면 다른 코드에서도 사용할 수 있게끔 자동으로 외부 인터페이스를 만들어 제공해줍니다.

Note : 클래스의 인스턴스를 통상 오브젝트(object) 로 칭합니다. 하지만 스위프트의 구조체와 클래스는 조금 더 기능적인 면모 ( much closer in functionality ) 가 부각되며, 이번 챕터 역시 클래스나 구조체의 인스턴스에 적용하는 기능들을 묘사할 예정입니다. 이에 따라 instance 라는 용어도 사용할 것 입니다.

블로그장 : 사견으로, 오브젝트와 인스턴스의 차이를 굳이 묘사하자면 (물론 말이 굉장히 많겠지만) 오브젝트를 객체, 즉 설계도로 보고 인스턴스를 객체에 데이터를 넣어서 메모리로 적재한 것으로 이해하고 있습니다. 다만 이런 구분 자체를 굳이 엄격하게 지을 필요는 없다고 생각되며, 구분 행위가 기능보다는 철학적인 면모를 더 내포한다고 생각합니다. 앞으로 나오는 인스턴스는 구분지을 수 있는 하나의 종류 혹은 메모리에 적재된 데이터 묶음 를 혼용해서 사용하는 것으로 이해하고 야매 번역하였음을 미리 알려드립니다. 관련된 StackOverFlow 를 첨부합니다.

* 볼드체만 해석 : 인스턴스와 클래스, 그리고 오브젝트는 같은 의미이며 종종 상호교환적으로 사용됩니다.

구조체와 클래스 비교하기 (Comparing Structures and Classes)

스위프트에서 구조체와 클래스는 유사한 부분이 많습니다.

• 속성을 정의하여 값을 저장할 수 있습니다.
• 메소드를 정의하여 함수를 제공할 수 있습니다.
• 서브스크립트를 정의하여 서브스크립트 문법으로 구조체나 클래스의 값에 접근할 수 있습니다. ex: array[1]
• 초기화(initializers) 를 정의하여 초기화 상태를 설정할 수 있습니다.
• 기본 구현을 넘어 구조체나 클래스의 기능(함수) 를 확장할 수 있습니다.
• 프로토콜을 준수하여 특정한 표준 함수를 제공하도록 할 수 있습니다.

클래스는 구조체는 할 수 없는 추가적인 능력들을 갖고 있습니다.

• 상속이 가능하여, 하나의 클래스의 특징들을 다른 클래스로 상속할 수 있습니다.
• 타입 캐스팅이 가능하여, 프로그래머가 런타임 때 클래스 인스턴스의 자료형을 확인하고 해석할 수 있습니다.
• 초기화해제 Deinitializers 가 가능하여 인스턴스된 클래스 내 할당된 리소스를 메모리로부터 해제할 수 있습니다.
• 참조 카운트 Reference counting 으로 클래스 인스턴스에 하나 이상의 참조를 허용합니다.

클래스가 추가적인 기능들로 지원하게 되면서 복잡도에 대한 비용이 증가하게 되었습니다.

구조체는 사용이 간단하기에 구조체를 사용하는 것을 권하며 클래스는 클래스의 사용이 적절하거나 필수적일 때만 사용할 것을 권합니다. 이는 프로그래머가 구조체나 열거형으로 커스텀 데이터 자료형을 정의하기를 추천드리는 것 입니다. 구조체와 클래스 중 하나를 선택하기

블로그장 : 클래스와 구조체의 선택에 대한 주석

클래스는 복사 시 주소를 참조하므로, 복사된 곳에서 클래스 속성의 변경이 원본에도 영향을 미치게 되어 전체적인 구조가 복잡해지게 됩니다.

class Cat {
    eye: String
}

var cheese = Cat(eye: "Gold")
var black = a
black.eye = "Black"

print(cheese.eye, black.eye)
// 출력 : Black, Black

반면 구조체는 복사 시 값만 전달할 뿐, 복사된 곳과 원본 사이에 연결성은 하나도 없습니다.

struct Cat {
    eye: String
}

var cheese = Cat(eye: "Gold")
var black = a
black.eye = "Black"

print(cheese.eye, black.eye)
// 출력 : Gold, Black

이를 쉽게 표현하기로는, 구조체는 복사본에게 원본을 사진을 인화하여 새롭게 준 것이고 클래스는 복사본에게 컴퓨터 내 사진 폴더 접속권을 준 것이라고 할 수 있습니다.

구조체는 인화한 사진을 주었으므로, 복사본에 낙서를 해도 영향을 안 받는 반면 클래스는 접속권을 준 사진 폴더 접속권을 주었기에, 사진에 낙서하거나 삭제하면 영향을 받습니다. Angela iOS 부트캠프 강의 (유데미)

또한 이외에도, 메모리에서 클래스의 저장공간은 힙 인데 반해 구조체의 저장공간은 스택이 됩니다. 스택에서의 저장은 가장 마지막 데이터의 위에 바로 저장하면 되므로 저장 속도가 굉장히 빠르지만, 힙에서의 저장은 동적으로 메모리의 빈 공간을 찾아서 저장해야 하므로 힙을 전체 탐색 -> 데이터 저장이라는 하나의 단계가 더 포함됩니다.

즉, 구조체는 저장 시 메모리의 빈 공간 탐색 없이 찾아도 되지만 클래스는 저장 시 메모리의 빈 공간을 탐색 후 저장해야 하므로 속도면에서 더 느릴 수 밖에 없습니다.

메모리 해제에도 스택은 사용이 끝나면 자연스럽게 해제되는 반면, 클래스는 클래스를 참조하고 있는 인스턴스들이 모두 해제되어야 클래스도 해제되므로 속도, 안정성 면에서 더욱 불안전 할 수 밖에 없습니다.

그렇기에 스위프트에서는 매우 적합한 사례거나 반드시 필요한 사례가 아니라면 구조체를 사용하는 것을 권고하는 것입니다. 앨런 Swift문법 마스터 스쿨

애플의 문서 구조체와 클래스 중 하나를 선택하기 에서 구조체의 사용을 "Using structures makes it easier to reason about a portion of your code without needing to consider the whole state of your app." 로 표현한 것도, 이와 유사한 의미입니다.

구조체는 스택에 저장되는 인스턴스이자 값 타입 이므로, 구조체가 다른 구조체에 영향을 주지 않는 반면 클래스는 다른 클래스에 영향을 주기 때문에 평범한 종류의 데이터, common kinds of data 라면 구조체를 사용하는 것을 권하는 것 입니다.

애플에서 언급하는 클래스를 사용해야 하는 경우는

• Object C 로 작성된 API 를 사용해서 데이터를 관리해야 하는 경우, API 가 상속받을 클래스를 요구하는 경우가 많으므로 클래스 사용 권장

• 메모리 관점에서 두 인스턴스가 동일한 지 확인해야 하는 경우, 즉 파일 관리, 네트워크, 하드웨어 기능 사용 등의 경우 클래스 사용 권장, 대표적인 예시로 사운드와 관련된 AVFoundation 의 AVAudioPlayer 로, 사운드를 담당하는 객체가 사운드를 할당받을 때 마다 새로운 인스턴스를 생성해버리면 오디오가 겹쳐서 들리게 됩니다.

정의 문법 (Definition Syntax)

구조체와 클래스는 정의하는 문법이 비슷합니다. '

struct SomeStructure {
    // 구조체 정의
}
class SomeClass {
    // 클래스 정의
}


// 실제 예시

struct Resolution {
    var width = 0
    var height = 0
}

class VideoMode {
    var resolution = Resolution()
    var interlaced = false
    var frameRate = 0.0
    var name: String?
}

Note : 프로그래머가 새로운 구조체나 클래스를 정의한다는 것은, 새로운 스위프트 자료형을 정의하는 것과 같습니다.

따라서 파스칼 케이스에 따라 대문자로 시작하고, 단어단위로 대문자를 붙여서 사용함으로써 기존의 스위프트 자료형들 (String, Int, Bool ...) 과 이름짓는 방식을 맞추는 것을 권해드립니다.

또한 속성이나 메소드에는 카멜 케이스에 따라 소문자로 시작하고, 단어단위로 대문자를 붙여서 자료형과 구분하는 것을 권합니다.

이때 속성들에는 기본값을 주거나, 안 줄 수도 있으며 기본값을 주지 않은 속성들은 초기화 시 반드시 값을 지정해야 합니다. 이때 자료형을 옵셔널로 지정하면 초기화 시 자동으로 nil 값이 적용됩니다.

구조체와 클래스 인스턴스 (Structure and Class Instances)

상단의 예시로 든 , Resolution 구조체와 VideoMode 클래스는 각각 Resolution 과 VideoMode 가 어떤 모습이어야 하는지 설명한 것에 불과합니다. 실제 모습으로 적용하고, 데이터로써 사용하려면 구조체나 클래스의 인스턴스를 만들어야 합니다.

구조체나 클래스를 인스턴스하는 문법은 다음과 같습니다.

let someResolution = Resolution()
let someVideoMode = VideoMode()

구조체와 클래스는 구조체(), 클래스() 형태로 인스턴스할 수 있으며, 자세한 사항은 Initialization 에서 다룹니다.

속성에 접근하기 (Accessing Properties)

인스턴스된 클래스나 구조체 바로 뒤에 . 을 사용하므로써 속성에 접근할 수 있습니다. 이때 속성이 또 다른 구조체나 클래스라면 다시 한번 . 를 사용하므로써 속성에 재접근할 수도 있습니다.

print("어떤 해상도의 넓이는 \(someResolution.width)")
// 출력: "어떤 해상도의 넓이는 0"

print("어떤 비디오의 넓이는 \(someVideoMode.resolution.width)")
// 출력: "어떤 비디오의 넓이는 is 0"

someVideoMode.resolution.width = 1280
print("어떤 비디오의 넓이는 이제 \(someVideoMode.resolution.width)")
// 출력: "어떤 비디오의 넓이는 이제 1280"

구조체 자료형의 똑똑한 속성 초기화 (Memberwise Initializers for Structure Type)

구조체는 클래스와 달리 구조체 내 초기화에 대한 내용이 안 적혀있다면 자동으로 memberwise initializer 를 생성합니다. 자세한 사항은 Initialization 에서 다룹니다.

구조체와 열거형은 값 타입이다. (Structures and Enumerations Are Value Types)

값 타입 (Value type) 은 변수나 상수에 할당하거나 함수에 인자로 전달될 때 그 값을 복사해서 주는 자료형을 의미한다.

사실 이전의 장들에서 당신은 여러번 값 타입들을 사용해왔습니다. 스위프트의 정수, 소수와 같은 숫자, Boolean, 스트링, 배열, 딕셔너리 등등은 모두 값 타입이고, 컴파일 뒷단에서는 구조체로써 적용되고 있습니다.

스위프트에서 모든 구조체와 열거형은 값타입입니다. 이 뜻은 어떤 자료형이나 열거형들을 인스턴스하고, 다른 코드에 전달할 때 언제나 그 값들을 복사해서 주는 것을 의미합니다.

Note : 표준 라이브러리로 정의되어 있는 배열, 딕셔너리, 스트링과 같은 컬렉션들은 복사를 위한 비용(cost) 를 줄이기 위해 최적화가 적용되어 있습니다. 이 컬렉션들은 바로 복사본을 만드는 것이 아니라, 각각의 원소들에 대해 동일한 메모리(인스턴스) 를 공유합니다. 이때 컬렉션 복사본들 중 하나가 수정된다면 모든 원소들이 수정 바로 전에 새롭게 값을 복사하고, 새롭게 메모리에 적재됩니다. 이 작업은 코드 상으로 항상 복사 이전에 수행됩니다.

let hd = Resolutioin(width: 1920, height: 1080)
let cinema = hd

위의 예시 코드에서 Resolution 는 구조체이므로 즉시 복사본 인스턴스가 만들어지고, 이렇게 만들어진 새로운 복사본이 cinema 에 할당됩니다. 비록 hd 와 cinema 가 똑같은 width, 똑같은 height 를 가졌더라도 컴퓨터 내부적으로 둘은 완벽하게 다른 인스턴스입니다.

이 예시를 통해 확인할 수 있습니다.

cinema.width = 2048

print("시네마는 이제 \(cinema.width) 픽셀입니다.")
// 출력 : "시네마는 이제 2048 픽셀입니다."

print("hd 는 아직 \(hd.width) 픽셀입니다.")
// 출력 : "hd 는 아직 1920 픽셀입니다."

도식화하면 이와 같습니다.

cinema 가 hd 값을 할당받았기 때문에, hd 는 자신과 동일한 값을 가진 새로운 인스턴스를 생성하여 cinema 에게 할당하였습니다. 이렇게 생성된 hd 와 cinema 는 같은 값을 가진 것 처럼 보여도, 서로 다른 인스턴스이기때문에 cinema 에서 값 변경이 hd 에 영향을 미치지 않는 것 입니다.

열거형에서의 예시입니다.

enum CompassPoint {
    case north, south, east, west
    mutating func turnNorth() {
        self = .north
    }
}
var currentDirection = CompassPoint.west
let rememberedDirection = currentDirection
currentDirection.turnNorth()

print("현재 방향은 \(currentDirection)")
print("기억하고 있는 방향은 \(rememberedDirection)")
// 출력 : "현재 방향은 north"
// 출력 : "기억하고 있는 방향은 west"

클래스는 참조타입이다. (Classes Are Reference Types)

참조타입은 변수나 상수에 할당되거나, 혹은 함수에 전달될 때 복사되지 않습니다. 복사 대신 현재 존재하는 인스턴스의 주소가 할당되거나, 전달됩니다.

let tenEighty = VideoMode()
tenEighty.resolution = hd
tenEighty.interlaced = true
tenEighty.name = "1080i"
tenEighty.frameRate = 25.0


let alsoTenEighty = tenEighty
alsoTenEighty.frameRate = 30.0

print(tenEighty.frameRate)
print(alsoTenEighty.frameRate)

// 출력 : 30
// 출력 : 30

클래스는 참조타입이기 때문에, tenEighty 와 alsoTenEighty 는 사싱 같은 VideoMode 인스턴스를 참조하고 있습니다. 결과적으로, 둘은 다른 이름으로 불리는 하나의 인스턴스가 되었으며, 이를 표현하면 다음과 같습니다.

이때문에, 프로그래머는 tenEighty 를 사용할 때마다 alsoTenEighty 를 고려해서 사용해야 합니다. 이와 반대로, 값 타입은 소스 파일 내 다른 값들과 상호작용이 막혀있기 때문에, 더 쉽게 사용할 수 있게 됩니다.

한편 tenEighty 와 alsoTenEighty 가 let 으로 선언되었음에도, 그 속성을 바꿀 수 있는 것도 주목해야 합니다. tenEighty 와 alsoTenEighty 가 상수로 저장하고 있는 것은 VideoMode 의 인스턴스, 그 자체가 아니라 VideMode 의 주소 를 저장하고 있는 것 입니다. 한편 VideoMode 의 속성은 let 이 아니므로, 이를 변경할 수 있게 되는 것 입니다.

식별 연산자 (Identity Operators)

클래스는 참조 타입이기 때문에, 다수의 상수와 변수가 하나의 클래스 인스턴스를 참조하는 것이 가능합니다. (구조체와 열겨형은 불가능합니다. 왜냐하면 구조체와 열거형은 언제나 새로운 인스턴스를 만들어서 할당하기 때문입니다.)

때때로 두 상수나 변수가 동일한 클래스 인스턴스를 참조하는지 확인하는 것이 유용할 때가 있는데, 이를 지원하기 위해 스위프트에서는 다음과 같은 연산자를 사용할 수 있습니다.

• 동일함, ===
• 동일하지 않음, !==

동일함은 두 상수나 변수가 동일한 클래스 인스턴스를 참조하고 있다는 것을 의미합니다. 여기서 동일이란 자료형의 제작자에 의해 두 인스턴스가 동일하거나, 동등한 값을 갖고 있음을 의미합니다.

포인터 (Pointers)

만약 당신이 C, C++, 혹은 Objective-C 경험이 있다면 이 언어들이 메모리의 주소를 언급하는 pointers 라는 개념을 사용하는 것을 알고 계실겁니다.

스위프트의 참조타입의 인스턴스를 갖고있는 상수나 변수는 C 의 포인터 개념과 유사하나, 그 상수나 변수 자체가 포인터임을 의미하진 않으며, 참조를 만들기 위해 * 작성을 필요로 하지 않습니다.

대신 이 참조들은 스위프트의 여느 다른 상수나 변수처럼 정의됩니다. 표준 라이브러리는 포인터와 버퍼 타입을 제공하고 있으며, 직접 포인터로 상호작용 해야한다면 Manual Memory Management 에서 확인할 수 있습니다.

참고

StackOverFlow - What is the difference between an Instance and an Object?

Angela iOS 부트캠프 강의 (유데미) : Advanced Swift Programming - Classes, Inheritance & Advanced Optionals

앨런 Swift문법 마스터 스쿨 : 클래스(Class)와 구조체(Struct)

열거형 (Enumeration) 은 관련이 있는 값들을 하나로 묶은 타입(자료형) 으로, 코드 상에서 개발자가 만든 자료형을 안전하게 사용할 수 있게 해줍니다.

열거형의 케이스들은 특정 데이터들을 담는 기능이 포함되어 있습니다. 이때 특정 데이터들은 어떠한 자료형이라도 케이스들이 저장할 수 있으며, 케이스 별로 서로 다른 데이터들을 포함할 수도 있습니다.

Swift 에서 열거형은 일급객체입니다. 열거형들은 클래스에서 지원하는 다양한 기능들을 지원하는데 연산 속성(computed properties) 를 통해 열거형의 현재 값에 대한 추가적인 정보를 제공하거나, 열거형에 속한 값을 함수로 제공하기 위해 메소드를 인스턴스하는 기능등이 포함됩니다.

일급객체 (First - Class) : 스위프트에서 일급객체란

• 상수(let)나 변수(var) 에 저장될 수 있습니다.
• 다른 함수에 인자로써 전달할 수 있습니다.
• 다른 함수의 리턴값으로 반환할 수 있습니다.
  3개의 특징을 지닌 type 을 의미합니다. 출처

열거형 문법 (Enumeration Syntax)

열거형은 enum 키워드를 사용하여 정의하고, 그 내부에 내용을 작성할 수 있습니다.
이때 내부의 내용이 여러개라면 쉼표를 통해 구분할 수도 있습니다.

enum CompassPoint {
    case north
    case south
    case east
    case west
}

enum Planet {
    case mercury, venus, earth, mars, jupiter, 
    saturn, uranus, neptune
}

Note: 다른 언어들과 달리, 스위프트의 열거형은 정수값을 기본적으로 선언하지 않습니다.

CompassPoint 의 예시를 보면 C 언어와 달리 north, south, east, west 는 각각 0, 1, 2, 3 으로 암시되지 않습니다. 그 대신, 열거형의 케이스들은 그 자체로써 자료형으로 정의됩니다.

각각의 열거형들은 새로운 자료형을 정의하는 것과 같습니다. 따라서 스위프트의 다른 자료형들처럼 대문자로 시작합니다. 열거형의 자료형은 단수형으로 지음으로써 이름 그 자체로써 이해하기 쉽도록 작성하는 것이 좋습니다.

어떤 변수가 한번 열거형으로 선언된다면 해당 변수는 새로운 값을 받을 때, 암시적으로 이전에 사용했던 열거형으로 선언될 것을 알 수 있습니다. 그렇기에 .case 의 형태로 짧게 표현하는 것도 가능합니다.

var directionToHead = CompoassPoint.west
directionToHead = .east

Switch 구문에서 열거형의 값 사용하기 (Matching Enumeration Values with a Switch Statement)

각각의 열거형 값들을 switch 구문에서 사용할 수도 있습니다. Control Flow 에서 언급하였듯, switch 구문은 반드시 모든 상황을 고려해야만 합니다.

이때 열거형을 사용하면, 열거형의 모든 케이스들에 각각 상황을 설정하였다면 default 구문을 사용하지 않아도 컴파일에서 오류가 발생하지 않습니다. 모든 상황을 고려했기 때문입니다. 반대로 열거형의 하나의 케이스라도 설정하지 않았다면 컴파일에서는 오류 구문을 발생시킵니다.

enum CompassPoint {
    case north
    case south
    case east
    case west
}

let directionToHead = CompassPoint.east

switch directionToHead {
case .north: 
    print("북쪽엔 다양한 행성들이 있어요!") 
case .south: 
    print("펭귄 조심하세요 ~") 
case .east: 
    print("태양이 떠오르는 방향이라네") 
case .west: 
    print("하늘이 푸르른 곳이라네") 
}

switch directionToHead {
case .north:
    print("북쪽엔 다양한 행성들이 있어요!")
default:
    print("동, 서, 남에는 다른 것들이 있죠!")
}

열거형 케이스들을 순회하여 사용하기 (Iterating over Enumeration Cases)

때때로 열거형들은 컬렉션처럼 순회하며 사용하는 것이 유용할 경우가 있습니다. 이때 열거형 뒤에 : CaseIterable 을 붙임으로써 얼거형을 컬렉션처럼 사용할 수 있습니다. 스위프트는 해당 열거형의 allCases 속성을 통해 해당 컬렉션들을 순회하며 보여주게 됩니다.

enum Beverage: CaseIterable {
    case coffe, tea, juice
}

let numberOfChoices = BeverageAllcases.count
print(numberOfChoices)

for beverage in Beverage.allCases {
    print(beverage)
}

// 3
// coffee
// tea
// juice

: CaseIterable 은 프로토콜입니다. 프로토콜에 대한 정보는 이곳에서 확인할 수 있습니다.

연관값 (Associated Values)

열거형의 케이스 값들에 특정한 데이터들을 함께 저장하는 것이 유용할 때가 있습니다. 이때 저장되는 데이터들을 연관값(associated value) 이라고 합니다.

스위프트 열거형에서 연관값은 어떠한 자료형의 값이라도 저장할 수 있으며, 하나의 열거형에서 연관값들의 자료형이 케이스마다 다르더라도 상관없습니다.

바코드를 통해 예시를 들 수 있습니다. 물품 추적 관리 시스템이 물건들을 관리할 때, 2개 종류의 바코드를 사용한다고 가정해봅니다.

첫번째 종류는 UPC 형식으로, 0 - 9 까지의 숫자를 사용하는 바코드입니다. 각 바코드들은 1자리의 시스템 숫자, 공장 번호 5자리 숫자, 물품 번호 5자리 숫자, 마지막으로 옳게 스캔되었는지 확인하는 1자리의 확인 숫자가 일렬로 늘어져있는 형태입니다.

두번째 종류는 QR 코드 방식으로 ISO 8859-1 방식의 문자를 2953 자까지 저장할 수 있는 형태입니다.

이런 경우 바코드 열거형을 생성한 후 UPC 형태는 4개의 정수를 가진 튜플로 지정하고, QR 코드는 길이 자유의 스트링으로 지정하는 것이 편리합니다.

코드로 표현하면 다음과 같아집니다.

enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}

var productBarcode = Barcode.upc(8, 85909, 51226, 3)
productBarcode = .qrCode("ABCDEFGHIJKLMNOPQRSTUWXYZ")

이때 하나의 변수인 productBarcode 가 .upc 일 때는 4개의 정수로 이루어진 튜플로, .qrCode 일 때는 스트링으로 이루어진 것을 확인할 수 있으며 자유롭게 변형이 가능한 것을 확인할 수 있습니다.

다만 이때, 하나의 변수가 upc 와 qrCode 두 가지 방식 모두를 포함할 수는 없습니다. 변수는 초기화되는 단 한번의 순간에, 하나만 저장할 수 있기 때문입니다.

위의 열거형에서 연관값들은 let, var 의 형태와 함께 각각 그 이름을 설정해줄 수 있습니다. 연관값들이 모두 let 이나 var 로 통일된다면 해당 선언은 case 바로 옆으로 빼서 사용할 수도 있습니다.

switch productBarcode {
    case .upc(let numberSystem, let manufacturer, let product, let check):
        print("UPC: \(numberSystem), \(manufacturer), \(product), \(check).")
    case .qrCode(let productCode):
        print("QR code: \(productCode).")
}

switch productBarcode {
    case let .upc(numberSystem, manufacturer, product, check):
        print("UPC: \(numberSystem), \(manufacturer), \(product), \(check).")
    case let .qrCode(productCode):
        print("QR code: \(productCode).")
}

위의 예시는 switch 에서 사용하였지만, enum 선언에서도 동일하게 사용할 수 있습니다.

원시값(Raw Values)

열거형 케이스들은 기본 값을 통해 사전에 값을 가질 수 있으며, 이때 사용되는 값들은 모두 동일한 자료형이어야 합니다. 그리고 이것을 원시값 이라고 지칭합니다.

enum ASCIIControlCharacter: Character {
    case tab = "\t"
    case lineFeed - "\n"
    case carriageReturn - "\r"
}

위의 예시는 아스키 컨트롤 문자들을 좀 더 사용하기 쉽도록 문자로 기본값을 설정한 열거형입니다.

이처럼 원시값은 문자열, 문자, 혹은 정수형이나 부동 소수점으로 정할 수 있습니다. 각 원시값들은 하나의 열거형내에서 고유해야합니다.

Note: 연관값과 원시값은 다른 용도로 사용됩니다. 원시값은 같은 열거형이면 언제나 같은 케이스를 지칭하지만,

연관값은 같은 열거형이여도 다른 케이스를 지칭할 수 있으며, 사실 케이스를 설명할 뿐 케이스를 지칭하지도 않습니다.

암시적 원시값 할당 (Implicitly Assigned Raw Values)

열거형을 정수나 스트링등의 원시값으로 설정할 때, 모든 케이스마다 일일히 값을 설정할 필요 없습니다. 하나만 설정하면, 스위프트가 알아서 값을 할당해줍니다.

enum Planet: Int {
    case mercuy = 1, venus, earth, mars, jupiter ...
}

위의 예시의 경우 mercury 가 1이므로, venus 부터 2, 3, 4 로 증가하며 원시값이 할당됩니다. 한편 특정 값을 설정하지 않고, : Int 를 사용하면 0부터 원시값이 할당됩니다.

원시값을 스트링으로 지정한다면, 각 케이스들의 이름이 원시값으로 할당됩니다.

원시값으로 초기화하기 (Initializing from a Raw Value)

열거형을 원시값과 함께 정의하면, 변수를 선언할 때 열거형의 파라미터로 원시값을 넣어서 초기화할 수 있습니다. (이때 파라미터의 이름은 rawValue 입니다.)

let possiblePlanet = Plaent(rawValue: 7)

이때 원시값을 제공하더라도, 해당 원시값이 열거형에 존재하는지 확신할 수 없기 때문에 원시값을 활용한 초기화는 옵셔널 타입으로 반환됩니다.

재귀 열거형 (Recursive Enumerations)

재귀 열거형은 열거형에서 자기 자신을 다시 호출하는 형태를 의미합니다.

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplecation(ArithmeticExpression, ArithmeticExpression)
}

(5 + 4) * 2 를 열거형을 통해 표현하고 싶을 때,

let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.addition(five, four)

let two = ArithmeticExpression.number(2)
let product = ArithmeticExpression.addition(sum, two)

func evaluate(_ expression: ArithmeticExpression) -> Int {
    switch expression {
    case let .number(value):
        return value
    case let .addition(left, right):
        return evaluate(left) + evaluate(right)
    case let .multiplecation(left, right):
        return evaluate(left) * evaluate(right)
    }
}

print(evaluate(product))
// 18

처럼 사용할 수 있습니다. ..이걸? 굳이?

함수는 특정한 업무를 수행하기 위해 모아놓은 코드 뭉치라고 할 수 있습니다. 함수를 사용하는 것은 "call"(호출) 이라고 표현하며 필요할 때 호출할 수 있습니다.

Swift 의 함수는 매개변수(parameters) 에 이름을 사용하지 않을 수 있으며, 기본 값을 지정해줄 수도 있는 등 다양한 편의를 제공합니다.

한편 모든 Swift 의 함수들은 자료형을 가지며, 매개변수 자료형과 반환값(Return) 자료형을 포함하고 있습니다. 함수의 자료형들은 다른 자료형과 마찬가지로 자유롭게 사용할 수 있으며, 함수 내에서 함수를 호출 하는 등의 기능도 제공하고 있습니다.

Defining and Calling Functions(함수 정의와 함수 호출)

함수를 정의할 때, 함수에는 이름이 필요합니다. 또한 함수가 입력값 - 매개변수(파라미터) - 을 받거나, 함수가 종료될 때 반환할 값 - 리턴 값(return)- 을 받는다면 추가적으로 함수를 정의할 때 함께 정의해야 합니다.

모든 함수는 함수의 이름을 가지고 있으며, 보통 그 이름은 함수가 수행할 내용을 묘사하도록 작성합니다. 함수를 사용하고 싶다면, 함수의 이름과 함수가 받는 입력값 (매개변수) 를 작성함으로써 호출 할 수 있습니다.

예시는 다음과 같습니다.

func greet(person: String) -> String {
    let greeting = "안녕, " + person + "!"
    return greeting
}

print(greet(person: "안나"))
// Prints "안녕, 안나!"
print(greet(person: "브라이언"))
// Prints "안녕, 브라이언!"

greet(person:) 함수를 호출하기 위해, 함수의 이름 을 적고, person: 인자 라벨 뒤에 String 값을 전달한 코드를 위에서 확인할 수 있습니다.

Note : print(_:separator:terminator:) 역시 함수인데, 첫번째 인자 (== 매개변수) 에 별 다른 라벨이 붙지 않은 것을 확인할 수 있습니다. 또한 2 번째, 3 번째인자들은 Optional 인 것을 확인할 수 있는데, 이 두 인자는 기본 값 default Value 를 갖기 때문입니다. 이와 같은 함수의 문법들은 하단에서 설명합니다.

Function Parameters and Return Values (함수의 매개변수와 반환 값)

Swift 에서 함수의 매개변수와 반환값은 굉장히 자유롭게 사용할 수 있습니다.

Function without Parameters (매개변수 없는 함수)

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())
// Prints "hello, world"

Function with Multiple Parameters (매개변수가 여러개인 함수)

func greet(person: String) -> String {
    let greeting = "안녕, " + person + "!"
    return greeting
}

func greetAgain(person: String) -> String {
    return "다시 한번 안녕," + person + "!"
}

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return greetAgain(person: person)
    } else {
        return greet(person: person)
    }
}
print(greet(person: "팀", alreadyGreeted: true))
// Prints "다시 한번 안녕, 팀!"

person 과 alreadyGreeted 라는 2개의 매개변수를 받고서, if 문에서 alreadyGreeted 매개변수를 통해 분기문을 만들고, 상황에 따라 각기 다른 함수를 호출하는 모습을 확인할 수 있다.

Functions without Return Values(리턴값이 없는 함수)

func greet(person: String) {
    print("안녕, \(person)!")
}
greet(person: "데이브")
// Prints "안녕, 데이브!"

함수 정의에서 반환 화살표 -> 를 통해 반환 값을 명시하지 않아서, 함수 호출에도 불구하고 함수 자체의 반환값은 없다.

혹은 함수의 리턴값을 의도적으로 무시할 수도 있다.

func printAndCount(string: String) -> Int {
    print(string)
    return string.count
}
func printWithoutCounting(string: String) {
    let _ = printAndCount(string: string)
}
printAndCount(string: "hello, world")
// 출력: "hello, world" 이며, 반환값은 12이다.
printWithoutCounting(string: "hello, world")
// 출력: "hello, world" 이며, 아무런 값도 반환하지 않는다.

Note: 함수의 리턴값은 무시될 수 있지만, 함수가 리턴을 정의했다면 함수는 반드시 특정 자료형을 리턴해야한다. 리턴이 정의된 함수가 리턴을 하지 않으면 컴파일 에러가 발생한다.

Functions with Multiple Return Values(여러개의 리턴값이 있는 함수)

함수는 여러개의 리턴 값을 하나로 뭉쳐서 리턴할 수 있다.

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("최소는 \(bounds.min) 이고, 최대는 \(bounds.max) 이다.")
// 출력: "최소는 -6 이고, 최대는 109 이다."

이때 bounds 가 tuple 형태의 리턴값을 받았음에도, 별다른 이름, min, max, 을 지정하지 않았는데 출력에서는 사용할 수 있는 이유는 함수가 리턴할 때 이미 튜플들의 이름을 정의했기 때문이다.

Optional Tuple Return Types (튜플 리턴값 옵셔널 처리)

만약 리턴 값이 튜플 자료형인데, 튜플 자체가 nil (없음) 에 해당할 수 있다면 tuple 전체에 ? 를 붙임으로써 optional 타입으로 반환할 수 있다.

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

이때 만약 튜플 이상의 자료를 리턴하고 싶다면 (Int, String, Int) 형태로 계속해서 붙여서 사용할 수 있으며, Optional 역시 동일하게 적용된다.

Note: (Int?, Int?) 와 (Int, Int)? 는 다르다. 전자는 각각의 값이 nil 일 수 있다면, 후자는 튜플 전체 자체가 nil 일 수 있음을 명시한 것이다.

Functions With an Implicit Return (함수의 암시적 리턴)

만약 함수가 리턴값이 있는데, 함수가 1줄이라면 암시적으로 그 1줄의 내용이 리턴된다.

func greeting(for person: String) -> String {
    "안녕, " + person + "!"
}
print(greeting(for: "데이브"))
// Prints "안녕, 데이브!"

func anotherGreeting(for person: String) -> String {
    return "또 한번 안녕, " + person + "!"
}
print(anotherGreeting(for: "데이브"))
// Prints "또 한번 안녕, 데이브!"

Shorthand Getter Declaration 에서 프로퍼티의 get 을 통한 암시적 반한을 확인할 수 있다.

Note: 함수가 리턴값이 없는데 암시적 리턴을 사용할 수는 없다.

Function Argument Labels and Parameter Names(함수의 인자 라벨과 파라미터 이름들)

각 함수의 파라미터는 인자 라벨 과 파라미터 이름 을 동시에 갖고 있다. 라벨은 함수를 호출할 때 사용되며, 파라미터는 함수 내에서 사용할 때 사용한다. 기본적으로 인자 라벨과 파라미터는 동일한 이름을 갖는다.

Specifying Argument Labels (인자 라벨 특정하기)

다음과 같은 방법으로 인자 라벨을 특정할 수 있다.

func someFunction(argumentLabel parameterName: String) {
    // 함수 내에서, 파라미터 이름은 parameterName 이 된다.
    // 함수 호출 시, 인자 라벨은 argumentLabel 이 된다.
    print(parameterName)
}
someFunction(argumentLabel: "그라데이션")

// 출력 : 그라데이션

응용은 다음과 같이 할 수 있다.

func greet(person: String, from hometown: String) -> String {
    return "안녕 \(person)!  \(hometown)에서 널 만나니 기뻐!"
}
print(greet(person: "빌", from: "쿠퍼티노"))
// Prints "안녕 빌!  쿠퍼티노에서 널 만나니 기뻐!"

Omitting Argument Labels (인자 라벨 생략)

만약 라벨이 필요 없다면 _ 을 사용해서 생략할 수 있습니다.

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    // 함수 내에서 firstParameterName 과 secondParameterName 은 호출될 때 받은 1과 2를 지칭합니다.
}
someFunction(1, secondParameterName: 2)

Default Parameter Values (파라미터 기본값)

파라미터 자료형 다음에 그 값을 할당해줌으로써, 함수의 어떤 파라미터든 기본값을 정의해줄 수 있습니다.

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // someFunction 을 호출할 때, 2번째 인자를 생략하면
    // 자동적으로 12가 할당되서 사용됩니다.
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault 의 값은 6으로 새롭게 할당됩니다.
someFunction(parameterWithoutDefault: 4) // parameterWithDefault 의 값이 기본값인 12로 할당됩니다.

Variadic Parameters (가변 파라미터)

가변 파라미터는 특정 값을 0개부터 다양한 값을 받을 수 있습니다. 가변 파라미터는 상수 배열로 할당됩니다.

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 5개의 평균인 3이 반환된다.
arithmeticMean(3, 8.25, 18.75)
// 3개의 평균인 10이 반환된다.

In-Out Parameters (인 아웃 파라미터)

함수의 매개변수들은 기본적으로 상수입니다. 함수 내에서 매개변수를 변경하려고 시도하면 컴파일 단계에서 에러를 발생시킵니다. 이는 파라미터를 실수로 변화시키지 못하도록 미연에 방지하는 역할을 합니다.

만약 함수내에서 파라미터의 값을 변경하고 싶으며, 이 변경이 원본 값에도 영향을 미치도록 하고 싶다면 파라미터를 in-out 파라미터로 정의할 수 있습니다.

파라미터 앞에 in-out 파라미터를 정의하여 사용할 수 있습니다. 함수 내에서 in-out 파라미터가 변경되면 함수에서 변경과 함께 원본 값 역시 변경됩니다.

in-out 파라미터는 반드시 변수, var 만 전달할 수 이습니다. in-out 파라미터에는 상수나 리터럴 값을 전달할 수 없는데, 상수나 리터럴은 수정이 불가능하기 때문입니다.

인자로 전달할때는 & 를 붙여서 전달하며, 함수 내에서 이 변수가 수정될 수 있다는 의미를 가집니다.

예시입니다.

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt는 \(someInt) 이며, anotherInt는 이제 \(anotherInt) 입니다.")
// Prints "someInt는 이제 107 이며, anotherInt는 이제 now 3"

Note: in-out 파라미터는 함수가 리턴하는 것과 다릅니다. 상단의 예시에서 swapTwoInts 는 리턴값이 없음에도 someInt 와 anotherInt 가 변경된 것을 확인할 수 있습니다. in-out 파라미터는 함수 안에서 함수 밖에 영향을 미치는 대안적인 방법으로 생각해볼 수 있습니다.

Function Types (함수의 자료형)

모든 함수는 특정한 함수의 자료형이 존재하며, 파라미터 자료형과 리턴 자료형으로 구성되어 있습니다.

예시입니다.

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

위의 함수는 다음과 같이 해석할 수 있습니다. "함수는 2개의 파라미터를 받는데, 둘 다 Int guddlrh, Int 자료형의 값을 반환하는구만"

다른 예시입니다.

func printHelloWorld() {
    print("hello, world")
}

위의 함수는 다음과 같이 해석할 수 있습니다 "함수는 파라미터가 없고, Void 를 리턴하는구만"

Nested Functions (중첩 함수들)

함수는 함수내에서도 다른 함수를 호출할 수 있습니다. (블로거: 물론 자기 자신도요 ! )

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backward ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero 는 이제 stepForward 와 중첩되어 호출됩니다.

while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!

Swift 는 다양한 제어 흐름을 제공합니다. 제어 흐름에는 for-in, while, if, guard, switch 등과 이를 조절하는 break, continue 등이 있습니다.

For-In Loops (For-in 반복)

For-in 반복 구문은 배열이나 특정 범위의 숫자, 혹은 문자열 내 캐릭터를 반복하는데 사용됩니다.

let names = ["안나", "알렉스", "브라이언", "잭"]
for name in names {
    print("안녕, \(name)!")
}
// 안녕, 안나!
// 안녕, 알렉스!
// 안녕, 브라이언!
// 안녕, 잭!

For-in 구문은 딕셔너리 역시 반복하여 접근할 수 있습니다. 딕셔너리의 원소들은 (key, value) 튜플로 반환되므로, (key, value) 를 for-in 반복 구문에 지정함으로써 이를 응용하여 사용할 수 있습니다. 단, 딕셔너리는 그 자체로 비정렬 컬렉션(Collection) 이기 때문에, for-in 반복 구문의 순서가 언제나 일정하지는 않습니다.

let numberOfLegs = ["거미": 8, "개미": 6, "고양이": 4]
for (animalName, legCount) in numberOfLegs {
    print("\(animalName)는 \(legCount)개의 다리가 있어요.")
}
// 고양이는 4개의 다리가 있어요.
// 개미는 6개의 다리가 있어요.
// 거미는 8개의 다리가 있어요.

for-in 구문을 통해 숫자 범위를 반복할 수도 있습니다. 이때 범위를 닫힌 범위로 사용하고 싶다면 ..< , ..> 를 사용할 수 있으며 열림 범위로 사용하고 싶다면 ... 를 사용할 수 있습니다.

for index in 1...5 {
    print("\(index) 곱하기 5 는 \(index * 5)")
}

// 1 * 5 는 5
// 2 * 5 는 10
// 3 * 5 는 15
// 4 * 5 는 20
// 5 * 5 는 25

let minutes = 60
for tickMark in 0..<minutes {
    print(tickMark, terminator: " ")
}
// 1 2 3 4 ..... 59

for-in 구문에서 사용되는 반복 지정자 (index) 는 for-in 구문 내에서 정의하여 사용할 수 있으며, let 키워드 없이도 상수로써 선언됩니다. 반복 지정자가 필요없다면 _ 를 사용하여 무시할 수도 있습니다.

let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
}
print("\(base)의 \(power)제곱은 \(answer)")
// Prints "3의 10제곱은 59049"

for-in 구문에서 반복 연산자에 특정 조건을 붙이고 싶다면 stride(from:to:by:) 혹은 stirde(from:through:by:) 를 사용할 수 있습니다.

let minutes = 60
let minuteInterval = 5
for tickMark in stride(from: 0, to: minutes, by: minuteInterval) {
    // 5분 단위로 반복하되, to 이전까지만 반복
    // (0, 5, 10, 15 ... 45, 50, 55)
}

let hours = 12
let hourInterval = 3
for tickMark in stride(from: 3, through: hours, by: hourInterval) {
    // 3 단위로 증가하며, through 를 포함해서 반복
    // (3, 6, 9, 12)
}

While

while 반복문은 조건이 성립될 때 까지 구문을 반복으로, 다음과 같은 일반적인 형태를 갖습니다.

Swift Language Guide - Control Flow - While 에서 주사위 놀이를 들어 while 을 설명하는데, 이는 생략하였습니다. 확인하기

while 은 repeat-while 형태로도 사용할 수 있습니다. 일반적인 형태는 다음과 같습니다.

Conditional Statements(조건 구문)

Swift 는 if 와 switch 2개의 조건 구문을 제공합니다. if 문은 상대적으로 짧은 구문에, switch 문은 상대적으로 길거나 복잡한 구문에 적합합니다.

if

if 구문은 주어진 조건이 참인 경우에만 실행되는, 분기를 만드는 조건문입니다.

var temperature = -5
if temperature <= 0 {
    print("밖이 매우 춥네요. 목도리를 입는게 어떨까요?")
}
// 출력: "밖이 매우 춥네요. 목도리를 입는게 어떨까요?"

if 구문 후 else 를 붙여서 다른 분기에 대한 실행구문을 설정할 수 있습니다. 이때 else 구문은 선택사항입니다.

var temperature = 10
if temperature <= 0 {
    print("밖이 매우 춥네요. 목도리를 입는게 어떨까요?")
} else {
    print("밖이 춥진 않네요. 티셔츠 입어요."
}
// 출력: "밖이 춥진 않네요. 티셔츠 입어요."

if 구문에서 여러개의 분기가 필요하다면 다음과 같이 사용할 수도 있습니다.

var temperature = 35
if temperature <= 0 {
    print("밖이 매우 춥네요. 목도리를 입는게 어떨까요?")
} else if temperature >= 30 {
    print("밖이 진짜 더워요. 자외선 차단제를 잊지마세요.")
} else {
    print("밖이 춥진 않네요. 티셔츠 입어요."
}
// 출력: "밖이 진짜 더워요. 자외선 차단제를 잊지마세요."

Switch

switch 구문은 특정 값이 여러개의 조건 중에서 참이 될 수 있는지 고려할 때 사용됩니다. 이때 특정 적합한 조건이 성립되면 해당 조건의 코드를 실행합니다. switch 는 여러개의 상황을 고려해야 할 때 if 구문 대신 사용할 수 있습니다.

switch 구문의 case 들은 value 가 성립할 가능성이 있는 구문들입니다. 만약 value 가 case 에 해당하면 그 구문에 해당하는 코드를 실행하게 됩니다. 한편 switch 는 반드시 해당 value 가 가질 수 있는 모든 상황을 고려해야하며, default 를 통해 case 에 해당하지 않는 값들에 대한 내용을 정의할 수 있습니다.

다음과 같은 예시를 들 수 있습니다.

let someCharacter: Character = "z"
switch someCharacter {
case "a":
    print("알파벳 첫번째 글자")
case "z":
    print("알파벳 마지막 글자")
default:
    print("알파벳들 중 하나")
}
// 출력: "알파벳 마지막 글자"

No Implicit Fallthrough(암시적으로 내려가지 않음)

switch 구문은 특정 case 가 성립되었을 때 해당 구문을 실행한 후 그 다음으로 내려가지 않습니다. 대신 처음으로 case 가 성립된다면 구문 실행 후 즉시 switch 구문에서 빠져나오게 됩니다. 이를 통해 switch 는 더욱 안정적이고 직관적인 사용을 제공합니다.

한편 switch 의 case 는 빈 구문으로 설정할 수 없습니다. 다음과 같은 예시를 들 수 있습니다.

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a": // 불가능, 케이스가 비어있다.
case "A":
    print("The letter A")
default:
    print("Not the letter A")
}
// case "a" 가 빈 구문이므로 compile 에러를 발생시킨다.

switch 의 case 에서 여러개의 값을 확인해야 한다면 다음과 같이 활용할 수 있습니다. 이때 여러줄에 걸쳐서도 사용할 수 있습니다.

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a", "A":
    print("A 알파벳")
default:
    print("A 알파벳이 아님")
}
// Prints "A 알파벳"

Interval Matching(범위로 확인)

switch 구문에서 case 는 범위로도 활용할 수 있습니다.

let approximateCount = 62
let countedThings = "moons orbiting Saturn"
let naturalCount: String
switch approximateCount {
case 0:
    naturalCount = "no"
case 1..<5:
    naturalCount = "a few"
case 5..<12:
    naturalCount = "several"
case 12..<100:
    naturalCount = "dozens of"
case 100..<1000:
    naturalCount = "hundreds of"
default:
    naturalCount = "many"
}
print("There are \(naturalCount) \(countedThings).")
// Prints "There are dozens of moons orbiting Saturn."

Tuples

switch 구문에서 tuple 을 활용할 수도 있습니다. 이때 특정 튜플의 원소를 비교하고 싶지 않다면 _ 를 사용할 수 있습니다.

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    print("\(somePoint) 는 원점에 있습니다.")
case (_, 0):
    print("\(somePoint) 는 x 축에 있습니다.")
case (0, _):
    print("\(somePoint) 는 y 축에 있습니다.")
case (-2...2, -2...2):
    print("\(somePoint) 는 박스 안에 있습니다.")
default:
    print("\(somePoint) 는 박스 밖에 있습니다.")
}
// Prints "(1, 1) 는 박스 안에 있습니다."

이때 No Implicit Fallthrough 에서 확인하였듯, 상단의 case 가 먼저 성립되면 하단의 case 들은 실행도 되지 않고 무시됩니다.

tuple 에서 특정 튜플 원소를 변수로 사용하고 싶다면 다음과 같이 사용할 수 있습니다.

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
    print(" \(x) 값을 가지며 x 축에 있음.")
case (0, let y):
    print(" \(y) 값을 가지며 y축에 있음.")
case let (x, y):
    print("(\(x), \(y)) 값을 가지며 x,y 축 안 어딘가에 있음.")
}
// Prints "2 값을 가지며 x 축에 있음."

이때 이 switch 구문은 default 가 없음에도 마지막 case 인 let (x, y) 가 모든 상황을 포괄하기 때문입니다.

Where

switch 구문의 case 는 where 를 활용하여 특정 조건을 더할 수 있습니다.

let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
    print("(\(x), \(y)) 는 x == y 선에 있습니다.")
case let (x, y) where x == -y:
    print("(\(x), \(y)) 는 x == -y 선에 있습니다.")
case let (x, y):
    print("(\(x), \(y)) 는 무작위 선에 있습니다.")
}
// Prints "(1, -1) 는 x == -y 선에 있습니다."

Compound Cases (복합 케이스)

switch 구문에서 복합 상황은 다음과 같이 표현할 수 있습니다.

let someCharacter: Character = "e"
switch someCharacter {
case "a", "e", "i", "o", "u":
    print("\(someCharacter) 는 모음이다.")
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
     "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
    print("\(someCharacter) 는 자음이다.")
default:
    print("\(someCharacter) 는 자음도, 모음도 아니다.")
}
// Prints "e 는 모음이다."

복합 상황에서도 특정 원소에 이름을 선언할 수 있습니다.

let stillAnotherPoint = (9, 0)
switch stillAnotherPoint {
case (let distance, 0), (0, let distance):
    print("축에 있으며, 원점으로부터 \(distance) 멀다.")
default:
    print("축에 있지 않다.")
}
// Prints "축에 있으며, 원점으로부터 9 멀다."

Control Transfer Statements (생략 구문)

생략에는 다음과 같은 키워드들을 사용할 수 있습니다.

• continue
• break
• fallthrough
• return
• throw

continue 는 반복 구문에서 사용할 수 있으며 continue 밑의 구문을 실행하지 않고 다음 반복을 진행합니다.

let puzzleInput = "great minds think alike"
var puzzleOutput = ""
let charactersToRemove: [Character] = ["a", "e", "i", "o", "u", " "]
for character in puzzleInput {
    if charactersToRemove.contains(character) {
        continue
    }
    puzzleOutput.append(character)
}
print(puzzleOutput)
// Prints "grtmndsthnklk"

break 는 반복 구문에서 사용할 수 있으며 반복구문을 빠져나옵니다.

fallthrough 는 switch 구문에서 사용되며, case 에서 사용 시 계속해서 다음 case 를 찾아서 실행하게 됩니다.

let integerToDescribe = 5
var description = "숫자 \(integerToDescribe) 는"
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
    description += " 소수이며,"
    fallthrough
default:
    description += " 자연수이다."
}
print(description)
// Prints "숫자 5 는 소수이며, 자연수이다."

Labeled Statements(라벨 구문)

중첩 구문을 사용하면 복잡한 조건 구문도 설계할 수 있습니다. 단 이때 continue, break 등을 사용하려면 불필요한 코드를 추가하게 될 수 있는데 이를 label 을 붙임으로써 해결할 수 있습니다.

gameLoop: while square != finalSquare {
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    switch square + diceRoll {
    case finalSquare:
        // diceRoll will move us to the final square, so the game is over
        break gameLoop
    case let newSquare where newSquare > finalSquare:
        // diceRoll will move us beyond the final square, so roll again
        continue gameLoop
    default:
        // this is a valid move, so find out its effect
        square += diceRoll
        square += board[square]
    }
}
print("Game over!")

Early Exit

guard let 을 활용하여 필요하지 않은 정보가 조건에 맞지 않는 구문이 왔을 때 해당 함수를 빠르게 빠져나올 수 있습니다.

func greet(person: [String: String]) {
    guard let name = person["name"] else {
        return
    }

    print("안녕 \(name)!")

    guard let location = person["location"] else {
        print("오늘 너가 가는 길의 날씨가 좋았으면 좋겠다.")
        return
    }

    print("오늘 너가 가는 \(location) 날씨가 좋았으면 좋겠다.")
}

greet(person: ["name": "존"])
// Prints "안녕 존!"
// Prints "오늘 너가 가는 길의 날씨가 좋았으면 좋겠다."
greet(person: ["name": "제인", "location": "쿠퍼티노"])
// Prints "안녕 제인!"
// Prints "오늘 너가 가는 쿠퍼티노 날씨가 좋았으면 좋겠다."

Checking API Availability

Swift 는 API 를 활용할 수 있는지 확인할 수 있는 기능을 내장하고 있으며, 이를 통해 사용할 수 없는 API 를 호출하지 않게 할 수 있습니다.

if 혹은 guard 구문과 함께 사용하여 다음과 같이 활용할 수 있습니다.

if #available(iOS 10, macOS 10.12, *) {
    // Use iOS 10 APIs on iOS, and use macOS 10.12 APIs on macOS
} else {
    // Fall back to earlier iOS and macOS APIs
}

@available(macOS 10.12, *)
struct ColorPreference {
    var bestColor = "blue"
}

// ------------------------------

func chooseBestColor() -> String {
    guard #available(macOS 10.12, *) else {
        return "gray"
    }
    let colors = ColorPreference()
    return colors.bestColor
}

// ------------------------------

if #available(iOS 10, *) {
} else {
    // Fallback code
}

if #unavailable(iOS 10) {
    // Fallback code
}

노드 추가와 마찬가지로 3개의 방법으로 노드를 추가할 수 있습니다.

1. pop : 링크드리스트 내 가장 첫번째 노드를 삭제합니다.
2. removeLast: 링크드리스트 내 가장 마지막 노드를 삭제합니다.
3. remove(at:) : 특정 인덱스의 노드를 삭제합니다.

pop

struct LinkedList<T> {
    ...
    mutating func pop() -> T? {
        defer {
            head = head?.next
            if isEmpty{
                tail = nil
            }
        }
        return head?.value
    }
}
// 출력 예제
var list = LinkedList<Int>()
list.push(3)
list.push(2)
list.push(1)

print("pop 이전의 링크드리스트 : \(list)")
let poppedValue = list.pop()
print("pop 이후의 링크드리스트 : \(list")
print("pop 한 값 : " + String(poppedValue))

// pop 이전의 링크드리스트 : 1 -> 2 -> 3
// pop 이후의 링크드리스트 : 2 -> 3
// pop 한 값 : Optional(1)

pop 는 링크드리스트의 head 를 삭제하고 리턴하며, head.next 를 새로운 head 로 설정하는 메소드입니다.

이때 리턴되는 값은 nil 일 수 있기에 (비어있는 링크드리스트를 pop 하는 경우) optional 값으로 주어지게 됩니다.

TMI 특기할 점이 2가지 입니다.

첫번째로 defer 의 사용입니다. defer 키워드는 의도적으로 return 바로 전에 실행하도록, 실행 순서를 가장 뒤로 설정하는 키워드입니다. 만약 defer 키워드를 사용하지 않는다면, 기존의 값, 즉 삭제되는 값인 head?.value 를 담을 변수가 필요하게 됩니다. 하지만 defer 를 통해서 return 이후에 head = head?.next 를 할당하므로 오직 리턴만을 위해 새로운 변수를 인스턴스할 필요가 없어지게 됩니다. * 리턴 뒤에 어떻게 함수가 작동하냐구요 ? 이렇다고 하네요. 감사합니다 :)

두번째는 메모리 정리에 관한 내용입니다. pop 메소드를 자세히보면 기존의 head Node 에 대해서는 nil 을 선언도 안하고, 바로 함수를 빠져나가는 것을 확인할 수 있습니다. 그러면 메모리는 계속해서 예전 head Node 를 계속해서 갖고 있을까요?

Swift 의 ARC(Auto Reference Calculator) 는 특정 객체가 메모리를 참조하는지 확인해주는 기능이 있습니다. 이때 특정 객체를 그 누구도 참조하지 않는다면 자동으로 메모리를 정리해주게 됩니다.

head Node 의 경우가 이에 해당됩니다. 기존의 LinkedList struct 에서 head 변수를 head?.next 로 변경하게 되면, 기존의 head 는 그 누구도 참조하지 않게 됩니다. 곧 참조 카운트가 0 이 되며, 참조 카운트가 0 인 객체는 함수 종료 시 ARC 가 자동으로 정리해줍니다.

removeLast

removeLast 메소드는 tail 을 삭제하고, tail 앞의 노드를 tail 로 만드는 메소드입니다. 말로는 간단하지만, 사실 여기에는 맹점이 하나 있습니다.

Node 에는 next 만 있고, prev(이전) 가 없기때문에 무슨 노드가 tail 의 앞의 노드인지 알 수 없습니다. 즉, 링크드리스트를 처음부터 끝까지 돌면서 tail 의 앞 노드가 어떤 노드인지 알아내야 합니다.

struct LinkedList<T> {
    ...
    mutating func removeLast() -> T? {
        guard let head = head else {
            return nil   // 1️⃣
        }

        guard head.next != nil else {
            return pop() // 2️⃣
        }

        // 3️⃣
        var prev = head
        var current = head

        while let next = current.next {
            prev = current
            current = next
        }

        // 4️⃣
        prev.next = nil
        tail = prev
        return current.value
    }
}

// 출력 예제
var list = LinkedList<Int>()
list.push(3)
list.push(2)
list.push(1)

print("removeLast 이전 링크드리스트 : \(list)")

let removedValue = list.removeLast()
print("removeLast 이후 링크드리스트 : \(list)")
print("removeLast 값 : " + String(removedValue)

// removeLast 이전 링크드리스트 : 1 -> 2 -> 3
// removeLast 이후 링크드리스트 : 1 -> 2
// removeLast 값 : optional(3)

1. 만약 head 가 nil 이였다면, nil 을 리턴해줍니다.
2. 만약 head 의 next 가 없다면, 즉 head == tail 인 상황이라면 pop 과 동일하므로 pop 을 리턴합니다.
3. 위의 두 상황이 아니라면, tail 이전의 노드가 어떤 노드인지 찾기 위해 while 로 탐색합니다.
4. tail 이전의 노드를 찾았다면 해당 노드의 next 를 없애고, tail 을 해당 노드로 바꾼 후 이전 tail 을 리턴합니다.

remove(after:)

remove(after:) 메소드는 특정 노드의 next 를 삭제하는 메소드입니다. 이때 next 의 next 를 특정 노드와 연결해주게 됩니다. 굳이

링크드리스트가 1 -> 2 -> 3 이였지만, remove(after:1) 을 통해 1 -> 3 으로 바꾼 모습입니다. 물론 연결 안해줄 수도 있습니다.

struct LinkedList<T> {
    ...
    mutating func remove(after node: Node<T>) -> T? {
        defer {
            if node.next === tail {
                tail = node
            }
            node.next = node.next?.next // ⭐️
        }
        return node.next?.value
    }    
}

// 출력 예제
var list = LinkedList<Int>()
list.push(3)
list.push(2)
list.push(1)

print("remove(after:0) 이전 링크드리스트 : \(list)")
let removedValue remove(after: node)

print("remove(after:0)" 이후 링크드리스트 : \(list)")
print("삭제된 노드값 : " + String(removedValue))
// remove(after:0) 이전 링크드리스트 : 1 -> 2 -> 3
// remove(after:0)" 이후 링크드리스트 : 1 -> 3
// "삭제된 노드값 : Optional(2)"

pop 과 같은 이유, 리턴을 위해 새로운 값을 인스턴하지 않기 위해서 defer 를 사용했으며

만약 삭제되는 node 가 tail 이였다면 tail 을 노드로 설정해주고, 아니라면 1 -> 3 과 같이 다음 다음 노드를 next 로 설정해주고 있습니다.

각 삭제 메소드들의 시간복잡도 분석

추가 메소드와 마찬가지입니다. 모든 메소드들이 O(1) 로, 단 한번에 노드를 추가할 수 있음을 확인할 수 있습니다 !

단, removeLast 는 removeLast 의 prev 를 찾기 위해서 O(LinkedList.count) 만큼의 시간복잡도를 추가적으로 갖게 됩니다.

다음편에서 완전 TMI LinkedList 를 Collection 에 넣기 위해 Protocol 을 준수해보자네 !

빠이네 ~ !!

참조

Data Structures & Algorithms in Swift - fourth Edition 위키백과 - 연결 리스트 The Swift Defer Keyword Swift 에서 "defer"란 무엇인가

링크드리스트는 특정 값들을 일렬로, 그것도 단방향으로 저장하는 형태의 자료구조를 의미합니다.

이때 링크드리스트가 담고 있는 값의 형태를 노드(node) 라고 표현합니다. 노드는 값 과 다음 노드의 메모리 주소 를 갖고 있습니다. 만약 다음 노드가 없다면 메모리주소에는 nil 을 할당합니다. 이는 해당 노드가 링크드리스트의 마지막임을 뜻하기도 합니다.

상단의 그림에서 노드는 총 3개로, 편의상 왼쪽부터 노드 1,2,3 으로 부른다면

• 노드 1 : 12 값과 노드 2의 메모리주소를 가진 노드
• 노드 2 : 99 값과 노드 3의 메모리주소를 가진 노드
• 노드 3 : 37 값과 다음 메모리 주소가 없는 노드

로 구분할 수 있습니다. 노드의 값은 중복될 수 있지만, 메모리주소는 당연히 중복될 수 없습니다. 메모리 내 같은 공간에 2개의 정보를 동시에 담을 순 없으니까요 :) 하지만 양자 컴퓨터가 나온다면 어떨까? 양.자.컴.퓨.터

노드 구현

링크드리스트를 구현하기 이전에, 링크드리스트에 포함될 노드를 먼저 구현해보겠습니다.

class Node<T> {
    var value: T
    var next: Node?

    init(value: T, next: Node? = nil) {
        self.value = value
        self.next = next
    }
}

// 밑의 코드는 print 시 편의를 위해 사용 
// 출처 : raywenderlich node
extension Node: CustomStringConvertible {
    var description: String {
        guard let next = next else {
            return "\(value)"
        }
        return "\(value) -> " + String(describing: next) + " "
    }
}

let node1 = Node(value:1)
let node2 = Node(value:2)
let node3 = Node(value:3)

node1.next = node2
node2.next = node3

print(node1)

// 출력
1 -> 2 -> 3

노드를 구현한 class 를 확인해보겠습니다.

우선 struct 가 아닌 class 로 구현되어 모든 노드들이 참조 타입 이 되도록 설정되었습니다. 이는 next 가 다음 노드의 메모리 주소를 참조한다는 것으로 이어집니다.

class 내부는 간단하게 되어있습니다. 제네릭타입으로 어떤 형태든 값을 받을 수 있는 var value: T 와 다음 노드를 저장할 next, 그리고 생성 시 초기화를 위한 init 이 있습니다.

* 여기서 T는 제네릭 타입으로, 어떤 자료형이든 초기에 받는 그 자료형을 이 변수의 자료형으로 사용하겠다 라는 의미입니다. Int 를 주면 앞으로는 Int, String 을 주면 String, 자신이 생성한 구조체를 주면 그 구조체가 됩니다. T 는 임의의 명칭으로, 자유롭게 바꿔서도 쓸 수 있습니다.

이후 하단에서 node1, node2, node3 을 생성하고 각각 1,2,3 이라는 값을 준 후, 1의 next 를 2, 2의 next를 3으로 주고 출력을 했더니

쨔잔 1 -> 2 -> 3 이라는 굉장히 직관적인 결과가 나왔습니다. 노드는 이와 같이 값과 다음 노드의 메모리주소를 갖는 class 입니다.

만약 struct 로 class 를 구현하면 어떻게 될까요? 그렇다면 Hashable, Equtable 프로토콜을 준수하도록 하고, 이후 메소드에서도 계속해서 값이 아닌 참조를 하도록 강제해야 합니다.

왜냐하면 struct 는 생성 및 할당 시 새로운 인스턴스를 생성, 즉 매번 새롭게 메모리에 적재되는 값 타입 인 반면 class 는 할당을 하더라도 그 주소가 할당되는 참조 타입 이기 때문입니다. 자세한 내용은 값 타입과 참조 타입을 확인해주세요.

LinkedList 구현

struct LinkedList<T> {
    var head: Node<T>?
    var tail: Node<T>?

    init() { }

    var isEmpty: Bool {
        head == nil
    }
}

// 밑의 코드는 print 시 편의를 위해 사용 
// 출처 : raywenderlich node
extension LinkedList: CustomStringConvertible {
    var description: String{
        return "Empty list"
    }
    return String(describing: head)
}

Linked List 구조체를 만들어보았습니다. Node<T>? 를 받는 2개의 변수 head 와 tail 이 있고, head 가 nil 이면 이 링크드리스트는 비어있다 라고 표현하고 있네요.

위의 그림을 다시 가져와서 살펴보면 head 는 링크드리스트의 가장 첫번째 노드를 의미합니다. tail 은 next 가 없는 노드, 즉 링크드리스트의 가장 마지막 노드를 의미합니다.

만약 head 의 next 가 없다면 head 는 tail 이기도 한거죠!

LinkedList 를 구현해보았지만, 무언가가 많이 부족합니다. 아직까지는 LinkedList 에 노드를 추가할수도, 삭제할수도 없기 때문입니다.

앞으로 push, append, insert 메소드를 구현해서 노드를 추가해보고 pop, removeLast, remove(after:) 메소드를 구현해서 노드를 삭제해보겠습니다.

많냐

LinkedList - 노드 추가하기

LinkedList 에는 3개의 방법으로 노드를 추가할 수 있습니다.

1. push : 링크드리스트의 가장 앞에 node 를 추가합니다.
2. append : 링크드리스트의 가장 맨 뒤에 node 를 추가합니다.
3. insert(after:) : 링크드리스트 내 특정 노드 뒤에 노드를 추가합니다.

push

struct LinkedList<T> {
    ...
    mutating func push(_ value: T) {
        head = Node(value: value, next: head)
        if tail == nil {
            tail = head
        }
    }
}

// 출력 예제
var list = LinkedList<Int>()
list.push(3)
list.push(2)
list.push(1)

print(list)
// 1 -> 2 -> 3

push 메소드는 추가하고자 하는 값을 알려주면 그 값을 지닌 Node 를 만들어서 head 로 선언해주고, 동시에 이전의 head 는 next 로 선언해줍니다.

이때 만약 tail 이 nil 이였다면 (== 처음 노드를 넣는다면) tail 을 head 로 지정합니다.

append

struct LinkedList<T> {
    ...
    mutating func append(_ value: T) {
        guard !isEmpty else {       // 1️⃣
            push(value)
            return
        }

        tail!.next = Node(value: T) // 2️⃣
        tail = tail!.next           // 3️⃣
    }
}

// 출력 예제
var list = LinkedList<Int>()
list.append(1)
list.append(2)
list.append(3)

print(list)
// 1 -> 2 -> 3

append 메소드는 추가하고자 하는 값을 알려주면 링크드리스트의 가장 마지막에 해당 노드를 만들어 추가해줍니다.

이때 로직은 3단계로 나누어집니다.

1. 만약 LinkedList 가 비어있다면, 이는 push 와 동일하기에 push 에 값을 넘겨주고 종료합니다.
2. LinkedList 가 비어있지 않다면, tail 의 next 에 전달받은 값으로 Node 를 생성하고 next 로 지정합니다.
3. tail 을 tail!.next 로 설정합니다. 이때 tail 은 반드시 존재하니 ! 로 옵셔널을 해제해줍니다.

insert(after:)

insert 는 해당 링크드리스트의 특정 노드 뒤에 새로운 노드를 추가하는 메소드입니다.

단, 바로 작성하기에는 문제가 하나 있는데 왜냐하면 지금 우리는 특정 노드가 몇번째에 있는지 알 수 없기 때문입니다.

노드들은 중복된 값을 가질 수 있고, 한편 LinkedList 는 [] 를 통해서 접근할 수 도 없으니 우선 해당 노드가 몇번째 노드인지 먼저 찾는 메소드부터 작성하고서, 그 후에 원하는 값을 노드로 추가해줄 수 있게됩니다.

struct LinkedList<T> {
    ...
    func find(at index: Int) -> Node<T>? {
        // 1️⃣
        var currentNode = head
        var currentIndex = 0

        // 2️⃣
        while currentNode != nil && currentIndex < index {
            currentNode = currentNode!.next
            currentIndex += 1
        }
        return currentNode
    }

find(at:) 메소드는 찾고자하는 노드의 인덱스를 주면 해당 인덱스에 해당하는 노드를 찾는 메소드입니다. 그것이 메소드니까..?

1. 현재노드와 현재 인덱스를 변수로 선언하고, 각각 head 와 0 을 줍니다.
2. 현재노드 변수는 계속해서 다음 노드를, 현재 인덱스는 계속해서 1을 더해가며 해당 인덱스를 찾거나, tail 다음(nil)에 도달할 때 까지 인덱스에 해당하는 노드를 찾습니다.
3. 원했던 노드를 리턴합니다.

이제 find 를 통해 insert(at:) 을 구현해보겠습니다.

struct LinkedList<T> {
    ...
    // 1️⃣
    @discardableResult
    mutating func insert(_ value: T, after node: Node<T>) -> Node<T> {
        // 2️⃣
        guard tail !== node else {
            append(value)
            return tail!
        }

        // 3️⃣
        node.next = Node(value: value, next: node.next)
        return node.next!
    }

}

// 출력 예제
var list = LinkedList<Int>()
list.push(3)
list.push(2)
list.push(1)

print("insert 이전의 링크드리스트 : \(list)")
var middleNode = list.node(at: 1)!
for _ in 1 ... 4 {
    middleNode = list.insert(-1, after: middleNode)
}
print("insert 이후의 링크드리스트 : \(list)")

// insert 이전의 링크드리스트 : 1 -> 2 -> 3
// insert 이후의 링크드리스트 : 1 -> 2 -> -1 -> -1 -> -1 -> -1 -> 3

1. @discardableResult 는 해당 함수의 리턴값이 사용되지 않더라도, Swift 컴파일러가 경고해줄 필요는 없다라는 의미입니다. insert 후에 해당 결과값이 필요할 수도 있지만, 안 필요한 경우가 더 많기 때문에 눈뽕 경고창을 해당 띄우지 않도록 설정해줍니다.
2. 만약 특정 노드가 링크드리스트의 tail 이였다면, 이는 append 와 동일한 메소드가 됩니다. append 에 값을 넘겨주고 종료합니다.
3. append 에서 했던 코드와 유사합니다. 해당 노드의 next 에 새로운 노드를 만듦과 동시에 새로운 노드의 next 는 기존 노드의 next 로 설정해줍니다.

3번의 경우 한 줄의 코드가 2개의 행동, 특정 노드의 next 를 내가 준 값의 새로운 노드로 설정 과 내가 준 값의 새로운 노드의 next 는 특정 노드의 원래 next 로 설정!

이 한번에 진행되어 헷갈릴 수 있지만 위와 같은 내용으로 insert(after:) 메소드를 만들 수 있습니다.

각 추가 메소드들의 시간복잡도 분석

모든 메소드들이 O(1) 로, 단 한번에 노드를 추가할 수 있음을 확인할 수 있습니다 !

왜일까요 ?

다른 노드들을 밀거나, 미루거나의 행동 없이 head, tail 혹은 next 만 재설정해주면 되기 때문입니다.

단, insert(after:) 를 위해서 특정 노드가 몇번째 노드인지 확인하는 행동에는 o(index) 만큼의 시간이 걸린다는 걸 확인할 수 있습니다.

그럼 다음 편에서 삭제를 알아보자네 ! 빠이네 !

참고

Data Structures & Algorithms in Swift - fourth Edition 위키백과

들어가기 전에 !! 나는 stack 이 어떤 것인지 알고, Swift 로 어떻게 쓰는지만 알고 싶다.

: 그냥 배열 쓰세용 :)

var stack = [T]() // T 에는 원하는 자료형 - Int, String ...
stack.append()  // push
stack.popLast   // pop
stack.isEmpty   // isEmpty
stack.last      // peek

Stack 정의

Stack 자료구조는 자료를 쌓듯이 저장하고, 사용할때도 가장 뒤에 있는 자료 먼저 꺼내서 사용하는 형태를 지칭합니다.

좀 더 편하게 말하자면, 프링글스 같은 자료구조 입니다. 넣을 때는 아래에서부터 차곡차곡 과자를 쌓았겠지만, 먹을 때는 위에서부터 차근차근 먹게 되는 구조.

Stack 입니다. 쏟아서 먹지만 않는다면

이때 과자_(자료)_를 넣는 행위를 push, 과자를 꺼내는 행위를 pop 이라고 합니다.

이러한 자료구조의 장점은 사용하고자 하는 용도가 명백할 때, 즉 자료를 차곡차곡 쌓아서 위에서 부터 쓰겠다. 를 지킨다면 언제나 시간복잡도를 O(1) 을 지킬 수 있기 때문에 굉장히 빠른 자료구조가 됩니다.

왜냐구요? 항상 맨 뒤에다가 넣으면 되고, 맨 뒤에 있는 것만 빼서 쓰면 되거든요 !!

단, 이때 이미 쌓여있는 자료 중 어떤 것이 몇번째에 있지 라든가, "뒤에 있는 것만 활용하겠다" 라는 취지를 어기게 되면 시간복잡도는 단숨에 확 늘어나게 됩니다.

왜냐구요? 프링글스를 뒤적뒤적 하면서 정확히 밑에서부터 42번째 있는 프링글스를 찾아가며 먹고 싶진 않잖아요 !!

Stack 의 메소드들

• push : 자료를 넣는 메소드에요.
• pop : 자료를 꺼내는 메소드에요.
• peek : 가장 뒷단, 혹은 상단에 있는 자료를 확인하는 메소드에요.
• isEmpty: 스택이 비어있는지 확인할 메소드에요.

Stack - Swift

struct Stack<T> {
    var storage = [T]()
    init(_ elements: [T]) {
        storage = elements
    }

    mutating func push(_ element: T) {
        storage.append(element)
    }
    mutating func pop() -> T? {
        storage.popLast()
    }

    func peek() -> T? {
        storage.last
    }
    var isEmpty : Bool {
        storage.isEmpty
    }
}

var stack = Stack<Int>([1,2,3,4,5])

앞으로 자료구조는 모두 struct 를 활용하여 구조체 형태로 만들게 될 것 입니다. 사실 Stack 은 가장 상단에서 언급하였듯, 배열을 활용해서 사용해도 되긴 하지만 struct 활용이 처음인만큼 어떤 내용들이 있는지 살펴보겠습니다.

• struct : 구조체를 정의하는 문법입니다. 해당 문법을 통해 사용자는 복잡한 형태를 하나의 자료형처럼 사용할 수 있게 됩니다. 이때 struct 는 값 타입 으로, 새로 생성될 때 마다 새로운 객체가 인스턴스 됩니다.

struct Coordinate<Int> {
   var y: Int
   var x: Int
}

var a = A<Coordinate>(y: 0, x: 0)
var b = a
b.y = 1; b.x = 1
print(a)
print(b)

// 출력 :
// Coordinate(y: 0, x : 0)
// Coordinate(y: 1, x : 1)
// 즉, 값 타입은 생성될 때 마다 새롭게 메모리에 적재되기에 (인스턴스 되기에)
// 새롭게 생성된 두 값 타입은 서로에게 영향을 미치지 않으며
// 구조체 struct 는 언제나 값 타입이다.

• Stack<T>: 이름인 Stack 과 자료형을 지칭하는 T 입니다. 이때 T 는 제네릭 타입이라고 지칭되며, 어떠한 자료형이든 입력을 받아주겠다 라는 의미로 사용됩니다. 한번 입력되고 나면 해당 함수 내에서는 처음에 입력된 자료형으로만 통일되어 사용할 수 있습니다. 제네릭 타입에 대해서 더 궁금하면 여기를 참고해보세요.

• var storage = [T](), init(...) { ... } : struct 를 통해 호출할 변수, 프로퍼티와 struct 를 처음 생성할 때 지시할 내용을 init 함수를 통해 지정할 수 있습니다. 여기서는 제네릭 타입 T 를 통해 프로퍼티인 배열 storage 를 생성하고, init 함수에서는 T 타입의 배열을 storage 에 넣는 것을 확인할 수 있습니다.

• mutating func ... () : struct 는 -좀 더 정확히는 값 타입의 프로퍼티들은- 기본적으로 내부의 값을 임의로 바꿀 수 없게 되어있습니다. 따라서 일반적인 func 함수를 호출해서 내부의 프로퍼티를 변경하려고 하면 "할 수 없어 !" 라고 컴파일러가 호되게 야단칩니다. 그래서 mutating 키워드를 활용하여 아니? 나 이거 바꿀건데 라고 컴파일러에게 요청할 수 있게됩니다. 여기서는 mutating func pop, mutating func push 를 통해 내부의 프로퍼티인 var storage 의 값을 원하는대로 바꾸고 있네요.

• func peek() ... : 상단의 mutating func 와 달리 mutating 이 없는 peek 는 이름 그대로, 가장 상단의 값을 확인만 할 뿐이니 mutating 이 필요가 없는 모습을 확인할 수 있습니다.

• var isEmpty : Bool { } : 연산 프로퍼티라고 불리는 변수입니다. 특징은 특정 값을 저장하지 않고, 다른 값을 읽어들여서 확인하거나, 수정하는 형태로 사용되는 프로퍼티입니다. 읽어들이는 행위를 GET, 특정 데이터를 수정하는 행위를 SET 이라고 합니다. 여기서는 GET 의 형태로만 사용되어, storage 가 비어있는지만 확인하고 있네요.

그래서 Stack 은 어떻게 쓰면 되는건데

정말 복잡했던 struct 설명이 애석하게도, 자세히 살펴보면 결국 Swift 의 기본 제공 Collection 인 배열의 메소드만 활용하고 있는 것을 확인할 수 있어요. 따라서 각각의 내용들은 이렇게 바꿔서 사용하는게 정신건강 편리할 것 같습니다.

var stack = [T]() 
: 원하는 자료형으로 stack 을 선언, 
struct Stack<T>{
    var storage = [T]()
    init (_elements: [T]) {
        storage = elements
    }

    ...
}
를 stack = [T]() 로 한번에 정리


stack.append()
: mutating func push(_ element: T) { 
    storage.append(element)
} 를 push 를 통해 정리


stack.popLast
: mutating func pop() -> T? {
    storage.popLast
} 를 통해 pop 을 정리


stack.last
:func peek() -> T? {
    storage.last
} 를 통해 last 를 정리


stack.isEmpty
: var isEmpty : Bool {
    storage.isEmpty
  } 를 통해 isEmpty 를 정리

요약은 상단처럼 볼 수 있습니다.

var stack = [T]() // T 에는 원하는 자료형 - Int, String ...
stack.append()  // push
stack.popLast   // pop
stack.isEmpty   // isEmpty
stack.last      // peek

그래서 Stack 이 알고리즘 푸는데 어디에 쓰여요

데이터가 언제나 순서대로 온다는 점을 착안해서 이런 문제들이 출제되고 있어요. 백준 - 좋은 단어 백준 - 문자열 폭발 프로그래머스 - 크레인 인형뽑기 게임

관통하는 주제로는 "순서대로 오는 무언가를, 특정 조건에 따라 구분할 수 있는가?" 가 될 것 같네요 !!

한편 Stack 은 Stack 그 자체로 쓰이기 보다는 CS 관점에서 볼 때 재귀함수와 DFS 의 기본 구조라서, 이를 활용한 문제들이 더 많이 나오게 됩니다.

ㅎㅎ.. 코틀린버전으로 쓴 게 있는데 확인해주면 ㅈ..ㅈ..좋아합니다! 언어 상관없이 이해되게 썻다고 하네요! 문과생이 적어보는 백트래킹 재귀와 DFS 를 곁들인

그럼 빠이네라네 ~

참고

Data Structures & Algorithms in Swift - fourth Edition Swift Language Guide 5.7 부스트코스 - iOS 프로그래밍을 위한 스위프트 기초

import Foundation

let monthList = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] // 월별 일자
let weekOfDay = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"] // 1월 1일의 요일을 가장 맨 앞에 둔다.
var week = ""

let input = readLine()!.split(separator: " ").map{ Int(String($0))! }
var (month, day) = (input[0], input[1])

var totalDay = 0
for i in 0 ..< month - 1 {
    totalDay += monthList[i]
}
totalDay += day - 1
week = weekOfDay[totalDay % 7]

while week != "SUN" {
    totalDay -= 1
    week = weekOfDay[totalDay % 7]

    day -= 1
    if day <= 0 {
        month -= 1
        day = monthList[month - 1]
    }
}

print("\(week), \(month) 월 \(day) 일")

언젠가 다시 필요할 수도 있을 것 같아서 ..

Swift 는 3개의 주요 컬렉션 (Collection) 자료형 Array, Set, Dictionaries 을 제공합니다. Array 는 값을 지니는 정렬된 컬렉션이며, Set 과 Dictionaries 는 비정렬 컬렉션으로, 각각 고유의 값을 지니거나 Key-Value 로 이루어진 컬렉션입니다.

Swift 에서 각 컬렉션들은 지닐 수 있는 자료형이 명백하게 정의되기에, 사용자는 잘못된 형태의 값을 컬렉션에 넣을 수 없게 됩니다. 또한 각각의 컬렉션은 컬랙션 내에서 동일한 자료형만 반복될 것임을 확신할 수 있게 됩니다.

Mutability of Collections(컬렉션 변경 가능 여부)

Array, Set, Dictionaries 를 만들 때 변수(variable)로 만들게 되면 해당 컬렉션은 변경 및 수정이 가능하게 되며, 이와 반대로 상수(constant)로 만들게되면 초기화를 할 때를 제외하면 변경 및 수정이 불가능하게 됩니다.

Arrays (배열)

array 는 같은 자료형으로 정렬된 목록의 값들을 저장하는 컬렉션입니다.

Note: Swift 의 배열은 Foundation 프레임워크의 NSArray class 와 연결되어 있습니다. Array 를 Foundation 과 Cocoa 를 통해 사용하고 싶다면 Bridging Between Array and NSArray 를 참고해주세요.

Array Type Shorthand Syntax (Array 자료형 줄임 문법)

Swift Array 자료형은 Array<Element> 의 형태로 정의됩니다. 이때 짧게 사용하는 방법으로 [Element] 를 통해 사용할 수 있습니다. 두 형태는 기능적으로 동일하며, 이하 Swift Language Guide 에서는 줄임 표현을 사용할 것 입니다.

Creating an Empty Array

빈 배열은 타음과 같이 만들 수 있습니다.

var someInts: [Int] = []
print("someInts 는 [Int] 자료형으로 \(someInts.count) 개수 만큼 원소를 갖고 있습니다.")
// "someInts 는 [Int] 자료형으로 0 개수 만큼 갖고 원소를 갖고 있습니다."

배열이 variable 에 Int 자료형으로 선언되었으므로 다음과 같이 사용할 수 있습니다.

someInts.append(3)
// someInts 는 이제 Int 자료형의 원소를 1개 갖고 있습니다.
someInts = []
// someInts 는 이제 빈 배열이지만, 여전히 [Int] 형입니다.

Creating an Array with a Default Value (초기값으로 배열 만들기)

Swift 의 배열 자료형은 초기화 시 특정 사이즈에 동일한 값을 넣어서 초기화 하는 방법을 제공합니다.

var threeDoubles = Array(repeating: 0.0, count: 3)
//threeDoubles 는 [Double] 자료형에 [0.0, 0.0, 0.0] 입니다.

// 번역 : 이런 형태도 가능합니다.
var threeDoubles = [Double](repeating: 0.0, count: 3)
// threeDoubles 는 [Double] 자료형에 [0.0, 0.0, 0.0] 입니다.

Creating an Array by Adding Two Arrays Together (두 배열을 합쳐 하나의 배열 만들기)

동일한 두 자료형의 배열을 + 연산자를 통해서 두 배열이 합쳐진 새로운 배열을 생성할 수 있습니다.

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 는 [Double] 자료형이며, [0.0, 0.0, 0.0, 2.5, 2.5, 2.5,] 입니다.

Creating an Array with an Array Literal(리터럴을 통해 배열 만들기)

리터럴을 통해서도 배열을 만들 수 있습니다. [] 안에 원하는 원소를 넣고, , 로 구분할 수 있습니다.

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 는 [String] 자료형에 Eggs 와 Milk 를 담고 있습니다.

이때 원소를 하나의 자료형으로 통일하면 배열의 자료형은 원소의 자료형으로 자동캐스팅이 됩니다.

var shoppingList = ["Eggs", "Milk"]
// shoppingList 는 [String] 자료형에 Eggs 와 Milk 를 담고 있습니다.

Accessing and Modifying an Array(배열 접근과 배열 수정)

배열의 메소드와 프로퍼티, 인덱스 문법을 통해 배열에 접근하거나 수정할 수 있습니다.

배열의 개수는 count 프로퍼티를 사용할 수 있습니다.

print("shoppingList 는 \(shoppingList.count)개의 원소를 갖고 있습니다.")
// 출력 : shoppingList 는 2개의 원소를 갖고 있습니다.

배열이 빈 값인지 확인하고 싶다면 isEmpty 프로퍼티를 사용할 수 있습니다. isEmpty 는 count == 0 과 동일합니다.

if shoppingList.isEmpty{
    print("쇼핑리스트는 비어있습니다.")
} else {
    print("쇼핑 리스트는 비어있지 않습니다.")
}
// 출력 : 쇼핑 리스트는 비어있지 않습니다.

배열에 원소를 추가하고 싶다면 append(_:) 메소드를 사용할 수 있습니다. * 번역 : 메소드나 함수에서 매개변수 앞에 _ 가 있으면 호출할 때 매개변수 라벨을 생략할 수 있습니다.

shoppingList.append("Flour")
// shoppingList 는 이제 3개의 아이템이 되었고, 팬케이크를 구울 것 같네요 :)

혹은 이런 방법으로도 배열에 원소를 추가할 수 있습니다.

shoppingList += ["Baking Powder"]
// 쇼핑리스트는 이제 4개의 아이템을 갖고 있습니다.
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// 쇼핑리스트는 이제 7개의 아이템을 갖고 있습니다.

인덱스 문법을 활용하여 배열 안의 값을 확인하거나, 새로운 값을 할당할 수도 있습니다.

var firstItem = shoppingList[0]
shoppingList[0] = "Six eggs"

// firstItem 은 Eggs 가 되고,
// shoppingList[0] 는 "Six eggs" 가 됩니다.
// 번역 : 이때, 배열은 "값 타입" 이기 때문에, firstItem 이 Six eggs 로 변경되지 않습니다. 

인덱스 문법을 활용할때는 사용하고자 하는 인덱스가 배열의 범위안에 있는지 확인하여야 합니다. 만약 배열에 포함되어 있지 않은 인덱스를 사용하면 런타임 에러가 발생할 것 입니다.

한편 다음과 같이 인덱스 문법을 활용하여 특정 범위의 배열에 접근하거나 수정할 수도 있습니다. 이때 배열은 배열 리터럴의 크기로 조정하여 기존의 값에 합쳐지게 됩니다.

shoppingList[4..6] = ["Bananas", "Apples"]
// shoppingList 는 이제 기존 3개 원소를 2개 원소로 줄여, 
// 6개의 아이템을 갖게 됩니다.

배열 내 특정 인덱스에 삽입을 하고 싶다면 insert(_:at:) 메소드 를 사용할 수 있습니다.

shoppingList.insert("Maple Syrup", at 0)
// shoppingList 의 첫번째 원소에 Maple Syrup 이 들어가며 , 총 7개의 원소를 갖게 됩니다.

이와 유사하게 배열 내 특정 인덱스를 삭제하고 싶다면 remove(at:) 메소드를 사용할 수 있습니다. remove 메소드는 삭제한 원소를 리턴하는데, 필요없다면 무시하고 사용할 수 있습니다.

let mapleSyrup = shoppingList.remove(at: 0)

Note : 배열의 총 크기는 0 ~ count - 1 입니다. 이때 count 가 0 이라면 빈 배열로, 접근할 수 없습니다. 인덱스를 활용한다면 이 점에 유의해서 사용해주세요.

Lterating Over an Array(배열 반복하기)

배열 내 전체 값들을 for-in 반복문을 통해 접근할 수 있습니다.

for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

반복 시 인덱스가 필요하다면 다음과 같은 형태도 고려해볼 수 있습니다.

for (index, value) in shoppingList.enumerated() {
    print("Item\(index + 1) : \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

Sets (세트 궁)

세트는 비정렬 컬렉션에 같은 자료형의 값들을 고유 하게 저장하는 컬렉션을 의미합니다. 원소들의 순서가 중요하지 않거나, 원소가 반드시 1개만 존재해야 한다면 set 를 사용할 수 있습니다.

Note : Swift 의 set 자료형은 Foundation 의 NSSet class 를 따릅니다. 더 자세한 내용은 Bridging Between Set and NSSet 를 확인해주세요.

Hash Values for Set Types (Set 자료형을 위한 해쉬 값)

Set 에 저장되는 값들은 반드시 hashable, 즉 각 값들이 hash value 를 지녀 다른 값과 계산할 수 있는 자료형이어야 합니다. *hash value 는 Int 값이며, 동일한 값은 동일한 hash value 를 갖고 있어야합니다. *

번역 : Swift 4.2 이후로부터 hashable 이 적용된 자료형은 컴파일러에서 자체적으로 hash algorithm 이 적용됩니다. 이에 따라 보다 빠른 최적화가 필요하거나 쌉컴덕 이 아니라면 컴파일러에게 맡기고, 아무것도 안하면 됩니다 ! sturct 등은 해당 제네릭 자료형에 Hashable protocol, equatable protocl 을 적용하면 됩니다. 참고

Swift 내 기본 자료형들 (String, Int, Double, Bool 등) 은 자체적으로 hashable 를 내장하고 있으며 set value 나 dictionary key type 에 사용할 수 있습니다. Enumeration 값 역시 자체적으로 hashable 이 적용됩니다.

Set Type Synatx (set 자료형 문법)

Set 은 Set<Element> 로 정의할 수 있으며, 배열과 달리 짧은 문법은 없습니다.

Creating and Initializing an Empty Set (빈 set 만들기)

var letters = Set<Character>()
print(letters 는 Set<Character> 자료형으로, \(letters.count)개의 원소를 갖고 있습니다.)
// letters 는 Set<Character> 자료형으로 0개의 원소를 갖고 있습니다.

한번 Set 을 초기화하면 자료형이 정해지기에 자료형을 언급하지 않아도 됩니다. 다음과 같이 활용할 수 있습니다.

letters.insert("a")
letters = []

Creating a Set with an Array Literal (리터럴로 Set 만들기)

리터럴을 통해 Set 을 초기화할 수도 있습니다.

var favoriteGeners: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGeners 는 3개의 원소로 초기화되었습니다.

// 다음과 같이 짧게 표현할 수도 있습니다.
var favoriteGeners: Set = ["Rock", "Classical", "Hip hop"]

한번 선언되면, 해당 Set 는 같은 자료형만 삽입할 수 있게 됩니다.

Accessing and Modifying a Set (Set 에 접근과 수정하기)

다음 메소드와 프로퍼티를 통해 Set 에 접근하거나 수정할 수 있습니다.

세트의 개수는 count 프로퍼티를 사용할 수 있습니다.

print("저는 \(favoriteGenres.count)개의 음악 장르를 선호해요.")
// 출력 : 저는 3개의 음악 장르를 선호해요.

세트가 빈 값인지 확인하고 싶다면 isEmpty 프로퍼티를 사용할 수 있습니다. isEmpty 는 count == 0 과 동일합니다.

if favoriteGenres.isEmpty {
    print("음악이 있기만 한다면, 난 까탈쟁이는 아니에요.")
} else {
    print("전 특정 음악을 선호해요.")
}
// 출력: "전 특정 음악을 선호해요. "

세트에 원소를 삽입하고 싶다면 insert(_:at:) 메소드 를 사용할 수 있습니다.

favoriteGenres.insert("Jazz")
// favoriteGenres 는 이제 4개의 원소를 갖고 있습니다.

이와 유사하게 세트 내 특정 인덱스를 삭제하고 싶다면 remove(at:) 메소드를 사용할 수 있습니다. remove 메소드는 삭제한 원소를 리턴하는데, 필요없다면 무시하고 사용할 수 있습니다.

if let removeGenre = fvoriteGenres.remove("Rock") {
    print("\(removeGenre)? 없앱니다 ~ ")
} els e{
    print("그런 장르 좋아한 적 없습니다.")
}
// 출력 : "Rock"? 없앱니다 ~

너는 록을 좋아하지 않아

Note : 배열의 총 크기는 0 ~ count - 1 입니다. 이때 count 가 0 이라면 빈 배열로, 접근할 수 없습니다. 인덱스를 활용한다면 이 점에 유의해서 사용해주세요.

한편 Set 가 특정 원소를 포함하고 있는지 확인하고 싶다면 contains(_:) 메소드를 사용할 수 있습니다.

if favoriteGenres.contains("Funk") {
    print("하하 내 화려한 발재간을 보아라")
} else {
    print("너무 시끄럽네 ..")
}
// 출력 : 너무 시끄럽네 ..

Iterating Over a Set (Set 반복하기)

세트 내 전체 값들을 for-in 반복문을 통해 접근할 수 있습니다.

for genre in favoriteGenres {
    print("\(genre)")
}
// Classical
// Jazz
// Hip hop

Swift 의 set 은 특정한 정렬이 없습니다. 혹시 특정한 기준으로 정렬된 set 를 반복하고 싶다면 sorted() 메소드를 활용해보세요.

for genre in favoriteGenres.sorted() {
    print("\(genre)")
}
// Classical
// Hip hop
// Jazz

Performing Set Operations (Set 최적화 수행)

Set 자료형은 set 의 구조를 작업하는 효율적인 메소드들을 제공합니다. 합집합, 교집합, 차집합, 대칭차집합 와 같은 내용입니다.

Fundamental Set Operations (기본적인 Set 작업)

다음과 같은 작업을 수행할 수 있습니다.

• intersection(_:) 메소드를 활용하여 교집합 set 을 얻을 수 있습니다.
• symmetricDifference(_:) 메소드를 활용하여 대칭차집합 set 을 얻을 수 있습니다.
• union(_:) 메소드를 활용하여 두 set 을 합칠 수 있습니다.
• subtracting(_:) 메소드를 활용하여 여집합 set 을 얻을 수 있습니다.

코드로 표현하면 다음과 같습니다.

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

Set Membership and Equality (Set 의 소속과 동일성)

다음 도표를 통해 Set 의 관계를 살펴볼 수 있습니다. Set a 는 Set b 를 포함하므로 a 는 b 의 상위집합입니다. 한편 b 는 a 의 부분집합이 됩니다. Set c 는 b 와 관련이 없는 별개의 집합이 됩니다.

• == 연산자를 통해 두 Set 이 모두 동일한 원소들을 포함하는지 확인할 수 있습니다.
• isSubset(of:) 메소드를 통해 어떤 Set 이 다른 Set 의 부분집합인지 확인할 수 있습니다.
• isSuperset(of:) 메소드를 통해 어떤 Set 이 다른 Set 의 상위집합인지 확인할 수 있습니다.
• isStrictSubset(of:) 혹은 isStrictSuperset(of:) 메소드들을 통해 각각이 부분집합, 상위집합이되 동일한 집합이 아닌지 확인할 수 있습니다.
• isDisjoint(with:) 을 통해 두 Set 가 공통된 원소를 없는지 확인할 수 있습니다.

코드로 표현하면 다음과 같습니다.

let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

Dictionaries (딕셔너리)

Dictionary 는 키와 값이라는 한 쌍을 기준으로 같은 자료형을 저장하는 비정렬 컬렉션입니다. 각 값들은 고유한 키에 속하게 되며, 이를 통해 딕셔너리 내에 값들을 확인할 수 있게 됩니다. 비정렬 컬렉션이므로, 실제 사전과 같이 특정 값을 찾고 싶다면 키를 통해 확인할 수 있습니다.

Note: Swift 의 딕셔너리는 Foundation 의 NSDictionary class 를 따릅니다. 자세한 사항은 Bridging Between Dictionary and NSDictionary 에서 확인할 수 있습니다.

Dictionary Ype Shorthand Syntax (딕셔너리 자료형 줄임 표현)

딕셔너리는 Dictionary<Key, Value> 의 형태로 선언되지만, [Key:Value] 로 짧게 표현할 수도 있습니다. 이때 Key 값은 Hashable protocol 을 따르는 자료형이어야 합니다.

Creating an Empty Dictionary (빈 딕셔너리 만들기)

var namesOfIntegers: [Int: String] = [:]
// namesOfIntegers 는 빈 [Int:String] 딕셔너리 입니다.

한번 딕셔너리를 초기화하면 자료형이 정해지기에 자료형을 언급하지 않아도 됩니다. 다음과 같이 활용할 수 있습니다.

namesOfIntegers[16] = "sixteen"
// namesOfIntegers 는 이제 1 쌍의 Key-Value 를 갖고 있습니다.
namesOfIntegers = [:]
// naemsOfIntegers 는 빈 딕셔너리입니다.

Creating a Set with an Array Literal (리터럴로 Set 만들기)

리터럴을 통해 딕셔너리를 초기화할 수도 있습니다.

var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
// airports 는 2개의 키-쌍 값을 갖고 있습니다.

// 다음과 같이 짧게 표현할 수도 있습니다.
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

한번 선언되면, 해당 딕셔너리는 같은 자료형만 삽입할 수 있게 됩니다.

Accessing and Modifying a Dictionary (딕셔너리에 접근과 수정하기)

다음 메소드와 프로퍼티를 통해 딕셔너리에 접근하거나 수정할 수 있습니다.

딕셔너리의 개수는 count 프로퍼티를 사용할 수 있습니다.

print("공항 딕셔너리는 \(airports.count)개의 원소를 갖고 있습니다.")
// 출력: "공항 딕셔너리는 2개의 원소를 갖고 있습니다."

딕셔너리가 빈 값인지 확인하고 싶다면 isEmpty 프로퍼티를 사용할 수 있습니다. isEmpty 는 count == 0 과 동일합니다.

if airports.isEmpty {
    print("공항 노선이 없습니다.")
} else {
    print("공항 노선이 있습니다.")
}
// Prints "공항 노선이 없습니다."

딕셔너리에 원소를 삽입하고 싶다면 인덱스 문법을 사용할 수 있습니다.

airports["LHR"] = "London"
// 공항 딕셔너리는 이제 3개의 원소를 갖고 있습니다.

딕셔너리의 원소를 수정하고 싶을때도 인덱스 문법을 사용할 수 있습니다.

airports["LHR"] = "London Heathrow"
// "LHR" 의 값은 "London Heathrow" 로 변경되었습니다.

인덱스 문법 대신 updateValue(_:forKey:) 메소드를 통해 특정 키의 값을 수정할 수 있습니다. 이때 updateValue(_:forKey:) 메소드는 해당 키가 존재하지 않는다면 nil 을 존재한다면 이전의 value 를 리턴합니다.

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("DUB 키의 이전 값은 \(oldValue) 입니다.")
}
// 출력: "DUB 키의 이전 값은 Dublin 입니다."

인덱스 문법 역시 이와 유사한 표현을 사용할 수 있습니다. 단, updateValue(_:forKey:) 메소드와 달리 이전의 값이 있더라도 그 값을 리턴하지 않습니다.

if let airportName = airports["DUB"] {
    print("공항 이름은 \(airportName) 입니다.")
} else {
    print("해당 공항은 없습니다.")
}
// Prints "공항 이름은 Dublin Airport 입니다."

딕셔너리 내 특정 키를 삭제하고 싶다면 인덱스 문법을 활용하여 특정 키에 nil 을 할당하면 됩니다.

airports["APL"] = "Apple International"
// "Apple International" 는 실제 공항이 아니므로 삭제합니다.
airports["APL"] = nil
// APL 은 딕셔너리에서 삭제되었습니다.

이와 유사하게 remove(at:) 메소드를 사용할 수 있습니다. remove 메소드는 삭제한 원소를 리턴하는데, 필요없다면 무시하고 사용할 수 있습니다.

if let removedValue = airports.removeValue(forKey: "DUB") {
    print("삭제된 공항의 이름은 \(removedValue) 입니다.")
} else {
    print("공항 딕셔너리는 DUB 키에 값을 갖고 있지 않습니다.")
}
// 출력: "삭제된 공항의 이름은 \(removedValue) 입니다."

Iterating Over a Dictionary (딕셔너리 반복하기)

딕셔너리 내 전체 값들을 for-in 반복문을 통해 접근할 수 있습니다.

for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}
// LHR: London Heathrow
// YYZ: Toronto Pearson

딕셔너리의 키나 벨류로 반복하고 싶다면 다음과 같이 사용할 수 있습니다.

for airportCode in airports.keys {
    print("공항 코드: \(airportCode)")
}
// 공항 코드: LHR
// 공항 코드: YYZ

for airportName in airports.values {
    print("공항 이름: \(airportName)")
}
// 공항 이름: London Heathrow
// 공항 이름: Toronto Pearson

혹시 API 에 사용하기 위해 딕셔너리의 키나 벨류가 필요하다면 Array instance 를 활용할 수 있습니다.

let airportCodes = [String](airports.keys)
// airportCodes 는 ["LHR", "YYZ"]

let airportNames = [String](airports.values)
// airportNames 는 ["London Heathrow", "Toronto Pearson"]

String 자료형은 Character 의 연속체로서 "hello, world" 나 "albatross" 와 같은 것을 의미합니다. Swift 의 자료형 String 과 Character 는 코드 속의 텍스트를 유니코드와 빠르게 호환할 수 있도록 합니다.

Note: Swift 의 String 자료형은 Foundation 내 NSString 와 연결되어 있습니다. Foundation 역시 String 자료형을 표현하기 위해 NSString 를 정의하고 있습니다. 이에 따라, Foundation 을 import 한다면 String 에서 NSSring 메소드들을 별다른 캐스팅 없이 사용할 수 있게 됩니다.

자세한 사항은 Bridging Between String and NSString 을 참고해주세요.

String Literals (문자열 리터럴)

Swift 에서 문자열 리터럴은 "" 에 감쌓인 캐릭터들의 연속체들입니다. 다음과 같이 문자열 리터럴을 초기화할 수 있습니다.

let someString = "Some string literal value"

번역 : 리터럴은 데이터 값 그 자체를 의미한다.
예시)  let a = 1 
      a는 변수 / 1은 리터럴 이다.

Multiline String Literals (다중 문자열스트링 리터럴)

필요하다면 다중 문자열 리터럴 - 캐릭터 연속체가 3개의 " 로 감싸인 형태- 를 사용할 수 있습니다.

let quotation = """
하얀 토끼는 자신의 안경을 내려놓았다. 그는 "어디서부터 시작하면 될까요,
주인님?" 라고 물어왔다.

"네가 시작한 곳에서 시작해라," 왕은 장엄하게 답하였다. "그리고 네가 마지막에 다다를 때 까지 가서, 그곳에서 멈추어라."
"""

// 번역 : Velog 의 편집기가 """ """ 를 인식 못 하고 있지만, 
// 실제 사용 시 전문이 하나의 String 으로 들어가게 됩니다.

이때 가독성을 위해, 백슬래시(\) 를 사용하여 코드 내에서 띄워쓰기를 표현할 수 있습니다.

한편 종결 """ 에서 공백 문자를 포함하면 다중 문자열 리터럴의 포맷에 들여쓰기를 할 수 있습니다. 이때 들여쓰이는 내용은 코드에만 반영될 뿐, 실제 출력에는 영향을 미치지 않습니다.

상단의 예시에서 종결 """ 에 4개의 공백문자를 쓰면 """ """ 내부의 문자열은 4개의 공백문자를 무시하게 됩니다. 2번째 문단을 보면 4개의 공백문자가 추가로 들어가있는데 이는 반영되어 4개의 공백문자 이후에 문자열이 시작됩니다.

Special Characters in String Literals (문자열 리터럴 내 특별한 캐릭터)

문자열 리터럴은 다음과 같은 특별한 캐릭터들을 사용할 수 있습니다.

• 탈출 문자 \, \0 == null, \\ == 백슬래시, \t == 수평 탭, \n == 한줄 띄기, \r == 리턴, \" == 큰 따옴표, \' == 작은 따옴표
• 임의의 유니코드 스칼라 값, \u{n} 의 형태로 적으며 n 에는 1 ~ 8 의 16진법 숫자가 들어갈 수 있습니다. (유니코드는 유니코드 에서 다룹니다.)

let wiseWords = "\"상상이 지식보다 더 중요하다.\" - 아인슈타인"
// "상상이 지식보다 더 중요하다." - 아인슈타인
let dollarSign = "\u{24}" // $, 유니코드 스칼라 U+0024
let blackHeart = "\u{2665} // 🖤, 유니코드 스칼라 U+2665
let sparklingHeart = "\u{1F496} // 💖, 유니코드 스칼라 U+1F496

이때 """ 를 사용한 다중 문자열 리터럴에서 """ 를 표현하고 싶다면 \"\"\" 형태로 표현해야 합니다.

Extended String Delimiters (확장 문자열 구분자)

문자열을 호출할 때 따옴표 양 옆에 문자열을 추가함으로써, 탈출 캐릭터를 \ 에서 \추가한 캐릭터 형태로 바꿀 수 있습니다.

#"1번째 줄 \n 2번째줄"#
#"1번째 줄 \#n 2번째줄"#

// 출력 : 1번째 줄 \n 2번째줄
// 출력 : 1번째 줄
//       2번째 줄

Initializing an Empty String (빈 문자열 초기화)

빈 문자열 값을 생성하거나, 할당하고 싶다면 다음과 같은 방법으로 사용할 수 있습니다.

var emptyString = ""
var anotherEmptyString = String()
// 모두 빈 문자열이자 동일한 값을 지닙니다.

String Mutability (문자열 호환)

특정 문자열을 수정하거나 추가할 수 있으나, var 문자열에만 적용되고 let 문자열은 수정할 수 없습니다.

var variableString = "말"
variableString += "과 마차"
// variableString 은 이제 "말과 마차" 입니다.

let constantString = "하이랜더"
let constantString += "와 또 다른 하이랜더"

// 컴파일 에러가 납니다.
// 번역 : 하이랜더는 머리가 잘리지만 않으면 불사신인 존재끼리
//       영혼의 맞다이를 떠서 살아남는 사람이 상을 받는다는 영화에서 나온 존재

Strings are Value Types (문자열은 값 타입이다.)

Swift 의 문자열 자료형은 값 타입입니다. 만약 새로운 문자열 값을 생성하고, 그 문자열이 함수나 메소드 등에 의해서 복사되거나, 변수나 상수에 할당된다면 복사본은 기존의 문자열 자료형에서 생성된, 새로운 문자열입니다. 값 타입은 이곳에서 더 상세하게 기술되어 있습니다.

Swift 의 복사 전제 문자열 행동은 문자열 값을 전달할 때 정확히 똑같은 값이지만, 어디에서 왔는지 확인할 필요 없는 새로운 값을 갖게 됩니다. 따라서 전달하는 문자열은 수정되지 않음을 확신할 수 있게 됩니다.

화면 뒷단에서 Swift 컴파일러는 문자열 사용의 최적화를 진행하며 오로지 필요할 때만 복사하게끔 합니다. 이에따라 개발자들은 언제나 문자열을 값 타입으로써 훌륭한 성능을 얻을 수 있게 됩니다.

근데 백준에서 왜 그렇게 안되는게 많아요

Working with Characters (캐릭터 활용하기)

for-in 과 이터레이팅(반복)을 사용하여 각각의 캐릭터 값을 문자열로부터 얻을 수 있습니다.

for character in "Dog!🐶"{
    print(character)
}
// D
// o
// g
// !
// 🐶

이와 유사하게, 하나의 값만 담고있는 문자열로부터 캐릭터 변수나 상수를 만들 수도 있습니다.

let exclmationMark: Character = "!"

문자열은 캐릭터 배열을 전달하여 만들 수도 있습니다.

let catCharacters: [Character] = ["고", "양", "이", "!", "🐱"]
let catString = String(catCharacters)
print(catString)

// "고양이!🐱" 가 출력된다.

Concatenating Strings and Characters (문자열과 캐릭터 연결)

문자열 값은 덧셈 연산자 + 를 활용하여 새로운 문자열 값으로 만들 수 있습니다.

// 번역 : 그런데 String + Character 은 안됩니다.

var string = "조아 햄 버 거"
var character: Character = "!"
print(string + character)

// 오류 - Character 를 String 으로 바꿀 수 없습니다.
// 이를 위해서 string.append() 를 사용할 수 있습니다.

var string = "조아 햄 버 거"
var character: Character = "!"
string.append(character)
print(string)

// 출력 : 조아 햄 버 거!

다중 문자열 리터럴 """ 에서 한 줄을 띄우지 않으면 끝난 지점에서 바로 다음 문자열이 붙게 됩니다.

let badStart = """
one
two
"""

let end = """
three
"""
print(badStart + end)
// one
// twoThree

let goodStart = """
one
two

"""
print(goodStart + end)
// one
// two
// three

String Interpolation(문자열 보간)

문자열 보간은 문자열 내에 새로운 문자열 값을 포함하는 방법을 의미합니다.

let multiplier = 3
let message = "\(multiplier) 곱하기 2.5 는 \(Double(multiplier) * 2.5)"

// 출력 3 곱하기 2.5 는 7.5

문자열 보간 때 확장 문자열 구분자를 사용하면 확장 문자열 구분자를 포함하여야 합니다.

let multiplier = 3
let message = #"\#(multiplier) 곱하기 2.5 는 \#(Double(multiplier) * 2.5)"#

// 출력 3 곱하기 2.5 는 7.5

Unicode (유니코드)

유니코드는 국제적인 규격으로 다양한 출력 시스템 내에서 인코딩, 표현과 텍스트 출력을 위해 사용됩니다. 유니코드를 통해 개발자는 외부 - 텍스트 파일이나 웹 페이지 등 - 에서 온 다른 언어의 캐릭터 자료형도 규격화된 양식 안에서 표현할 수 있게 되며, 해당 글자들을 읽고 쓸 수 있게 됩니다. Swift 의 문자열과 캐릭터는 유니코드 호환 자료형이며 이번 목차에서 설명합니다.

Unicode Scalar Values (유니코드 스칼라 값)

화면 뒷단에서, Swift 의 네이티브 문자열 자료형은 유니코드 스칼라 값을 통해 만들어집니다. 유니코드 스칼라 값은 21 비트 크기의 숫자 혹은 캐릭터, 수정자를 표현하는 고유한 값입니다. 이를테면 U+0061 은 "LATIN SMALL LETTER A" 인 "a" 를 표현하고, U+1F425 는 "서 있는 병아리" 를 의미합니다.

번역 : 앞으로 나오는 유니코드는 
      한국어 문자뷰어 (한국 맥에서 fn 키를 누르면 나오는 표현) 를 사용합니다.

Extended Grapheme Clusters(확장된 음운 단위체들)

Swift 내 모든 인스턴스된 캐릭터 자료형들은 하나의 음운을 표현합니다. 확장 음운 단위체는 하나 이상의 유니코드 스칼라들을 합쳐서 만들어진 값이 됩니다.

확장된 음운 단위체들은 복잡한 문자 체계를 하나의 캐릭터 값으로 표현하는데 편리한 기능을 제공합니다. 예를 들어 한국어의 알파벳인 한글은 유니코드의 합쳐진 형태와 분리된 형태로 나누어서 표현할 수 있게 됩니다. Swift 에서는 두 형태 모두 하나의 캐릭터로써 값을 지니게 됩니다.

let precomposed: Character = "\u{D55c}" // 한
let decomposed: Character = "\u{1112}\u{1161}\u{11AB}" // ㅎ, ㅏ, ㄴ

// precompose 는 "한" 이며
// decomposed 역시 "한" 이 된다.

한편 유니코드 스칼라에서 지역 상징 표현은 한 쌍의 캐릭터 값으로 묶어서 해당 국기를 표현할 수 있습니다.

let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
// regionalIndicatorForUS == 🇺🇸

Counting Characters(캐릭터 개수 세기)

문자열 값의 캐릭터 갯수를 세기 위해서 문자열 값의 count 프로퍼티를 사용할 수 있습니다.

let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪" 
print("unusualMenagerie 은 \(unusualMenagerie.count) 캐릭터를 갖고 있습니다.") 
// Prints "unusualMenagerie 은 40 캐릭터를 갖고 있습니다."

이때 Swift 는 확장 음운 단위체를 캐릭터에 사용하므로, 문자열 합치기나 수정이 언제나 문자열 캐릭터 갯수에 영향을 미치지 않습니다.

번역 :
한국어의 경우 "한" 으로 표기하든 "ㅎ","ㅏ","ㄴ" 으로 표기하든
swift 는 1개의 캐릭터로 인식하므로
언제나 문자열 + 문자열이 갯수가 늘어나는 것은 아니라는 것을 말한다.


예시 ) var ha:Character = "\u{1112}\u{1161}" // 하
      var n:Character  = "\u{11AB}"         // ㄴ
      var han = String(ha) + String(n)
      print("\(han), \(han.count)")
      // 출력 한, 1

Note: 확장 음운 단위체는 다중의 유니코드 스칼라와 합쳐질 수 있습니다.같은 캐릭터라도 다른 표기를 한다면 메모리의 양 역시 달라질 수 있음을 의미합니다. 이때문에 Swift 는 각각의 문자열들이 동일한 메모리를 저장하고 있지 않게 됩니다. 이와 마찬가지 이유로 문자열의 캐릭터 수 또한 반복(iterating)을 통해 해당 문자열의 확장 음운 단위들을 확인해야만 알 수 있게 됩니다. 특별하게 긴 문자열 값들을 다룬다면 갯수 프로퍼티는 반드시 반복(iterate) 를 통해서 전체 문자열 내 유니코드 스칼라를 확인할 것이고, 그에 따라 문자열 내 캐릭터의 갯수를 정한다는 것을 주의하세요.

같은 캐릭터를 포함하더라도 count 프로퍼티를 통해 반환된 캐릭터들의 카운트가 언제나 NSString 의 length 와 같은 값을 갖는 것은 아닙니다. NSString 의 length 는 UTF-16 표현에 의한 16비트 코드 유닛의 갯수를 세는 반면 count 는 확장 음운 단위에 준한 값으로 계산하기 때문입니다.

Accessing and Modifying a String(문자열 접근과 수정)

문자열 메소드나 프로퍼티, 서브스크립트 문법을 활용하여 문자열에 접근하거나 수정할 수 있습니다.

String Indices(문자열 인덱스)

각 문자열 값은 String.Index 라는 인덱스와 연결되어 있습니다. String.Index 는 문자열 내 각 캐릭터들의 자리를 표현합니다.

상단에서 언급되엇듯, 다른 캐릭터들은 다른 메모리의 저장을 요구합니다. 이에 따라 캐릭터의 명확한 자리를 확정하고 싶다면 String 의 시작부터 끝까지 각각의 유니코드 스칼라를 반복해서 확인해야 합니다. 이러한 이유로 스위프트는 정수 값의 인덱스를 제공할 수 없습니다.

startIndex 프로퍼티를 사용하여 문자열의 첫번째 캐릭터에 접근할 수 있습니다. 한편 endIndex 프로퍼티를 사용하여 문자열의 마지막 캐릭터 다음의 값에 접근할 수 있습니다. 이에 따라 endIndex 프로퍼티는 문자열 내 subscript 의 매개변수로 유요한 값을 전달하지 못합니다. 만약 문자열이 비었다면 startIndex 와 endIndex 는 같습니다.

subscript 문법을 활용하여 문자열의 특정 인덱스에 접근할 수 있습니다.

let greeting = "Guten Tag!"
greeting[greeting.startIndex]
// G
greeting[greeting.index(before: greeting.endIndex)]
// !
greeting[greeting.index(after: greeting.startIndex)]
// u
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index]
// a

만약 문자열의 범위를 벗어나는 인덱스를 조회하려고 하면 문자열 범위는 런타임 에러를 발생시킬 것 입니다.

greeting[greeting.endIndex] // Error
greeting.index(after: greeting.endIndex) // Error

indices 프로퍼티를 활용하여 문자열 내 각각의 캐릭터에 접근할 수 있습니다.

for index in greeting.indices {
    print("\(greeting[index]) ", terminator: "")
}
// Prints "G u t e n   T a g ! "

Inserting and Removing

단일 캐릭터를 문자열의 특정 위치에 삽입하고 싶다면 inser(_:at:) 을 사용할 수 있습니다.

var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)
// welcome now equals "hello!"

welcome.insert(contentsOf: " there", at: welcome.index(before: welcome.endIndex))
// welcome now equals "hello there!"

삭제는 다음과 같습니다.

welcome.remove(at: welcome.index(before: welcome.endIndex))
// welcome now equals "hello there"

let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
welcome.removeSubrange(range)
// welcome now equals "hello"

Substrings (부분 문자열)

subscript 나 prefix(_:) 와 같은 메소드를 사용하여 부분 문자열 =을 얻으면, 이 인스턴스된 결과는 문자열 이 아닌 부분 문자열이 됩니다. 부분 문자열 는 Swift 의 문자열과 유사한 자료형으로, 문자열과 같이 사용할 수 있습니다. 다만 문자열과 다르게 짧은 작업을 위해서 사용할 것을 권장합니다. 만약 결과값을 저장하여 긴 시간 동안 사용하고 싶다면 부분 문자열 을 문자열 인스턴스로 바꿔서 저장할 것을 권장합니다.

let greeting = "Hello, world!"
let index = greeting.firstIndex(of: ",") ?? greeting.endIndex
let beginning = greeting[..<index]
// beginning is "Hello"

// Convert the result to a String for long-term storage.
let newString = String(beginning)

부분 문자열과 문자열의 차이는, 최적화를 위해서 부분 문자열은 원본 문자열의 메모리를 재사용한다는 것 입니다. (문자열 역시 비슷한 최적화를 갖고 있으나, 만약 두 문자열이 같은 메모리를 공유한다면 이는 같은 것으로 간주됩니다.) 이 최적화는 실제로 문자열이나 부분 문자열의 값을 수정하기 전까지는 메모리를 복사하는 비용을 지불하지 않도록 도와줍니다. 그렇기에 부분 문자열을 장 기간 사용하는 것을 지향하게 됩니다. 부분 문자열은 문자열의 저장 공간을 재사용하기 때문에, 전체 문자열이 부분 문자열을 위해 계속해서 메모리상에 존재해야하기 때문입니다.

상단의 예시에서 greeting 은 문자열로, 실제 메모리 상에서 저장되어 있는 값입니다. 한편 beginning 은 greeting 의 부분 문자열이기 때문에 beginning 은 greeting 의 저장 공산을 재 사용하게 됩니다. 이에 반해 newString 은 새로운 문자열을 인스턴스하며 메모리상에 적재되었습니다. 이를 다음과 같이 도식화할 수 있습니다.

Note: 문자열과 부분 문자열은 모두 StringProtocol 프로토콜을 따릅니다. 이는 문자열과 관련된 메소드나 함수를 사용할 때 StringProtocol 값을 받아들인다는 뜻 입니다. 그렇기에 개발자는 문자열이나 부분 문자열에 StringProtocl 내 함수들을 사용할 수 있습니다.

Comparing Strings

Swift 는 동일, 접두사 동일, 접미사 동일 3개의 텍스트 비교 값을 제공합니다.

문자열과 캐릭터 비교

두 문자열 비교는 == 혹은 != 로 확인할 수 있습니다. 이때, 두 문자열 사이에 확장 음운 단위가 있다면 이는 사람이 일반적으로 받아들이는 언어적 의미에서 동일한지에 대해서 비교합니다.

즉 Unicode 를 활용한 확장 음운이 존재하면, 
두 문자열이 "언어적"으로 같은 지 확인한다는 뜻입니다.

예를 들어 유니코드로 적은 "한" 과 "ㅎ","ㅏ","ㄴ" 은
동일한 문자열이 되지만
라틴알파벳 "à(`a)" 와 러시아 알파벳 "à(`a)" 는 다르게 인식된다는 뜻입니다.

접두사와 접미사 비교

두 문자열이 특정한 접두사나 접미사를 가지고 있는지 확인하려면 string prefix 혹은 suffix 를 사용할 수 있습니다. 메소드는 string.hasPrefix(_:),string.hasSuffix(_:) 으로, 두 메소드 다 문자열 매개변수를 받고 Boolean 값을 리턴합니다.

다음과 같은 예시에서 사용할 수 있습니다.

let romeoAndJuliet = [
    "Act 1 Scene 1: Verona, A public place",
    "Act 1 Scene 2: Capulet's mansion",
    "Act 1 Scene 3: A room in Capulet's mansion",
    "Act 1 Scene 4: A street outside Capulet's mansion",
    "Act 1 Scene 5: The Great Hall in Capulet's mansion",
    "Act 2 Scene 1: Outside Capulet's mansion",
    "Act 2 Scene 2: Capulet's orchard",
    "Act 2 Scene 3: Outside Friar Lawrence's cell",
    "Act 2 Scene 4: A street in Verona",
    "Act 2 Scene 5: Capulet's mansion",
    "Act 2 Scene 6: Friar Lawrence's cell"
]

위와 같은 본문이 있을 때, prefix 를 활용하여 접두사를 확인할 수 있습니다.

var act1SceneCount = 0
for scene in romeoAndJuliet {
    if scene.hasPrefix("Act 1 ") {
        act1SceneCount += 1
    }
}
print("There are \(act1SceneCount) scenes in Act 1")
// Prints "There are 5 scenes in Act 1"

한편 suffix 를 활용하여 접미사도 확인할 수 있습니다.

var mansionCount = 0
var cellCount = 0
for scene in romeoAndJuliet {
    if scene.hasSuffix("Capulet's mansion") {
        mansionCount += 1
    } else if scene.hasSuffix("Friar Lawrence's cell") {
        cellCount += 1
    }
}
print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
// Prints "6 mansion scenes; 2 cell scenes"

prefix 와 suffix 역시 확장 음운 단위가 있다면, 문자열과 캐릭터 비교 에서 처럼 언어의 의미적 단위에서 비교하게 됩니다.

Unicode Representations of Strings(문자열의 유니코드 표현법)

유니코드 문자열을 텍스트 파일에 작성하거나 저장할 때, 문자열 내 유니코드 스칼라들은 유니코드에서 사전 정의된 여러 인코딩 양식 중 하나를 따라 인코딩됩니다. 각 양식은 코드 유닛이라 부르는 작은 덩어리들로 문자열을 인코딩합니다.

양식에는 UTF-8 양식 (문자열을 8 비트 코드 유닛으로 인코딩), UTF-16 양식(문자열을 16 비트 코드 유닛으로 인코딩), UTF-32 양식(문자열을 32 비트 코드 유닛으로 인코딩) 이 있습니다.

Swift 는 문자열의 유니코드 표현법 접근을 위해 여러 방법을 제공합니다. for-in 구문을 활용해서 반복(iterating) 할 수 있으며, 유니코드 확장 음운 단위로서 각 캐릭터 값에 접근할 수 있습니다. 이 프로세스는 상단의 Working with Characters 에서 설명되었습니다.

대체적으로 문자열 값은 3개의 유니코드 컴파일 표현법으로 접근할 수 있습니다.

• UTF-8 코드 유닛 집합
• UTF-16 코드 유닛 집합
• 21 비트 유니코드 스칼라 값 집합 (값은 UTF-32 인코딩과 동일)

각 표현법은 같은 let dogString = "Dog!!"🐶 도 다르게 표현됩니다.

UTF-8 Representations(UTF-8 표현법)

for codeUnit in dogString.utf8 {
    print("\(codeUnit) ", terminator: "")
}
print("")
// Prints "68 111 103 226 128 188 240 159 144 182 "

이때 "D", "o", "g" 는 ASCII 코드와 동일한 값입니다.

UTF-16 Representations(UTF-16 표현법)

for codeUnit in dogString.utf16 {
    print("\(codeUnit) ", terminator: "")
}
print("")
// Prints "68 111 103 8252 55357 56374 "

마찬가지로 "D", "o", "g" 는 ASCII 코드와 동일한 값입니다.

Unicode Scalar Representation(유니코드 스칼라 표현법)

for scalar in dogString.unicodeScalars {
    print("\(scalar.value) ", terminator: "")
}
print("")
// Prints "68 111 103 8252 128054 "

이때 참고로, 다음과 같은 표현으로 각 scalr 에 접근할 수 있습니다.

for scalar in dogString.unicodeScalars {
    print("\(scalar) ")
}
// D
// o
// g
// ‼
// 🐶

연산자는 다음과 같이 값을 확인하거나 변화, 합치기 위해 사용되는 특별한 상징이나 구문을 의미합니다.

let i = 1 + 2
if enteredDoorCode && passedRetinaScan

Swift 의 연산자들은 비정상적인 결과값을 갖지 않도록 연산의 결과가 오버플로우 하는지를 감지하는데, 오버플로우 행동과 관련된 연산자를 활용하고 싶다면 Overflow Operators 를 확인해주세요.

Swift 는 C 언어에서는 제공되지 않았던 a..<b 나 a...b 와 같은 줄임표현도 제공합니다. 더 많은 연산자들을 확인하고 싶다면 Advanced Operators 를 확인해주세요.

Terminology (용어)

연산자는 크게 단항 (unary), 이항 (binary), 삼항 (ternary) 으로 구분할 수 있습니다.

• 단항 연산자는 -a 와 같이 1개의 목표 대상을 지닌 연산자를 의미하며, 접두연산자 prefix, 앞에 붙는 연산자, !a 와 접미연산자 postfix, 뒤에 붙는 연산자, a! 로 구분할 수 있습니다.
• 이항 연산자는 2 + 3 과 같이 2개의 목표 대상을 지닌 연산자를 의미하며 중위 연산자 (infix) 라고도 불립니다.
• 삼항 연산자는 3개의 목표 대상을 지닌 연산자로, Swift 에서는 딱 1개 , 조건부 연산자 (conditional operator) 만 있습니다. a ? b : c

목표 대상은 피연산자 (operand) 로 지칭합니다. 1 + 2 에서 + 는 이항 연산자, 중위 연산자 (infix) 이며 1 과 2 는 피연산자 (operand) 입니다.

Assignment Operator (할당 연산자)

할당 연산자 (a = b) 는 값을 초기화하거나 새롭게 할당할 때 사용합니다.

let b = 10
var a = 5
a = b
// a 의 값은 이제 10 입니다.

만약 오른쪽의 값이 튜플과 같이 여러개의 값을 갖고 있다면 한번에 나누어서 값을 할당할 수 있습니다.

let (x,y) = (1,2)
// x 는 1 이며, y 는 이제 2 입니다.

C 언어와 다르게 Swift 의 할당연산자 = 는 스스로 값을 리턴하지 않습니다. 따라서 다음과 같은 구문은 사용할 수 없습니다.

if x = y {
   code ....
   code ....
} 

Arithmetic Operators (산술연산자)

• 더하기 + , ex) 1 + 2 더하기는 String 타입에서도 사용할 수 있습니다. ex) "Hello", + "World!"

• 빼기 - , ex) 5 - 3

• 곱하기 * , ex) 2 * 3

• 나누기 / , 10.0 / 2.5

나머지 연산자 (remainder)

나머지 연산자 a % b 는 b 가 a에 근접하도록 최대한의 곱셈을 해준 후, 남은 값을 반환하는 연산자입니다.

다른 언어에서는 나머지 연산자를 "modulo" 연산자로 알려져있습니다, 만 
Swift 의 나머지 연산자는 음의 나머지 값을 반환하므로, 
엄밀히 말해서, "remainder" 연산자라고 부르는 것이 맞습니다.

번역 : 
a = -9, b = 4 일 때, 

% 를 modulo 연산을 하게 되면
4 * 3 을 한 후 남은 3이 나머지 값이 되지만

% 를 remainder 로 계산하게 되면
4 * 2 를 한 후 남은 -1 이 나머지 값이 됩니다.

Swift 는 % 계산을 하면 -1 이 남으므로 
용어는 remainder 가 맞다라고 "엄밀히" 말하고 있습니다.

단항 빼기 연산자 (Unary Minus Operator)

정수는 접두연산 - 를 사용해서 양의 값을 음으로 바꿀 수 있습니다.

let three = 3
let minusThree = -three        // minusThree == -3
let plusThree = -minusThree    // plusThree == 3

이처럼 빼기 - 를 값의 바로 앞에 붙임으로써 해당 값이 연산되기 이전에 값을 바꾸도록 사용할 수 있습니다.

단항 더하기 연산자 (Unary Plus Operator)

더하기도 똑같이 할 수 있습니다. 만 아무런 영향도 미치지 않습니다.

Compound Assignment Operators(복합연산자)

C 언어처럼 Swift 는 = 과 다른 연산자를 합친 복합 연산자를 지원합니다.

var a = 1
a += 2

Note : 단 복합연산자는 값을 리턴하지 않습니다. 따라서 다음과 같은 구문은 사용할 수 없습니다.

let b = a += 2

Swift standard library 가 제공하는 연산자에 대한 정보를 확인하고 싶으시다면 Operator Declarations 를 확인해주세요.

Comparison Operators(비교 연산자)

Swift 는 다음과 같은 비교 연산을 지원합니다.

• 동일하다 : a == b
• 동일하지 않다 : a != b
• 크다 : a > b
• 작다 : a < b
• 크거나 같다 : a >= b
• 작거나 같다 : a <= b

비교 연산자는 if 구문에서 자주 사용됩니다. if 구문에 대해 더 알고 싶다면 Control Flow 를 확인해주세요.

비교 연산자는 같은 자료형과 같은 갯수를 가진 튜플(tuple) 에도 사용할 수 있습니다. 튜플을 비교할 때는 왼쪽에서 오른쪽으로, 한번에 한번씩만 비교하며 두 값이 다를 때 까지만 진행됩니다.

(1, "zebra") < (2, "apple")
// true, 1이 2보다 작기 때문입니다. zebra 와 apple 은 비교되지 않습니다.

(3, "apple") < (3, "bird")
// ture, 3과 3이 같고 apple 이 bird 보다 작기 때문입니다.
// 번역 : String 은 길이가 아닌 서로의 앞 글자부터 아스키코드 값을 비교합니다.

(4, "dog") == (4, "dog")
// true, 4과 4가 같고 "dog" 가 "dog" 로 같기 때문입니다. 

위의 예시와 같이 비교 연은 왼쪽에서 오른쪽으로 진행되는 것을 확인할 수 있습니다. 첫번째 예시를 보면 "zebra" 와 "apple" 이 비교되지 않는 것을 확인할 수 있는데, 비교 연산이 이미 첫번째로 비교한 1 2 비교에서 끝났기 때문입니다. 만약 서로의 첫번째 원소가 같다면 두번째 원소로 이동하여 서로를 비교하게 됩니다.

튜플끼리의 비교는 각 튜플 원소들의 값을 비교할 수 있을 때만 적용할 수 있습니다. 예를 들어 아래의 예시와 같이 (String, Int) 튜플은 비교할 수 있지만 (String, Bool) 은 비교할 수 없습니다. Bool 은 <, >, ==로 비교할 수 없기 때문입니다.

("blue", -1) < ("purple", 1)  // 비교 가능하며 true 입니다.
("blue", false) < ("purple", true) // 비교 자체가 불가능합니다.

Note: Swift standard library 에서 튜플은 7개 미만의 원소만 비교할 수 있습니다. 7개 이상의 원소를 포함한 튜플을 비교하고 싶다면 직접 비교 연산을 적용시켜야 합니다.

Ternary Conditional Operator (삼항 연산자)

삼항 연산자는 question ? answer1 : answer2 , 3 부분으로 이루어진 특별한 연산을 수행합니다. question 이 true 라면 answer1 을, false 라면 answer2 를 리턴합니다.

삼항 연산자는 다음의 줄임 표현입니다.

question? answer1 : answer2

if question {
    answer1
} else {
    answer2
}

침대의 가로길이를 맞추려고 할 때, 침대가 머리맡 선반이 있다면 50을, 없다면 20을 주고 싶은 상황이라면 다음과 같이 코드를 작성할 수 있습니다.

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)

-----------------------------------------------------

let contentHeight = 40
let hasHeader = true
let rowHeight: Int
if hasHeader {
    rowHeight = contentHeight + 50
} else {
    rowHeight = contentHeight + 20
}

삼항연산자는 효율적으로 표현을 줄일 수 있습니다. 하지만 남용하면 지나친 간결성이 코드의 가독성을 저해하므로 여러개의 상황을 결합하여 삼항 연산자를 사용하지 않도록 합니다.

Nil-Coalescing Operator(닐-병합 연산자)

닐 병합연산자 a ?? b (이하 병합연산자) 는 옵셔널(optional) 을 꺼내 풀어서 값을 갖고 있다면 (a 가 nil 이 아니라면) 그 값을, 값이 nil 이라면 기본 값인 b 를 리턴하는 연산을 의미합니다. 이때 a 는 항상 옵셔널(optional) 자료형이어야 하며, b 는 항상 a 의 자료형과 일치해야 합니다.

병합연산자는 다음의 줄임 표현이라고 할 수 있습니다.

a != nil ? a! b

이 코드는 삼항 연산자를 통해 a! 를 수행하고, 만약 a 의 값이 nil 이라면 b 를 리턴하고 있습니다.

Note: 만약 a 가 옵셔널 자료형이 아니라면 b 는 수행되지 않습니다. short-circuited 에 준하는 내용입니다.

병합 연산자의 예시로, 기본색과 유저가 정한 색을 고르는 상황입니다.

let defaultColorName = "red"
var userDefinedColorName: String? // nil 이 기본값입니다.

var colorNameToUse = uerDefinedColorName ?? defaultColorName
// userDefinedColorName 이 nil 이라면 
// colorNameToUse 에는 defaultColorName 이 할당됩니다.

userDefinedColorName 변수는 옵셔널 String 으로 정의되어 있기에, 병합연산자를 통해서 값을 정해줄 수 있습니다.

만약 userDefinedColorName 이 nil 이 아니라면 defaultColorName 대신 userDefinedColorName 이 사용됩니다.

userDefinedColorName = "green"
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName 이 nil 이 아니기때문에, colorNameToUse 는 "green" 으로 할당됩니다.

Range Operators(범위 연산자)

Swift 는 범위를 짧게 표현할 수 있는 여러 범위 연산자가 있습니다.

Closed Range Operator(닫힌 범위 연산자)

닫힌 범위 연산자는 (a...b) 로 a 부터 b 까지 범위에 a 와 b 를 모두 함하는 연산을 의미합니다. 이때 a 는 반드시 b 보다 작아야합니다.

닫힌 범위 연산자는 for ... - in ... 반복문처럼 모든 값을 확인하고 싶을 때 유용합니다.

for index in 1...5 {
    print("\(index) 곱하기 5 는 \(index * 5)")
}
// 1 곱하기 5 는 5
// 2 곱하기 5 는 10
// 3 곱하기 5 는 15
// 4 곱하기 5 는 20
// 5 곱하기 5 는 25

더 자세한 for-in 반복문은 Control Flow 를 확인해주세요.

Half-Open Range Operator(반열림 범위 연산자)

반열림 범위 연산자 (a..<b) 는 a 부터 b 까지의 범위 중 b 를 포함하지 않는 연산을 의미합니다. 반열림의 의미는 처음의 값은 포함하지만 마지막을 포함하지 않기 때문입니다. 닫힘 범위 연산자가 그러했듯 a 는 b 보다 작아야합니다. 만약 a 와 b 가 같다면 해당 범위 연산자는 빈 값을 리턴합니다.

반열림 범위 연산자는 특히 0을 기준으로한 배열과 함께 사용할 때 유용합니다.

let names = ["안나", "알렉스", "브라이언", "뉴원"]
let count = names.count
for i in 0..<count {
    print("사람\(i+1) 은 \(naems[i])라고 불립니다.")
}
// 사람1 안나라고 불립니다.
// 사람2 알렉스라고 불립니다.
// 사람3 브라이언라고 불립니다.
// 사람4 뉴원라고 불립니다.

위에서 반열림 범위 연산자는 배열이 4개의 원소를 갖고 있지만, 0..<count 가 3, 배열의 마지막 인덱스, 까지만 호출하고 있습니다. 배열에 대해 더 자세히 알고 싶다면 Arrays를 참고해주세요.

One-Sided Ranges(한방향 범위 연산자)

닫힌 범위 연산자는 한 방향으로 계속해서 반복하는 형태의 연산자를 가질 수 있습니다. 이를테면 범위는 2부터 배열의 끝까지 가도록 할 수 있습니다. 이때 특정 값을 범위 연산자로부터 꺼내 사용할 수 있게됩니다. 이런 종류의 연산자를 한방향 범위 연산자(One-Sided Ranges) 라고 합니다. 연산자가 한쪽 방향에만 있기 때문에 이러한 이름이 붙게 되었습니다.

for name in names[2...] {
    print(name)
}
// 브라이언
// 뉴원

for name in names[...2] {
    print(name)
}
// 안나
// 알렉스
// 브라이언

반열림 범위 연산자 역시 위와 동일한 맥락에서 사용할 수 있습니다.

for name in names[..<2] {
    print(name)
}
// 안나
// 알렉스

한방향 범위 연산자는 for-in 구문에서만 사용할 수 있는 것이 아닌, 다른 상황에서도 사용할 수 있습니다. 하지만 이때 한방향 범위 연산자는 범위가 정해져있지 않는 연산자에게서 값을 지정할 수 없게됩니다. 범위가 정해져있지 않기에 그 값이 명확하지 않기 때문입니다.

let range = ...5
range.contains(7) // false
range.contains(5) // true
range.contains(-1) // true

Logical Operators(논리 연산자)

논리 연산자는 Boolean 자료형의 논리 값을 true 나 false 로 수정하거나 병합하는 연산자를 의미합니다. Swift 는 C 언어 바탕의 3개의 논리 연산자를 제공합니다.

• 논리 부정, NOT (!a)
• 논리곱, AND (a && b)
• 논리합, OR (a || b)

NOT 연산자

NOT 연산자, 부정 연산자 !a 는 Boolean 자료형의 값을 뒤집는 것으로 true 가 false 로, false 가 true 로 전환되는 것을 의미합니다.

부정 연산자는 접미 연산자로, 해당 값이 연산되기 이전에 나타나며 "a 가 아니다 (not a)" 로 읽을 수 있습니다.

let allowedEntry = false
if !allowedEntry {
    print("ACCESS DENIED")
}
// "ACCESS DENIED" 가 출력됩니다.

부정 연산자를 활용함으로써 코드의 가독성과 간결성을 유지할 수 있으며, 부정형을 두번 사용하거나 혼란스러운 논리 기재를 피할 수 있습니다.

AND 연산자

AND 연산자, 논리곱 연산자 a && b 는 두 값이 모두 true 임을 통해 전체 표현또한 true 임을 나타내는 연산자입니다.

만약 두 값이 false 라면 전체 표현 역시 false 가 됩니다. 이때, 사실 첫번째 값이 false 라면 두번째 값은 계산조차 되지 않는데 왜냐하면 이미 전체 표현식은 true 가 될 수 없기 때문입니다.

let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
    print("Welcome!")
} else {
    print()"ACCESS DENIED
}
// "ACCESS DENIED" 가 출력됩니다.

OR 연산자

OR 연산자, 논리합 연산자 a || b 는 중위 연산자로 파이프 모양의 Character 가 2개 있는 것으로 만들 수 있습니다. OR 연산자는 둘 중 하나의 값이라도 true 라면 전체 표현 역시 true 임을 나타내는 연산자입니다.

OR 연산자도 AND 연산자와 마찬가지로, 첫번째 값이 true 라면 두번째 값부터는 계산조차 되지 않는데 왜냐하면 이미 전체 표현식은 false 가 될 수 없기 때문입니다.

let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
     print("ACCESS DENIED")
}
// "Welcome" 이 출력됩니다.

논리 연산자 조합하기

논리 연산자들을 여러개 사용하여 더욱 길고, 조합된 표현식을 사용할 수도 있습니다.

if enteredDoorCode && passRetinaScan || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// "Welcome" 이 출력됩니다.

위의 코드는 길어보이지만 3개의 논리 연산을 진행하고 있습니다. enteredDoorCode 와 passRetinaScan 가 true 인지, hasDoorKey 가 true 인지 knowsOverridePassword 가 true 인지

입니다.

Note: Swift 의 논리연산자는 왼쪽이 우선순위에 있습니다. 즉, 다수의 논리 연산자를 사용하더라도, 내부에서 나뉘더라도 왼쪽부터 논리 연산을 진행합니다.

괄호를 통해 명백하게 하기 (Explicit Parentheses)

위의 코드에서 괄호를 통해 코드를 명백하게 할 수 있습니다.

if (enteredDoorCode && passRetinaScan) || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// "Welcome" 이 출력됩니다.

괄호가 연산에 영향을 미치지는 않습니만, 코드의 가독성을 위해 활용할 수 있습니다.

기본형태

let input = readLine()!
print(input + ", " + "\(type(of: input))")

// 입력 : 10
// 결과 : 10, String

readLine() 에 ! 를 붙이지 않으면 Optional String 으로 받는다.

정수로 입력받기

let input = Int(readLine()!)!
print("\(input)" + ", " + "\(type(of: input))")

// 입력 : 10
// 결과 : 10, Int

readLine()! 으로 받더라도, String 이 Int 로 캐스팅 실패할 수도 있으므로
!를 붙여 그럴 가능성이 없다고 선언한다.

끝날 때 까지 계속 입력받기

while let readString = readLine() {
    s += readString
}

문자열을 Array<Character> 으로 받기

let input = Array(readLine()!)
print("\(input)" + " " "\(type(of: input))")

// 입력 : ABABAB
// 결과 : ["A", "B", "A", "B", "A", "B"] Array<String>

공백문자를 기준으로 띄워서 Array<String> 으로 받기

import foundation

let input = readLine()!.components(separatedBy: " ")
print("\(input)" + " " "\(type(of: input))")

// components 는 foundation Library 에 포함되어있다.
// 입력 : A B A B A B
// 결과 : ["A", "B", "A", "B", "A", "B"] Array<String>

공백문자를 기준으로 띄워서 Array<Int> 으로 받기

let input = readLine()!.split(separator: " ").map{Int($0)!}
print("\(input)" + ", " + "\(type(of: input))")

// 입력 : 1 0 1 0 1
// 결과 : [1, 0, 1, 0, 1], Array<Int>

한 줄 정수를 Array<Int> 로 입력받기

let input = Array(readLine()!).map{ Int(String($0))! }
print("\(input)" + ", " + "\(type(of: input))")

// String 형변환 후 Int 로 하면 속도가 더 빠르다.
// 이유는 SubString 과 String 의 차이
// 참조 : https://icksw.tistory.com/218

// 입력 : 10101
// 결과 : [1, 0, 1, 0, 1], Array<Int>

공백문자를 기준으로 띄워서 이차원배열에 Array<Int> 로 받기

var input = [[Int]](repeating: [Int](repeating: 0, count: 5), count: 5)
for i in 0...input.count - 1 {
    input[i] = readLine()!.components(separatedBy: " ").map{ Int(String($0))! }
}

print("\(input)" + ", " + "\(type(of: input))")

// 입력 : 
0 1 1 1 1
0 1 1 1 1
0 0 0 1 1
1 1 0 0 0
1 1 1 1 0

// 결과 :
[[0, 1, 1, 1, 1], [0, 1, 1, 1, 1], [0, 0, 0, 1, 1], [1, 1, 0, 0, 0], [1, 1, 1, 1, 0]], Array<Array<Int>>

공백문자 없이 이차원배열에 Array<Int> 로 받기

var input = [[Int]](repeating: [Int](repeating: 0, count: 5), count: 5)
for i in 0...input.count - 1 {
    input[i] = Array(readLine()!.map{Int(String($0))! })
}

print("\(input)" + ", " + "\(type(of: input))")

// 입력 :
01111
01111
00011
11000
11110

// 결과 :
[[0, 1, 1, 1, 1], [0, 1, 1, 1, 1], [0, 0, 0, 1, 1], [1, 1, 0, 0, 0], [1, 1, 1, 1, 0]], Array<Array<Int>>

공백문자를 기준으로 띄워서 이차원배열에 Array<String> 로 받기

var input = [[String]](repeating: [String](repeating: "", count: 5), count: 5)
for i in 0...input.count - 1 {
    input[i] = readLine()!.components(separatedBy: " ")
}

print("\(input)" + ", " + "\(type(of: input))")

// 입력 :
A B B B B
A B B B B
A A A B B
B B A A A
B B B B A

// 결과 :
[["A", "B", "B", "B", "B"], ["A", "B", "B", "B", "B"], ["A", "A", "A", "B", "B"], ["B", "B", "A", "A", "A"], ["B", "B", "B", "B", "A"]], Array<Array<String>>

공백문자 없이 이차원배열에 Array<String> 로 받기

var input = [String](repeating: "", count: 5)
for i in 0...input.count - 1 {
    input[i] = readLine()!
}

print("\(input)" + ", " + "\(type(of: input))")

// 입력 :
ABBBB
ABBBB
AAABB
BBAAA
BBBBA

// 결과 :
["ABBBB", "ABBBB", "AAABB", "BBAAA", "BBBBA"], Array<String>

------------------------------

var input = [[String]](repeating: [String](repeating: "", count: 5), count: 5)
for i in 0...input.count - 1 {
    input[i] = Array(readLine()!.map{ String($0) })
}

print("\(input)" + ", " + "\(type(of: input))")

// 입력 :
ABBBB
ABBBB
AAABB
BBAAA
BBBBA

// 결과 :
[["A", "B", "B", "B", "B"], ["A", "B", "B", "B", "B"], ["A", "A", "A", "B", "B"], ["B", "B", "A", "A", "A"], ["B", "B", "B", "B", "A"]], Array<Array<String>>

문제로 이동하기

핵심 로직

• 이분 탐색으로 인덱스가 아닌 실제 값을 찾기
• 이분 탐색 중 Upper bound 를 활용하기

코드

lateinit var lanCable: Array<Int>  

fun solve(K: Int, N: Int): Long {  
    var minimumLan:Long = 0  
    var maximumLan:Long = lanCable[lanCable.lastIndex] + 1.toLong()  
    var mid: Long  
    var count:Long  

    while (minimumLan < maximumLan){  
        mid = (maximumLan + minimumLan) / 2  
        count = 0  

        for(i in lanCable.indices){  
            count += (lanCable[i] / mid)  
        }  

        if (count < N)  
            maximumLan = mid  
        else  
            minimumLan = mid + 1  
    }  

    return minimumLan  
}  

fun main() {  
    val br = System.`in`.bufferedReader()  
    val bw = System.`out`.bufferedWriter()  

    val (K, N) = br.readLine().split(" ").map {it.toInt()}

    lanCable = Array(K) { 0 }  

    for (i in lanCable.indices)  
        lanCable[i] = br.readLine().toInt()  

    lanCable.sort()  

    bw.append("${solve(K, N) - 1}")  
    bw.flush()  
    bw.close()  
}

풀이

랜선 자르기의 핵심은 여러 값들이 주어졌을 때, 문제의 조건을 만족하는 최댓값을 구하는 것이다.

비교를 해야할 여러 값들이 존재하고, 그 값들과 특정 조건이 만족하는 상황을 구하는 것인데 그림으로 표현하자면 다음과 같다.

랜선 K (예제 입력 : 4) 개가 각각의 길이로 주어졌을 때, 각각의 랜선을 잘라서 N (예제 입력 : 11)개로 만들고자 하는데, 모든 랜선을 균일하게 자른다고 가정했을 때, 가장 길게 자를 수 있는 값은 무엇인가 ?

로 정리할 수 있다.

이때 일반적인 방법을 사용하면 시간초과를 받게 되고, 이분탐색 중 Upper bound 를 통해 보다 빠르게 찾아낼 수 있다.

원래의 이분탐색 중 Upper bound 는 중복이 있는 배열에서 중복의 가장 마지막 인덱스 값을 찾기 위해 사용된다.

fun binarySearch(arr: IntArray, target: Int): Int {
    var low = 0
    var high = arr.lastIndex
    var mid: Int

    while (low <= high) {
        mid = (low + high) / 2

        when {
            target < arr[mid] -> high = mid - 1
            target >= arr[mid] -> low = mid + 1
            // 찾고자 하는 값이 중앙값보다 크거나, *같다면(!!)*
            // 시작값(low)를 mid + 1 로 올려서
            // 만족하는 최대 인덱스를 찾는다.
        }
    }
    return low
}

하지만 이것을 조금 비틀어서
인덱스 대신 실제 값 으로 Upper bound 를 수행하는 것이 포인트다.

while (minimumLan < maximumLan){  
    mid = (maximumLan + minimumLan) / 2  
    count = 0  

    for(i in lanCable.indices){  
        count += (lanCable[i] / mid)  
    }  

    if (count < N)  
        maximumLan = mid  
    else  
        minimumLan = mid + 1  
}  

return minimumLan

여기서 count 는 랜선의 갯수를 세는 변수로, 조건에 부합한지 확인하는 변수이다. 위 코드의 target 역할을 한다.

주의사항

1. Int 범위를 넘어갈 수 있음. mid 를 구하는 방법이 (max + min ) / 2 이며, 입력 상, max 와 min 을 합칠 때 Int 를 초과할 수 있으므로 Long 을 써주어야 한다.
   
   

2. max 는 항상 max + 1 이어야 함. Upper bound 를 통해 찾는 값은 min ~ max 내에서 찾게 된다. 이는 특정 케이스, 최소와 최대가 0일 때 문제가 생긴다.

 min = 0
 max = 0
 mid = (min + max) / 2  // 0

 // min < max 가 아니기에, 
 // 이분탐색이 수행되지 않고 종료된다.

일반화 및 후기

해당 문제의 로직은 여러 값들 중에서 조건을 만족하는 최댓값을 구할 때 사용할 수 있다.

어려운 개념은 아닌데, 선뜻 손이 안 갔던 문제였다.

객체(Object) 를 지향(Oriented) 하는 프로그래밍은 코딩을 작성할 때 사용할 수 있는 하나의 패러다임, 더 일반적으로는 하나의 글쓰기 장르라고 볼 수 있다.

잠시 객체 지향 프로그래밍을 접어두고, 코딩이 어떻게 동작하는지부터 생각해보자. 어떤 프로그래밍 언어를 쓰더라도 코드는 컴파일러를 거쳐서 수행된다. 사람이 작성한 코드를 기계어로 번역하는 작업이 필요한 것인데, 이때 코드는 위에서부터 아래로 한 줄씩 코드를 읽고, 번역하고, 내용을 수행한다.

화가가 그림을 그려서 파는 작업을 위의 문단의 내용만 갖고서 코드로 표현하면 다음과 같다.

var 화가 지갑 = 0
var 화가가 갖고 있는 그림 = 1

var 손님 지갑 = 20000
var 손님이 갖고 있는 그림 = 0
var 손님은 그림을 갖고 싶다 = true

if (10000 >= 손님 지갑 && 손님은 그림을 갖고 싶다) {
    손님 지갑 -= 10000
    화가 지갑 += 10000
    손님이 갖고 있는 그림 += 1
    화가가 갖고 있는 그림 -= 1

    손님은 그림을 갖고 싶다 = false
}  

Kotlin 컴파일러는 위에서부터 읽으며 모든 내용을 절차대로 수행할 것이다. 이때, 만약 손님이 1명이 아니라 여러 명이라면 코드는 계속해서 저 코드를 부분적으로 반복하며, 많은 줄을 작성해야할 것이다.

그렇다. 굉장히 귀찮은 작업이며, 이것을 해결하기 위해 나온 것이 절차적 프로그래밍과 객체 지향 프로그래밍이다.

잠깐, 절차적 프로그래밍 ? 절차적 프로그래밍은 함수의 재호출을 이용해 코드를 재활용하는 방법을 의미한다.

즉, 컴파일러가 위에서부터 아래로 순서대로 읽는 것과는 별개로 (애초에 모든 코드는 절차적이다.) , 함수같은 Procedural 를 재활용하자는 의미에서 Procedural Programming 인 것이다.

이 글에서 절차적 프로그래밍은 함수를 통해 코드를 재활용한다는 의미로만 사용하고, 그 이상의 내용은 다루지 않는다.

객체 지향 프로그래밍(Object Oriented Programming)

객체(Object) 를 지향(Oriented) 하는 프로그래밍은 코딩을 작성할 때 사용할 수 있는 하나의 패러다임, 더 일반적으로는 하나의 글쓰기 장르라고 볼 수 있다.

객체를 지향한다고 하니, 객체가 무엇인지 알아보자.
여기서 말하는 객체 란 하나로써 존재할 수 있는 무언가를 의미한다. 사람, 고양이, 우주, 자동차 등이 될 수 있다.

언급된 객체들의 특징은 자신이 주체 가 될 수 있다는 점이다. 고양이는 고양이로서 존재할 수 있고, 우주는 우주로서 존재할 수 있다. 고양이를 이루는 것 중에는 털이 있지만, 털이 조금 빠진다고 고양이가 고양이가 되진 않는다. 털이 빠진 고양이가 될 순 있지만.

굉장히 관념적이지만, 여기서 말하는 객체 가 하나로서 존재할 수 있는 어떤 추상적인 무언가 로 이해했다면 완벽하다.

객체 지향 프로그래밍은 프로그래밍을 짤 때 객체 단위로 코드를 작성하기를 지향 한다는 것이다.

고양이라는 하나의 객체에는 성격, 근육, 털, 행동 등등 여러가지 것들이 포함될 수 있다. 어떠한 것들은 있을 수도 있고, 없을 수도 있지만 고양이 라는 객체는 존재하며,

이 같은 생각을 바탕으로 코드를 작성하겠다는 패러다임이 바로 객체 지향 프로그래밍(Object Oriented Programming) 이다.

Kotlin 과 객체 지향 프로그래밍

코틀린으로 실제 객체, 고양이를 작성을 해보자.

위에서 언급한 하나로서 존재할 수 있는 객체, 즉 고양이는 Class 로 정의되며, 그 내부의 털, 성격, 근육 등은 변수 혹은 함수 로 정의할 수 있다.

fun main(){
  val cat = Cat()

  println("눈동자는 ${cat.눈동자}, 털은 ${cat.털}, 성격은 ${cat.성격}")

  cat.털 = "깎아버리기!"
  cat.눈동자 = "까망색"
  println("${cat.털}, ${cat.눈동자}")

  cat.밥과 관련된 행동(true)
}

class Cat(){
   val 눈동자: String = "Blue"
   var 털: String = "너무 많아"
   val 성격: String = "커여워"

   fun 밥과 관련된 행동(밥: Boolean){
      if(!밥){
         println("냥냥펀치!!")
      } else {
         println("와구와구")
      }
   }
}

결과
눈동자는 Blue, 털은 너무 많아, 성격은 커여워
눈동자는 Blue, 털은 깎아버리기!, 성격은 커여워
와구와구

• 클래스는 다음과 같이 미리 class 를 만들어 놓은 후, 변수로 선언하여 사용할 수 있다. 클래스의 내부 변수 접근은 . 으로 할 수 있다.

• class 로 정의된 변수 중, var 변수는 외부에서도 변경이 가능하지만 val 변수는 변경이 되지 않기 때문에 털은 변하되 눈동자는 변하지 않는다.

• 클래스 내부 함수 접근 역시 . 로 할 수 있다.

한편, 클래스도 매개변수를 받을 수 있다. 같은 내용을 매개변수를 받는 형태로 바꾼다면 다음과 같다.

fun main(){
  val cat = Cat()

  println("눈동자는 ${cat.눈동자}, 털은 ${cat.털}, 성격은 ${cat.성격}")

  cat.털 = "깎아버리기!"
  cat.눈동자 = "까망색"
  println("${cat.털}, ${cat.눈동자}")

  cat.밥과 관련된 행동(false)
}

class Cat( val 눈동자: String = "Blue", 
           var 털: String, 
           val 성격: String = "커여워") 
{
      fun 밥과 관련된 행동(밥: Boolean){
           if(!밥){
              println("냥냥펀치!!")
           } else {
              println("와구와구")
           }
      }
}

결과
Error --> 매개변수 값을 선언해주세요.
눈동자는 Blue, 털은 깎아버리기!, 성격은 커여워
냥냥펀치!!

• 클래스의 매개변수는 val, var 타입이 올 수 있으며 val 은 변경 불가, var 은 변경 가능이다.

• 클래스의 매개변수는 Cat 의 눈동자와 같이 기본값을 줄 수도 있고, 털처럼 기본값을 안줄 수도 있다. 기본값을 주지 않은 매개변수는 선언 시 반드시 매개변수값을 넣어주어야 한다. 기본값이 있는 곳에 새로운 매개변수 값을 넣으면 새로운 값으로 덮어쓴다.

  
  

이렇게 작성된 코드는 반복작업도 굉장히 간편하다. 밥과 관련된 행동을 반복하고 싶다면 다음과 같이, 코드 한 줄이면 반복 작업을 수행할 수 있다.

fun main(){
  val cat = Cat()

  cat.밥과 관련된 행동(false)
  cat.밥과 관련된 행동(true)
  cat.밥과 관련된 행동(true)
  cat.밥과 관련된 행동(true)
}

class Cat( val 눈동자: String = "Blue", 
           var 털: String, 
           val 성격: String = "커여워") 
{
      fun 밥과 관련된 행동(밥: Boolean){
           if(!밥){
              println("냥냥펀치!!")
           } else {
              println("와구와구")
           }
      }
}

결과
냥냥펀치!!
와구와구
와구와구
와구와구

한편 같은 객체이지만, 서로 다른 존재를 부르고 싶을때도 간편하다.

fun main(){
  val catBlue = Cat("Blue", "너무많아!", "도도해!")
  val catBlack = Cat("Black", "조금있어!")
  val catOdd = Cat("Odd", "깍어비리기!!", "나른해")

  println("${catBlue.눈동자}, ${catBlue.털}, ${catBlue.성격}")
  println("${catBlack.눈동자}, ${catBlack.털}, ${catBlack.성격}")
  println("${catOdd.눈동자}, ${catOdd.털}, ${catOdd.성격}")
}

class Cat( var 눈동자: String, 
           var 털: String, 
           val 성격: String = "커여워") 
{
      fun 밥과 관련된 행동(밥: Boolean){
           if(!밥){
              println("냥냥펀치!!")
           } else {
              println("와구와구")
           }
      }
}

결과
Blue, 너무많아!, "도도해!
Black, 조금있어! 커여워
Odd, 깍어비리기!!, 나른해

참고로 Class 를 직접 부르면 컴파일러는

클래스는 직접 호출하지 않고, 반드시 변수 등에 선언을 하고서 사용해야 한다. 클래스는 수치만 들어간 설계도이기에 설계도를 직접 호출하면 당연히 실제 사용자는 ? 를 띄울 뿐이다.

정리

객체 지향 프로그래밍은 하나의 객체를 관점으로 프로그래밍을 작성하는 것을 의미한다. 반복적인 작업을 피하고, 이해와 효율성을 높이기 위해 사용된다.

Class 는 하나의 객체를 담는 그릇이다. 실제 치수, 내용 등을 포함하고 있지만 기본적으로 설계도이기에 사용 시 다른 변수에 선언을 하고서 사용해야 한다.

모듈화를 통해 코드 전체의 이해와 재사용으로 효율성이 높아진다. 단, 모듈화로 인해 컴파일러는 더 많은 코스트를 요구하여 성능에는 더 안 좋다. 또한 설계 자체에 시간이 오래 걸릴 수 있다.

감사합니다 :)

참고 Udemy # Android Jetpack Compose: The Comprehensive Bootcamp [2022]

Blog # 객체 지향 프로그래밍이 뭔가요? (꼬리에 꼬리를 무는 질문 1순위, 그놈의 OOP)

작성자 : 뉴원 (Newon)

유클리드 호제법이란
두 정수 a, bﾠﾠ|ﾠﾠ a 와 b 의 최대공약수 𝒹 ﾠﾠ|ﾠﾠ a / b 했을 때 나오는 나머지 𝛾 ﾠﾠ|ﾠﾠ 이 있을 때

𝒹 = gcd(a, b) = gcd(b, 𝛾) 가 성립함을 의미한다. 이때 gcd(a, b) 는 a 와 b 사이의 최대공약수를 뜻한다.

이때 𝒹 = gcd(a, b) = gcd(b, 𝛾) 를 확장해서 𝛾´이 b를 𝛾로 나누었을때의 나머지라고 한다면 𝒹 = gcd(a, b) = gcd(b, 𝛾) = gcd(𝛾, 𝛾´) ... 이 성립하게 된다. 이 성질을 이용해서 알고리즘에서 최대공약수를 구할 때 gcd 를 구하는 함수를 만들고, 이를 for 문이나 재귀함수로 반복해서 푸는 방법이 성립하게 된다.

이를 간단하게 코드로 작성하면 다음과 같이 나타난다.

fun Gcd(a:Int, b:Int):Int {
    var r = a % b
    if (r == 0)
       return b
    else
       return Gcd(b, r)
}

fun main() {
    val br = System.`in`.bufferedReader()
    val (a,b) = br.readLine().split(' ').map {it.toInt()}

    var gcd = Gcd(a,b)
    println(gcd)                                               // a 와 b 의 최대공약수
    println(a*b/gcd)                                           // a 와 b 의 최소공배수

/* 
*    백준 2609, 최대공약수와 최소공배수 문제이다.
*    코틀린으로 작성되었다.
*/

이게 왜 됨?

글의 본문이다. 왜 될까?

a, b, 𝛾(= a와 b의 나머지) 에는 무슨 관계가 있길래 gcd(a,b) 와 gcd(b,𝛾) 과 같고, 𝛾가 𝛾의 나머지(𝛾´) 의 최대공약수, gcd(𝛾, 𝛾´)와 같고
이걸 { ... } 반복해도 성립하게 되는걸까?

이게 왜 되는지 이해해보는 것이 이 글의 목표이다.

두 정수 a, b가 있고 a > b 이면서, 𝒹(최대공약수) 를 지니고 있는 수를 통해 알아보자. ﾠﾠﾠﾠﾠ ﾠﾠﾠﾠﾠ ﾠﾠﾠﾠﾠﾠ대전제 = a 와 b 의 최대공약수 𝒹
우선 우리는 a 와 b 의 최대공약수 𝒹를 알고 있으니, a 와 b 를 다음과 같이 바꿔본다.

a = 𝒹 * ⍺
b = 𝒹 * β
⍺와 β는 𝒹를 곱했을 때 각각 a 와 b 가 나오는 정수

그럼 우린 다음과 같이 쓸 수 있다.

a = q * b + 𝛾ﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠ//ﾠﾠq 는 a / b 의 목,ﾠ 𝛾 은 나머지이다.
𝒹 * ⍺ = q * 𝒹 * β + 𝛾ﾠﾠﾠﾠﾠﾠﾠﾠﾠ//ﾠﾠa 를 𝒹 * ⍺로,ﾠ b 를 𝒹 * β 로 치환했다.ﾠﾠﾠﾠ ﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠ⍺와 β는 조건을 만족하는 임의의 수
𝛾 = 𝒹 (⍺ - q * β)ﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠ//ﾠﾠ위의 식을 𝛾 과 나머지로 정리하였다.
𝛾 = 𝒹 * (⍺ - q * β)ﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠ//ﾠﾠ?!ﾠﾠ 𝛾 ﾠ로 정리하였더니,ﾠ 𝒹 * (⍺ - q * β) 의 형태이므로,ﾠ 𝛾 의 약수에도 𝒹 가 들어감을 알 수 있다 !!
올, 위와 같이 정리하였더니 우리는 𝛾 의 약수에 a 와 b 의 최대공약수인 𝒹가 있음을 알 수 있었다!!

그렇다면, 𝒹는 b 와 𝛾 의 최대공약수이기도 할까?

그렇다, 이것이 이 글의 핵심 주제 ①이다. 𝒹는 a 와 b 와 𝛾의 최대공약수가 참인지 거짓인지 확인하는 것이 오늘 주제의 핵심 주제 중 하나이다.
미리 스포하자면 핵심 주제는 핵심 주제 ② (crazy_𝛾은 언젠가는 0이 될 수 밖에 없다) 까지 있다.

우리는 현재 a 와 b 의 최대공약수가 𝒹 라는 것을 알고 있으며 𝛾 에도 𝒹라는 공약수가 들어간다는 것을 안다.

이때 𝛾 에게 있어서도 𝒹가 최대공약수가 된다면 우리는 a 와 b 와 𝛾 의 최대공약수가 𝒹 로 같다는 것을 알 수 있게 된다 !!

𝛾 의 최대공약수가 a와 b의 최대공약수인 𝒹 와 같다는 동화 .. 가능 ?

인생은 호락호락하지 않다, 그리고 우리는 𝒹가 𝛾의 최대공약수라고 확신할 수 없다. 확신할 수 없으니 𝒹 가 𝛾의 최대공약수가 아님 이라고 가정해보자.ﾠ

대 가정 = 𝒹 가 𝛾의 최대공약수가 아님

𝛾의 최대공약수가 𝒹 가 아니라면, 𝛾 의 최대공약수는 그 어떤 임의의 수 𝒹´ 일 것이다. 잠시 정리해서

• 𝒹 = gcd(a,b) 이고 𝒹´ = gcd(b, 𝛾) 이라면
  
• 𝒹´ 는 언제나 𝒹 보다 작아야한다.

조건 ① = (𝒹 < 𝒹´)

• 왜? 대 가정에 의해서 𝒹 는 𝛾 의 최대공약수가 아니고, 𝒹´ 가 𝛾 의 최대공약수이어야 하기 때문이다.

현재 우리는 대 가정과 조건 ①를 갖고 있다.

그럼, 𝒹´의 관점에서 b 와 𝛾를 다시 써보자.

b = 𝒹´ * b´ﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠ//ﾠﾠb´은 b = 𝒹´ * b´ 를 만족하는 수
𝛾 = 𝒹´ * r´ﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠ//ﾠﾠr´은 𝛾 = 𝒹´ * r´를 만족하는 수

이걸 위에서 사용했던 a = q * b + 𝛾ﾠﾠﾠ에 대입해보자.

a = q * 𝒹´ * b´ﾠ+ 𝒹´ * r´ﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠ// b 와 r 에 𝒹´에서 본 b 와 r 를 넣었다.
a = 𝒹´ * (q * b´ + r´)ﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠﾠ// 넣어본 김에 깔끔하게 𝒹´로 정리해보았다.

어 ? a 의 공약수에도 𝒹´가 들어간다. 하지만 알다시피, 대전제로 우리는 a 와 b 의 최대공약수 𝒹 라고 하였으며,
또 따라서 𝒹´는 𝒹 보다 작을 수 밖에 없다 !! 조건 ② = (𝒹´ < 𝒹)

? 조건 ① = (𝒹 < 𝒹´) 과 조건 ② = (𝒹´ < 𝒹) 이 모순된다.

문과인 나도 안다. 어떠한 정수 𝒹가 𝒹´ 보다 작으면서 클 수는 없다

그렇다면 잘못된 건 대 가정 = 𝒹 가 𝛾의 최대공약수가 아님 !!
해당 가정의 결론이 거짓이니, 그 가정의 반대는 참 ! 즉 𝒹 는 𝛾의 최대공약수임

따라서 우리는 a 와 b 와 𝛾 의 최대공약수가 𝒹로 같다. 는 이야기가 동화인 줄 알았지만
사실 팩트기반 실제 사례 기반 수필로써 핵심주제 ① : a 와 b 와 𝛾 의 최대공약수가 𝒹로 같다. 가 True임을 알 수 있었다.

ㅇㅋ, 근데 왜 a 와 b 와 𝛾 의 최대공약수가 같다고 그걸 저렇게 반복해도 성립하는거임?

그렇다, 우리가 핵심 주제 ① : a 와 b 와 𝛾 의 최대공약수가 𝒹로 같다. 라는 팩트를 갖고 있어도 우리는 코틀린 예제로 쓰인 저 코드가 잘 작동하게 되는 이유를 아직 찾지 못했다.

코드를 다시 한번 살펴보자

fun Gcd(a:Int, b:Int):Int {
    var r = a % b
    if (r == 0)
       return b
    else
       return Gcd(b, r)
}
{ ... }

Gcd() 는 나머지 𝛾 이 0이 될 때 모든 연산을 끝내게 된다. 다시 말하면 𝛾 은 유한한 횟수 안에 언젠가 0 된다는 것이다. 언젠가는 나머지가 0이 된다라는걸 확신하는 듯한 저 표정이 거만하기 짝이 없다. 저게 블러핑인지 아닌지 한번 확인해보자.

a / b 의 나머지가 𝛾 이듯, b / 𝛾 의 나머지가 𝛾´ 라고 말해보자.

핵심 주제 ① = 𝒹 는 a와 b 와 𝛾의 최대공약수임 에 따라서 gcd(a, b) = gcd(b, 𝛾) 이듯 gcd(b, 𝛾) 은 gcd(𝛾, 𝛾´) 이다.

..어 왜?

두 정수 a 와 b 를 다시 한번 살펴보자. (a > b), a 와 b 의 최대공약수를 𝒹 라고 할 때

a = q * b + 𝛾 gcd(a, b) = gcd(b, 𝛾) a 와 b 의 최대공약수 == b 와 𝛾 의 최대공약수

마찬가지로 이번엔 위의 내용과 상관없이 순수하게 두 정수 b 와 r 을 살펴보자. (b > 𝛾)

b = q * 𝛾 + 𝛾´ gcd(b, 𝛾) = gcd (𝛾, 𝛾´) b 와 𝛾 의 최대공약수 == 𝛾 와 𝛾´의 최대공약수

핵심 주제 ① = a 와 b 와 𝛾 의 최대공약수가 𝒹로 같다.에 따라서

• gcd(a,b) == gcd(b,𝛾) 인데
• gcd(b,𝛾) == gcd(𝛾, 𝛾´) 이니
• gcd(a,b) == gcd(𝛾, 𝛾´) 이다.

오, 그렇다면 𝛾´ 과 𝛾´´ 사이에도 최대공약수는 𝒹 이고 𝛾´´ 과 𝛾´´´ 에도 최대공약수는 𝒹 이고 𝛾´´´ 과 𝛾´´´´ 에도 𝒹 이고 { ... } 에도 𝒹

무한한 나머지와 그 나머지의 최대공약수는 언제나 a 와 b 의 최대공약수와 같다는 건 알겠지만, 혹시 𝛾´´´´´´{...}가 0이 안되면 어떻게 될까??

𝛾´´´´´´{...} 를 이제부터 crazy_𝛾이라고 불러보자. 나머지를 계속하다보면 언젠가는 우린 crazy_𝛾를 만나게 될텐데, 그때의 식은 다음과 같을 것이다.

b > 𝛾 > 𝛾' > 𝛾'' > 𝛾''' ... crazy_r != 0

우리는 기억해내야 한다, b 와 𝛾 도, 그 어떠한 crazy_𝛾 들도 모두 정수 라는 것을. 즉, crazy_𝛾 이 정수고, 0이 아니라면 less_crazy_𝛾과 crazy_𝛾로 나눠서 more_crazy_𝛾´라는 정수를 만들 수 있으니

b > 𝛾 > 𝛾' > 𝛾'' > 𝛾''' ... > less_crazy_𝛾 > crazy_𝛾 > more_crazy_𝛾 > more_crazy_𝛾2 { ... }

가 성립함을 알 수 있고, 여기서 항상 crazy_𝛾은 crazy_𝛾 > more_crazy_𝛾를 성립하게 된다. 왜냐하면 more_crazy_𝛾는 crazy_𝛾의 나머지이니까.

정수가 언제나 앞의 숫자보다 작아진다면, 언젠가는 0에 도달하게 된다. 왜냐고? 그것이 정수이니까 (끄덕)

a > b 일 때, a 와 b 가 정수라면 a 와 b 차이의 최솟값은 1 a > b > b' 는 최소한 1씩 줄어드는 정수이며, 이게 계속해서 반복된다면 언젠가는 0에 도달하게 된다.

따라서 핵심주제 ② = crazy_𝛾은 언젠가는 0이 될 수 밖에 없다 !!

마지막으로 코드를 다시 한번 살펴보면

fun Gcd(a:Int, b:Int):Int {
    var r = a % b
    if (r == 0)
       return b
    else
       return Gcd(b, r)
}
{ ... }

var r 은 재귀함수로 돌아가며 계속해서 𝛾, 𝛾´, 𝛾´´, 𝛾´´´ {...} crazy_𝛾 이 된다 하더라도 핵심주제 ② = crazy_𝛾은 언젠가는 0이 될 수 밖에 없다에 의해서 언젠가는 0이 된다는 걸 할 수 있다. 그렇기 때문에, 위의 코드가 무한히 돌지 않고 유한한 횟수 내에서 나머지가 0인 순간을 찾을 수 있는 것이다.

결론

유클리드 호제법을 통해 우리는 다음과 같이

• 핵심주제 ① : a 와 b 와 𝛾 의 최대공약수가 𝒹로 같다.
• 핵심주제 ② : crazy_𝛾은 언젠가는 0이 될 수 밖에 없다

가 성립함을 알 수 있었고, 이에 따라 Gcd(최대공약수)를 구하는, 소위 나머지 알고리즘라는 것이 성립함을 알 수 있었다.

즉 정수 a, b, 𝛾 이 있을 때

fun Gcd(a:Int, b:Int):Int {
    var r = a % b
    if (r == 0)
       return b
    else
       return Gcd(b, r)
}

와 같이 a 와 b 를 나눈 나머지 𝛾가 0이 될 때 까지

• a = b
• b = r 을 반복하다보면 언젠가 최대공약수가 나온다는 것을 알게되었다.

Gcd 문제 푸는데 이걸 다 알아야 하냐고?

출처 brain from 감자 4호
알고리즘 공부하면서 알아본 내용입니다, 오류 • 오타 등 알려주시면 정말 감사하겠습니다 :)

들어가기에 앞서서, 해당 글은 기본적인 문법 (for, while, print, 입력받기, 배열)에 대해서 알고 있음을 전제로 합니다.
만약 기본적인 문법을 모르는 상태라면 반복문과 출력, 배열, 입력받기에 대해서 먼저 이해한 후 다시 찾아와주세요. :)

이 글은 백트래킹만 언급하는 것이 아니라 재귀함수부터 백트래킹까지 모든 내용을 차례대로 다룹니다.
그 과정에서 약간의 자료구조(Stack), 명령형 프로그래밍과 선언형 프로그래밍의 차이, DFS 를 재귀로 구현하는 이유 등에 대해서 언급합니다.
예제에서 C언어와 Kotlin 을 섞어서 사용하고 있지만, 최대한 언어적 특징없이 기본적인 문법만 사용합니다.

글은 작성자가 이해한 흐름에 따라 작성되었으며, 의식의 흐름에 따라 작성되어 존대없이 편한 말로 작성되었습니다.
오류 및 오타 지적 감사합니다. :)
작성자 : 뉴원(Newon)

백트래킹, DFS 탐색 중 가지치기 하는 것.

백트래킹은 완전 탐색 방법 중 하나인 깊이 우선 탐색(DFS)을 진행하면서 조건을 확인,
해당 노드가 유망하지 않으면 더 이상 탐색하지 않는 것을 의마한다.

백트래킹은 일반적으로 재귀의 형태로 작성되며, 크게 다음의 3개 내용을 작성해야한다.

• 재귀를 진행하는 동안 사용될 깊이(depth)를 매개변수로 넣기
• 재귀가 종료되는 시점에서 수행해야할 내용
• 재귀가 진행중이면 가지치기(백트래킹)할 내용

여기에 재귀함수를 편하게 돌리고 싶다면 재귀에 필요하지만 변하지 않는 변수들과 재귀에서 사용하는 배열들을 전역변수로 선언하면
재귀함수의 매개변수가 깔끔해져서 편하다.

코드로 확인해보자. 백준 N과 M(1) 문제 를 확인하면
1 ~ N 까지의 숫자 중에서 M개를 중복없이 오름차순으로 출력하는 것이 문제이다.

코드는 C언어로 쓰였지만, 코드만의 특징없이 작성되었다.

// 목표 : 1 ~ N 까지의 숫자에서 M개르 선택하고 중복없이 오름차순으로 출력하기

#include <stdio.h>
#include <stdbool.h>

int arr[10] = {0, };                              // 1부터 N까지이니, 마음편하게 10개의 배열을 선언하였다.
bool isusedArr[10] = {false,};                    // 해당 숫자의 중복 여부를 위해 사용했는지 안했는지를 파악할 같은 크기의 배열을 하나 더 선언했다.
int N;                                            // 재귀에서 사용하지만 그 숫자가 변하지는 않는 변수를 전역변수로 선언하였다.
int M;                                            // 재귀에서 사용하지만 그 숫자가 변하지는 않는 변수를 전역변수로 선언하였다.

void Solve(int k){                                // 재귀함수가 사용되는 동안 사용될 depth 를 여기선 k로 표현하고 있다. 
    if(k == M){                                   // 해당 재귀함수는 k가 계속 증가하며, k == M 일때 멈추는 구조를 가지고 있다.
        for (int i = 0; i < M; i++){              // 종료될 때, 수행해야할 내용은 "출력"이므로, 출력을 하고 있다.
            printf("%d ", arr[i]);
        }
        printf("\n");                             // 엔터를 출력하고 있다.
    return;                                   // 마지막에 수행해야할 내용들을 다 수행했으면 return 으로 함수를 종료한다.
    }

    for (int i = 1; i <= N; i++){                 // 재귀함수가 종료시점이 아니라면 for 문을 통해 재귀를 진행한다.
        if(!isusedArr[i]){                        // 가지치기할 내용을 찾고있다. 이번 같은 경우는 중복을 없애기 위해 다음과 같이 적용하고 있다.
            arr[k] = i;                           // arr[k] 에 i를 사용하고 있다.
            isusedArr[i] = true;                  // 사용하니까, 사용했음을 표시하고 있다.
            Solve(k+1);                           // 여기에서 재귀가 계속 반복되고 있다. k는 자릿수로 계속 증가하다가, k == M일 때 종료돨 것이다.
            isusedArr[i] = false;                 // 다음 DFS 를 위해 다시 사용하지 않았으로 바꿔주고 있다.
        }
    }
}

int main(){
    scanf("%d %d", &N, &M);                       // 함수의 시작이다. N과 M을 입력받고 있다.
    Solve(0);                                     // 재귀함수의 시작이다. 0부터 시작하고 있다.
}

코드를 크게크게 확인해보자

• Solve 함수는 DFS 함수로 k를 기준으로 진행되고 있다.
• Solve 의 맨 위에선 재귀가 종료될 시점에 출력을 하고 변경없이 return 으로 함수를 종료하고 있다.
• Solve 의 밑 에서는 for 문을 통해 가지치기할 내용을 확인하고 있다.
  if(!isusedArr[i]) 를 통해 isusedArr이 0, 즉 사용하지 않은 숫자라면 재귀를 진행하고 있다.
  세부적으론, arr[k] 에 i를 넣고있고, 해당 i를 사용처리 한 후 다음 재귀로 넘어가고 난 후 비사용으로 바꿔주고 있다.

백트래킹은 위의 구조를 기본 골조로 하며, 조건의 추가 & 삭제, 혹은 해당 depth 의 사용, 미사용 등의 조합으로 사용된다.

아 그래서 그게 뭔데 ㄹㅇㅋㅋ

만약 당신이 위의 글만 보고서 아 ! 백트래킹이란 저런거구나 ㅎㅎ 이해했어 라면 이제 뒤로가기를 눌러도 좋다.
이제부터 이 글은 철저하게 아무것도 모르는 문과생의, 문과생에 의한, 문과생을 위한 언어로 설명된다.

우선 우리는 ① 재귀함수가 무엇인지 정확하게 알 필요가 있다.
그 다음으로 ② DFS 함수에 대해서 알아야 하며,
최종적으로 DFS 를 진행할 때 ③ 가지치기(백트래킹)을 어떻게 하는 지 알아볼 것이다.

① 재귀함수가 뭔데

가. 재귀함수란?

재귀함수란 코드 내에서 자기 자신을 호출하는 함수를 의미한다.
내가 나를 부르고, 다시 내가 나를 부르고, 틱X 이나 유튜브숏X에서 자주 보던 그것들이 맞다.

프로그래밍으로 재귀함수는 다음처럼 쓰인다.

fun DFS(N: Int){
    print("$N ")
    return DFS(N + 1);
}

fun main(){
    DFS(0)
}

위의 코틀린 함수를 확인해보자.

main 함수에서 DFS라는 함수를, 0을 넣어서 호출하고 있다. 함수 이름에는 우선 신경쓰지 말자
DFS 라는 함수가 뭐하는 녀석인지 확인해보면, 우선 이녀석은 N을 매개변수로 받고 있다.
이후 print("$N ") 을 통해서 N과 스페이스바를 출력하고, 종료할 때 자기 자신에 (N+1)을 넣은 것, DFS(N + 1) 을 호출하고 있다.

그렇다면 이 재귀함수는 어떻게 작동할까?

• DFS(0) 호출 - DFS(0)의 내용 수행 - DFS(0 + 1) 호출
• DFS(1) 호출 - DFS(1)의 내용 수행 - DFS(1 + 1) 호출
• DFS(2) 호출 - DFS(2)의 내용 수행 - DFS(2 + 1) 호출
• 무한반복 ...

와 같이 반복하게 된다.
언제 끝날까? 영원히 끝나지 않는다. 왜냐하면 위의 함수는 자기자신을 호출하곤 있지만, 종료 조건이 없기 때문이다.
따라서 위의 컴퓨터의 메모리가 허락할 때 까지 0 1 2 3 4 5 ... 백만스물하나 ... 백만스물둘...
을 출력하고 있을 것이다.

이 터미널 창을 DFS 함수라고 비유한다면, 다음과 같이 1을 받고 1 출력 종료 -> 2를 받고 2 출력 종료 ... 를 무한반복 중인 것이다.

위의 재귀함수를 다음과 같이 바꿔보자.

fun DFS(N: Int){
    if(N == 11)
      return;

    printf("$N ")
    return DFS(N + 1)
}

fun main(){
    DFS(0)
}

위의 코드와 차이점은 N이 11일 때, 아무것도 하지 않고 그냥 종료가 된다는 것이다.
그럼 이 함수는 다음과 같이 작동한다.

• DFS(0) 호출 - N이 11인지 확인 - 11이 아님 - DFS(0)의 내용 수행 - DFS(0 + 1) 호출
• DFS(1) 호출 - N이 11인지 확인 - 11이 아님 - DFS(1)의 내용 수행 - DFS(1 + 1) 호출
• DFS(2) 호출 - N이 11인지 확인 - 11이 아님 - DFS(2)의 내용 수행 - DFS(2 + 1) 호출 ...
• DFS(11) 호출 - N이 11인지 확인 - N이 11임 - 그냥 종료

if 문에서 N이 11일 때 종료하라는 내용을 통해서, 해당 재귀함수는 무한반복하지 않고 N이 11일 때 바로 종료하게 된다.
따라서 위의 코드는 다음과 같이 출력하고 0 1 2 3 4 5 6 7 8 9 10
이후 함수가 종료된다.

if 문을 통해서 재귀함수가 종료될 조건을 단 것, 이것을 Base Condition 이라고 부른다.

재귀함수는 매개변수를 통해서 Base Condition 에 점차 다가가도록 설계하는 것이 원칙이다.
그래야 재귀함수를 안전하게 종료시킬 수 있기 때문이다.

매개변수는 Base Condition 에 다가갈수만 있다면 증가해도, 감소해도 상관없지만 일반적으로 감소하도록 설계한다.

이 짤방을 다시 한번 살펴보자, 모든 함수는 return을 기준으로 종료하게 되어있다. 그렇다면 기존에 불려진 함수들은 언제 종료가 될까?

정답은 호출된 순서의 역순으로 닫힌다 이다. 짤방으로 표현하자면 이렇게 된다.

그래서 코드를 이렇게 짜면, 역순으로 정렬할 수도 있다.

fun DFS(N: Int){
    if(N == 11){
      return;
    }

    DFS(N + 1)
    print("$N ")
    return;
}

fun main(){
   DFS(0)
}

위의 코드는 DFS 를 호출한 다음에 N을 print 하고 있다.
따라서 N 이 11까지 이른 다음에야 순차대로 종료되며 N이 10일 때, N이 9일 때, 8..7..
순서대로 출력되고 가장 마지막 == 가장 처음에 호출한 함수가 종료된다.
출력은 요렇게 나온다. -> 10 9 8 7 6 5 4 3 2 1 0

이 의미가 이해되었다면 재귀함수란? 에 가장 먼저 나왔던 2개의 짤 중 밑의 짤방이 전부 이해될 것이다.

이러한 방식을 자료구조 중 Stack 이 적용된 것 이라고 한다. `

설명에서 push 는 자료 삽입을, pop은 자료를 빼는 것을 의미하며
스택 구조가 적용되면 데이터는 언제나 마지막에 넣은 것부터 빼내게 되고, 처음에 넣은 것 이 가장 마지막에 나오게 된다.

재귀, DFS, 백트래킹이 전부 Stack 이 적용되지만 본 글에서는 이 이상의 Stack 개념은 사용하지 않는다.
궁금하거나 필요하다면 Stack 을 찾아보는 것을 추천한다.

어 음 그런데 말이죠 ..?

사실 위의 출력문들은 굳이 재귀로 하지 않고, for 문으로도 쉽게 만들 수 있다.

for(i in 0..10){
   print("$i ")
}

// 역순이면 이렇게

for(i in 10 downTo 0){
   print("$i ")
}

게다가 하나의 함수를 호출하는 것은 단순한 중복문보다 많은 메모리를 요구하며 속도 역시 압도적인 힘ㅇ.. 느리다.
이러한 이유에도 불구하고 재귀함수를 쓰는 이유를 알아보자.

나. 메모리도 많이 잡아먹고 헷갈리는 재귀함수 왜 씀? (Feat. 선언형 프로그래밍)

코드란 컴퓨팅 효율적으로만 설계하는 것이 아니라
이후 타인에 의한 유지 보수를 고려하여 적어야 한다.

즉 누가 보더라도 코드는 쉽게 읽히며, 코드가 수행하는 내용이 직관적이여서 개발자의 작업시간을 줄이는 것
또한 좋은 코드의 조건 중 하나이다.

이러한 관점에서 재귀함수는 for 문으로 작성했을 때 보다 월등히 가독성이 높아서, 개발자의 시간을 줄여줄 수 있을 때 사용한다.

#

재귀함수가 직관적이라니, 이게 무슨소리일까?

피보나치의 수열을 예시로 들어보자.
수학에서, 피보나치 수(영어: Fibonacci numbers)는 첫째 및 둘째 항이 1이며 그 뒤의 모든 항은 바로 앞 두 항의 합인 수열이다.
1 1 2 3 5 8 13 21 34 55 ...

이걸 For 문과 재귀함수로 구현하면 다음과 같다.

// for 문으로 작성한 피보나치
fun Fibonacci(N: Int): Int{
   var one = 1
   var two = 1
   var result = 0

   if(N <= 2){
      print("$one ")
      return;
   }

   for (i in 3..N){
      result = one + two
      one = two
      two = result
   }
   return result
}

// 재귀로 작성한 피보나치
fun Fibonacci(N: Int): Int{
    if(N == 0)
       return 0
    if(N == 1)
       return 1

    return Fibonacci(N - 1) + Fibonacci(N - 2)
}

fun main(){
    print(Fibonacci(10))
}
// 출력은 같은 10이다.

잠시 저 두 함수가 피보나치를 출력한다는 것을 모른채로 비교해보자.

For 문으로 적힌 함수를 이해하려면 one 이 어떤 변수인지, two 가 어떤 변수인지, result 는 어떤 변수인지
N 이 왜 2일땐 one만 출력하고 리턴하는지, for문은 왜 3부터 시작하고 그때마다 result 는 one + two 를 받는지 이해하고나야 비로서
이 함수가 피보나치 함수임을 이해할 수 있다.

그에 반면 재귀로 작성된 함수는 간단하다.
계산이 어떻게 되는진 모르겠지만 함수(N) 은 함수(N-1) + 함수(N-2) 이고,
이걸 계속해서 반복하다보면 N 이 0일 땐 0을, N이 1일 땐 1을 리턴하여서 이를 반복한다고 적혀있다.

더 간단하게는, 내부가 어떻게 돌아가는진 모르겠지만 우린 함수(N) = 함수(N-1) + 함수(N-2) 임을 알 수 있다.

이것이 재귀함수를 사용했을 때 가독성이 늘어나는 대표적인 사례이다.
피보나치 수열은 그나마 2개의 항이 만드는 상황만 이해하면 되었지만, 이보다 더 복잡한 사례가 나온다면 For 문으로 작성된 함수는 더더욱 힘들 것이다.

바로 그런 사례가 있다.
재귀함수를 구글링했다면 바로 접해봤을 문제, 하노이의 탑 문제이다.

하노이의 탑 문제는 다음과 같다. 게임

간략히 요약하면, 3개의 대가 있고 크기가 오름차순인 원반들이 있고, 이걸 한번에 하나씩 옮겨서 다른 대로 옮기되,
큰 원반은 작은 원반 위에 갈 수 없다 는 조건 속에서 수행하라는 것이다.
알고리즘 문제로 치환하자면 원반이 움직일 때 마다 어디서 어디로 옮겼는지 출력하고, 최종적으로 몇번 움직였는지 출력하라 정도로 바꿀 수 있겠다.

For 문으로 도전.. . 도전은 언제나 아름답지만, 이번엔 추천하진 않는다.
For 문으로 만들고 싶다면 우선 원반의 갯수만큼 For 문을 만들어야할 것이며, 한번 옮겨질 때 마다 이전의 For 문들은 어떻게 해야하는지,
횟수는 어디에서 세야할 지도 막막한데, 원반의 갯수가 N으로 입력받아야 한다면 ..

여기서 우리는 재귀함수의 진정한 사용이유를 알 수 있다.
재귀함수의 가장 큰 장점은 For 문과 같은 명령형 프로그래밍이 아니라, 선언형 프로그래밍이라는 점에 있다.

무슨 의미일까?
잠시 하노이의 문제는 접어두고, N 팩토리얼을 한번 출력해보자.
알다시피, 방법은 For 문과 재귀함수 2개가 있다.

팩토리얼이란 N을 기준으로 n부터 1까지의 모든 수를 곱한 값이다. (표기는 n!)
이때 명령형 프로그래밍의 관점에서 10!을 구하려면 다음과 같이 바라보게 된다.

var value = 1
for (i in 1..10){
    value *= i
}

----------------
value = 1 * 2
value = (1 * 2) * 3
value = (1 * 2 * 3) * 4
...
value = (1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9) * 10

• value 에 대하여 사용자는 모든 i 항들에 대하여 절차적으로 구하고 나서야 팩토리얼 n을 알게되는 것으로 인식한다.

이를 다시 선언형 프로그래밍 관점에서 바라본다면 다음과 같아진다.

fun Factorial(N: Int): Int{    
    if(N == 1) return 1
    return Factorial(N - 1) * N  
}

----------------
N == 10  Factorial(9) * 10
N == 9   Factorial(8) * 9
N == 8   Factorial(7) * 8
...
N == 2   Factorial(1) * 2
N == 1   1

• 재귀함수 Factorial 은 return 값이 재귀함수와 어떤 관계가 있는지 선언만 하였다.
• 그 이후 절차에 관련한 것은 return 을 수행하는 컴퓨터에게 맡겨버리고 사용자는 선언에 해당하는 결과값을 갖는 것으로 인식한다.

같은 결과값이지만 명령형 프로그래밍의 관점은 사용자가 모든 절차를 인지하고 있음을 전제하는 반면
선언형 프로그래밍의 관점은 사용자가 결과와 그 나머지의 관계를 선언만 한다는 점에서 차이가 나타난다.

즉, 재귀함수의 장점 중 하나는 계산에 대한 내용을 컴퓨터에게 맡겨버린다에 있다.
이를 하노이에 적용시켜보자.
문제를 한정시켜서, N개의 원판과 대 A, B, C 가 있을 때 원판들은 최초에 A에 있고, N개의 원판을 C로 옮기는 것을 목표로 한다.

하노이의 탑 문제의 답을 거꾸로 추적해보면 다음과 같은 특성을 지닌다.

• 가장 마지막의 원판을 제외하고, N - 1 개의 원판들을 B에 옮겨놓는다.
• 마지막 원판을 C에 갔다 놓는다.
• B에 옮겨놨던 원판들을 C에 통째로 옮긴다.

이걸 역순으로 반복하면 우리가 게임 에서 진행했던 순서가 된다.

// C로 작성되었다.
// 대의 이름은 각각 A, B, C 이며 N개의 원판이 있는 상황이다. 

#include <stdio.h>

int N;
int count;

void Hanoi(int N, int A, int B, int C){
                                                                     // N 이 0 일때가 Base condition 이지만 이번 경우엔 수행해야할 내용이 없으므로, 적지 않았다.
    if(N > 0){                                                   // N 이 0이 아닌동안, 즉 Base Condition 에 도달하지 않는 동안 수행할 내용이다.
        Hanoi(N-1,A,C,B);                                    // A에 있는 N - 1개 원판들을 C를 이용해서 B로 옮긴다.
        printf("%d 에서 %d 로 가장 맨 위의 원판 이동\n", A,C);      // A에 있는 남아있는 원판, 가장 큰 원판을 C로 옮긴다.
        Hanoi(N-1,B,A,C);                                    // B에 있는 N - 1개 원판들을 A를 이용해서 C로 옮긴다.
    }
}

int main(){
    scanf("%d", &N);
    Hanoi(N,1,2,3);
}

이 함수에서 개발자는 절차마다 그 값이 무엇인지에 대해서 작성한 코드는 단 1개도 없다.

개발자는 그저 N - 1 일 때 어떻게 해야하는지 논리적으로 선언만 하였고, 컴퓨터가 대신 계산한 것이다.
이것이 재귀함수를 이용하는 이유이다.

위의 내용이 이해가 안간다면 다음의 영상을 참고하면 좋을 것 같다.Tower of Hanoi Problem - Made Easy

위의 하노이와 관련된 내용은 참고에 연결된 유튜브 영상의 내용을 요약하여 옮긴 것이다.
컴퓨터에 맡겨버린다 라는 의미가 궁금하다면 다음 블로그를 참고해보자. 반복과 재귀 : DFS 문제를 재귀로 구현하면 편리한 이유

재귀함수편 요약

1. 재귀함수란 자기 자신을 호출하는 함수이다.
2. 재귀함수는 매개변수를 통해 Base Condition 에 도달하도록 설계한다.
3. 모든 재귀함수는 이론적으로 For문이나 While 문으로 구현이 가능하나, 사용자의 편의(가독성)를 위해서 사용된다.

재귀함수는 다이나믹 프로그래밍에서 다시 한번 쓰이게 된다.

② DFS 함수

이제 본론이다. 백트래킹은 뭐길래 DFS와 함께 쓰이는 걸까?
한줄 요약하자면 DFS 를 하는 와중에 더 이상 탐색할 필요가 없는걸 쳐내는 행위를 백트래킹이라고 한다.

DFS(Depth - First - Search) 는 깊이 우선 탐색을 의미한다.
어떠한 내용을 완전 탐색(브루트 포스)해야 할 때, 깊이 먼저 탐색하는 것을 의미한다.
그리고 우린 이 DFS 를 여태 실컷 살펴보았던 재귀를 통해 구현할 것이다.

DFS는 그래프나 트리와 연계되어 사용되지만, 본 글에서는 그래프나 트리의 내용 없이 DFS 그 자체에 대해서만 알아본다.
완전 탐색(브루트 포스)라는 개념이 생소하다면 본 글에서는 모든 걸 다 탐색한다 정도로 인지하면 된다.

DFS는 완전탐색 중 하나이니, 모든걸 탐색해야하는 상황을 가정해보자.

1부터 6까지의 숫자 중에서 3개를 뽑는 모든 경우의 수를 출력해보고자 한다.
여러가지 방법이 있겠지만 우린 다음과 같은 방법을 써보고자 한다.

목표 출력 예제는 다음과 같다.

  1 1 1                            |    수행 로직
  1 1 2                            |    ① 3개의 빈칸을 만든다.
  1 1 3                            |    ② 첫번째 자리에 1을 넣어본다.
  1 1 4                            |    ③ 두번째 자리에 1를 넣어본다.
  1 1 5                            |    ④ 세번째 자리에 1을 넣어본다
  1 1 6                            |    ⑤ 세번째 자리에 1을 빼고, 2를 넣어본다.
  1 2 1                            |    ⑥ 6까지 반복하고 나면, 두번째 자리를 2으로 바꾼다.
  1 2 2                            |    ⑦ 세번째 자리를 1부터 채워넣는다.
  ...                              |    ⑧ 6 6 6 가 될때까지 반복한다.  
  6 6 4                            |
  6 6 5                            |
  6 6 6                            |

재귀함수로 구성할 것이며, 미리 코드를 보기 전에 고민해보는 것도 좋다.
코드는 다음과 같다.

#include <stdio.h>

int arr[3];                                    // 빈칸을 전역변수로 선언하여 함수가 호출할 때 마다 넣어주는 번거로움을 줄였다.
int N, M;                                      // 문제에선 6개 중 3개이지만, 언제든 입력값에 따라 바꿀 수 있게 N과 M으로 설정했다.
                                               // 여기서는 각각 6과 3으로 직접 하드코딩하지만 밑의 예제는 N과 M으로 넣는다.

void DFS(int depth){                           // 이 재귀함수는 depth 를 기준으로 움직인다. 따라서 Base Condition 도 depth 를 기준으로 작성된다.
     if(depth == 3){                           // depth == 3일 때가 Base Condition 이다.
        for(int i = 0; i < 3; i++){            // 배열에 쌓인 내용을 출력하고 있다.
        printf("%d ", arr[i]);
    }
    printf("\n");
    return;
     }

     for(int i = 1; i <= 6; i++){              // Base Condition 이 아닐때 for문을 돌며 후보군(1 ~ 6)을 찾고 있다.
        arr[depth] = i;                    // 후보군을 찾으면 배열의 빈 칸에 넣고 있다.
        DFS(depth + 1);                    // 다음 깊이로 넘어가고 있다.
     }
}

int main(){
    scanf("%d %d", &N, &M);                    // N과 M을 받고 있다.
    DFS(0);                                    // DFS를 0의 깊이부터 선언하고 있다.
}

DFS 재귀함수는 0부터 시작하고 있으며,
배열의 인덱스 0 1 2 를 하나의 깊이로 인지하고, 0 -> 1 -> 2의 형태를 취하고 있다.

따라서 DFS 가 전달받는 depth 는 배열의 왼쪽부터 순서대로 탐색하게 된다.
그렇게 DFS 는 1부터 6까지 3개의 숫자를 넣는 방법을 중복을 포함해서 전부 넣고있다.

이것이 DFS 다.
깊이를 설정하고, 해당 깊이에 A가 있음을 상정하고, 다음 깊이로 가서 해당 깊이에 있을 수 있는 것을 다시 넣고 !!

하지만 출력문을 보니 좀 불편하다.
모든걸 깊이대로 탐색하는건 좋은데 중복도 없애고 싶고, 오름차순으로 정렬하고 싶은 마음이 들 수도 있다.
그걸 수행하는 것이 바로 백트래킹이다.

③ 백트래킹

위의 문제를 다시 한번 바꿔보자.
이번에는 1부터 6까지의 숫자 중에서 3개를 뽑되,
중복은 허용하지 않으며 오름차순으로 정렬할 것이다.
그림으로 표현하자면 다음과 같아진다.

목표 출력 예제는 다음과 같다.

  1 2 3          |      수행로직
  1 2 4          |      3개의 빈칸을 만든다.
  1 2 5          |      첫번째 자리에 1을 넣어본다.
  1 2 6          |      두번째 자리에 2를 넣어본다.
  1 3 4          |      세번째 자리에 3을 넣어본다.
  1 3 5          |      세번째 자리에 3을 빼고, 4를 넣어본다.
  ...            |      6까지 반복하고 나면, 두번째 자리를 3으로 바꾼다.
  3 4 6          |      세번째 자리를 3을 제외한 2~6까지 넣어본다.
  3 5 6          |      4 5 6 가 될때까지 반복한다. 
  4 5 6          |      

재귀파트에서 살펴보았던 것과 마찬가지로, 이걸 반복문을 통해서 만들수도 있겠지만 제법 많은 고생을 해야한다.
우리는 계산에 관한건 컴퓨터에 맡기고 선언으로 구현하고자 한다.
또한 조건에 부합하지 않는 것을 이제부터 유망하지 않다라고 표현한다.

#include <stdio.h>

int arr[M];                                    // 빈칸을 전역변수로 선언하여 함수가 호출할 때 마다 넣어주는 번거로움을 줄였다.
int visit[7] = {0, };                          // 마찬가지 이유이다. visit 배열의 용도는 사용한 숫자인지 아닌지를 체크한다. 0 = 미방문, 1 = 방문
int N, M;                                      // 문제에선 6개 중 3개이지만, 언제든 입력값에 따라 바꿀 수 있게 N과 M으로 설정했다.

void DFS(int depth){                           // 이 재귀함수는 depth 를 기준으로 움직인다. 따라서 Base Condition 도 depth 를 기준으로 작성된다.
     if(depth == M){                           // depth == 3일 때가 Base Condition 이다.
        for(int i = 0; i < 3; i++){            // 배열에 쌓인 내용을 출력하고 있다.
        printf("%d ", arr[i]);
    }
    printf("\n");
    return;
     }

     for(int i = 1; i <= N; i++){              // Base Condition 이 아닐때 for문을 돌며 후보군을 찾고 있다.
         if(!visit[i]){                        // 가지치기를 하고 있다, 방문한 곳은 가지 않고 있다.
        arr[depth] = i;                    // 조건에 부합하면 빈 칸에 넣고 있다.
        visit[i] = 1;                      // 가지치기를 위해 조건을 설정하고 있다, 방문한 곳을 방문했다라고 표현하고 있다.
        DFS(depth + 1);                    // 다음 깊이로 넘어가고 있다.
        visit[i] = 0;                      // 다음 단계를 위해 초기화해주고 있다.
     }
     }
}

int main(){
    scanf("%d %d", &N, &M);
    DFS(0);
}

//P.s. C언어에서 배열은 변수를 넣어 선언할 수 없어서, stdlib.h 의 동적할당 int* arr = (int*)malloc(sizeof(int) * M)) 을 사용해야하나
//       이해의 편의를 위해서 arr[M]을 넣었다.

가장 상단에서 재귀함수에 필요하되, depth 가 아닌 것들을 전부 전역변수로 선언하였다.

DFS 재귀함수는 depth 라는 매개변수를 가지고서, Base Condition 에 도달하도록 조정되고 있다.
여기서는 depth 가 0부터 1씩 증가하며, Base Condition 이 3일 때 배열에 담긴 내용을 출력하고 종료되도록 설계되었다.

DFS 재귀함수에서 for문은 Baes Condition 에 도달하지 못했을 때 for 문에 들어가게 된다.
for 문에서는 후보군을 찾는 것과 동시에, 후보군을 찾더라도 방문하지 않은 곳 이라는 조건에 부합하지 않으면 유망하지 않으니 가지치기하고 있다.
유망하면 배열에 넣고, 방문처리를 한 후에, 다음 depth + 1 을 한 DFS를 호출함으로써 다음 깊이로 넘어가고 있다.

하나의 재귀함수가 Base Condition (depth == 3)에 도달하더라도
for 문에서 불려졌던 재귀함수들은 아직 종료되지 않았다.
DFS를 호출한 그곳으로 다시 돌아가서 방문처리 한 내용을 다시 미방문처리하고 (== 해당 깊이의 끝을 보아서 거슬러 올라가기), for 문에서 다음 후보군을 찾고 다시 가지치기를 진행하고, 배열에 넣고, 유망한지 확인하고, 다음 깊이로 넘어가는 작업을 반복하고 있다.
또한 for 문은 계속해서 증가하게 되므로, 오름차순으로 자연스럽게 정렬이 된다.

이것이 깊이 우선 탐색에서 사용되는 백트래킹이다.
그래프와 트리의 개념없이 설명되었지만 사실 다음 깊이로 상정한 배열 을, 다음 노드로 바꾼다면 같은 맥락이 된다.

결론

여기까지 따라와주셔서 감사합니다 :)

이제 다시 한번 맨 위의 글을 보면 무슨 내용을 말했는지 완벽하게 이해가 갈 것이다.
여기까지 읽었다면 백트래킹을 좀 더 체화하기 위해서 백준의 N과 M 시리즈를 전부 풀어보는 것을 추천한다.
설령 내용이 완벽하게 이해가 안 가더라도, 문제를 풀면서 자연스럽게 체화될 것이다.

그리고 N과 M을 전부 풀었다면, 당신은 그 악명높은 N-Queen 문제도 풀 수 있는 실력이 된 것이다.
화이팅 !

안뇽 ~ :)

참고

[자료구조] 스택(Stack)이란?
피보나치 수열
6. Recursion and Dictionaries
Tower of Hanoi Problem - Made Easy
반복과 재귀 : DFS 문제를 재귀로 구현하면 편리한 이유

1. 안드로이드 스튜디오 좌측 App 에 오른쪽 버튼 New -> Module 을 클릭한다.

2. Application / Library name 에 Kotlin Module 이름 생성

   Module name 에는 문법을 위한 이름이 설정된다.

3. [설정한 이름]의 새로운 모듈 내부에, java 파일 내부에서 원하는 코틀린을 실행한다.

• fun main(){} 은 Kotlin 의 시작이다. 없으면 실행이 안된다.

• 해당 코틀린 파일 (혹은 class) 을 오른쪽 클릭, 실행을 누르면 실행할 수 있다.

• App 과 별개로 코틀린이 작동되며, 밑에 터미널처럼 결과가 나온다. (인텔리제이처럼 나온다.)

• Kotlin Playground 에서도 가능하긴 하지만, 입력을 자유자재로 할 수 있는 이 방법이 더 편한 듯 하다.

  ---

Jetpack Compose 함수를 쉽게 Composable 로 분할해보자.

상황

Column 안에 이러한 코드가 있는 상황에서, Surface 함수 전체를 Composable 함수로 분할하고 싶은 상황이다.

1. 분할하고자 하는 코드를 전부 드래그해서 블록을 씌운 후, 오른쪽 클릭 -> Refactor -> Function

2. 함수의 이름을 설정하면 ..?

3. 무쳤다 ..

4. modifier 로 파라미터를 넘겨주고 싶다면 modifier: Modifier = Modifier 를 넣자.

• 이때, 함수 내부의 모든 Modifier 는 매개변수의 modifier 로 교체해주어야 한다.
• 새로운 modifier 가 들어오면 새로운 값은 override, 기존 값은 그대로 있는다.

5. 매개변수를 미리 넣고 싶다면 ..

   ... 안되는 듯..? var image:String = "abcde"형태로 미리 선언한 값을 넣은 후, Composable 분할 후 다시 복사해서 매개변수 값에 넣고 var 나 val 만 지우는 방법을 쓰면 그나마 편하긴 하지만, Refactor 단위에서 하는 방법은 없는 것 같다.