SWIFT 기초 문법(02) Unwrap, 클래스 vs 스트럭트, 프로퍼티 옵저버, 함수 매개변수, 제네릭, 클로저

Unwrap 옵셔널 변수 

옵셔널이란? 값이 있는지 없는지 모르는 것

var someVariable : Int? = nil

// 값이 비었다. 아직 값을 설정하지 않은 상태 var someVariable : Int?
// 값이 비어있다면 변수에 값을 넣는다.
if someVariable == nil {
    someVariable = 90
}

// 언랩핑이란? 감싸져있는 것을 벗기는 것
if let otherVariable = someVariable {
    print("값이 있다(언래핑 되었다), otherVariable : \(otherVariable)")
} else {
    print ("값이 없다.")
}

someVariable = nil

let myValue = someVariable ?? 10
// someVarible 에 값이 없다면 기본값으로 10을 넣겠다.
print("myValue : \(myValue)") // 출력 - myValue : 10




var firstValue : Int? = 30
var secondValue : Int? = 50

func unwrap(_ parameter: Int?) {
    print("unwrap() called")
    // 값이 없으면 리턴, 즉 지나간다

    guard let unWrappedParam = parameter else {
        return
    }
    print("unWrappedParam: \(unWrappedParam)")
}


// 출력 값에 Optional을 없애고 싶다면
unwrap(firstValue) // unWrappedParam: 30
unwrap(secondValue) // unWrappedParam: 50

print("firstValue: \(firstValue)") // firstValue: (Optional(30)
print("secondValue: \(secondValue)") // secondValue: (Optional(50)

 

Unwrap옵셔널변수란?

• 옵셔널 변수에서 값을 추출하여 사용하는 것
• 옵셔널 변수는 값이 존재할 수도 있고, 존재하지 않을 수도 있는 변수, 따라서 옵셔널 변수에 직접적으로 접근하여 사용하는 것은 안전하지 않다. 대신 옵셔널 변수에서 언랩핑(Unwrapping)을 사용해 값을 추출하여 사용하면 된다.
• 언랩핑은 옵셔널 변수에 접근하여 값이 존재할 경우 그 값을 추출하는 작업을 말함. 단, 이 과정에서 옵셔널 변수가 값이 없는 경우(즉, nil인 경우)에 대비하여 안전하게 처리해야 한다. 옵셔널 바인딩(if let, guard let)이나 강제 언랩핑(!)을 사용하여 옵셔널 변수를 언랩핑할 수 있다.
• 따라서 "Unwrap 옵셔널 변수"란 옵셔널 변수에 안전하게 접근하여 값을 추출하는 작업을 의미한다. 옵셔널 변수를 사용할 때 발생할 수 있는 런타임 에러를 방지할 수 있다.

 

클래스 vs 스트럭트

// 구조체 (Struct)
struct YoutuberStruct {
    var name: String
    var subscribersCount: Int
}

var devJeong = YoutuberStruct(name: "jeongDaeRi", subscribersCount: 99999)
var devJeongClone = devJeong

print("devJeongClone.name : \(devJeongClone.name)") // 출력: devJeongClone.name : jeongDaeRi
devJeongClone.name = "hoho"

// 값 복사이기 때문에 둘의 값이 다릅니다.
print("struct - devJeongClone.name : \(devJeongClone.name)") // 출력: struct - devJeongClone.name : hoho
print("struct - devJeong.name : \(devJeong.name)") // 출력: struct - devJeong.name : jeongDaeRi

// 클래스 (Class)
class Youtuber {
    var name: String
    var subscribersCount: Int
    
    init(name: String, subscribersCount: Int) {
        self.name = name
        self.subscribersCount = subscribersCount
    }
}

var jeongDaeRi = Youtuber(name: "jeongDaeRi", subscribersCount: 9999999)
var me = jeongDaeRi
print("class - me.name : \(me.name)") // 출력: class - me.name : jeongDaeRi
me.name = "hoho"

// 서로 연결되어있기 때문에 (참조) 둘다 값이 변경됩니다.
print("class - me.name : \(me.name)") // 출력: class - me.name : hoho
print("class - jeongDaeRi.name : \(jeongDaeRi.name)") // 출력: class - jeongDaeRi.name : hoho

 

프로퍼티 옵저버

var myAge = 0 {
    willSet {
        print("값이 설정될 예정이다. / myAge: \(myAge)")
    }
    didSet {
        print("값이 설정되었다. / myAge: \(myAge)")
    }
}

myAge = 20
print("myAge: \(myAge)")

 

프로퍼티 옵저버란?

• 특정 프로퍼티의 값이 변경될 때 실행되는 코드 블록
• willSet: 프로퍼티의 값이 변경되기 직전에 호출되는 옵저버, 새로운 값이 파라미터로 제공됨
• didSet:  프로퍼티의 값이 변경된 직후에 호출되는 옵저버, 이전 값이 파라미터로 제공됨
• 주로 프로퍼티의 값이 변경될 때 특정 동작을 수행하거나 다른 프로퍼티와의 연관 관계를 유지하기 위해 사용

 

함수 매개변수

// 함수, 메소드 정의
// 함수 호출 시 매개변수 이름 name
func myFunction1(name: String) -> String {
    return "안녕하세요. \(name) 입니다."
}

print(myFunction1(name: "Wood"))
// 출력: 안녕하세요. Wood입니다.



// 함수 호출 시 매개변수 이름 myName
func myFunction2(myName name: String) -> String {
    return "안녕하세요. \(name) 입니다."
}

print(myFunction2(myName: "myName Wood"))
// 출력: 안녕하세요. myName Wood입니다.



// 함수 호출 시 매개변수 이름 없음
func myFunction3(with name: String) -> String {
    return "안녕하세요. \(name) 입니다."
}
// or
func myFunction3(_ name: String) -> String {
    return "안녕하세요. \(name) 입니다."
}

print(myFunction3("개발자 Wood"))
// 출력: 안녕하세요. 개발자 Wood입니다.

 

 

함수 매개변수란?

• 매개변수(Parameter): 함수 정의 시 입력을 받기 위해 사용되는 변수
• 매개변수는 함수의 괄호 안에 정의되며, 함수의 동작에 필요한 입력값을 저장됨  
• 함수를 호출할 때 전달되는 실제 값은 매개변수에 저장됨 
• 매개변수의 이름은 함수 내부에서 사용, 함수의 호출 시 해당 이름과 함께 값을 전달 

 

제네릭

struct Friend {
    var name: String
}

// 제네릭 <T>
// 제네릭으로 어떤 자료형이 들어올 수 있도록 설정
struct myName<SomeElement> {
    // 멤버변수
    var elements = [SomeElement]()

    // 생성자 메소드
    // _ 앞에 언더바를 넣음으로서 매개변수 이름 생략
    init(_ elements: [SomeElement]) {
        self.elements = elements
    }
}

var myIntegerArray = MyArray([1, 2, 3])
print("myIntegerArray : \(myIntegerArray)")

var myStringArray = MyArray(["가", "나", "다"])
print("myStringArray : \(myStringArray)")

let firstFriend = Friend(name: "철수")
let secondFriend = Friend(name: "영희")
let thirdFriend = Friend(name: "수잔")

var myFriendsArray = MyArray([firstFriend, secondFriend, thirdFriend])
print("myFriendsArray: \(myFriendsArray)")

 

제네릭이란?

• 제네릭은 코드의 재사용성을 높이기 위해 사용되는 개념
• 함수, 구조체, 클래스, 열거형 등에서 일반적인 형식을 사용하여 코드를 작성할 수 있음 
• 특정한 데이터 타입에 종속되지 않고, 다양한 데이터 타입에 대해 일반적인 기능 수행
• 코드의 유연성과 안정성을 높일 수 있음 

 

클로저

// String을 반환하는 클로저
let myName : String= {
    // myName 으로 들어간다.
    return"정대리"
}()
print (myName)

var yourName : String {
    return "호호할머니"
}
print (yourName)

// 매개변수를 가지고 String 으로 반한하는 클로져
let myRealnamestring = { (nane: String) -> String in
    return "개발하는 1(name)"
}
print(myRealNameString("정대리"))

// 클로저 가 print 로직을 담고 있다
let name = 1
print ("정대리")
name()

// 클로저가 매개변수를 가지며 아래 로직을 담고 있다
let myRealName = { (name: String) in
    print("개발하는 1(name)")
}
myRealName ("정대리")