20250915_iOS_3

2주차

1. 타입 어노테이션 (Type Annotation)

• 프로그래머가 명시적으로 자료형을 지정하는 방식입니다.
• 변수나 상수를 선언할 때 : 기호를 사용해 타입을 지정

let name: String = "Choi"
var age: Int = 27

//변수나 상수의 초기값을 반드시 지정해야 하는 것은 아님

2. 타입 추론 (Type Inference)

• Swift 컴파일러가 초기값을 보고 자동으로 자료형을 추론하는 방식입니다.
• 타입을 따로 지정하지 않아도 초기값의 형태를 기준으로 타입이 결정

let city = "Seoul"   // 컴파일러가 String으로 추론
var score = 95       // 컴파일러가 Int로 추론
var pi = 3.14        // 컴파일러가 Double로 추론

3. 튜플(Tuple)

//중간문제
let myTuple = (10, 12.1, "Hi")
var myString = myTuple.2 print(myTuple, myString)

튜플(Tuple)
튜플은 Swift에서 가장 강력한 기능 중 하나
Python, TypeScript, C#, Rust 등에서도 지원
여러 값을 하나의 개체에 일시적으로 묶는 방법
괄호 안에 콤마로 구분된 타입들의 리스트 튜플에 저장되는 항목들은 어떠한 타입도 될 수 있으며, 동일한 타입일 필요도 없음
let myTuple = (10, 12.1, "Hi") //tuple 

let oddNumbers = [1, 3, 5, 7, 9] // Array

특정 튜플 값은 인덱스 위치를 참조하면 간단하게 접근

맨 첫 번째 값은 인덱스 0
인덱스 2 위치를 추출하고, 그 값을 문자열 변수 myString에 할당
 let myTuple = (10, 12.1, "Hi")
var myString = myTuple.2 print(myTuple, myString)
//출력되는 값은?
HSH, Induk University
24 튜플(Tuple) 실습

단 한 줄의 코드로 튜플의 모든 값을 추출하여 변수 또는 상수에 할당

let myTuple = (10, 12.1, "Hi") //myTuple의 자료형?, print(type(of:myTuple)) let (myInt, myFloat, myString) = myTuple

튜플의 값을 선택적으로 추출할 수 있으며, 무시하고 싶은 값에 밑줄을 사용하면 그 값은 무시 

var (myInt, _, myString) = myTuple //12.1 무시 

튜플을 생성할 때 각 값에 이름을 할당할 수도 있음

let myTuple = (count: 10, length: 12.1, message: "Hi") //myTuple의 자료형?

튜플에 저장된 값에 할당된 이름은 각 값을 참조하는 데 사용 myTuple 인스턴스의 message 값을 출력하는 코드 

print(myTuple.message, myTuple.2) //과제 : 실행 결과

튜플의 가장 강력한 점은 함수에서 여러 값들을 한 번에 반환하는 것

Void는 빈 튜플(empty tuple)
typealias Void = () //아무 내용도 없는 튜플, typealias 새로운자료형명 = 기존자료형명 

반환값이 없는 함수의 자료형

 

---

3주

1. 옵션 타입 (Option Type)

var y : Int? = 10 
var z : Int! = 10
//10일수도 값이 없는 nil일수도 있다
//출력시 Optional(10)
//바로 연산 불가능한 자료형
//nil은 null과는 달리 값 자체가 아예 없음을 의미함
//like 원자, like 슈뢰딩거스 고양이

var x : Int
print(x)
>>>error

var x : Int?
print(x)

>>>nil

변수나 상수가 값을 아예 갖지 못할 경우를 대비한?

 

1.1 강제 언래핑(forced unwrapping)

옵셔널형 선언 : 자료형 뒤 ? 

옵셔널 언래핑 : 변수명 뒤 !

var x : Int? //옵셔널 정수형 변수 x 선언
var y : Int = 0
x = 10 // 주석처리하면?
//print(x) // Optional(10)

//print(x!) // forced unwrapping해서 10이 나옴

if x != nil {
    print(x!)
}//띄어쓰기 주의 x!=nli, x != nil, x !=10
//x != nil

var x : Int? //옵셔널 정수형 변수 x 선언 
var y : Int 
//x = 10 // 주석처리하면?
print(x) // Optional(10)

print(x!) // forced unwrapping해서 10이 나옴

잘못된 사용으로 크래시 발생 가능

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

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

1.2 옵셔널 바인딩(forced binding)

****************************** 중간고사 문제의 20% ********************************

var x : Int? 
var y : Int?

x = 10, y = 20

if let xx = x {
print(xx)
} 
else { print("nil") 
}

if let yy = y {
print(yy)
}
else { 
print("nil")
}

var x : Int?
x = 10
if let xx = x {
print(x,xx) } else {
print("nil") } var x1 : Int?

//옵셔널 변수 x가 값(10)이 있으므로 언래핑해서 일반 상수 xx에 대입하고 if문 실행
//Swift 5.7부터는 if let x 라고 써도 됨 
//short form of if-let to the Optional Binding

if let xx = x1 {
print(xx) } else {
print("nil") }

여러 옵셔널을 언래핑

var pet1: String? 
var pet2: String?

pet1 = "cat"
pet2 = "dog"

if let firstPet = pet1, let secondPet = pet2 { 
print(firstPet, secondPet) 
} else {
print("nil") 
}

과제 : 위 소스를 short form of if-let to the Optional Binding으로 변경

var pet1: String? 
var pet2: String?

pet1 = "cat"
pet2 = "dog"
//-----------------------------
if let pet1, let pet2 {
    print(pet1, pet2)
} else {
    print("nil")
}

과제 : short form of if-let to the Optional Binding으로도 변경

var x : Int? 
var y : Int?

x = 10
y = 20

if let xx = x {
print(xx)
} 
else { 
print("nil") 
}

if let yy = y {
print(yy)
} 
else { 
print("nil") 
}

//과제 : short form of if-let to the Optional Binding으로도 변경

//~ ~ ~

if let x {
    print(x)
} else {
    print("nil")
}

if let y {
    print(y)
} else {
    print("nil")
}

2. 암묵적인 언래핑(implicitly unwrapped)

let x : Int? = 1 
let y : Int = x!
let z = x 

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

let a : Int! = 1 //Implicitly Unwrapped Optional 
let b : Int = a //일반 상수로 사용할 수 있으면 a를 자동으로 언래핑함 
let c : Int = a! //물론 강제언래핑해도 됨 
let d = a //Optional로 사용될 수 있으므로 Optional형임 
let e = a + 1 //1과 더하려면 a를 일반형으로 자동으로 언래핑함 

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

//작년 시험 문제
var x : Int?
var y : Int!

//위 두 문장의 공통점과 차이점을 표로 정리해줘
//위 문제의 개념을 쉽게 설명하고 이 개념을 활용한 예상 시험문제들을 정리해줘

잘 안쓰이는 개념

 

Any와 AnyObject
AnyObject(protocol)
- 모든 클래스 타입(객체)만 표현할 수 있음

- 구조체(struct), 열거형(enum), 기본 타입(Int, String 등)은 사용할 수 없음
Any
- 모든 타입(Int, String, Double, dtruct, enum, class, 함수 등)의 값을 표현할 수 있는 타입 

- 클래스(class), 구조체(struct), 열거형(enum), 함수 타입도 가능

class Dog {} 
class Cat {} 
let dog = Dog() 
let cat = Cat() 
var o1: AnyObject = dog 
var o2: AnyObject = cat
//------------------------------
var x: Any = "Hi" print(x, type(of:x))

x=10
print(x, type(of:x))
x=3.5
print(x, type(of:x))
//type을 검사해서 사용

---

3. 연산자(operator)

 

자주 사용하는 연산자

 

1. 대입 =
2. 산술 +, -, *, /, %
3.복합 대입 +=, -=, *=, /=, %=
4. 비교 ==, !=, <, <=, >, >=
5. 논리 &&, ||, !
6. 옵셔널 ?, !, ??

ㄴ ?는 옵셔널 선언, !는 강제 언래핑, ??는 nil 병합 연산자
7. 범위 연산자 (..., ..<)
ㄴ ...는 닫힌 범위, ..<는 반열린 범위

---

대입 연산자

• var x: Int?        // 옵셔널 Int 변수를 선언함
• var y = 10         // 일반 Int 변수를 선언하고 초기화함
• x = 10             // 값을 x에 할당함
• print(x)           // Optional(10)

• //옵셔널 변수에 일반값을 할당해도 옵셔널 값으로 저장됨
• x = x! + y         // 10+10 결과를 x에 할당함
• print(x)           // Optional(20)

• x = y              // y의 값 10을 x에 할당함
• print(x)           // Optional(10)

---

산술 연산자

-(단항)

*

/

+

-

%

---

---

증가, 감소 연산자

 

x = x + 1 // x 변수의 값을 1 증가시킴, x+=1 

x = x - 1 // x 변수의 값을 1 감소시킴, x-=1 

위의 표현식은 x의 값을 1 증감 

이러한 방법 대신 ++ 연산자와 --연산자를 사용할 수도 있었음
x++ // x를 1 증가시킴, Swift 3에서 없어짐, x+=1나 x=x+1을 사용

x-- // x를 1 감소시킴, Swift 3에서 없어짐, x-=1나 x=x-1을 사용

var x: Int = 1 

x++  /

/error: cannot find operator '++' in scope; did you mean '+= 1'?

---

범위 연산자

for i in 1...5 { 
print(i) 
} 
for i in 1..<5 {
print(i, terminator:" ") 
}

닫힌 범위 연산자(closed range operator)
x...y

   x에서 시작하여 y로 끝나는 범위에 포함된 숫자

5…8
   5, 6, 7, 8

반 열린 범위 연산자(half-open range operator)
x..<y

   x부터 시작하여 y가 포함되지 않는 모든 숫자

5..<8
   5, 6, 7

for i in 1...5 { print(i) } for i in 1..<5 {
print(i, terminator:" ") }
One-Sided Ranges

 let names = ["A", "B", "C", "D"]
for name in names[2...] { //[...2], [..<2] //과제: 실행 결과 
print(name) 
} // C 
// D

과제

*** nil-coalescing operator (nil병합연산자) ?? ***

 

let defaultAge = 1 
var age : Int?
age = 3
print(age) //과제:값은?
var myAge = age ?? defaultAge
//age가 nil이 아니므로 언래핑된 값이 나옴
print(myAge) //과제: 값은?
var x : Int? = 1 
var y = x ?? 0 
print(y)

과제 : Opptional(3), 3

var x : String? = "Hi" 
// = "Hi" 지우고도 실습 
print(x, x!) 
if let a = x { 
print(a) 
} 
let c = x ?? "" 
print(c) 
/*
이 방법이 더 쉬운데 x가 nil이면
crash 위험이 있어서 비추
*/
let b = x!.count 
print(type(of:b),b)
/*
optional chaining 결과가 옵셔널로 나와서 번거롭지만 안전
(x가 nil이면 문장의 결과가 nil로 나옴) 하기 때문에 추천 
이 문장의 반환값은 다시 한번 옵셔널 언래핑(바인딩) 해야 함
*/
let b1 = x?.count 
print(type(of:b1),b1, b1!)

***객체지향 언어에서 중요시되는 개념

타입검사 ㅑㄴ

타입 검사(type check)
let x = 1
if x is Int {

print("Int!")

}

객체가 MyClass라는 이름의 클래스의 인스턴스인지 검사
  인스턴스가 해당 클래스인가?
  인스턴스 is 클래스

class A {} 

let a = A()

if a is A{ 

print("Yes")

 }

---

4. 제어문 (Control Flow)

for문
조건-증가(condition-increment) for 문 (지금은 지원하지 않음) ->   for-in 반복문

for 문 다음의 실행 코드가 한 줄이라도 괄호({})를 필수적으로 사용

ㄹ

dictionary의 항목 접근

let numberOfLegs = ["거미": 8, "개미": 6,"개": 4] 
//dictionary는 key:value형식의 배열
for (animalName, legCount) in numberOfLegs { 
print("\(animalName)는 \(legCount)개 다리") }
/*
개는 4개 다리
거미는 8개 다리
개미는 6개 다리
*/

while 반복문

- for 반복문은 몇 번 반복해야 할지 아는 경우에 적합 

- 조건이 만족하면 작업을 반복해야 하는 경우 while문 사용 

- 지정된 조건을 만족할 때까지 작업을 반복

var myCount = 0 
while myCount < 1000 { 
myCount+=1 
} 
print(myCount) //결과는?
//1000

repeat ~ while 반복문

- repeat … while 반복문 블럭은 적어도 한번은 실행

var i = 5
repeat {
i=i-1
print(i) 
//출력 결과 
} while (i > 0)

 

***시험 빈출 ***

반복문에서 빠져나오기(break)
반복문이 완료되는 조건 전에 반복문을 빠져나오기
특히 무한 루프를 생성할 경우
현재의 반복문에서 빠져나와서 반복문 바로 다음에 있는 코드를 실행

for i in 1..<10 { 
if i > 5 break 
//중요!! 에러 수정 과제: error: expected '{' after 'if' condition 
//if 문 다음의 실행 코드가 한 줄이라도 괄호({})를 필수적으로 사용 
print(i) 
}

/*
if i > 5 {break} 
*/

 

continue문
continue 문은 반복문에서 continue문 이후의 모든 코드를 건너뛰고 반복문의 상단 시작 위치로 돌아감

for i in 1...10 { 

if i % 2 == 0 {

continue 

} 

print(i) 

}