iOS 3주차 수업 내용 및 수업 후 과제

let은 초기값이 반드시 있어야 하는것은 아니다.

 

#튜플

튜플은 소괄호를 사용한다.

let myTuple = (10, 12.1, "Hi")
var myString = myTuple.2
print(myTuple, myTuple.0)

배열은 대괄호([])를 사용한다. 

_는 값을 무시할 수 있다.

 

튜플은 시험에 많이 내기때문에 집중적으로 봐야한다.

let myTuple = (count: 10, length: 12.1, message: "Hi") //myTuple의 자료형?
print(myTuple.message, myTuple.2) //과제 : 실행 결과

 

void는 빈 튜플

 

✅ 튜플의 특징

여러 타입 저장 가능

let person = ("홍길동", 25, true) 
// (String, Int, Bool)


인덱스로 접근

print(person.0) // "홍길동"
print(person.1) // 25
print(person.2) // true


요소에 이름 지정 가능

let person = (name: "홍길동", age: 25, isStudent: true)
print(person.name)      // "홍길동"
print(person.age)       // 25
print(person.isStudent) // true


변수 해체(Destructuring)

let (name, age, student) = person
print(name)   // "홍길동"
print(age)    // 25
print(student) // true


함수 반환값으로 활용

func getUserInfo() -> (String, Int) {
    return ("이수환", 22)
}

let user = getUserInfo()
print(user.0) // "이수환"
print(user.1) // 22

 

#옵셔널

 

그냥 int형은 반드시 값이 있어야 하고 

옵셔널 int형은 값이 있을 수도 있고 없을수도 있다

스위프트에서 값이 없다는 의미로 nil이라고 한다.

?은 값이 있을수도 있고 없을수도 있지만 !는 반드시 값이 있어야한다.

 

 

print(Int("hi")) //nil
print("123") //123

hi는 정수형으로 바꿀수가 없어 nil이 나오고 string 123은 정수형으로 바꿀수 있어서 123이라고 값이 나온다.

옵셔널 변수는 초기값을 주지 않으면 nil이 나온다

선언문에 ?나 !가 있으면 옵셔널 변수가 된다.

 

 

#강제 언래핑

 

var x : Int? // 옵셔널 정수형 변수 x 선언 (값이 있을 수도 있고, 없을 수도 있음)
var y : Int = 0 // 일반 정수형 변수 y 선언 (값이 무조건 있어야 함)

x = 10 // x에 값 10을 저장 (옵셔널이므로 내부적으로는 Optional(10) 형태로 저장됨)

// 만약 위의 x = 10 을 주석 처리하면 x는 아직 nil 상태가 됨
// nil 상태에서 x! 를 쓰면 강제 언래핑이므로 실행 중 에러 발생

print(x)  
// 그냥 출력하면 "Optional(10)" 이라고 표시됨
// print()는 Any 타입을 받는데, 옵셔널(Int?)가 자동 변환되면서
// "Optional(...)" 형식으로 출력됨 (경고 메시지가 뜨기도 함)

print(x!) 
// 느낌표(!)를 붙여서 강제로 꺼내면 Optional이 벗겨지고 실제 값 10이 출력됨

print(y) 
// y는 일반 정수형이므로 그냥 0이 출력됨

// x = x! + 2
// 오른쪽: x! = 10 → 10 + 2 = 12
// 하지만 대입하려고 하면 왼쪽 x는 Int? (옵셔널)이기 때문에
// 다시 Optional(12) 형태가 되며 타입 충돌 에러가 발생함

// y = x!
// x가 Optional(10)이라면, y에 바로 대입할 수 없음
// Int? 타입은 Int 타입과 다르기 때문 (강제 언래핑을 해주면 가능)

y = x! // 올바른 사용법 → x! 로 강제 언래핑하면 Int가 되어 y에 대입 가능
print(y) // 10 출력

옵셔널에 래핑된 값을 푸는 가장쉬운 방법은 !을 사용하는것인데 추천하지는 않는다.

 

var x : Int?
x = 10
if x != nil {
    print(x!)
}
else {
    print("nil")
}

 

조건식 쓸때 주의점

주의 :
if x!=nil //if x! = nil의 의미, if x != nil 아님
이라고 쓰면 안됨
error: 'nil' cannot be assigned to type 'Int'
// '!'은 '=' 보다 우선 순위 높음
//반드시 '!=' 양쪽에 공백을 넣어야 함

 

optional binding(가장중요)

 

첫번째 방법

var x : Int?
x = 10
if let xx = x { //옵셔널 변수 x가 값(10)이 있으므로 언래핑해서 일반 상수 xx에 대입하고 if문 실행
print(x,xx)
}
else {
print("nil")
}

두번째 방법

var x : Int?
x = 10
if let x = x { //옵셔널 변수 x가 값(10)이 있으므로 언래핑해서 일반 상수 xx에 대입하고 if문 실행
print(x)
}
else {
print("nil")
}

3번째 방법

var x : Int?
x = 10
if let x { //옵셔널 변수 x가 값(10)이 있으므로 언래핑해서 일반 상수 xx에 대입하고 if문 실행
print(x)
}
else {
print("nil")
}

 

• if let newName = name { ... }
  → 새로운 변수(newName)를 만들어서 언래핑
• if let name { ... }
  → 같은 이름(name)으로 언래핑 (short form)

 

 

이 3가지는시험에 많이 나옴

 

var pet1: String?
var pet2: String?
pet1 = "cat"
pet2 = "dog"
if let firstPet = pet1, let secondPet = pet2 {
    print(firstPet, secondPet)
} else {
    print("nil")
}

 

if는 1개만 쓰지만 let은 ,할때마다 써줘야한다

 

 

시험에 자주 나오는 내용 if문 여러개를 1개의 if문으로 합치기

var x : Int?
var y : Int?
x = 10
y = 20
if let x = x,let y = y{
    print(x,y)
}
else{
    print("lililil")
}

 

var x : Int?
var y : Int?
x = 10
y = 20
if let x,let y{
    print(x,y)
}
else{
    print("lililil")
}

 

옵셔널 변수에 대한 예제와 설명

// 1. 옵셔널 변수 선언
var number: Int? = 10  
// Int? → 값이 있을 수도(nil) 없을 수도 있는 정수형

// 2. 그냥 출력
print(number)  
// 결과: Optional(10)
// 이유: 옵셔널 변수라서 값이 "Optional(...)" 형태로 출력됨

// 3. 강제 언래핑 (Forced Unwrapping)
print(number!)  
// 결과: 10
// !를 붙이면 옵셔널을 강제로 벗기고(Int) 값만 꺼냄
// ⚠️ 만약 number = nil 이라면 실행 중 에러 발생

// 4. 옵셔널 바인딩 (if let) → 안전하게 언래핑
if let value = number {
    print("옵셔널 바인딩 성공: \(value)")  
    // number에 값이 있어서 value에 안전하게 할당됨
} else {
    print("옵셔널에 값이 없습니다.")
}

// 5. 옵셔널 변수를 nil 로 바꿔보기
number = nil

// 다시 강제 언래핑하면 에러 발생 → 주석 처리해야 안전
// print(number!)  // Fatal error 발생!

// 대신 옵셔널 바인딩을 사용하면 안전하게 처리 가능
if let value = number {
    print("값: \(value)")
} else {
    print("값이 없어서 nil 상태입니다.")  
}

 

✅ Int? vs Int! 차이(매년 시험에 나오는 내용)

 

선언 방식	var x: Int?	var x: Int! (implicitly unwrapped)
값	정수 또는 nil 저장 가능	정수 또는 nil 저장 가능
사용 시	항상 언래핑 필요 (if let, !, ??)	자동으로 언래핑됨 (마치 일반 Int처럼 사용 가능)
안전성	안전 → nil 체크 안 하면 컴파일 시 경고	위험 → nil인데 접근하면 런타임 에러
주로 쓰는 곳	값이 있을지 없을지 모르는 변수	UIKit 등에서 초기화 시점에는 nil이지만 이후에는 반드시 값이 들어올 변수
예시	swift var a: Int? = 10 print(a!) // 10	swift var b: Int! = 10 print(b) // 10

---

📌 예제 코드

 

var a: Int? = 10      // 일반 옵셔널
var b: Int! = 20      // 암시적 추출 옵셔널

print(a)   // Optional(10)
print(a!)  // 10 → 강제 언래핑 필요

print(b)   // 20 → 자동 언래핑, 그냥 Int처럼 사용 가능

 

⚠️ 만약 a = nil 이고 print(a!) 하면 에러 발생
⚠️ 만약 b = nil 이고 print(b) 해도 똑같이 에러 발생

---

👉 정리하자면:

• Int? → 항상 안전하게 처리해야 함 (추천)
• Int! → 특별한 경우에만 사용 (예: iOS IBOutlet)

왠만하면 자동으로 옵셔널은 푼다

 

✅ 첫 번째 부분: Int?

 

let x : Int? = 1       // x는 Optional<Int>, 즉 값이 있거나(nil) 없을 수 있는 정수
let y : Int = x!       // x를 강제 언래핑(!) 해서 일반 Int로 y에 대입
let z = x              // 타입 추론에 의해 z도 Optional<Int>

print(x,y,z)           // 출력: Optional(1) 1 Optional(1)

• x 자체를 찍으면 Optional(1)
• y는 x!로 언래핑했으므로 1
• z는 그냥 x를 넣었으니 Optional(1)

 

print(type(of:x), type(of:y), type(of:z))
// 출력: Optional<Int> Int Optional<Int>

👉 정리:

• x → Optional<Int>
• y → Int
• z → Optional<Int>

---

✅ 두 번째 부분: Int! (암시적 추출 옵셔널)

 

let a : Int! = 1       // a는 Implicitly Unwrapped Optional (자동 언래핑 가능한 옵셔널)
let b : Int = a        // a를 Int로 대입하면 자동으로 언래핑되어 1이 들어감
let c : Int = a!       // 강제 언래핑해도 결과는 같음 → 1
let d = a              // 타입 추론 시에는 Optional<Int> 로 취급됨
let e = a + 1          // 연산을 위해 자동으로 언래핑됨 → 1 + 1 = 2

 

---

print(type(of:x), type(of:y), type(of:z))
// 출력: Optional<Int> Int Optional<Int>

• a → Optional(1) (타입 자체는 Int!인데 출력하면 Optional 표시)
• b → 1 (자동 언래핑됨)
• c → 1 (강제 언래핑했으므로 Int)
• d → Optional(1) (타입 추론 시 옵셔널로 유지)
• e → 2 (연산할 때 자동 언래핑됨)

---

 

print(type(of:a), type(of:b), type(of:c), type(of:d), type(of:e))
// 출력: Optional<Int> Int Int Optional<Int> Int

👉 정리:

• a → Optional<Int> (실제 내부 타입은 암시적 추출 옵셔널이지만 런타임 표현은 Optional<Int>)
• b → Int
• c → Int
• d → Optional<Int>
• e → Int

---

📌 전체 요약

1. Int? (옵셔널) → 항상 언래핑(!, if let, ??)을 해줘야 일반 Int처럼 쓸 수 있음.
2. Int! (암시적 추출 옵셔널) → 필요할 때 자동으로 언래핑됨.
   • 하지만 여전히 Optional 특성은 있어서 그냥 대입하면 Optional로 남기도 함.
3. 연산(a + 1)이나 대입(let b: Int = a) 같은 경우에는 자동 언래핑.
4. 그냥 다른 변수에 대입(let d = a)하면 타입 추론에 의해 Optional로 처리됨.

시험공부할 때는 옵셔널이 가장 많이 나오고 가장 많이 공부해야되는 부분이다.

 

Any

• Any는 모든 타입을 담을 수 있는 타입이다.
• 기본 타입(Int, String, Double), 구조체, 열거형, 클래스, 함수까지 모두 가능하다.
• 값이 어떤 타입인지 알 수 없으므로, 실제 사용할 때는 type(of:)로 타입을 확인하거나 캐스팅이 필요하다.

 

AnyObject(protocol)

• Swift에서 AnyObject는 클래스 타입(객체)만 담을 수 있는 타입이다.
• 구조체(struct), 열거형(enum), 기본 타입(Int, String 등)은 사용할 수 없다.

스위프트에서 가장 많이 사용하는 연산자

 

옵셔널 변수의 대입연산자 사용법

 

 

스위프트에서는 ++과 --를 지원하지 않는다.

 

비교연산자는 거의 똑같지만 ==은 값이 같은지 비교하는것이고 ===는 메모리의 주소가 같은지 비교하는 것이다.

 

시험에 자주나옴

 

시험에 무조건 나오는 내용

 

 

옵셔널을 푸는 2가지 방식을 제공하고 있다.

Coalesce 방식과 !를 사용하여 강제로 푸는 방법 2가지 제공중이다.

 

마지막을 제외한 여태까지 욥셔널 언래핑하는 방법들

 

자식에서 부모 클래스로 가는것을 업캐스팅 이라고 하고  as를 사용한다.

부모에서 자식으로 가는 것을 다운캐스팅이라고 하고 as! 또는 as?를 사용한다.

 

타입검사하는 is 연산자