• 하나의 함수에서 자신을 다시 호출하여 작업을 수행하는 방식으로 문제를 푸는 방법
• 반복무능로 구현되는 알고리즘은 재귀함수로 표현할 수 있다.

작은 문제를 먼저 해결하고 큰 문제를 해결하는게 재귀적 아이디어의 핵심 재귀함수는 반드시 탈출조건(base case)이 있어야 한다.

팩토리얼 예제

• 반복문 예제

  func factorial (_ n : Int) -> Int {
    var answer = 1
    for i in 2...n {
        answer = answer * i
    }
    return answer
  }
  // 1 * 2 <-- answer에 할당
  // 2(기존 answer) * 3 <-- answer에 할당
  // 6(기존 answer) * 4 <-- answer에 할당
  // ... 이런식으로 반복해서 곱해주는 형식

• 재귀 예제

  func factorialR (_ n : Int) -> Int {
    if n == 1 { return 1 }
    return n * factorialR(n - 1)
  }
  

// factorialR(3) 일 경우 // 3 * factorialR(2) // 2 * factorialR(1) // 1 // n == 1 이 탈출조건(base case)이기 때문에 1을 리턴하면서 마무리

### 피보나치 예제
* 반복문 예제
```swift
func fibonacci(_ n : Int) -> Int {
    if n == 1 || n == 0 { return n }
    var answer = 0
    var (a, b) = (0, 1)
    for _ in 2...n {
        answer = a + b
        a = b
        b = answer
    }
    return answer
}

• 재귀함수 예제

  func fibonacciR(_ n : Int) -> Int {
    if n == 1 || n == 0 { return n }
    return fibonacciR(n - 1) + fibonacciR(n - 2)
  }

최대공약수 예제

유클리드 호제법 a를 b로 나눈 나머지를 r이라고 할때 (단, a > b) a와 b의 최대 공약수는 b와 r의 최대 공약수와 같다는 성질을 이용하는 방법

• 재귀함수 예제

  func gcdR(a:Int, b:Int) -> Int {
    if a == b { return a }
    else if a > b { //
        if a % b == 0 { return b }
        else { return gcdR(a: b, b: a % b) }
  
    } else {
        if b % a == 0{ return a }
        else { return gcdR(a: a, b: b % a) }
    }
  }
  gcdR(a: 12, b: 16)

Swift의 데이터 타입을 공부하던 중, 기존에 알고 있던 언어(Javascript)에는 없는 자료형을 발견해서, '신기하다... 배열이랑 비슷하네' 정도의 소감을 가지고 익혔는데 문득, 실제 개발시 튜플을 활용하면 좋은 상황을 미리 알아두면 좋겠다 싶어서 추가적으로 알아보기로 했다.

튜플이란?

기본 모양

let 우리고양이 = ("까까", "Black", 7)

튜플이란 ()안에 여러가지 표현식이 들어가 있는 자료형을 말한다. () 안에는 위의 예시처럼 여러가지 타입이 섞여 들어가도 관계가 없다.

print(type(of: 우리고양이)) // (String, String, Int)

.을 통해 멤버에 접근할 수 있다.

우리고양이.0 == "고양이"
우리고양이.1 == "Black"
우리고양이.2 == 7

튜플에 이름 넣어주기

let 우리고양이 = (name: "까까", color: "Black", age: 7)

라벨로 이름을 붙일 수 있고, .뒤에 index가 아닌 라벨을 통해 접근 가능하다.

kkakka.name == "까까"
kkakka.color == "Black"
kkakka.age == 7

구조 분해 할당

let 우리고양이 = (name: "까까", color: "Black", age: 7)

let (name, color, age) = 우리고양이

이런식으로 구조를 분해해서 할당할 수 있다.

다양한 튜플의 활용법

위에 적은 내용이 튜플의 기본적인 활용법인데, 사실 튜플 안에는 배열도 함수도 들어갈 수 있다. 튜플을 보다 다양하게 사용하는 예시를 살펴보자

switch 문의 활용

let 해상도 = (3840.0, 2160.0)

func 해상도알려주는함수 (가로: Double, 세로: Double) -> String {
    let 해상도 = (가로, 세로)
    switch 해상도 {
    case(3840...10000, _):
        return "와이드모니터 같은데요?"
    case (3840.0, 2160.0):
        return "4k"
    case (2560, 1440) :
        return "QHD"
    case (1920, 1080) :
        return "FHD"
    case let (x, y) where x == y:
        return "정사각형 모니터...?"
    case let (x, y) where x < y:
        return "가로랑 세로를 잘못 입력하신거 같아요"
    default:
        return "이상한데요?"
    }
}

print(해상도알려주는함수(가로: 2160, 세로: 5000))

배열 안의 튜플

튜플을 활용하면, 더 다양한 타입의 데이터 타입을 한 배열에 넣을 수 있다.

var catArr : [(name: String, age: Int)] = []

catArr.append((name : "까까", age : 7))
catArr.append((name : "루", age : 4))

print(catArr)

print(catArr[0].name) // 까까

for (index, element) in catArr.enumerated() {
    print("\(index + 1)번째 고양이는 \(element.name)이고, 나이는 \(element.age)살 입니다.")
}
/*
1번째 고양이는 까까이고, 나이는 7입니다.
2번째 고양이는 루이고, 나이는 4입니다.
*/

간단한 유저 정보 등을 배열 속에 넣어서 관리할 때 유용하게 사용할 수 있을 것 같다.

튜플 안에 배열

let 우리고양이 = (name: "고양이", color: "Black", age: 7, likes: ["츄르", "냉장고", "캣폴"])

print(우리고양이.likes) // ["츄르", "냉장고", "캣폴"]

for 좋아하는거 in 우리고양이.likes {
    print(좋아하는거)
}

이처럼 튜플 안에 배열을 넣어서 디테일한 정보를 담을 수 있다.

튜플 안에 함수

func getName () -> String {
    return "김대성"
}

func getAge () -> Int {
    return 99
}

let userInfo = (name : getName(), age : getAge())

print(userInfo.name, userInfo.age) // 김대성 99

func 주식계산기 (name: String, price: Double, amount: Double) -> (name: String, value: Double) {
    return (name, price * amount)
}

let 삼성전자 = 주식계산기(name: "삼성전자", price: 67400, amount: 50)
let 현대자동차 = 주식계산기(name: "현대자동차", price: 186000, amount: 20)
let 네이버 = 주식계산기(name: "네이버", price: 286500, amount: 10)

let 내주식 = (삼성전자, 현대자동차, 네이버)

print("\(내주식.0.name)을 \(내주식.0.value)만큼 들고 있습니다.")

함수 값을 튜플에 담는 것 역시 가능하다.

멀티 리턴 함수

func calculateTip(billAmount: Double, tipPercent: Double) -> (tipAmount: Double, totalAmount:Double) {
    let tip = billAmount * (tipPercent / 100)
    let total = billAmount + tip
    return (tipAmount: tip, totalAmount: total)
}

print(calculateTip(billAmount: 1000, tipPercent: 10))

let (tipAmount, totalAmount) = calculateTip(billAmount: 1000, tipPercent: 20)

print(tipAmount, totalAmount)

멀티 리턴 함수를 만들어서 활용할 수 있다. 리턴되는 타입이 복잡할 경우 typealias를 통해 관리할 수 있다.

typealias TipType = (tipAmount: Double, totalAmount:Double)

func calculateTip(billAmount: Double, tipPercent: Double) -> TipType {
    let tip = billAmount * (tipPercent / 100)
    let total = billAmount + tip
    return (tipAmount: tip, totalAmount: total)
}

http://minsone.github.io/mac/ios/swift-map-filter-reduce-and-inference

고차함수

다른 함수를 전달 인자로 받거나 함수 실행의 결과를 함수로 반환하는 함수

map, filter, reduce

// map
let numbers = [0,1,2,3]
let mapArray = numbers.map { (number) -> Int in
    return number * 2
}
print("map \(mapArray)") // map [0, 2, 4, 6]

// filter
let intArray = [10,5,20,13,4]
let filterArray = intArray.filter{ $0 > 5} // 클로져 간소화
print("filter \(filterArray)") // filter [10, 20, 13]

//reduce
let someArray = [1,2,3,4,5]
let reduceResult = someArray.reduce(0) {
    (acc: Int, cur: Int) -> Int in
    print("\(acc) + \(cur)")
    return acc + cur
}
/*
 0 + 1
 1 + 2
 3 + 3
 6 + 4
 10 + 5
 */

print("reduce \(reduceResult)") // reduce 15

코드에서 전달 및 사용할 수 있는 독립 기능 블록이며, 일급 객체의 역할을 할 수 있음

일급 객체?

전달 인자로 보낼 수 있고, 변수/상수 등으로 저장하거나 전달할 수 있으며, 함수의 반환값이 될 수도 있다.

코드 예시

import UIKit

/*
 { (parameters) -> return type in
     statements
 }
 */

let hello = { () -> () in
    print("hello")
}

hello()

let hello2 = { (name: String) -> String in
    return "Hello, \(name)"
}

//hello2(name: "Daeseong") // Error : 전달인자 레이블을 적으면 오류 발생

hello2("Daeseong") // "Hello, Daeseong"

func doSomething(closure: () -> ()) {
    closure()
}

doSomething(closure : { () -> () in
    print("hello")
}) // "hello"

func doSomething2() -> () -> () {
    return { () -> () in
        print("hello!")
    }
}

doSomething2()() // hello!


// Closure의 축약
func doSomething3(closure: (Int, Int, Int) -> Int) {
    closure(1,2,3)
}

doSomething3(closure: {(a,b,c) in
    return a+b+c
})

doSomething3(closure : {
    return $0+$1+$2
})

doSomething3(closure : {
    return $0+$1+$2
})

doSomething3(closure : {
    $0+$1+$2
})

doSomething3(){
    $0+$1+$2
}

doSomething3 {
    $0+$1+$2
}

프로그램 내에서 에러가 발생한 상황에 대해 대응하고 이를 복구하는 과정

Swift 에러 처리

1. 발생(throwing)
2. 감지(catching)
3. 전파(propagating)
4. 조작(manipulating)

4가지의 일급 클래스를 제공

코드 예시

enum PhoneError : Error {
case unknown
case batteryLow(batteryLevel: Int)
}

// 에러를 던져준다.
//throw PhoneError.batteryLow(batteryLevel: 20)
/*
 ▿ PhoneError
   ▿ batteryLow : 1 element
     - batteryLevel : 20
*/


func checkPhoneBatteryStatus(batteryLevel: Int) throws -> String {
    guard batteryLevel != -1 else {throw PhoneError.unknown}
    guard batteryLevel > 20 else { throw PhoneError.batteryLow(batteryLevel: 20)}
    return "배터리 상태가 정상입니다."
}

/*
 do {
 try 오류 발생 가능 코드
 } catch 오류 패턴 {
  처리 코드
 }
*/

do {
    try checkPhoneBatteryStatus(batteryLevel: 20)
} catch PhoneError.unknown{
    print("알수 없는 에러입니다.")
} catch PhoneError.batteryLow(let batteryLevel){
    print("배터리 전원 부족! 남은 배터리 : \(batteryLevel)")
} catch {
    print("그 외 오류 발생 : \(error)")
}

let status = try? checkPhoneBatteryStatus(batteryLevel: 30)
//print(status) // nil (in batteryLevel : -1)
print(status) // Optional("배터리 상태가 정상입니다.") (in batteryLevel : 30)

let status2 = try! checkPhoneBatteryStatus(batteryLevel: 30)
// 에러가 절대로 발생하지 못하는 상황
print(status2) // "배터리 상태가 정상입니다."

옵셔널에 속해있는 nil일지도 모르는 프로퍼티, 메서드, 서브스크립션에 질의(query)를 하는 과정

-> 만약 옵셔널이 프로퍼티나 메소드 혹은 서브스크립트에 대한 값을 갖고 있다면 그 값을 반환하고 만약 값이 nil이면 nil을 반환한다. 여러 질의를 연결해서 할 수도 있는데, 연결된 질의에서 어느 하나라도 nil이면 전체 결과는 nil이 된다.

코드 예시

import UIKit

struct Developer {
    var name:String
}

struct Company {
    let name : String
    var developer : Developer?
}

var developer = Developer(name: "Daeseong")

var company = Company(name: "DK", developer: developer)

print(company.developer) // nil
//print(company.developer.name) // Error: 옵셔널을 벗기지 않아서
print(company.developer?.name) // Optional("Daeseong")
print(company.developer!.name) // "Daeseong" , 강제 언래핑

열거형은 관련된 값으로 이루어진 그룹을 공통의 형으로(type) 선언해 형 안전성(type-safety)을 보장하는 방법으로 코드를 다룰 수 있게 해준다. enum키워드를 사용하여 선언

코드 예시

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

var direction = CompassPoint.east
direction = .west // west

// Switch 구문과 함께 다양하게 활용할 수 있다.

switch direction {
case .north:
    print("north")

case .south:
    print("south")

case .east:
    print("east")

case .west:
    print("west")
}

// 원시형 값도 넣을 수 있다.
enum CompassPoint2 : String {
    case north = "북"
    case south = "남"
    case east = "동"
    case west = "서"
}

var direction2 = CompassPoint2.north
direction2 = .west

switch direction2 {
case .north:
    print(direction2.rawValue)

case .south:
    print(direction2.rawValue)

case .east:
    print(direction2.rawValue)

case .west:
    print(direction2.rawValue)
} // 서

// 원시값으로 열거형을 반환하게 할 수 있다.
let direction3 = CompassPoint2(rawValue: "남") // south

// 열거형은 연관값도 가질 수 있다. (각 항목 옆에 소괄호로 표현)

enum PhoneError {
    case unknown
    case batteryLow(String) // 연관값의 타입을 소괄호에 표현
}

let error = PhoneError.batteryLow("배터리가 곧 방전됩니다.")

// 연관값의 추출 (Switch)


switch error {
case .batteryLow(let message):
    print(message)

case .unknown:
print("알 수 없는 에러입니다.")
} // "배터리가 곧 방전됩니다.

익스텐션을 이용해 클래스, 구조체, 열거형 혹은 프로토콜 타입에 기능을 추가할 수 있다.

• 연산 타입 프로퍼티 / 연산 인스턴스 프로퍼티
• 타입 메서드 / 인스턴스 메서드
• 이니셜라이저
• 서브스크립트
• 중첩 타입
• 특정 프로토콜을 준수할 수 있도록 기능 추가

익스텐션은 타입에 새 기능을 추가할 수 있지만 오버라이드는(override)는 할 수 없다.

코드 예시

extension Int {
    var isEven : Bool {
        return self % 2 == 0
    }
    var isOdd : Bool {
        return self % 2 == 1
    }
}

var number = 3
number.isEven // false
number.isOdd // true


extension String {
    func convertToInt () -> Int? {
        return Int(self)
    }
}

var string = "0"

string.convertToInt() // 0 (Int type)

특정 역할을 하기 위한 메서드, 프로퍼티, 기타 요구사항 등의 청사진

• 클래스, 구조체, 열거형 등이 정의한 요구사항을 준수하도록 요구한다.
• 프로토콜을 만족시키는 타입을 프로토콜을 따른다(conform)고 말한다.
• 프로토콜에 필수 구현을 추가하거나 추가적인 기능을 더하기 위해 프로토콜을 확장(extend)하는 것이 가능하다.

코드 예시

protocol SomeProtocol {

}

protocol SomeProtocol2 {

}

struct SomeStructure : SomeProtocol, SomeProtocol2 {

}

class SomeSuperclass {

}

class SomeClass : SomeSuperclass, SomeProtocol, SomeProtocol2 {

}

이와같이 프로토콜을 따르도록 한다.

protocol FirstProtocol {
    var name : Int { get set }
    var age : Int { get } // 읽기 전용
}

protocol AnotherProtocol {
    static var someTypeProperty : Int { get set }
}

protocol FullyNames {
    var fullName : String { get set }
    func printFullName()
}

struct Person : FullyNames {
    var fullName : String
    func printFullName () {
        print(fullName)
    }
}

protocol SomeProtocol3 {
    func someTypeMethod()
}

protocol SomeProtocol4 {
    init(someParameter : Int)
}

protocol SomeProtocol5 {
    init()
}

class SomeClass : SomeProtocol5 {
    required init() { // class에서 생성자 요구사항을 채택하려면 required 키워드가 필요하다. struct는 x

    }
}

• 특정 조건을 체크하고, 조건이 성립되지 않으면 메세지를 출력하게 할 수 있는 함수
• 주로 디버깅 중 조건의 검증을 위하여 사용

guard

• 조건문을 검사하여 그 다음에 오는 코드를 실행할지 말지 결정 하는 것
• guard 문에 주어진 조건문이 거짓일때 구문이 실행됨 -> 방어 코드로 많이 사용

코드 예시

// assert

var value = 0
assert(value == 0)

value = 2
assert(value == 0, "값이 0이 아닙니다.")
 Assertion failed: 값이 0이 아닙니다.


// guard
/*
 guard 조건 else {
  // 조건이 false면 else 구문이 실행되고
 return or throw or break를 통해 이후 코드를 실행하지 않도록 만든다.
 }
 */

func guardTest(value : Int) {
    guard value == 0 else {return} // value가 0이 아닐 경우 코드 종료
    print("안녕하세요")
}

guardTest(value: 0) // 안녕하세요
guardTest(value : 2) // 아무 일도 없었다..


func guardTest2(value : Int?) {
    guard let value = value else {return} // value가 0이 아닐 경우 코드 종료
    print(value)
}

guardTest2(value : 2) // 2
guardTest(value : nil) // 함수가 종료, 

guard문을 활용하면 옵셔널 바인딩된 상수를 조건문 범위 바깥에서도 사용할 수 있다.

인스턴스의 타입을 확인하거나 어떠한 클래스의 인스턴스를 해당 클래스 계층 구조의 슈퍼 클래스나 서브 클래스로 취급하는 방법

서브 클래싱

class MediaItem {
    var name : String
    init(name: String) {
        self.name = name
    }
}

MediaItem 클래스를 서브클래싱 해서 두개의 다른 서브클래스를 만든다.

class Moive : MediaItem {
    var director : String
    init(name: String, director:String){
        self.director = director
        super.init(name: name)
    }
}

class Song : MediaItem {
    var artist : String
    init(name: String, artist: String){
        self.artist = artist
        super.init(name: name)
    }
}

Movie와 Song 클래스를 아이템으로 갖는 library 배열을 선언한다.

let library = [
Movie(name: "Casablanca", director: "Michael Curtiz"),
Song(name: "Blue Suede Shoes", artist: "Elvis Presley"),
Movie(name: "Citizen Kane", director: "Orson Welles"),
Song(name: "The One And Only", artist: "Chesney Hawkes"),
Song(name: "Never Gonna Give You Up", artist: "Rick Astley")
]

형 확인 (Checking Type)

is연산자를 이용해 인스턴스의 타입을 확인 할 수 있다.

var movieCount = 0
var songCount = 0

for item in library {
    if item is Movie {
        movieCount += 1
    } else if item is Song {
        songCount += 1
    }
}

print ("영화 갯수 : \(movieCount), 노래 갯수 : \(songCount)") // 영화 갯수 : 2, 노래 갯수 : 3

다운캐스팅 (Downcasting)

특정 클래스 타입의 상수나 변수는 특정 서브클래스의 인스턴스를 참조하고 있을 수 있다. as?와 as! 연산자를 통해 어떤 타입의 인스턴스인지 확인할 수 있다. as? -> 특정 타입이 맞는지 확신할 수 없을 때 사용 as! -> 특정 타입이 맞는지 확신할 때 사용 (만약 지정한 타입이 아니라면 런타임 에러가 발생하니 주의)

for item in library{
    if let movie = item as? Movie {
        print("영화 제목 : \(movie.name), 감독 : \(movie.director)")
    } else if let song = item as? Song {
        print("노래 제목 : \(song.name), 창작자 : \(song.artist)")
    }
}
/*
영화 제목 : Casablanca, 감독 : Michael Curtiz
노래 제목 : Blue Suede Shoes, 창작자 : Elvis Presley
영화 제목 : Citizen Kane, 감독 : Orson Welles
노래 제목 : The One And Only, 창작자 : Chesney Hawkes
노래 제목 : Never Gonna Give You Up, 창작자 : Rick Astley
*/

클래스가 다른 클래스로부터 프로퍼티나 메소드 등을 상속받는 것 상속받는 클래스 : 자식 클래스, 서브 클래스 상속하는 클래스 : 부모 클래스, 슈퍼 클래스

코드 예시

// base class
class Vehicle {
    var currentSpeed = 0.0
    var description : String {
        return "traveling at \(currentSpeed) miles per hour"
    }
    func makeNoise(){
        print("부아앙아아아아앙")
    }
}

/*
 // sub class
 class 클래스 이름 : 부모클래스 이름 {
   // 하위 클래스 정의
 }
*/

class Bicycle : Vehicle {
    var hasBasket = false
}

var bicycle = Bicycle()

bicycle.currentSpeed = 15.0
bicycle.currentSpeed // 15
bicycle.makeNoise() // in Console : 부아앙아아아아앙

// 오버라이딩 : 서브클래스에서 슈퍼클래스의 기능을 자신만의 기능으로 바뀌는 것
// override 키워드를 사용

class Train : Vehicle {
    override func makeNoise() {
        super.makeNoise() // 슈퍼클래스에서 정의된 것부터 나오고 다음에 오버라이딩 된 특성이 나온다.
        print("추추~~")
    }
}

let train = Train()
train.makeNoise() // 부아앙아아아아앙, 추추~~

class Car : Vehicle {
    var gear = 1
    override var description : String {
        return super.description + " in gear \(gear)"
    }
}

let car = Car()
car.currentSpeed = 30.0
car.gear = 2
print(car.description) // traveling at 30.0 miles per hour in gear 2


class AutomaticCar: Car {
    override var currentSpeed: Double {
        didSet {
            gear = Int(currentSpeed / 10) + 1
        }
    }
}

let automatic = AutomaticCar()
automatic.currentSpeed = 35.0
print("AutomaticCar : \(automatic.description)")
// AutomaticCar : traveling at 35.0 miles per hour in gear 4
// 프로퍼티 옵저버 didSet으로 슈퍼클래스인 Car의 프로퍼티인 gear를 변경한다.


class SomeClass {
    // final 키워드를 사용하면 상속이 불가능해진다.
    final var something : 1
}

• 값을 저장할 프로퍼티를 선언할 수 있다.
• 함수적 기능을 하는 메서드를 선언할 수 있다.
• 내부값에 .을 사용하여 접근할 수 있다.
• 생성자를 사용해 초기 상태를 설정할 수 있다.
• extension을 사용하여 기능을 확장할 수 있다.
• Protocol을 채택하여 기능을 설정할 수 있다.

클래스와 구조체의 차이점

1. 클래스

• 참조 타입
• 할당 또는 파라미터 전달 시에 객체를 가리키고 있는 메모리의 주소 값이 복사
• Heap Memory에 저장되어 속도가 느리다.
• 상속이 가능

2. 구조체

• 값 타입
• 할당 또는 파라미터 전달 시 value copy가 일어남
• Stack Memory에 저장되어 속도가 빠르다.
• 상속이 불가능

코드 예시

class SomeClass {
    var count : Int = 0
}

var class1 = SomeClass()
var class2 = class1
var class3 = class1

class3.count = 2
class1.count // 2 , 참조 타입이기 때문에 복사본과 원본값이 같게 된다.

struct SomeStruct {
    var count : Int = 0
}

var struct1 = SomeStruct()
var struct2 = struct1
var struct3 = struct1

struct2.count = 2
struct3.count = 3

struct1.count // 0
struct2.count // 2
struct3.count // 3 , 값 타입이기 때문에 매번 새로운 메모리가 할당되어서 값을 변경해도 다른 구조체에 영향을 주지 않는다.

클래스, 구조체 또는 열거형 등에 관련된 값 -> 인스턴스의 값

저장 프로퍼티 (클래스, 구조체)

클래스나 구조체에 저장된 값

/ in struct...
struct Pig {
    var name: String
    let gender:String
}

var pig = Pig(name: "꿀꿀이", gender: "수컷")

pig.name = "멧돼지"
// pig.gender = "암컷" // Error : gender가 상수로 선언

// 인스턴스 자체를 상수로 선언했을 때,
let pig2 = Pig(name: "왕돼지", gender: "수컷")
//pig.name = "작은돼지" // Error : 프로퍼티도 모두 상수로 되어서 에러 발생, 구조체는 value 타입이기 때문!

// in Class

class Cow {
    var name:String
    let gender:String

    init(name:String, gender: String) {
        self.name = name
        self.gender = gender
    }
}

let cow = Cow(name: "물소", gender : "수컷")
cow.name = "황소"
print(cow.name) // "황소" 에러가 나지 않는 이유 : Class는 참조 타입라서 가능하다.

연산 프로퍼티 (클래스, 구조체, 열거형)

값을 직접적으로 저장하는 대신에, getter와 setter를 사용해서 다른 프로퍼티에 접근 가능

struct Stock {
    var averagePrice: Int
    var quantity: Int
    var purchasePrice : Int {
        get {
            return averagePrice * quantity
        }

        set(newPrice) {
            averagePrice = newPrice / quantity
        }
    }
}

var stock = Stock(averagePrice: 2300, quantity : 3)

stock.purchasePrice // 6900, 연산 프로퍼티에 접근하면 get 블록 안의 코드가 실행된다.
stock.purchasePrice = 3000
stock.averagePrice // 1000, 연산 프로퍼티의 값이 바뀌면 set 블록 안의 코드가 실행된다.

프로퍼티 옵저버

class Account {
    var credit : Int = 0 {
    // 소괄호로 이름 지정 가능 (default : newValue / oldValue)
        willSet {
            print("변경 예정 : \(newValue)")
        }
        didSet {
            print("변경 전 : \(oldValue)")
        }
    }
}

// willSet - 값이 저장되기 직전에 불리는 옵저버
// didSet - 값이 저장된 직후에 불리는 옵저버

var account = Account()
account.credit = 1000 // 변경 예정 : 1000 , 변경 전 : 0

타입 프로퍼티

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty : Int {
        return 1
    }
}

SomeStructure.computedTypeProperty // 1
SomeStructure.storedTypeProperty // Some value.
SomeStructure.storedTypeProperty = "Daeseong"
SomeStructure.storedTypeProperty // Daeseong

변수에 클래스나 구조체를 할당해 인스턴스 없이도 값에 접근이 가능하다.

다른 글에 정리되어 있습니다.

클래스와 구조체의 정의와 차이점

코드 예시

class 클래스 이름 {
 프로퍼티와 메서드
}

구조체와 거의 동일하다

class Cat {
    var name : String = ""
    var age: Int = 0

    init() {
        // 인스턴스가 생성되면 호출
    }

    func introduce() {
        print("name \(name) age : \(age)")
    }
}


var cat = Cat()
cat.name = "kkakka"
cat.age = 7
cat.introduce() // name kkakka age : 7

다른 글에 정리되어 있습니다.

클래스와 구조체의 정의와 차이점

코드 예시

struct 구조체 이름 {
프로퍼티와 메소드
}

프로퍼티와 메소드를 묶어 멤버라고도 하며, 멤버 변수는 프로퍼티 멤버 함수는 메소드를 의미한다.

// 구조체나 클래스는 카멜케이스로 정의
struct User {
    var nickname: String
    var age: Int

    func information() {
        print("별명은 \(nickname)이고, 나이는 \(age)입니다.")
    }

}

// 인스턴스 생성 - 클래스나 구조체를 사용하기 위해서 메모리에 생성하는 것
// 클래스나 구조체의 실체

var user = User(nickname: "Daeseong", age : 30)

user.nickname // "Daeseong"
user.nickname = "DK"
user.nickname // "DK"

user.information() // 별명은 DK이고, 나이는 30입니다.

프로그램의 코드를 추상화 하기 위해 사용 property와 method를 이용해 구조화된 데이터와 기능을 가질 수 있음

공통점

• 프로퍼티와 메소드를 사용하여 구조화된 데이터와 기능을 가짐
• 새로운 사용자 정의 타입을 만들어줌
• 초기화(Init)를 통해 초기 상태를 설정할 수 있음
• 확장할 수 있음
• 프로토콜 사용이 가능
• 특정 값에 접근할 수 있는 서브스크립트 문법 사용 가능

차이점

1. 클래스

• 참조 타입
• 할당 또는 파라미터 전달 시에 객체를 가리키고 있는 메모리의 주소 값이 복사
• Heap Memory에 저장되어 속도가 느리다.
• 상속이 가능

2. 구조체

• 값 타입
• 할당 또는 파라미터 전달 시 value copy가 일어남
• Stack Memory에 저장되어 속도가 빠르다.
• 상속이 불가능

언제 구조체를 사용해야 할까?

• 연관된 값들의 집합을 캡슐화하는 것이 목적일 경우
• 캡슐화된 값을 참조하는 것보다 복사하는 것이 좋을 때
• 상속이 필요하지 않을때 등등...

초기화 init

클래스 구조체 또는 열거형의 인스턴스를 사용하기 위한 준비 과정

// init
/*
 init(매개변수: 타입, ...) {
    // 프로퍼티 초기화
    // 인스턴스 생성시 필요한 설정을 해주는 코드 작성
 }
 */


class Member {
    var nickname:String
    var age: Int

    init(nickname: String, age: Int) {
        self.nickname = nickname
        self.age = age
    }

    init(age: Int){
        self.nickname = "self"
        self.age = age
    }

    // 인스턴스가 메모리에서 해제될 때 실행, !! 클래스에서만 가능
    deinit {
        print("deinit member")
    }

}

var member = Member(nickname: "DK", age: 30)
member.nickname // "DK"
member.age // 30

var member2 = Member(age: 50) // Member
member2.nickname // "self"
member2.age = 50

// member를 메모리에서 해제시키는 과정, member3가 nil이 될수 있으므로 옵셔널 타입으로 지정
var member3: Member? = Member(age:23)
member3 = nil // In console : deinit member

값이 있을 수도 있고 없을 수도 있다.

지정하는 방법

변수의 타입을 설정할때 ?키워드를 삽입하고, nil을 할당해준다.

var number:Int? = nil
var name:String? = nil

값이 없는 변수에 접근을 하면 다른 언어에서는 일반적으로 런타임 에러가 발생하지만, swift에서 옵셔널로 설정한 변수에는 접근해도 오류가 발생하지 않는다.

• 옵셔널로 선언된 값의 형태

  var optionalName: String? = "Daeseong"
  print(optionalName) // Optional("Daeseong")

  Optional("Daeseong")

• 이처럼 바로 String이 아니라 Optional이라는 포장지에 둘러쌓인 형태로 나온다. 이 변수를 사용하기 위해서는 옵셔널 바인딩이라는 과정이 필요하다.

옵셔널의 해제 방법

1. 명시적 해제

• 강제 해제
• 비강제 해제(옵셔널 바인딩)

2. 묵시적 해제

• 컴파일러에 의한 자동 해제
• 옵셔널의 묵시적 해제

명시적 해제 - 강제해제

옵셔널 해제 연산자 !를 통해 해결할 수 있다.

var number: Int? = 11
print(number) // Optional(11)
print(number!) // 11

강제해제는 만약 값이 nil인 변수를 강제 해제할 경우 오류가 발생하게 되므로 위험하다.

명시적 해제 - 옵셔널 바인딩

if문과 guard문을 통해 바인딩 할 수 있다.

var number: Int? = 3

// if 문
if let result = number {
    print(result)
} else {
    // 값 추출이 실패할 경우
} // 3

// guard 문
func test() {
    let number: Int? = 5
    guard let result = number else { return }
    print(result)
}

test() // 5

묵시적 해제 - 컴파일러에 의한 자동 해제

비교연산자를 이용해서 다른 값이랑 비교하면 컴파일러가 자동으로 해제하게 된다.

let value : Int? = 10

if value == 10 {
    print("value는 10이다")
} else {
    print("Nah..")
}

묵시적 해제 - 옵셔널의 묵시적 해제

let string = "12"
var stringToInt: Int! = Int(string)
print(stringToInt) // Optional(12)
print(stringToInt + 1) // 13

// ? Case...
let string = "12"
var stringToInt: Int? = Int(string)
print(stringToInt)
print(stringToInt + 1) // Error : Value of optional type 'Int?' must be unwrapped to a value of type 'Int'
// 해제가 안되는 것을 볼 수 있다.

string을 Int화시킬 때 string이 숫자가 아닌 경우 nil이 되기 때문에 Optional로 타입을 지정할 필요가 있음 이때 옵셔널 ? 대신 !을 사용하면 옵셔널을 묵시적으로 해제한 상태로 사용할 수 있음.

반복적으로 코드가 실행되게 만드는 구문 swift에서는 for-in, while, repeat-while의 세가지 구문이 있다.

for-in 문

for 루프상수 in 순회대상 {
    // 실행할 구문...
}

// 루프상수는 순회대상에 포함되는 아이템을 넘겨받는다
// 순회대상에는 Array, Dictionary, Set , 범위 데이터, 문자열과 같은 타입을 사용할 수 있다.

// 범위 데이터
for i in 1...4 {
    print(i)
}
//1,2,3,4

// 배열 상수
let array = [1,2,3,4,5]

for i in array {
    print(i)
}
//1,2,3,4,5

while 문

 while 조건식 {
  실행할 구문
 }

var number = 5

while number < 10 {
    number+=1
}

number // 10

repeat while 문

 repeat {
    실행할 구문
 } while 조건식

var x = 6

repeat {
    x+=2
} while x < 5

print(x) // 8 , repeat...while문은 적어도 한번은 실행된다.

주어진 조건에 따라 다르게 동작하도록 하는 것 swift에는 if, switch, guard의 세가지 종류가 있음

if 문

• 사용법

  if 조건식 {
    실행할 구문
  } else if 조건식 2 {
    조건식 2를 만족할 때 실행할 구문
  } else {
    만족하지 않으면 해당 구문 실행
  }
  

  • 예시

    func feedAnimal (animal : String) {
    if animal == "dog" {
        print("강아지 사료주기")
    } else if animal == "cat" {
        print("고양이 사료주기")
    } else {
        print("해당하는 동물 사료가 없음")
    }
    }
    

feedAnimal(animal: "cat") // 고양이 사료주기 feedAnimal(animal: "pig") // 해당하는 동물 사료가 없음

### switch 문    

* 사용법
```swift
switch 비교대상 {
case 패턴1:
    패턴1 일치할 때 실행되는 구문
case 패턴2, 패턴3
    패턴2, 3이 일치할 때 실행되는 구문
default :
    어느 비교 패턴과도 일치하지 않을 때 실행되는 구문
}

• 예시

  func findColor(color : String) {
    switch color {
    case "blue" :
        print("파란색입니다.")
    case "green" :
        print("초록색입니다.")
    case "yellow" :
        print("노란색입니다.")
    default :
        print("찾는 색상이 없습니다.")
    }
  }
  

findColor(color: "blue") // 파란색입니다. findColor(color: "yellow") // 노란색입니다.

// 범위 지정 (...키워드(!!!!편리하다)) func getSeasons (temp : Int) -> String { switch temp { case -20...9: return "겨울 입니다."

case 10...14:
    return "가을 입니다."

case 15...25:
    return "봄 입니다."

case 26...35:
    return "여름 입니다."

default:
    return "이상 기후입니다."
}

}

getSeasons(temp: 20) // "봄 입니다." getSeasons(temp: 200) // "이상 기후입니다."