Hyun's_Devlog

operator

Observable이 수행하는 메소드. Observable에서 파생되는 스트림을 구성하는 rxSwift의 핵심요소라고 할 수 있다. 

Observable에는 수행가능한 여러가지 operator가 있는데, 그중 대표적인것들에 대해서 적어보려고 한다. 

just()

static func just(_ element: [String]) -> Observable<[String]>
//returns an Observable sequence that contains a single element
Observable.just(_ element: )

입력 요소에 대해 그대로 반환되는 연산자이다. 예시를 통해 보자. 

@IBAction func exJust1() {
    Observable.just("Hello World")
        .subscribe(onNext: { str in
            print(str)
        })
        .disposed(by: disposeBag)
}
//Hello World!    출력

@IBAction func exJust2() {
    Observable.just(["Hello", "World"])
        .subscribe(onNext: { arr in
            print(arr)
        })
        .disposed(by: disposeBag)
}
//["Hello","World"]    출력

배열을 넣어도 배열이 통째로 출력되는 모습을 볼 수 있다.

from()

public static func from(_ array: [Element]) -> Observable<Element>
//Converts an array to an observable sequence.
Observable.from(_ array: [_])

배열의 원소들을 Observable의 형태로 리턴해준다.

@IBAction func exFrom1() {
    Observable
        .from(["RxSwift", "In", "4", "Hours"])
        .subscribe(onNext: { str in
            print(str)
        })
        .disposed(by: disposeBag)
}
//RxSwift
//In
//4
//Hours 출력

from을 통해 나오는 Observable<String>형태의 원소들이 subscribe(OnNext: )부분에서 출력이 된다.

map()

func map<Result>(_ transform: @escaping (String) throws -> Result) -> Observable<Result>
//Projects each element of an observable sequence into a new form.

swift에서의 map()과 같은 동작을 하는 operator이다. Observable에서 생성되어 내려오는 데이터들에 closure에 적힌 동작에 따라 가공하여 리턴해준다. 

@IBAction func exMap1() {
    Observable.just("Hello")
        .map { str in "\(str) RxSwift" }
        .subscribe(onNext: { str in
            print(str)
        })
        .disposed(by: disposeBag)
}
//Hello RxSwift 출력

@IBAction func exMap2() {
    Observable.from(["RxSwift", "ReactiveX"])
        .map { $0.count }
        .subscribe(onNext: { str in
            print(str)
        })
        .disposed(by: disposeBag)
}
//7
//9 출력

아마도 가장 많이 쓰게될 operator가 아닐까 생각된다.

filter()

func filter(_ predicate: @escaping (Int) throws -> Bool) -> Observable<Int>
//Filters the elements of an observable sequence based on a predicate.

swift의 filter()함수와 동일하게 동작하는 오퍼레이터이다. 서술한 조건에 맞는 경우에만 Observable을 내보낸다.

@IBAction func exFilter() {
    Observable.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
        .filter { $0 % 2 == 0 }
        .subscribe(onNext: { n in
            print(n)
        })
        .disposed(by: disposeBag)
}
//2
//4
//6
//8
//10 출력

배열요소들 중에 짝수인 요소만 출력된다.

stream

우리는 이러한 여러가지 오퍼레이터들을 통해 Observable을 가공하여 비동기 프로그래밍을 할 수 있게 된다. 앞의 글에서도 설명했지만 이러한 가공의 과정을 stream이라 부르기로 했고, 이러한 Observable을 통한 stream을 통해 비동기 프로그래밍을 할 수 있게 해주는 것이 RxSwift이다.

@IBAction func exMap3() {
    Observable.just("800x600")
        .map { $0.replacingOccurrences(of: "x", with: "/") }    //"800/600"
        .map { "https://picsum.photos/\($0)/?random" }          //"https://picsum.photos/\800/600/?random"
        .map { URL(string: $0) }                                //URL?
        .filter { $0 != nil }
        .map { $0! }                                            //URL!
        .map { try Data(contentsOf: $0) }                       //Data
        .map { UIImage(data: $0) }                              //UIImage?
        .subscribe(onNext: { image in
            self.imageView.image = image
        })
        .disposed(by: disposeBag)
}

Observable이 여러가지 오퍼레이터를 통해 어떤식으로 변화하는지 주석으로 적어놓았다. 

이외에도 정말 많은 오퍼레이터들이 있으며, 사용처에 따라 알맞은 오퍼레이터를 사용하면 된다. 각 오퍼레이터에 대한 상세한 내용들도 홈페이지에서 열람 가능하다.

[참고영상]

[유튜브] 곰튀김 RxSwift 4시간에 끝내기 - 4

[유튜브] 곰튀김 RxSwift 4시간에 끝내기 - 5

mutating

구조체의 객체를 변경하는 함수에는 함수의 선언시 앞에 mutating을 붙여야한다. 

왜 구조체를 써야하나요?

클래스와 구조체의 큰 차이점은 바로 클래스는 참조타입, 구조체는 값타입이라는 것이다. 클래스 객체는 힙 메모리 내부에 존재하며, 클래스 객체를 전달할 경우(함수나 변수에 전달 시), 객체를 가리키는 포인터가 전달되는 것이다. 이런 식으로 전달이 여러번 이루어 지다 보면 무수히 많은 포인터가 존재하게 되고 만다. 

하지만 구조체 객체의 경우 힙 메모리에 존재하지 않고, 구조체를 전달하게 될 때, 구조체 객체가 계속해서 복사된다. 스위프트의 경우, 객체의 내용이 변경되었을 때에만 복사가 이루어지므로 경우에 따라 클래스보다 구조체를 이용하는 것이 메모리 관리에 더욱 효율적일수가 있다. 이렇게 객체의 내용에 변경이 생길 시, 스위프트에게 알려야하는데 그러한 알림이 바로 mutating 키워드다.

따라서 예제의 Concentration 클래스를 구조체로 변경하기 위해서 func chooseCard(at index: Int)에 mutating키워드를 적어주었다. 카드배열을 순회후 카드의 앞면, 뒷면 여부가 변경되기 때문이다.

protocol

별도의 구현이 없는 함수와 변수의 리스트이다. 별도의 저장공간이 없으며 변수와 함수의 선언만 작성되어있다. 따라서 프로토콜을 상속받은 뒤 상속받은 곳에서 구현을 해야하는데, 유의할 점은 프로토콜에 선언된 모든 변수와 함수를 구현해야 한다는 점이다.

*오브젝티브-C에서의 프로토콜은 선택적으로 구현을 할 수 있으므로 차이점을 잘 알아두어야 한다. 

선언은 아래와 같이 구현은 하지 않은채로 작성하면 된다.

protocol someProtocol : inheritancedProtocol1, inheritencedProtocol2 {
	var someProperty : Int{get, set}	//읽기 쓰기가 가능한 변수
	func aMethod (...) -> someType		//함수 
	mutating func changeIt()		//객체변경 함수
	init(arg:Type)				//초기화
 }

프로토콜에는 저장공간이 할당되어있지 않으므로 선언만 가능하며, 여러개의 프로토콜을 동시에 상속받을수도 있고, 프로토콜이 다른 프로토콜을 상속받는 것 또한 가능하다. 당연히 마지막에는 상속받은 모든 프로토콜의 사항들을 구현해주어야 한다. 

사용방법

struct someStruct : someProtocol, otherProtocol {
	//someStruct 구조체의 내용을 작성.
	//물론 someProtocol, otherProtocol의 모든 변수와 함수의 내용을 구현해야한다.
}

extension something : someProtocol {
	//something에 추가할 someProtocol의 모든 변수와 함수를 구현.
}

상속 및 확장이 가능하며 프로토콜의 모든 함수와 변수의 구현을 해주면 된다.

objective - C

@objc protocol UIScrollViewDelegate {
	@available(iOS 2.0, *)
    optional func scrollViewDidScroll(_ scrollView: UIScrollView)

    @available(iOS 3.2, *)
    optional func scrollViewDidZoom(_ scrollView: UIScrollView)
    ...
}

objective-C(objc)로 작성된 프로토콜을 들여다 보면 optional이라는 키워드를 볼 수 있다. 앞서 말한 objc로 작성된 프로토콜은 선택적 구현이 가능하다 했는데, 바로 저 optional이 선택적 구현이 가능한 함수이다.

String

문자열(String)은 문자(Character)의 배열이다. 문자열을 다룰때 주의해야 할 점은 스위프트의 문자열은 유니코드방식으로 구성되어있다보니 정수형태의 index를 사용할 수 없다. 스위프트에서 문자열을 다루려면 String.index를 다루어야 한다. 다행히 String은 collection이라는 프로토콜을 상속받았고, String에는 index를 다루기 위한 편리한 collection의 메소드들이 구현되어있다.

//문자열 생성
let str:String = "apple computer"
//첫번째 String.index반환
let firstIndex = str.startIndex
//첫번째 인덱스로부터 4번째 즉 5번째 String.index반환
let fifthIndex = str.index(firstIndex, offsetBy: 4)
//다섯번째 문자 반환
let fifthCharacter = str[fifthIndex]

//출력결과 Index(_rawBits: 262401)
print(fifthIndex)
//출력결과 e
print(fifthCharacter)


//nil을 반환할 수 있기에 if let을 사용한다.
if let firstSpaceIndex = str.firstIndex(of: " "){
    //공백 다음 첫번째 인덱스 저장
    let firstIndexAfterSpace = str.index(firstSpaceIndex, offsetBy: 1)
    let firstCharacterAfterSpace = str[firstIndexAfterSpace]
    //출력결과 c
    print(firstCharacterAfterSpace)
    
    //공백이후 두번째 문자열 저장
    let secondWord = str[firstIndexAfterSpace..<str.endIndex]
    //출력결과 computer
    print(secondWord)
}

String.index를 출력해보면 정수형태가 아닌 것을 알 수 있다. 예시와 같이 메소드를 활용해 문자열을 배열로서 활용해보도록 하자.

카드뒤집기 예제에서도 문자열을 활용해보았다.

    //이모티콘 후보들이다. 배열로 담겨있었으나 문자열로 변경하였다.
    var emojiChoices = "🦇😱🙀👿🎃👻🍭🍬🍎"
    
    //emojiChoices에서 이모지를 뽑아 [카드의 id: 이모지] 쌍으로 딕셔너리를 생성한다.
    var emoji = [Int:String]()
    
    //카드에 이모지를 그려넣는 함수. 카드를 매개변수로 받는다. 이모지를 반환한다.
    func emoji(for card: Card) -> String{
        if emoji[card.identifier] == nil, emojiChoices.count > 0{
            //만약 매개변수 카드의 id가 emoji딕셔너리의 키로 존재하지 않는다면, 
            //이모지 후보에서 랜덤하게 뽑아온뒤 [카드id:이모지] 딕셔너리에 추가한다.
            let randomStringIndex = emojiChoices.index(emojiChoices.startIndex,
            offsetBy: emojiChoices.count.arc4random)
            emoji[card.identifier] = String(emojiChoices.remove(at: randomStringIndex))
        }
        
        //카드 id를 키값으로 이모지 반환
        return emoji[card.identifier] ?? "?"
    }

NSAttributedString

문자열의 모든 문자가 각각 딕셔너리를 가지는 문자열이다. 딕셔너리에는 폰트, 색상 등 여러가지가 될수 있다. 즉 각각의 문자가 속성을 가진 문자열인 셈이다. 

//속성 생성 및 정의
let attributes:[NSAttributedString.Key:Any] = [
	.strokeColor:UIColor.orange,
	.strokeWidth:5.0
]
//속성문자열 생성
let attributedString = NSAttributedString(string: "flipCount: \(flipCount)", attributes: attributes)
//문자열 활용
flipCountLabel.attributedText = attributedString

*NS가 붙은 API들은 대부분 오래된 objc클래스이다.

주의할 점은 NSAttributedString은 수정할 수 없다. 따라서 문자열을 수정하고 싶다면 setAttributedString()메소드가 담겨있는 NSMutableAttributedString()으로 생성해야 한다는 점을 알아두자.

속성문자열은 카드뒤집기 예제의 flipCount에 적용해보았다.

    //flipCount 글자를 속성문자열로 수정하는 함수.
    private func updateFlipCount(){
        let attributes:[NSAttributedString.Key:Any] = [
            .strokeColor:UIColor.orange,
            .strokeWidth:5.0
        ]
        let attributedString = NSAttributedString(string: "flipCount: \(flipCount)",
        attributes: attributes)
        flipCountLabel.attributedText = attributedString
    }
    
    //카드를 뒤집은 수를 나타내는 레이블.
    @IBOutlet weak var flipCountLabel: UILabel!{
    	//didset을 통해 값의 변경이 일어날 때 마다 updateFlipcount()가 실행된다.
        didSet{
            updateFlipCount()
        }
    }
    
    //flipCountLabel에 표시할 변수. 당연하게도 0부터 시작한다.
    var flipCount = 0 {
        //변수의 값 변동이 일어날 때마다 수행되는 메소드. flipCountLabel에 변경된 값을 전달하고 표시한다.
        didSet{
            updateFlipCount()
        }
    }

FunctionTypes

함수를 하나의 타입으로 선언한다. 

//함수 타입 선언 Double을 입력받고 Double을 반환한다.
var operation: (Double) -> Double
//sqrt메소드 입력(제곱근 반환)
operation = sqrt

//출력결과 2.0
print(operation(4.0))

sqrt메소드와 달리 직접 함수를 작성해서 대입하는 것도 가능하다.

//함수 타입선언
var operation: (Double) -> Double

//함수생성
func changeSign(operand: Double) -> Double{
    return -operand
}

//생성한 함수 대입
operation = changeSign(operand:)
//출력결과 -4.0
print(operation(4.0))

하지만 함수를 새로 생성하는 점은 코드의 라인이 길어지는 단점이 생긴다.

closure

이전 예시에서 더 짧게 코드를 줄이는 방법이 클로저를 활용하는 방법이다. 클로저는 인라인 함수로 인자에 함수를 적어서 넣을수 있다.

var operation: (Double) -> Double

//{}중괄호 안에 함수의 내용을 적으면 되며 반환값은 "in return" 키워드를 사용한다.
operation = {(operand:Double) -> Double in return -operand}

operation = changeSign(operand:)
print(operation(4.0))

여기서 더 강력한 기능은 스위프트의 타입추론이다. 위에 정의한 operation에서 이미 매개인자와 출력인자의 타입이 정의되어있으므로 클로저에서는 타입생략이 가능한 것이다.

//입력인자와 출력인자에 대한 타입과 갯수가 정의되어있다.
var operation: (Double) -> Double

//매개인자들의 타입 생략 가능.
operation = {(operand) in return -operand}

//출력결과 -4.0
print(operation(4.0))

이어서 스위프트는 operation에는 리턴값이 존재한다는 것 또한 인지하고 있다. 즉 return이라는 키워드를 생략할 수 있게 되는데, 

//입력인자와 출력인자에 대한 타입과 갯수가 정의되어있다.
var operation: (Double) -> Double

//매개인자들의 타입 생략 가능.
operation = {(operand) in -operand}

//출력결과 -4.0
print(operation(4.0))

이런식으로 in이라는 키워드만 적으면 된다. 클로저에는 더 강력한 기능이 있는데, 바로 매개인자의 치환이 가능하다는 것이다. 첫번째 매개인자는 $0, 두번째 매개인자가 있다면 $1, 이런식으로 $0, $1, $2 ... 을 통해 매개인자를 대치할 수 있게 되는데, 그렇게 되어 최종적으로 다음 예시처럼 완성이 된다.

//입력인자와 출력인자에 대한 타입과 갯수가 정의되어있다.
var operation: (Double) -> Double

//매개인자의 부호변경
operation = {-$0}

//출력결과 -4.0
print(operation(4.0))

map()

배열에는 map()이라는 메소드가 존재한다. 하나의 인수를 받고 새로운 배열로 반환을 하는데, 이때 인자는 함수를 받는다. 즉 배열의 요소를 하나씩 뽑아서 인자로 받은 함수에 입력한뒤 결과값을 배열로 반환하는 메소드이다. 앞서 설명한 클로저와 항상 쓰이는 메소드이다.

let primes = [2.0,3.0,4.0,5.0]
let negativePrimes = primes.map({-$0})

//출력결과 [-2.0, -3.0, -4.0, -5.0]
print(negativePrimes)

여기서 TrailingClosure라는 문법이 있는데, 어떠한 함수라도 마지막 인자가 클로저라면 클로저를 괄호밖으로 내놓고 작성하는 문법이다. 

인자가 유일하다면 메소드의 괄호를 생략도 가능한데, 이러한 문법들은 모두 인자로 받는 함수가 길어지게 되었을 때의 가독성을 위한 문법이다. 편한 방식을 선택해서 작성하면 된다.

let primes = [2.0,3.0,4.0,5.0]

let negativePrimes = primes.map({-$0})
//출력결과 [-2.0, -3.0, -4.0, -5.0]
print(negativePrimes)

//클로저를 괄호 밖에서 작성해도 된다.
let primes2 = primes.map() {Int($0)}
//출력결과 [2, 3, 4, 5]
print(primes2)

//인자가 유일하다면, 괄호를 생략가능하다.
let primes3 = primes.map {1.0/$0}
//출력결과 [0.5, 0.3333333333333333, 0.25, 0.2]
print(primes3)

filter()

배열이 상속받고 있는 collection 프로토콜의 메소드이다. 하나의 함수를 인자로 받고, Bool을 반환한다. true를 반환하는 요소만 배열에 추가하여 사용한다.

let arr = [1,2,3,4,5,6,7,8,9,10]
//짝수만 새로운 배열에 추가
let evenArr = arr.filter(){$0 % 2 == 0}

//출력결과 [2,4,6,8,10]
print(evenArr)

카드뒤집기 예제에서는 앞면인 카드를 확인하는 연산변수(computedProperty)에 적용해보았다. 주석처리된부분이 filter를 통해 삭제된 라인들이다. 상당수의 라인이 제거된다.

//유일하게 앞면 상태의 카드를 나타내는 속성 이후에 두번째로 오픈되는 카드와 id를 비교하기위해 사용된다.
    var indexOfOneAndOnlyFaceupCard:Int? {
        //indexOfOneAndOnlyFaceupCard 호출시
        get{
            //카드 배열 속 앞면인 카드들을 모두 반환. 
            //만약 앞면인 카드가 단 한장이라면 해당 카드인덱스 반환. 한장보다 많다면 nil 반환
            return cards.indices.filter{cards[$0].isFaceUp == true}.oneAndOnly

//            //리턴을 위한 임시 변수 생성. optional로 생성한다.
//            var foundIndex:Int?
//
//            //카드배열을 돌면서 앞면상태인 카드를 탐색한다.
//            for index in cards.indices{
//                if cards[index].isFaceUp{
//                    //앞면인 카드발견 + foundIndex가 nil, 즉 앞면인 카드가 오로지 한장이라면,
//                    if foundIndex == nil {
//                        //앞면이 유일한 카드는 해당 카드가 된다.
//                        foundIndex = index
//                    } else{
//                        //foundIndex에 값이 있는경우, 즉 앞면인 카드가 한장보다 많다면, 유일하게 앞면인 상태가 아니므로 nil을 반환한다.
//                        return nil
//                    }
//                }
//            }
//            //foundIndex의 값으로 indexOfOneAndOnlyFaceupCard설정
//            return foundIndex
        }
        //indexOfOneAndOnlyFaceupCard 대입시
        set{
            //카드 배열을 돌면서 카드의 앞면, 뒷면을 설정한다.
            for index in cards.indices{
                //사용자가 선택한 카드번호(nexValue)가 아닌 나머지 카드들은 모두 뒷면으로 설정한다.
                cards[index].isFaceUp = (index == newValue)
            }
        }
    }
    
extension Collection{
    var oneAndOnly:Element?{
    	원소가 한개라면? 첫번째를(하나뿐인 원소를) 반환해라. 두개이상이라면 nil을 반환한다.
        return count == 1 ? first : nil
    }
}