듄의 기록노트

[RxSwift] Operator - Filter

듀니듀니 — Fri, 16 Dec 2022 17:24:13 +0900

안녕하세요!

오늘은 RxSwift의 Operator중 Filter에 대해 적어두려고 해요 :)

출처 - https://rxmarbles.com

테스트 조건을 만족하는 항목들만 배출해요. 조건식이 10보다 큰 수 였으니 6개의 정수중에 30, 22, 60만 배출되었어요.

예시)

let disposeBag = DisposeBag()
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Observable.from(numbers)
    .filter { $0.isMultiple(of: 2) }
    .subscribe { print($0) }
.disposed(by: disposeBag)

/* 실행결과

next(2)
next(4)
next(6)
next(8)
next(10)
completed

*/

[Swift] guard와 if-let 비교해보기

듀니듀니 — Wed, 7 Dec 2022 17:31:38 +0900

안녕하세요!

오늘은 guard문과 if문의 차이를 비교정리해보겠습니다 :0

1. guard문

guard 문은 뭔가를 검사하여 그 다음에 오는 코드들을 실행할지 말지 결정, guard 문에 주어진 조건문이 거짓일 때, 여기에 달려있는 코드 블럭이 실행된다.
조건식에 이 함수가 수행하는데 필요한 조건을 그대로 나타낸다는 점에서 if문에서 부정적인 조건식으로 표현하는 것보다 가독성이 높은 장점.
if 문과 다르게, else를 항상 달아야 한다.

func guardFunc (be: String?) {
	guard be != nil else { return }
	print(be)
}

guardFunc(be: "20")
guardFunc(be: nil)

옵셔널 바인딩은 if-let 문법을 사용한 옵셔널 바인딩과 다르게 옵셔널 바인딩된 상수를 조건문 범위 바깥에서도 사용할 수 있다.
guard문의 경우 상수의 사용범위는 함수 나머지 영역이 된다.

func guardInFunc (string: String?) {

    guard let letString = string else { return }

    print(letString!, "second param", separator: "")
}
guardInFunc("test")

복합 옵셔널 바인딩
복합해서 사용가능, 모든 파라미터가 nil이 아닐경우 조건을 충족하고 출력문을 수행한다.

func guardWithCompoundOptionalBinding (firstName: String?, lastName: String?, dateOfBirth: String?) {

    guard let fname = firstName, let lname = lastName, let dob = dateOfBirth else { return }

    print("\(fname) \(lname) \(dob)")

}

guardWithCompoundOptionalBinding("sun", lastName : "kim", dateOfBirth: "")

2. if-let

var optionalName: String? = "Daeyeon"
var greeting = "Hello!"

if let name = optionalName 
{
  greeting = "Hello, \(name)"
}

“non-optional 변수인 name”에 “Optional 변수인 optionalName” 안에 들어 있는 값을 할당할 수 있다면 {} 안의 내용을 실행하라”라는 의미. (name은 내가 만든상수, if 문 안에서만 사용가능하다.

3. 결론

if 문 - 조건이 하나이거나 조건 전제가 단순할 때, 바인딩한 상수를 다른 값에 처리하는 상황

guard 문 - 복잡한 문장일때, 바인딩한 상수를 동일한 스코프에서 사용할 때

[RxSwift] Observable & Observer

듀니듀니 — Mon, 5 Dec 2022 17:17:13 +0900

Observable와 Observer에 대해 정리해두려고 해요.

Observable ------ Event ----> Observer(Subscriber)

Observable <-- Subscribe --- Observer(Subscriber)

-> 옵저버블에서 발생한 새로운 이벤트는 Next를 통해 방출(Emission)

Observable

// #1 원형. create로 이벤트 만들기
Observable<Int>.create { (observer) -> Disposable in
    observer.on(.next(0))
    observer.onNext(1)
    
    observer.onCompleted()
    return Disposables.create()
}

// #2 이미 구현되어있는 이벤트 사용

Observable.from([0,1])

Observer

let o1 = Observable<Int>.create { (observer) -> Disposable in
   observer.on(.next(0))
   observer.onNext(1)
   
   observer.onCompleted()
   
   return Disposables.create()
}

// #1
o1.subscribe {
    print("== Start ==")
    print($0)
    if let elem = $0.element {
        print(elem)
    }
    print("== End ==")
}
print("-----------------------")

// #2
o1.subscribe (onNext: { elem in
    print(elem)
})


Observable.from([1, 2, 3])

/* 실행 결과

== Start ==
next(0)
0
== End ==
== Start ==
next(1)
1
== End ==
== Start ==
completed
== End ==
-----------------------
0
1

*/

[RxSwift] Why RxSwift?

듀니듀니 — Mon, 5 Dec 2022 16:04:16 +0900

안녕하세요 . 오늘은 RxSwift의 장단점에 대해 적어두려고 해요!

ReactiveX는 관찰 가능한 시퀀스를 사용하여 비동기식 및 이벤트 기반 프로그램을 구성하기 위한 라이브러리 입니다.

장점

1. 반응형 패러다임이 제공하는 명확함

비동기를 동기화 된 것인양 작성할 수 있음

2. 일관성이 없는 비동기 코드를 해결

어떤 곳에서는 DispatchQueue, 어떤 곳에서는 OperationQueue…
하나의 비동기 코드로 개발이 가능함

3. 확장 불가능한 아키텍처 패턴을 해결

일관성 없는 비동기 코드를 작성하게 되어 서로 다르게 구현한 로직을 조합하거나 확장하기에 어려운 부분을 해결
Rx로 일관된 코드를 작성하면서 아키텍처의 확장이 가능함

4.콜백지옥에서 탈출

5. Thread 처리가 용이

MainThread 에서 처리하기, 백그라운드 에서 처리하다 다시 메인 다시 백그라운드 .. 쉽게 처리할 수 있음.

단점

1. 러닝커브

학습하기가 어려움. 하지만 점점 좋은 자료들이 많이 생기고 있는 추세

2. Debugging이 어렵다.

Stack이 깊게 있어서 트래킹하기 어려운 느낌

3. 클로저의 캡쳐리스트(closure capture list)를 조심

클로저 사용이 많음. 캡쳐리스트를 사용하여 메모리 누수를 일으키는 강한 순환 참조(strong reference cycle)를 피할 수 있게 신경써야됨.

[Swift] 속성 감시자 (Property Observer)

듀니듀니 — Fri, 25 Nov 2022 18:08:08 +0900

오늘은 속성 감시자에 대해 정리하려고 합니다.

속성 감시자는 저장 속성이 변하는 시점을 관찰합니다.

저장 속성이 변하는 순간, 구현되어 있는 메서드가 호출됩니다.

1) willSet은 값이 저장되기 직전에 호출됩니다.

2) didSet은 새 값이 저장된 직후에 호출됩니다.

class Apple {
    
    // 일반 저장 속성
    var message: String = "가격이 변경 되었습니다."
    // 속성 감시자
    var price: Int {
        willSet(price) {  // 바뀔 값이 파라미터로 전달
            print("사과의 가격이 \(self.price)원에서 \(price)원으로 변경될 예정입니다.")
            print("가격 변경전")
        }
        didSet(price) {   // 바뀌기 전의 과거값이 파라미터로 전달
            print("사과의 가격이 \(price)원에서 \(self.price)원으로 이미 변경되었습니다.")
            print("가격 변경후")
        }
    }
    
    init(price: Int) {
        self.price = price
    }
    
}
let apple = Apple(price: 3000)
apple.price
apple.price = 5000

/* 실행결과 */
//사과의 가격이 3000원에서 5000원으로 변경될 예정입니다.
//가격 변경전
//사과의 가격이 3000원에서 5000원으로 이미 변경되었습니다.
//가격 변경후

- 클래스, 구조체, (열거형) 동일하게 적용

- 어떤 속성이 변하는 시점을 알아차리도록 시점에 제약을 만드는 코드를 짜기는 어려움

- 그래서 실제 서비스에 활용할때 좋은 수단

- 일반적으로는 willSet 또는 didSet 중에서 한가지만 구현

- 실제 프로젝트에서는 didSet을 많이 사용

[Swift] 서브스크립트 (Subscripts)

듀니듀니 — Fri, 25 Nov 2022 15:08:24 +0900

오늘은 서브스크립트에 대해 정리해볼게요!

서브스크립트란?

-> 대괄호를 이용해서 접근가능하도록 만든 문법

Ex)

-> 배열 array[index]

-> 딕셔너리 dictionary[key]

var array = ["banana", "apple", "tomato"]

array[0] // banana
array[1] // apple
// 내부적으로 대괄호를 사용하면 어떤 값을 리턴하도록 구현이 되어 있어서 가능한 일

직접 구현해보기

class SportsData {
	var datas = ["soccer", "baseball", "basketball", "tennis"]
    
    subscript(index: Int) -> String {
    	get {
        	return datas[index]
        }
        set {
        	datas[index] = newValue
        }
    }
}

var sportsData = SportsData()
sportsData[0] // soccer
sportsData[0] = "swim"
sportsData[0] // swim

- 함수의 구현이 특별한 키워드인 subscript로 명명

- 메서드이기 때문에 인스턴스에 메모리 공간이 할당되어 있지 않음

- 메서드 접근 시, 인스턴스 이름으로 접근 해야함 -> instance[파라미터]

 - get블록만 선언하면 읽기전용(read-only) 계산 속성이 됨 (필수 구현)

- set블록은 선택적 구현

- set블록에서 기본 파라미터 newValue가 제공됨

객체지향 프로그래밍 (OOP)

듀니듀니 — Tue, 22 Nov 2022 14:41:40 +0900

안녕하세요 오늘은 객체지향에 특징에 대해 간단히 적어두려합니다!

Object Oriented Programming이란..

1. 추상화 (Abstraction) - 모델링

- 추상화란 실생활에서의 구체적인 것을 관찰자가 관심있는 부분만 가지고 재조합 하는 것
- 실체들에서 관심있고, 공통적인 특성을 뽑아내서 하나의 분류(class)로 만든 것 (모델링)
- 객체지향의 관점에서, 실체들의 공통적 특성을 뽑아내서 클래스로 정의하는 것 자체가 추상화의 개념 

- 예) 도서관리 프로그램 ➡ 제목 / 저자 / 출판사 / 총페이지 / 가격 등

2. 캡슐화 (Encapsulation) - 모델링 / 정보 은닉 / 데이터 캡슐화

- 연관이 있는 속성(상태)과 메서드(기능)를 “하나의 클래스”로 묶어서 활용한다는 개념
- 묶을 때, 객체는 자신이 맡은 역할을 수행하기 위한 하나의 목적을 가진 실체라는 관점에서 접근해야함 - 추상화와 밀접하게 연결되는 개념.  

(추상화는 디자인 레벨 관점에서 바라보는 개념인데 반해, 캡슐화는 실제 코드로 구현하는 레벨에서의 개념) 
- 은닉화(Information Hiding): 캡슐화를 하면, 접근제어자(private, public 등)를 사용해 객체 외부에서 내부  

데이터의 접근 통제가 가능해짐

3. 상속성 (Inheritance) - 재사용 / 확장

- 부모클래스의 속성과 메서드를 자식클래스에서 그대로 물려받는 개념
- 상속을 통해, 코드가 재활용되기 때문에 생산성이 높아짐(클래스의 재사용과 확장을 위해 상속이 사용됨) - 객체지향의 개념에서, 클래스가 다른 타입과 구별되는 결정적인 차별점

4. 다형성 (Polymorphism) - 사용편의 / 동적바인딩

-하나의 객체가 여러가지 타입의 형태로 저장 될 수 있고, 다양한 메서드의 형태로 동작 가능함을 의미  (하나의 객체는 부모의 타입으로도 저장이 가능하고, 프로토콜 타입으로도 저장이 가능)

- 하나의 객체는 다양한 방식으로 동작 가능(동적 바인딩/Method Dispatch) 
(또한 오버라이딩(overriding)과 오버로딩(overloading)을 통해 하나의 메서드나 클래스를 다양한 방법으로   동작시키는 것을 포함하는 개념 - 이 부분에 대해서는 컴퓨터공학자들 사이에서 이견이 있음)

SwiftMaster(주교재)_김도윤

추상화 (Abstraction)

[Swift] 클래스와 구조체 (Class, Struct)

듀니듀니 — Tue, 22 Nov 2022 11:42:56 +0900

오늘은 클래스와 구조체를 정리해보겠습니다 :)

구조체(struct) vs 클래스(class)

타입 -> Value Type (값 형식) vs Reference Type (참조 형식)

메모리 -> 값의 저장: Stack / 복사 전달 (메모리에서 자동제거) vs Heap / 주소 전달 (ARC로 관리)

선언 -> 인스턴스 상수(let)로 선언시, 저장속성이 전부 상수로 선언 vs 인스턴스 상수(let)로 선언하면  가르키는 인스턴스 고정 (저장 속성은 각 let/var 선언에 따름) 

소멸자 -> 소멸자 없음 vs 소멸자 있음

상속여부 -> 상속 불가능 vs 상속 가능

값 형식(struct) vs 참조 형식(class)

타입 -> Value Type vs Reference Type

메모리 상의 저장 위치 -> Stack vs Heap

메모리 관리 방식 -> 값이 들어있는 스택의 스코프 종료시, 메모리에서 자동 제거 vs

Reference Counting을 통해 메모리를 관리

타입 예시 -> 스위프트 기본 타입(Int, String ...), 구조체 vs 클래스, 클로저

[Swift] Optional

듀니듀니 — Thu, 17 Nov 2022 11:21:03 +0900

Optional?

안전한 코드를 작성하기 위해 사용하는 문법

nil -> 값이 없음을 표현하는 키워드

String = 값이 없으면 에러

String? = 에러가 나지 않도록 임시적인 타입을 담아둠

let str: String = "Swift"
let optionalStr: String? = nil

let a: Int? = nil
let b: Int? = a //nil
b // nil

옵셔널 타입 추출 방법

1. 강제 추출 - nil이 아닌 값이 있다는 것을 확신하고 강제로 값을 추출 (값이 없는 경우 크래시 위험)

let value: String? = "val"
value! // val

let value2: String?
value2! = 에러

2. nil 확인후, 강제 추출

if value != nil {
	print(value!)
}

3. 옵셔널 바인딩 (if let, guard let) - 바인딩이 되는 경우에만 특정 작업을 실행

// if let
if let number = optionalNumber {
	print(number)
}

// guard let
func callName(name: String?) {
    guard let n = name else { return }
    print(n)
}

callName(name: nil) // 아무 반응 없음

4. Nil - Coalescing - 옵셔널 표현식 뒤에 기본 값을 제시해서, 옵셔널의 가능성을 없앤다

optionalValue ?? "기본값"

[Swift] Array

듀니듀니 — Wed, 16 Nov 2022 15:29:52 +0900

오늘은 Array(배열)에 대해 정리해봤어요.

- 간단한 특징

Ordered Collection (저장된 순서대로 저장)
Single Type (배열안의 자료형은 동일해야함)
중복 가능, 같은 값이라 해도 개별요소로 처리
0-based Index // 배열의 요소를 찾을 때 사용

Array ?

[elem, elem, ....]
let nums =[1, 2, 3]

Array<T> // 정식 문법
[T]      // 단축 문법

let strArray: Array<String>
let strArray2: [String]

Array - Creating an Array

let nums = [1, 2, 3]

let emptyArray: [Int] = [] // 빈 리터럴을 사용할땐 형식 지정해줘야함

let emptyArray2 = Array<Int>()
let emptyArray3 = [Int]()

let zeroArray = [Int](repeating: 0, count: 10) // 0이 10개가 채워진 배열이 생성

Accessing Elements

let fruits = ["Apple", "Banana", "Melon"]
let emptyArray: [Int] = []

fruits[0] // Apple
fruits[3] // error

fruits[0...1] // Apple, Banana

fruits[fruits.startIndex] // Apple

fruits[fruits.endIndex] // Error, endIndex 전 데이터에 접근해야함

fruits[fruits.index(before: fruits.endIndex)] // Melon

fruits.first // Apple
fruits.last // Melon

emptyArray.first // nil
emptyArray.last // nil

Adding Elements

var alphabet = ["A", "B", "C"]
alphabet.append("E") // E 추가

alphabet.append(contentsOf: ["F", "G"])

//insert는 오버헤드가 발생할 수 있기에 가급적 사용하지 않는다.
alphabet.insert("D", at: 3) // 3번쨰 칸에 추가

alphabet.insert(contestOf: ["a", "b", "c"], at:0) // 0번째칸에

alphabet[0...2] = ["x", "y", "z"] // 0,1,2 번째 배열데이터를 바꿈

alphabet.replaceSubrange(0...2, with: ["a", "b", "c"]) // 위아같은 배열 바꿔치기

alphabet[0...2] = ["z"] // 0~2 번째 배열을 "z"로 바꿈 (3개 -> 1개가 됨)

alphabet[0..<1] = [] // 빈배열을 보내면 원하는 범위가 삭제됨

Removing Elements

numArray = [1, 2, 3, 4, 5]
numArray.remove(at: 2) // 3 제거

//빈배열에 removeFirst 쓰면 에러
numArray.removeFirst() // 첫번째 요소 제거후 출력

numArray.removeFirst(2) // 앞 2개 제거, 출력은 x

numArray.removeAll() // 배열에 있는 모든 요소 제거, 빈 배열이 됨

numArray= [1, 2, 3, 4, 5, 6, 7]
numArray.popLast() // 7 제거

numArray.removeSubrange(0...2) // 0,1,2번째 배열 제거

numArray[0...2] = [] // 위와 같이 해당 범위 제거

Finding Elements

let nums = [1, 2, 3, 1, 4, 5, 2, 6, 7, 5, 0]

nums.contain(1) // true
nums.contain(8) // false

nums.contains { (n) -> Bool in
	return n % 2 == 0
} // true

num.first { (n) -> Bool in
	return n % 2 == 0
} // 2

num.firstIndex { (n) -> Bool in
	return n % 2 == 0
} // 1

nums.firstIndex(of: 1) // 2번째 인덱스 1

nums.lastIndex(of: 1) // 5

Sorting

// sort -> 배열을 직접 정렬
// sorted -> 정렬된 새로운 배열을 리턴

nums.sorted() // 오름차순으로 정렬 

nums.sorted { (a, b) -> bool in
	return a > b
} // 내림차순으로 정렬

nums.sorted().reversed()
[Int](nums.sorted().reversed())

var mutableNums = nums

mutableNums.sort() // 오름차 
mutableNums.reverse() //내림차

mutableNums.swapAt(0, 1) // 첫번째와 두번째 요소의 위치가 바뀜

mutableNums.shuffle() // 순서 무작위로 바꿈