Ver3.0 ๐ Swift ํ๋ก๊ทธ๋๋ฐ ์ฒ ํ๊ณผ ์ธ์ด ์ค๊ณ ์์น ์ดํด

๐ Swift ํ๋ก๊ทธ๋๋ฐ ์ฒ ํ๊ณผ ์ธ์ด ์ค๊ณ ์์น ์ดํด
์ ํ์ด ๋ง๋ ํ๋์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ฒ ํ์ ํํค์ณ๋ณด์! ๐ฏ
๋ง์ ๊ฐ๋ฐ์๋ค์ด Swift์ ๋ฌธ๋ฒ์ด๋ ๊ธฐ๋ฅ์๋ง ์ง์คํ๋๋ฐ, ์ฌ์ค Swift๋ฅผ ์ ๋๋ก ์ดํดํ๋ ค๋ฉด ๊ทธ ๋ฐ๋ฐํ์ ๊น๋ฆฐ ์ฒ ํ๊ณผ ์ค๊ณ ์์น์ ์์์ผ ํด. ๋ง์น ๊ฑด์ถ๋ฌผ์ ์ดํดํ๋ ค๋ฉด ๊ฒ๋ชจ์ต๋ฟ๋ง ์๋๋ผ ์ค๊ณ ์๋์ ๊ตฌ์กฐ ์๋ฆฌ๋ฅผ ์์์ผ ํ๋ ๊ฒ์ฒ๋ผ ๋ง์ด์ผ! ๐๏ธ
๐จ Swift์ ํต์ฌ ์ค๊ณ ์ฒ ํ
Swift์ ์ค๊ณ ์ฒ ํ์ ํฌ๊ฒ ๋ค ๊ฐ์ง ๊ธฐ๋ฅ ์์ ์ธ์์ ธ ์์ด. ์ด ๋ค ๊ฐ์ง๋ ์๋ก ๊ธด๋ฐํ๊ฒ ์ฐ๊ฒฐ๋์ด ์์ผ๋ฉด์๋ ๊ฐ๊ฐ ๋ ๋ฆฝ์ ์ธ ๊ฐ์น๋ฅผ ์ง๋๊ณ ์์ง.๐ก๏ธ ์์ ์ฑ (Safety)
ํ๋ก๊ทธ๋๋ฐ ์ค๋ฅ๋ฅผ ์ปดํ์ผ ํ์์ ์ต๋ํ ์ก์๋ด์๋ ์ฒ ํ์ด์ผ. ๋ฐํ์ ํฌ๋์๋ณด๋ค๋ ์ปดํ์ผ ์๋ฌ๊ฐ ํจ์ฌ ๋ซ๋ค๋ ๊ฑฐ์ง!
โก ์ฑ๋ฅ (Performance)
C ์ธ์ด ์์ค์ ์ฑ๋ฅ์ ๋ชฉํ๋ก ํด. ๊ณ ์์ค ์ถ์ํ๋ฅผ ์ ๊ณตํ๋ฉด์๋ ์คํ ์๋๋ฅผ ํฌ์ํ์ง ์๋ ๊ฒ ํต์ฌ์ด์ผ.
โจ ํํ๋ ฅ (Expressiveness)
์ฝ๋๊ฐ ์๋๋ฅผ ๋ช ํํ๊ฒ ๋๋ฌ๋ด์ผ ํ๋ค๋ ์ฒ ํ. ์ฝ๊ธฐ ์ฝ๊ณ ์ดํดํ๊ธฐ ์ฌ์ด ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ด์ผ ํด.
๐ ํ๋์ฑ (Modernity)
์ต์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์ด๋ก ๊ณผ ํจ๋ฌ๋ค์์ ์ ๊ทน ์์ฉํด. ํจ์ํ, ํ๋กํ ์ฝ ์งํฅ, ์ ๋ค๋ฆญ ํ๋ก๊ทธ๋๋ฐ ๋ฑ์ ๋ชจ๋ ์ง์ํ์ง.
๐ ์์ ์ฑ: Swift๊ฐ ๊ฐ์ฅ ์ค์ํ๊ฒ ์๊ฐํ๋ ๊ฐ์น
Swift์ ์ค๊ณ์๋ค์ "์์ ์ฑ์ด ์ต์ฐ์ "์ด๋ผ๋ ์์น์ ์ฒ ์ ํ ์ง์ผฐ์ด. ์ด๊ฒ ๋ฌด์จ ์๋ฏธ๋๋ฉด, ๊ฐ๋ฐ์๊ฐ ์ค์ํ ์ ์๋ ์ฌ์ง๋ฅผ ์ธ์ด ์ฐจ์์์ ์ต๋ํ ์ค์ธ๋ค๋ ๊ฑฐ์ผ. ๐ฏ์ต์ ๋(Optional): ๋ ์์ ์ฑ์ ํ๋ช
ํ ๋ ํธ์ด(Tony Hoare)๋ null ์ฐธ์กฐ๋ฅผ "10์ต ๋ฌ๋ฌ์ง๋ฆฌ ์ค์"๋ผ๊ณ ๋ถ๋ ์ด. Swift๋ ์ด ๋ฌธ์ ๋ฅผ ์ต์ ๋์ด๋ผ๋ ๊ฐ๋ ์ผ๋ก ํด๊ฒฐํ์ง.// Objective-C ์์ ์ ์ํํ ์ฝ๋
NSString *name = [self getName];
NSInteger length = [name length]; // name์ด nil์ด๋ฉด ํฌ๋์!
// Swift์ ์์ ํ ์ ๊ทผ
let name: String? = getName()
let length = name?.count ?? 0 // ์์ ํ๊ฒ ์ฒ๋ฆฌ๋จ
ํ์ ์์ ์ฑ๊ณผ ํ์ ์ถ๋ก
Swift๋ ๊ฐํ์ ์ธ์ด์ผ. ํ์ง๋ง ํ์ ์ถ๋ก ๋๋ถ์ ์ฝ๋๊ฐ ์ฅํฉํด์ง์ง ์์.// ํ์
์ ๋ช
์ํ์ง ์์๋ Swift๊ฐ ์ถ๋ก ํจ
let message = "Hello, Swift!" // String์ผ๋ก ์ถ๋ก
let count = 42 // Int๋ก ์ถ๋ก
let pi = 3.14159 // Double๋ก ์ถ๋ก
// ํ์ง๋ง ํ์
์ด ๋ง์ง ์์ผ๋ฉด ์ปดํ์ผ ์๋ฌ
let result = message + count // ์๋ฌ! String๊ณผ Int๋ ๋ํ ์ ์์
๊ฐ ํ์ ์ฐ์ ์ฃผ์
Swift๋ ๊ตฌ์กฐ์ฒด(struct)์ ์ด๊ฑฐํ(enum) ๊ฐ์ ๊ฐ ํ์ ์ ์ ๊ทน ๊ถ์ฅํด. ์ด๋ ๋ฐ์ดํฐ ๊ฒฝ์(data race)๊ณผ ์์์น ๋ชปํ ์ํ ๋ณ๊ฒฝ์ ๋ฐฉ์งํ๊ธฐ ์ํจ์ด์ผ.struct Point {
var x: Double
var y: Double
}
var point1 = Point(x: 0, y: 0)
var point2 = point1 // ๋ณต์ฌ๋จ
point2.x = 10
print(point1.x) // 0 (์ํฅ๋ฐ์ง ์์)
print(point2.x) // 10
โก ์ฑ๋ฅ: ์ถ์ํ์ ๋น์ฉ์ ์ ๋ก๋ก
Swift์ ๋ ๋ฒ์งธ ํต์ฌ ์ฒ ํ์ "์ ๋ก ๋น์ฉ ์ถ์ํ(Zero-cost Abstraction)"์ผ. ์ด๊ฒ ๋ฌด์จ ๋ป์ด๋๋ฉด, ๊ณ ์์ค์ ์ถ์ํ๋ฅผ ์ฌ์ฉํ๋๋ผ๋ ์ฑ๋ฅ ์ ํ๊ฐ ์์ด์ผ ํ๋ค๋ ๊ฑฐ์ง. ๐์ ์ ๋์คํจ์น์ ๋์ ๋์คํจ์น์ ๊ท ํ
Swift๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ์ ๋์คํจ์น๋ฅผ ์ฌ์ฉํด์ ์ฑ๋ฅ์ ์ต์ ํํด. ํ์ง๋ง ํ์ํ ๋๋ ๋์ ๋์คํจ์น๋ ์ง์ํ์ง.| ํน์ฑ | ์ ์ ๋์คํจ์น | ๋์ ๋์คํจ์น |
|---|---|---|
| ๊ฒฐ์ ์์ | ์ปดํ์ผ ํ์ | ๋ฐํ์ |
| ์ฑ๋ฅ | ๋น ๋ฆ (์ธ๋ผ์ด๋ ๊ฐ๋ฅ) | ์๋์ ์ผ๋ก ๋๋ฆผ |
| ์ ์ฐ์ฑ | ๋ฎ์ | ๋์ (๋คํ์ฑ) |
| Swift ์ ์ฉ | struct, final class | class, protocol |
// ์ ์ ๋์คํจ์น (๋น ๋ฆ)
struct FastCalculator {
func calculate() -> Int {
return 42
}
}
// ๋์ ๋์คํจ์น (์ ์ฐํจ)
class FlexibleCalculator {
func calculate() -> Int {
return 42
}
}
// final ํค์๋๋ก ์ ์ ๋์คํจ์น ๊ฐ์
final class OptimizedCalculator {
func calculate() -> Int {
return 42
}
}
์ ๋ค๋ฆญ์ ํน์ํ(Specialization)
Swift ์ปดํ์ผ๋ฌ๋ ์ ๋ค๋ฆญ ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ ๊ตฌ์ฒด์ ์ธ ํ์ ๋ง๋ค ์ต์ ํ๋ ๋ฒ์ ์ ์์ฑํด. ์ด๋ฅผ "์ ๋ค๋ฆญ ํน์ํ"๋ผ๊ณ ๋ถ๋ฌ.func swap<T>(_ a: inout T, _ b: inout T) {
let temp = a
a = b
b = temp
}
// ์ปดํ์ผ๋ฌ๊ฐ Int์ฉ, String์ฉ ๋ฑ ๊ฐ๊ฐ ์ต์ ํ๋ ๋ฒ์ ์ ์์ฑ
var x = 10, y = 20
swap(&x, &y) // Int ํน์ํ ๋ฒ์ ์ฌ์ฉ
var str1 = "Hello", str2 = "World"
swap(&str1, &str2) // String ํน์ํ ๋ฒ์ ์ฌ์ฉ
Copy-on-Write ์ต์ ํ
Swift์ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ปฌ๋ ์ ๋ค(Array, Dictionary, Set)์ Copy-on-Write๋ฅผ ๊ตฌํํด์ ๋ถํ์ํ ๋ณต์ฌ๋ฅผ ํผํด.var array1 = [1, 2, 3, 4, 5]
var array2 = array1 // ์ค์ ๋ก๋ ๋ณต์ฌ๋์ง ์์ (์ฐธ์กฐ๋ง ๊ณต์ )
array2.append(6) // ์ด ์์ ์ ์ค์ ๋ณต์ฌ ๋ฐ์
// array1์ [1, 2, 3, 4, 5]
// array2๋ [1, 2, 3, 4, 5, 6]
๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ: ARC์ ํจ์จ์ฑ
Swift๋ ์๋ ์ฐธ์กฐ ์นด์ดํ (ARC)์ ์ฌ์ฉํด. ๊ฐ๋น์ง ์ปฌ๋ ์ ๋ณด๋ค ์์ธก ๊ฐ๋ฅํ๊ณ ์ค๋ฒํค๋๊ฐ ์ ์ด.class Person {
let name: String
init(name: String) {
self.name = name
print("\(name) ์ด๊ธฐํ๋จ")
}
deinit {
print("\(name) ํด์ ๋จ")
}
}
var person1: Person? = Person(name: "์ฒ ์")
var person2 = person1 // ์ฐธ์กฐ ์นด์ดํธ ์ฆ๊ฐ
person1 = nil // ์ฐธ์กฐ ์นด์ดํธ ๊ฐ์ (์์ง ํด์ ์ ๋จ)
person2 = nil // ์ฐธ์กฐ ์นด์ดํธ 0, ์ฆ์ ํด์ ๋จ
โจ ํํ๋ ฅ: ์ฝ๋๋ ์(่ฉฉ)์ฒ๋ผ
Swift์ ์ธ ๋ฒ์งธ ์ฒ ํ์ ์ฝ๋์ ํํ๋ ฅ์ด์ผ. ์ฝ๋๋ฅผ ์ฝ๋ ์ฌ๋์ด ์์ฑ์์ ์๋๋ฅผ ์ฝ๊ฒ ์ดํดํ ์ ์์ด์ผ ํ๋ค๋ ๊ฑฐ์ง. ๐๋ช ํํ ๋ค์ด๋ฐ ๊ฐ์ด๋๋ผ์ธ
Swift API ๋์์ธ ๊ฐ์ด๋๋ผ์ธ์ ๋งค์ฐ ๊ตฌ์ฒด์ ์ด์ผ. ๋ช ๊ฐ์ง ํต์ฌ ์์น์ ๋ณด์:๋ช ํ์ฑ์ด ๊ฐ๊ฒฐํจ๋ณด๋ค ์ค์
// ๋์ ์
func rm(_ path: String)
// ์ข์ ์
func remove(at path: String)
์ฌ์ฉ ์์ ์์์ ๋ช ํ์ฑ
// ๋์ ์
list.insert(element, n)
// ์ข์ ์
list.insert(element, at: n)
๋ถํ์ํ ๋จ์ด ์๋ต
// ๋์ ์
func removeElementAt(position: Int)
// ์ข์ ์
func remove(at position: Int)
ํ์ ๋ณด๋ค ์ญํ ๊ธฐ๋ฐ ๋ค์ด๋ฐ
// ๋์ ์
var stringArray: [String]
// ์ข์ ์
var names: [String]
๊ฐ๋ ฅํ ํ์ ์ถ๋ก
Swift์ ํ์ ์ถ๋ก ์ ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ๋ง๋ค๋ฉด์๋ ํ์ ์์ ์ฑ์ ์ ์งํด.// ํ์
์ ๋ช
์ํ์ง ์์๋ ๋จ
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
let sum = doubled.reduce(0, +)
// ํ์ง๋ง ํ์ํ๋ฉด ๋ช
์ ๊ฐ๋ฅ
let explicitNumbers: [Int] = [1, 2, 3, 4, 5]
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ์ง์
Swift๋ ์ผ๊ธ ํจ์, ํด๋ก์ , ๊ณ ์ฐจ ํจ์ ๋ฑ์ ์ง์ํด์ ํํ๋ ฅ์ด ๋ฐ์ด๋.let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// ๋ช
๋ นํ ์คํ์ผ
var evenSquares: [Int] = []
for number in numbers {
if number % 2 == 0 {
evenSquares.append(number * number)
}
}
// ํจ์ํ ์คํ์ผ (๋ ํํ๋ ฅ์ด ์ข์)
let evenSquares2 = numbers
.filter { $0 % 2 == 0 }
.map { $0 * $0 }
// ๊ฒฐ๊ณผ๋ ๋์ผ: [4, 16, 36, 64, 100]
ํ๋กํ ์ฝ ์งํฅ ํ๋ก๊ทธ๋๋ฐ
Swift๋ ์์๋ณด๋ค ํ๋กํ ์ฝ ์กฐํฉ์ ๊ถ์ฅํด. ์ด๋ ๋ ์ ์ฐํ๊ณ ํ ์คํธํ๊ธฐ ์ฌ์ด ์ฝ๋๋ฅผ ๋ง๋ค์ด.// ํ๋กํ ์ฝ ์ ์
protocol Drawable {
func draw()
}
protocol Animatable {
func animate()
}
// ํ๋กํ ์ฝ ์กฐํฉ
struct Button: Drawable, Animatable {
func draw() {
print("๋ฒํผ ๊ทธ๋ฆฌ๊ธฐ")
}
func animate() {
print("๋ฒํผ ์ ๋๋ฉ์ด์
")
}
}
// ํ๋กํ ์ฝ ํ์ฅ์ผ๋ก ๊ธฐ๋ณธ ๊ตฌํ ์ ๊ณต
extension Drawable {
func draw() {
print("๊ธฐ๋ณธ ๊ทธ๋ฆฌ๊ธฐ")
}
}
2. ๊ฐ ํ์ (struct, enum)์๋ ์ ์ฉ ๊ฐ๋ฅ
3. ํ๋กํ ์ฝ ํ์ฅ์ผ๋ก ๊ธฐ๋ณธ ๊ตฌํ ์ ๊ณต
4. ๋ ๋์ ํ ์คํธ ๊ฐ๋ฅ์ฑ๊ณผ ๋ชจํน(mocking)
๐ ํ๋์ฑ: ์ต์ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์์ ์งํฉ์ฒด
Swift๋ ๋จ์ํ ์๋ก์ด ์ธ์ด๊ฐ ์๋๋ผ, ์์ญ ๋ ๊ฐ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์ฐ๊ตฌ ์ฑ๊ณผ๋ฅผ ์ง๋์ฑํ ํ๋์ ์ธ์ด์ผ. ๐๋ค์ค ํจ๋ฌ๋ค์ ์ง์
Swift๋ ์ฌ๋ฌ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์์ ์์ฐ์ค๋ฝ๊ฒ ํผํฉํ ์ ์์ด.| ํจ๋ฌ๋ค์ | ์ค๋ช | Swift ์ง์ |
|---|---|---|
| ๊ฐ์ฒด ์งํฅ | ํด๋์ค, ์์, ์บก์ํ | โ ์์ ์ง์ |
| ํ๋กํ ์ฝ ์งํฅ | ํ๋กํ ์ฝ ๊ธฐ๋ฐ ์ค๊ณ | โ ํต์ฌ ํจ๋ฌ๋ค์ |
| ํจ์ํ | ์ผ๊ธ ํจ์, ๋ถ๋ณ์ฑ, ์์ ํจ์ | โ ๊ฐ๋ ฅํ ์ง์ |
| ์ ๋ค๋ฆญ | ํ์ ๋งค๊ฐ๋ณ์ํ | โ ๊ณ ๊ธ ๊ธฐ๋ฅ |
| ๋ช ๋ นํ | ์์ฐจ์ ๋ช ๋ น ์คํ | โ ๊ธฐ๋ณธ ์ง์ |
๊ฐ๋ ฅํ ์ ๋ค๋ฆญ ์์คํ
Swift์ ์ ๋ค๋ฆญ์ ๋จ์ํ ํ์ ์ ๋งค๊ฐ๋ณ์ํํ๋ ๊ฒ์ ๋์ด์, ํ์ ๊ฐ์ ๊ด๊ณ๋ฅผ ํํํ ์ ์์ด.// ๊ธฐ๋ณธ ์ ๋ค๋ฆญ
func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) -> Int? {
for (index, value) in array.enumerated() {
if value == valueToFind {
return index
}
}
return nil
}
// Associated Type์ ์ฌ์ฉํ ํ๋กํ ์ฝ
protocol Container {
associatedtype Item
mutating func append(_ item: Item)
var count: Int { get }
subscript(i: Int) -> Item { get }
}
// ์ ๋ค๋ฆญ where ์
func allItemsMatch<C1: Container, C2: Container>
(_ container1: C1, _ container2: C2) -> Bool
where C1.Item == C2.Item, C1.Item: Equatable {
if container1.count != container2.count {
return false
}
for i in 0..<container1.count {
if container1[i] != container2[i] {
return false
}
}
return true
}
์๋ฌ ์ฒ๋ฆฌ์ ํ๋์ ์ ๊ทผ
Swift์ ์๋ฌ ์ฒ๋ฆฌ๋ ์์ธ(exception)์ ๋ค๋ฅธ ๋ ํนํ ๋ฐฉ์์ด์ผ.enum FileError: Error {
case fileNotFound
case insufficientPermissions
case corruptedData
}
func readFile(at path: String) throws -> String {
guard fileExists(at: path) else {
throw FileError.fileNotFound
}
guard hasPermission(for: path) else {
throw FileError.insufficientPermissions
}
// ํ์ผ ์ฝ๊ธฐ ๋ก์ง
return "ํ์ผ ๋ด์ฉ"
}
// ์๋ฌ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ 1: do-catch
do {
let content = try readFile(at: "/path/to/file")
print(content)
} catch FileError.fileNotFound {
print("ํ์ผ์ ์ฐพ์ ์ ์์ต๋๋ค")
} catch FileError.insufficientPermissions {
print("๊ถํ์ด ์์ต๋๋ค")
} catch {
print("์ ์ ์๋ ์๋ฌ: \(error)")
}
// ์๋ฌ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ 2: try?
if let content = try? readFile(at: "/path/to/file") {
print(content)
}
// ์๋ฌ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ 3: try!
let content = try! readFile(at: "/path/to/file") // ์๋ฌ ๋ฐ์ ์ ํฌ๋์
๋์์ฑ(Concurrency): async/await
Swift 5.5๋ถํฐ ๋์ ๋ ๊ตฌ์กฐํ๋ ๋์์ฑ์ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ์ ํ์ ์ ์ผ๋ก ๊ฐ์ ํ์ด.// ์ ํต์ ์ธ ์ฝ๋ฐฑ ๋ฐฉ์ (์ฝ๋ฐฑ ์ง์ฅ)
func fetchUserData(completion: @escaping (User?, Error?) -> Void) {
fetchUserID { userID, error in
guard let userID = userID else {
completion(nil, error)
return
}
fetchUserProfile(userID: userID) { profile, error in
guard let profile = profile else {
completion(nil, error)
return
}
fetchUserPosts(userID: userID) { posts, error in
// ๋ ๊น์ด์ง๋ ์ค์ฒฉ...
}
}
}
}
// async/await ๋ฐฉ์ (๊น๋!)
func fetchUserData() async throws -> User {
let userID = try await fetchUserID()
let profile = try await fetchUserProfile(userID: userID)
let posts = try await fetchUserPosts(userID: userID)
return User(id: userID, profile: profile, posts: posts)
}
// ์ฌ์ฉ
Task {
do {
let user = try await fetchUserData()
print("์ฌ์ฉ์ ๋ฐ์ดํฐ: \(user)")
} catch {
print("์๋ฌ ๋ฐ์: \(error)")
}
}
2. ์๋ฌ ์ฒ๋ฆฌ๊ฐ ๋๊ธฐ ์ฝ๋์ ๋์ผ
3. ์ปดํ์ผ๋ฌ๊ฐ ์ค๋ ๋ ์์ ์ฑ ๊ฒ์ฆ
4. ์๋ ์ทจ์ ์ ํ(cancellation propagation)
๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ๊ณผ ๋ฐ์ดํฐ ๊ฒฝ์ ๋ฐฉ์ง
Swift๋ ์ปดํ์ผ ํ์์ ๋ง์ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ๋ฌธ์ ๋ฅผ ์ก์๋ด.// ๋๊ธ๋ง ํฌ์ธํฐ ๋ฐฉ์ง
func createDanglingReference() -> UnsafeMutablePointer<Int> {
var value = 42
return withUnsafeMutablePointer(to: &value) { $0 }
// ์ปดํ์ผ ์๋ฌ! value์ ์๋ช
์ฃผ๊ธฐ๊ฐ ๋๋จ
}
// ๋ฐฐ์ด ๋ฒ์ ๊ฒ์ฌ
let numbers = [1, 2, 3, 4, 5]
// let invalid = numbers[10] // ๋ฐํ์ ์๋ฌ (ํฌ๋์)
let safe = numbers.indices.contains(10) ? numbers[10] : nil // ์์
// ๋์ ์ ๊ทผ ๋ฐฉ์ง
var counter = 0
func increment() {
counter += 1
}
// Swift ์ปดํ์ผ๋ฌ๊ฐ ๋ฐ์ดํฐ ๊ฒฝ์ ๊ฐ๋ฅ์ฑ์ ๊ฒฝ๊ณ
DispatchQueue.concurrentPerform(iterations: 1000) { _ in
increment() // ๊ฒฝ๊ณ : ๋์ ์ ๊ทผ ๊ฐ๋ฅ์ฑ
}
๐ฏ Swift์ ์ค๊ณ ์์น ์์ธ ๋ถ์
์ด์ Swift์ ๊ตฌ์ฒด์ ์ธ ์ค๊ณ ์์น๋ค์ ํ๋์ฉ ํํค์ณ๋ณด์. ์ด ์์น๋ค์ Swift ์ฝ์ด ํ์ด ์ธ์ด๋ฅผ ๋ฐ์ ์ํฌ ๋ ํญ์ ๊ณ ๋ คํ๋ ๊ธฐ์ค์ด์ผ. ๐์์น 1: ์ ์ง์ ๊ณต๊ฐ(Progressive Disclosure)
Swift๋ ์ด๋ณด์๋ ์ฝ๊ฒ ์์ํ ์ ์์ง๋ง, ์ ๋ฌธ๊ฐ ์์ค์ ๊ธฐ๋ฅ๋ ์ ๊ณตํด์ผ ํ๋ค๋ ์์น์ด์ผ.// ์ด๋ณด์ ๋ ๋ฒจ: ๊ฐ๋จํ ๋ณ์์ ํจ์
var greeting = "Hello"
func sayHello() {
print(greeting)
}
// ์ค๊ธ์ ๋ ๋ฒจ: ์ต์
๋๊ณผ ์๋ฌ ์ฒ๋ฆฌ
var name: String?
func greet() throws {
guard let name = name else {
throw GreetingError.noName
}
print("Hello, \(name)")
}
// ์ ๋ฌธ๊ฐ ๋ ๋ฒจ: ์ ๋ค๋ฆญ๊ณผ ํ๋กํ ์ฝ
protocol Greetable {
associatedtype GreetingType
func greet() -> GreetingType
}
struct AdvancedGreeter<T: CustomStringConvertible>: Greetable {
typealias GreetingType = String
let name: T
func greet() -> String {
return "Hello, \(name.description)"
}
}
์์น 2: ๋ช ์์ ์ฐ์ (Explicit over Implicit)
Swift๋ ์๋ฌต์ ์ธ ๋์๋ณด๋ค ๋ช ์์ ์ธ ์ฝ๋๋ฅผ ์ ํธํด. ์ด๋ ์ฝ๋์ ์๋๋ฅผ ๋ช ํํ ํ๊ธฐ ์ํจ์ด์ผ.// ๋์ ์: ์๋ฌต์ ํ์
๋ณํ (Swift๋ ํ์ฉ ์ ํจ)
// let result = 3.14 + 5 // ์๋ฌ!
// ์ข์ ์: ๋ช
์์ ๋ณํ
let result = 3.14 + Double(5) // OK
// ๋์ ์: ์๋ฌต์ ์ต์
๋ ์ธ๋ํ
// let length = optionalString.count // ์๋ฌ!
// ์ข์ ์: ๋ช
์์ ์ต์
๋ ์ฒ๋ฆฌ
let length = optionalString?.count ?? 0 // OK
// ๋ฉ์๋ ํธ์ถ๋ ๋ช
์์
array.insert(element, at: index) // 'at' ๋ ์ด๋ธ๋ก ์๋ ๋ช
ํํ
์์น 3: ๊ฐ ์๋ฏธ๋ก (Value Semantics)
Swift๋ ๊ฐ๋ฅํ ํ ๊ฐ ํ์ ์ ์ฌ์ฉํ๋๋ก ๊ถ์ฅํด. ์ด๋ ์์ธก ๊ฐ๋ฅ์ฑ๊ณผ ์์ ์ฑ์ ๋์ฌ.// ๊ฐ ํ์
(struct)
struct Point {
var x: Double
var y: Double
}
var point1 = Point(x: 0, y: 0)
var point2 = point1 // ๋ณต์ฌ๋จ
point2.x = 10
print(point1.x) // 0 (๋
๋ฆฝ์ )
print(point2.x) // 10
// ์ฐธ์กฐ ํ์
(class)
class MutablePoint {
var x: Double
var y: Double
init(x: Double, y: Double) {
self.x = x
self.y = y
}
}
var mutablePoint1 = MutablePoint(x: 0, y: 0)
var mutablePoint2 = mutablePoint1 // ์ฐธ์กฐ ๊ณต์
mutablePoint2.x = 10
print(mutablePoint1.x) // 10 (์ํฅ๋ฐ์!)
print(mutablePoint2.x) // 10
โข ๋ฐ์ดํฐ๊ฐ ๋น๊ต์ ์๊ณ ๋จ์ํ ๋
โข ๋ ๋ฆฝ์ ์ธ ๋ณต์ฌ๋ณธ์ด ํ์ํ ๋
โข ์ค๋ ๋ ์์ ์ฑ์ด ์ค์ํ ๋
โข ๋๋ฑ์ฑ ๋น๊ต๊ฐ ๊ฐ ๊ธฐ๋ฐ์ผ ๋
์ฐธ์กฐ ํ์ ์ ์ฌ์ฉํด์ผ ํ ๋:
โข ๊ฐ์ฒด์ ์ ์ฒด์ฑ(identity)์ด ์ค์ํ ๋
โข ์ํ๋ฅผ ์ฌ๋ฌ ๊ณณ์์ ๊ณต์ ํด์ผ ํ ๋
โข ์์์ด ํ์ํ ๋
โข Objective-C์ ์ํธ์ด์ฉํด์ผ ํ ๋
์์น 4: ํ๋กํ ์ฝ ์ฐ์ (Protocol-Oriented)
Swift๋ ์์๋ณด๋ค ํ๋กํ ์ฝ ์กฐํฉ์ ๊ถ์ฅํด. ์ด๋ ๋ ์ ์ฐํ๊ณ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ์ฝ๋๋ฅผ ๋ง๋ค์ด.// ์ ํต์ ์ธ ์์ ๋ฐฉ์์ ๋ฌธ์ ์
class Animal {
func makeSound() {
print("Some sound")
}
}
class Dog: Animal {
override func makeSound() {
print("Woof!")
}
}
class Cat: Animal {
override func makeSound() {
print("Meow!")
}
}
// ๋ฌธ์ : Robot๋ ์๋ฆฌ๋ฅผ ๋ผ ์ ์์ง๋ง Animal์ ์์๋ฐ์ ์ ์์!
// ํ๋กํ ์ฝ ์งํฅ ๋ฐฉ์
protocol SoundMaking {
func makeSound()
}
struct Dog: SoundMaking {
func makeSound() {
print("Woof!")
}
}
struct Cat: SoundMaking {
func makeSound() {
print("Meow!")
}
}
struct Robot: SoundMaking {
func makeSound() {
print("Beep boop!")
}
}
// ํ๋กํ ์ฝ ํ์ฅ์ผ๋ก ๊ธฐ๋ณธ ๊ตฌํ ์ ๊ณต
extension SoundMaking {
func makeSound() {
print("Default sound")
}
}
// ์ฌ๋ฌ ํ๋กํ ์ฝ ์กฐํฉ
protocol Movable {
func move()
}
protocol Drawable {
func draw()
}
struct GameCharacter: SoundMaking, Movable, Drawable {
func makeSound() { print("Character sound") }
func move() { print("Moving") }
func draw() { print("Drawing") }
}
๐ง ์ค์ ์ค๊ณ ํจํด๊ณผ Swift ์ฒ ํ์ ์กฐํ
Swift์ ์ฒ ํ์ ์ค์ ์ฝ๋ ์์ฑ์ ์ด๋ป๊ฒ ์ ์ฉ๋ ๊น? ๋ช ๊ฐ์ง ์ค์ ์์ ๋ฅผ ํตํด ์์๋ณด์. ๐ผ์ต์ ๋ ์ฒด์ด๋๊ณผ nil ๋ณํฉ ์ฐ์ฐ์
Swift๋ nil ์ฒ๋ฆฌ๋ฅผ ์ฐ์ํ๊ฒ ๋ง๋๋ ์ฌ๋ฌ ๋๊ตฌ๋ฅผ ์ ๊ณตํด.struct Address {
var street: String
var city: String
}
struct Person {
var name: String
var address: Address?
}
let person: Person? = Person(name: "์ฒ ์", address: nil)
// ์ต์
๋ ์ฒด์ด๋
let city = person?.address?.city // nil
// nil ๋ณํฉ ์ฐ์ฐ์
let cityName = person?.address?.city ?? "์ ์ ์์" // "์ ์ ์์"
// ์ต์
๋ ๋ฐ์ธ๋ฉ
if let person = person,
let address = person.address,
let city = address.city {
print("๋์: \(city)")
} else {
print("์ฃผ์ ์ ๋ณด ์์")
}
// guard let (์กฐ๊ธฐ ๋ฐํ ํจํด)
func printCity(person: Person?) {
guard let person = person,
let address = person.address,
let city = address.city else {
print("์ฃผ์ ์ ๋ณด ์์")
return
}
print("๋์: \(city)")
}
Result ํ์ ์ผ๋ก ์๋ฌ ์ฒ๋ฆฌ
Swift 5๋ถํฐ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํฌํจ๋ Result ํ์ ์ ์ฑ๊ณต/์คํจ๋ฅผ ๋ช ์์ ์ผ๋ก ํํํด.enum NetworkError: Error {
case invalidURL
case noData
case decodingError
}
// Result๋ฅผ ๋ฐํํ๋ ํจ์
func fetchData(from urlString: String) -> Result<Data, NetworkError> {
guard let url = URL(string: urlString) else {
return .failure(.invalidURL)
}
// ๋คํธ์ํฌ ์์ฒญ ์๋ฎฌ๋ ์ด์
guard let data = simulateNetworkRequest(url: url) else {
return .failure(.noData)
}
return .success(data)
}
// Result ์ฌ์ฉ
let result = fetchData(from: "https://api.example.com/data")
switch result {
case .success(let data):
print("๋ฐ์ดํฐ ์์ : \(data.count) bytes")
case .failure(let error):
print("์๋ฌ ๋ฐ์: \(error)")
}
// map๊ณผ flatMap์ผ๋ก ์ฒด์ด๋
let processedResult = fetchData(from: "https://api.example.com/data")
.map { data in
// ๋ฐ์ดํฐ ์ฒ๋ฆฌ
return String(data: data, encoding: .utf8) ?? ""
}
.flatMap { jsonString in
// JSON ํ์ฑ
return parseJSON(jsonString)
}
2. ์๋ฌ ํ์ ์ด ๋ช ํํจ
3. ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ํจํด ์ ์ฉ ๊ฐ๋ฅ
4. ์ฝ๋ฐฑ ๊ธฐ๋ฐ API๋ฅผ ๋ ์์ ํ๊ฒ ๋ง๋ฆ
Property Wrapper๋ก ๋ฐ๋ณต ์ฝ๋ ์ ๊ฑฐ
Property Wrapper๋ Swift 5.1์์ ๋์ ๋ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ด์ผ.// UserDefaults ์ ๊ทผ์ ๊ฐ๋จํ๊ฒ
@propertyWrapper
struct UserDefault<T> {
let key: String
let defaultValue: T
var wrappedValue: T {
get {
return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
}
set {
UserDefaults.standard.set(newValue, forKey: key)
}
}
}
// ์ฌ์ฉ
struct Settings {
@UserDefault(key: "username", defaultValue: "Guest")
var username: String
@UserDefault(key: "isDarkMode", defaultValue: false)
var isDarkMode: Bool
@UserDefault(key: "fontSize", defaultValue: 14)
var fontSize: Int
}
var settings = Settings()
settings.username = "์ฒ ์" // ์๋์ผ๋ก UserDefaults์ ์ ์ฅ
print(settings.username) // ์๋์ผ๋ก UserDefaults์์ ์ฝ์
// ์ ํจ์ฑ ๊ฒ์ฆ Property Wrapper
@propertyWrapper
struct Clamped<Value: Comparable> {
private var value: Value
private let range: ClosedRange<Value>
var wrappedValue: Value {
get { value }
set { value = min(max(range.lowerBound, newValue), range.upperBound) }
}
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
self.range = range
self.value = min(max(range.lowerBound, wrappedValue), range.upperBound)
}
}
struct GameCharacter {
@Clamped(0...100)
var health: Int = 100
@Clamped(0...10)
var level: Int = 1
}
var character = GameCharacter()
character.health = 150 // ์๋์ผ๋ก 100์ผ๋ก ์ ํ๋จ
character.level = -5 // ์๋์ผ๋ก 0์ผ๋ก ์ ํ๋จ
ํ๋กํ ์ฝ ํ์ฅ์ผ๋ก ๊ธฐ๋ฅ ์ถ๊ฐ
ํ๋กํ ์ฝ ํ์ฅ์ Swift์ ๊ฐ์ฅ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ ์ค ํ๋์ผ.// ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํ๋กํ ์ฝ ํ์ฅ
extension Collection {
// ์์ ํ ์ธ๋ฑ์ค ์ ๊ทผ
subscript(safe index: Index) -> Element? {
return indices.contains(index) ? self[index] : nil
}
// ๋ ๋ฒ์งธ ์์ ๊ฐ์ ธ์ค๊ธฐ
var second: Element? {
return self.count > 1 ? self[self.index(after: startIndex)] : nil
}
}
let numbers = [1, 2, 3, 4, 5]
print(numbers[safe: 10]) // nil (ํฌ๋์ ์์)
print(numbers.second) // Optional(2)
// ์ปค์คํ
ํ๋กํ ์ฝ๊ณผ ํ์ฅ
protocol Identifiable {
var id: String { get }
}
extension Identifiable {
// ๊ธฐ๋ณธ ๊ตฌํ ์ ๊ณต
func printID() {
print("ID: \(id)")
}
// ๊ณ์ฐ ํ๋กํผํฐ ์ถ๊ฐ
var shortID: String {
return String(id.prefix(8))
}
}
struct User: Identifiable {
let id: String
let name: String
}
let user = User(id: "abc123def456", name: "์ฒ ์")
user.printID() // "ID: abc123def456"
print(user.shortID) // "abc123de"
๐ Swift์ ์งํ: ๋ฒ์ ๋ณ ์ฃผ์ ์ฒ ํ์ ๋ณํ
Swift๋ ๊ณ์ ์งํํ๊ณ ์์ด. ๊ฐ ๋ฒ์ ๋ง๋ค ์ธ์ด์ ์ฒ ํ์ ๋ ์ ๊ตฌํํ๊ธฐ ์ํ ๊ฐ์ ์ด ์ด๋ฃจ์ด์ก์ง. ๐| ๋ฒ์ | ์ฃผ์ ๋ณํ | ์ฒ ํ์ ์๋ฏธ |
|---|---|---|
| Swift 1.0 (2014) |
์ด๊ธฐ ๋ฆด๋ฆฌ์ค, ๊ธฐ๋ณธ ๋ฌธ๋ฒ ํ๋ฆฝ | ์์ ์ฑ๊ณผ ํ๋์ฑ์ ๊ธฐ์ด ๋ง๋ จ |
| Swift 2.0 (2015) |
์๋ฌ ์ฒ๋ฆฌ, guard ๋ฌธ, ํ๋กํ ์ฝ ํ์ฅ | ๋ช ์์ ์๋ฌ ์ฒ๋ฆฌ์ ํ๋กํ ์ฝ ์งํฅ ๊ฐํ |
| Swift 3.0 (2016) |
API ๋์์ธ ๊ฐ์ด๋๋ผ์ธ, ๋ค์ด๋ฐ ๊ฐ์ | ํํ๋ ฅ๊ณผ ์ผ๊ด์ฑ ํฅ์ |
| Swift 4.0 (2017) |
Codable, ๋ฌธ์์ด ๊ฐ์ , ์ ๋ค๋ฆญ ๊ฐํ | ์ค์ฉ์ฑ๊ณผ ์ฑ๋ฅ ๊ฐ์ |
| Swift 5.0 (2019) |
ABI ์์ ํ, Result ํ์ | ์์ ์ฑ๊ณผ ์ํธ์ด์ฉ์ฑ ํ๋ณด |
| Swift 5.1 (2019) |
Property Wrapper, Opaque Type | ์ถ์ํ ๋ฅ๋ ฅ ํฅ์ |
| Swift 5.5 (2021) |
async/await, Actor | ๋์์ฑ ์์ ์ฑ ํ์ |
| Swift 5.7 (2022) |
if/switch ํํ์, ์ ๋ค๋ฆญ ๊ฐ์ | ํํ๋ ฅ ๋์ฑ ๊ฐํ |
| Swift 5.9 (2023) |
๋งคํฌ๋ก ์์คํ , ์์ ๊ถ ๊ฐ์ | ๋ฉํํ๋ก๊ทธ๋๋ฐ๊ณผ ์ฑ๋ฅ ์ต์ ํ |
Swift 5.5์ ํ๋ช : ๊ตฌ์กฐํ๋ ๋์์ฑ
async/await์ ๋์ ์ Swift์ ์์ ์ฑ ์ฒ ํ์ ๋์์ฑ ์์ญ์ผ๋ก ํ์ฅํ ๊ฑฐ์ผ.// ์ ํต์ ์ธ GCD ๋ฐฉ์ (๋ฐ์ดํฐ ๊ฒฝ์ ์ํ)
var sharedCounter = 0
let queue = DispatchQueue(label: "counter")
DispatchQueue.concurrentPerform(iterations: 1000) { _ in
queue.async {
sharedCounter += 1 // ๋๊ธฐํ ํ์
}
}
// Actor๋ฅผ ์ฌ์ฉํ ์์ ํ ๋์์ฑ
actor Counter {
private var value = 0
func increment() {
value += 1
}
func getValue() -> Int {
return value
}
}
let counter = Counter()
Task {
await withTaskGroup(of: Void.self) { group in
for _ in 0..<1000 {
group.addTask {
await counter.increment()
}
}
}
let finalValue = await counter.getValue()
print("์ต์ข
๊ฐ: \(finalValue)") // ํญ์ 1000
}
Swift 5.9์ ๋งคํฌ๋ก: ๋ฉํํ๋ก๊ทธ๋๋ฐ์ ์์ ํ ๊ตฌํ
๋งคํฌ๋ก๋ ์ปดํ์ผ ํ์์ ์ฝ๋๋ฅผ ์์ฑํ์ง๋ง, C์ ๋งคํฌ๋ก์ ๋ฌ๋ฆฌ ํ์ ์์ ํด.// ๋งคํฌ๋ก ์ ์ (๊ฐ๋จํ ์์)
@freestanding(expression)
macro stringify<T>(_ value: T) -> (T, String)
// ์ฌ์ฉ
let result = #stringify(1 + 2)
// ์ปดํ์ผ๋ฌ๊ฐ ๋ค์๊ณผ ๊ฐ์ด ํ์ฅ:
// let result = (1 + 2, "1 + 2")
// ์ค์ฉ์ ์ธ ์: ์๋ Equatable ๊ตฌํ
@attached(member)
macro AutoEquatable()
@AutoEquatable
struct Point {
let x: Int
let y: Int
// ์ปดํ์ผ๋ฌ๊ฐ ์๋์ผ๋ก == ์ฐ์ฐ์ ์์ฑ
}
๐ Swift ์ฒ ํ์ ์ค๋ฌด์ ์ ์ฉํ๊ธฐ
์ด๋ก ์ ์ถฉ๋ถํ ๋ดค์ผ๋, ์ด์ ์ค๋ฌด์์ Swift์ ์ฒ ํ์ ์ด๋ป๊ฒ ์ ์ฉํ ์ง ์์๋ณด์. ๐ ๏ธ1. ์ต์ ๋์ ๋๋ ค์ํ์ง ๋ง๊ณ ์ ๊ทน ํ์ฉํ๊ธฐ
๋ง์ ๊ฐ๋ฐ์๋ค์ด ์ต์ ๋์ ๊ท์ฐฎ์ํ์ง๋ง, ์ด๋ Swift์ ํต์ฌ ์์ ์ฅ์น์ผ.// ๋์ ์: ๊ฐ์ ์ธ๋ํ ๋จ์ฉ
func processUser(id: String) {
let user = database.findUser(id: id)! // ์ํ!
print(user.name)
}
// ์ข์ ์: ์ต์
๋ ์ฒด์ด๋๊ณผ guard
func processUser(id: String) {
guard let user = database.findUser(id: id) else {
print("์ฌ์ฉ์๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค")
return
}
print(user.name)
// ์ถ๊ฐ ์ฒ๋ฆฌ...
}
// ๋ ๋์ ์: Result ํ์
ํ์ฉ
func processUser(id: String) -> Result<Void, UserError> {
guard let user = database.findUser(id: id) else {
return .failure(.userNotFound)
}
print(user.name)
return .success(())
}
2. ๊ฐ ํ์ ์ ๊ธฐ๋ณธ์ผ๋ก, ์ฐธ์กฐ ํ์ ์ ํ์ํ ๋๋ง
// ์ข์ ์ค๊ณ: ๊ฐ ํ์
์ฐ์
struct UserProfile {
let id: String
var name: String
var email: String
var preferences: UserPreferences
}
struct UserPreferences {
var theme: Theme
var notifications: Bool
var language: String
}
// ์ฐธ์กฐ ํ์
์ด ํ์ํ ๊ฒฝ์ฐ: ์ ์ฒด์ฑ์ด ์ค์ํ ๋
class UserSession {
let profile: UserProfile
private(set) var isLoggedIn: Bool
init(profile: UserProfile) {
self.profile = profile
self.isLoggedIn = true
}
func logout() {
isLoggedIn = false
}
}
3. ํ๋กํ ์ฝ๋ก ์์กด์ฑ ์ญ์ ํ๊ธฐ
// ๋์ ์: ๊ตฌ์ฒด ํ์
์ ์์กด
class UserViewController {
let database = SQLiteDatabase() // ๊ฐํ ๊ฒฐํฉ
func loadUsers() {
let users = database.fetchUsers()
// ...
}
}
// ์ข์ ์: ํ๋กํ ์ฝ์ ์์กด
protocol UserRepository {
func fetchUsers() async throws -> [User]
func saveUser(_ user: User) async throws
}
class UserViewController {
let repository: UserRepository // ๋์จํ ๊ฒฐํฉ
init(repository: UserRepository) {
self.repository = repository
}
func loadUsers() async {
do {
let users = try await repository.fetchUsers()
// ...
} catch {
// ์๋ฌ ์ฒ๋ฆฌ
}
}
}
// ๋ค์ํ ๊ตฌํ ๊ฐ๋ฅ
struct SQLiteUserRepository: UserRepository {
func fetchUsers() async throws -> [User] {
// SQLite ๊ตฌํ
}
func saveUser(_ user: User) async throws {
// SQLite ๊ตฌํ
}
}
struct MockUserRepository: UserRepository {
func fetchUsers() async throws -> [User] {
// ํ
์คํธ์ฉ ๋ชฉ ๋ฐ์ดํฐ
return [User(id: "1", name: "Test User")]
}
func saveUser(_ user: User) async throws {
// ํ
์คํธ์ฉ ๊ตฌํ
}
}
4. ์๋ฌ ์ฒ๋ฆฌ๋ฅผ ๋ช ์์ ์ผ๋ก
// ๋ช
ํํ ์๋ฌ ํ์
์ ์
enum ValidationError: Error {
case emptyField(fieldName: String)
case invalidFormat(fieldName: String, expected: String)
case outOfRange(fieldName: String, min: Int, max: Int)
}
struct UserValidator {
func validate(name: String) throws {
guard !name.isEmpty else {
throw ValidationError.emptyField(fieldName: "name")
}
guard name.count >= 2 else {
throw ValidationError.outOfRange(
fieldName: "name",
min: 2,
max: 50
)
}
}
func validate(email: String) throws {
guard !email.isEmpty else {
throw ValidationError.emptyField(fieldName: "email")
}
let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
guard email.range(of: emailRegex, options: .regularExpression) != nil else {
throw ValidationError.invalidFormat(
fieldName: "email",
expected: "example@domain.com"
)
}
}
}
// ์ฌ์ฉ
let validator = UserValidator()
do {
try validator.validate(name: "")
try validator.validate(email: "invalid-email")
} catch ValidationError.emptyField(let fieldName) {
print("\(fieldName) ํ๋๊ฐ ๋น์ด์์ต๋๋ค")
} catch ValidationError.invalidFormat(let fieldName, let expected) {
print("\(fieldName) ํ์์ด ์ฌ๋ฐ๋ฅด์ง ์์ต๋๋ค. ์: \(expected)")
} catch ValidationError.outOfRange(let fieldName, let min, let max) {
print("\(fieldName)๋ \(min)~\(max) ๋ฒ์์ฌ์ผ ํฉ๋๋ค")
} catch {
print("์ ์ ์๋ ์๋ฌ: \(error)")
}
๐ Swift vs ๋ค๋ฅธ ์ธ์ด: ์ฒ ํ์ ๋น๊ต
Swift์ ์ฒ ํ์ ๋ ์ ์ดํดํ๊ธฐ ์ํด ๋ค๋ฅธ ์ธ์ด๋ค๊ณผ ๋น๊ตํด๋ณด์. ๐Swift vs Objective-C
| ์ธก๋ฉด | Objective-C | Swift |
|---|---|---|
| Nil ์์ ์ฑ | nil ๋ฉ์์ง๋ ์กฐ์ฉํ ๋ฌด์๋จ | ์ต์ ๋๋ก ๋ช ์์ ์ฒ๋ฆฌ |
| ํ์ ์์คํ | ๋์ ํ์ (๋ฐํ์) | ์ ์ ํ์ (์ปดํ์ผ ํ์) |
| ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ | ARC (์ฐธ์กฐ ํ์ ๋ง) | ARC (๋ชจ๋ ํ์ ) |
| ๋ฌธ๋ฒ | C ๊ธฐ๋ฐ, ์ฅํฉํจ | ํ๋์ , ๊ฐ๊ฒฐํจ |
| ํ๋กํ ์ฝ | ๊ธฐ๋ณธ ์ง์ | ํ๋กํ ์ฝ ์งํฅ ํต์ฌ |
// Objective-C
@interface Person : NSObject
@property (nonatomic, strong) NSString *name;
@property (nonatomic, assign) NSInteger age;
- (void)greet;
@end
@implementation Person
- (void)greet {
NSLog(@"Hello, I'm %@", self.name);
}
@end
// Swift
struct Person {
let name: String
let age: Int
func greet() {
print("Hello, I'm \(name)")
}
}
Swift vs Java
| ์ธก๋ฉด | Java | Swift |
|---|---|---|
| Null ์ฒ๋ฆฌ | NullPointerException ์ํ | ์ต์ ๋๋ก ์์ ํ๊ฒ |
| ๊ฐ ํ์ | ์์ ํ์ ๋ง | struct, enum ์์ ์ง์ |
| ์ ๋ค๋ฆญ | ํ์ ์๊ฑฐ(Type Erasure) | ์์ ํ ์ ๋ค๋ฆญ |
| ํจ์ํ | Java 8๋ถํฐ ์ ํ์ | ์ผ๊ธ ์๋ฏผ |
| ํ์ฅ | ๋ถ๊ฐ๋ฅ | ํ๋กํ ์ฝ ํ์ฅ ๊ฐ๋ ฅ |
Swift vs Kotlin
Kotlin๊ณผ Swift๋ ๋๋๋๋ก ๋น์ทํ ์ฒ ํ์ ๊ฐ์ง๊ณ ์์ด. ๋ ๋ค ์์ ์ฑ๊ณผ ํํ๋ ฅ์ ์ค์ํ์ง.// Kotlin
data class Person(val name: String, val age: Int)
fun greet(person: Person?) {
person?.let {
println("Hello, ${it.name}")
} ?: println("No person")
}
// Swift
struct Person {
let name: String
let age: Int
}
func greet(person: Person?) {
if let person = person {
print("Hello, \(person.name)")
} else {
print("No person")
}
}
Swift vs Rust
Rust์ Swift๋ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ ๋ํ ์ ๊ทผ์ด ๋ค๋ฅด์ง๋ง, ๋ ๋ค ์์ ์ฑ์ ์ต์ฐ์ ์ผ๋ก ํด.| ์ธก๋ฉด | Rust | Swift |
|---|---|---|
| ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ | ์์ ๊ถ ์์คํ (์ปดํ์ผ ํ์) | ARC (๋ฐํ์) |
| Null ์์ ์ฑ | Option ํ์ | Optional ํ์ |
| ์ฑ๋ฅ | ์ ๋ก ๋น์ฉ ์ถ์ํ (์์ ) | ์ ๋ก ๋น์ฉ ์ถ์ํ (๋๋ถ๋ถ) |
| ํ์ต ๊ณก์ | ๊ฐํ๋ฆ | ์๋งํจ |
| ์ฃผ ์ฉ๋ | ์์คํ ํ๋ก๊ทธ๋๋ฐ | ์ ํ๋ฆฌ์ผ์ด์ ๊ฐ๋ฐ |
๐ก Swift ์ฒ ํ์ ๋ฐฐ์ฐ๋ ์ต๊ณ ์ ๋ฐฉ๋ฒ
Swift์ ์ฒ ํ์ ์ง์ ์ผ๋ก ์ดํดํ๋ ค๋ฉด ๋จ์ํ ๋ฌธ๋ฒ์ ๋ฐฐ์ฐ๋ ๊ฒ์ ๋์ด์์ผ ํด. ์ฌ๊ธฐ ๋ช ๊ฐ์ง ํ์ ๊ณต์ ํ ๊ฒ! ๐ฏ1. ๊ณต์ ๋ฌธ์์ ์ ์์ ์ฝ๊ธฐ
Swift Evolution ์ ์์๋ค์ ์ฝ์ผ๋ฉด ๊ฐ ๊ธฐ๋ฅ์ด ์ ์ถ๊ฐ๋์๋์ง ์ดํดํ ์ ์์ด.โข Swift Evolution ์ ์์ (github.com/apple/swift-evolution)
โข WWDC ์ธ์ ๋น๋์ค
โข Swift ํฌ๋ผ ํ ๋ก
โข "The Swift Programming Language" ์ฑ
2. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์ค ์ฝ๋ ์ฝ๊ธฐ
Swift ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์คํ์์ค์ผ. ์ต๊ณ ์ Swift ์ฝ๋๋ฅผ ๋ณผ ์ ์๋ ๊ณณ์ด์ง.// Array์ map ๊ตฌํ (๊ฐ์ํ ๋ฒ์ )
extension Array {
func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] {
var result: [T] = []
result.reserveCapacity(count)
for element in self {
result.append(try transform(element))
}
return result
}
}
3. ์ค์ ํ๋ก์ ํธ์์ ์ ์ฉํ๊ธฐ
์ด๋ก ๋ง ์์์๋ ๋ถ์กฑํด. ์ค์ ํ๋ก์ ํธ์์ Swift์ ์ฒ ํ์ ์ ์ฉํด๋ด์ผ ํด.๐ฎ ์์ ํ๋ก์ ํธ๋ถํฐ
๊ฐ๋จํ CLI ๋๊ตฌ๋ iOS ์ฑ์ ๋ง๋ค์ด๋ณด๋ฉด์ Swift์ ๊ธฐ๋ฅ๋ค์ ํ๋์ฉ ์ ์ฉํด๋ด.
๐ ๋ฆฌํฉํ ๋ง ์ฐ์ต
๊ธฐ์กด ์ฝ๋๋ฅผ Swift์ ์ฒ ํ์ ๋ง๊ฒ ๋ฆฌํฉํ ๋งํด๋ด. ํนํ ์ต์ ๋๊ณผ ํ๋กํ ์ฝ ํ์ฉ์ ์ง์ค!
๐ฅ ์ฝ๋ ๋ฆฌ๋ทฐ
๋ค๋ฅธ ์ฌ๋์ Swift ์ฝ๋๋ฅผ ๋ฆฌ๋ทฐํ๊ณ , ์์ ์ ์ฝ๋๋ ๋ฆฌ๋ทฐ๋ฐ์๋ด. ์ฒ ํ์ ๊ด์ ์์ ํ ๋ก ํ๋ ๊ฒ ์ค์ํด.
๐ ๋ธ๋ก๊ทธ ์์ฑ
๋ฐฐ์ด ๋ด์ฉ์ ๊ธ๋ก ์ ๋ฆฌํ๋ฉด ์ดํด๊ฐ ๋ ๊น์ด์ ธ. ๋ค๋ฅธ ์ฌ๋์๊ฒ ์ค๋ช ํ ์ ์์ด์ผ ์ง์ง ์๋ ๊ฑฐ์ผ!
4. ์ปค๋ฎค๋ํฐ ์ฐธ์ฌ
Swift ์ปค๋ฎค๋ํฐ๋ ๋งค์ฐ ํ๋ฐํด. ํฌ๋ผ, ์ฌ๋, ๋์ค์ฝ๋ ๋ฑ์์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ์ํตํด๋ด.๐ฌ ๋ง๋ฌด๋ฆฌ: Swift ์ฒ ํ์ ๋ฏธ๋
Swift๋ ๊ณ์ ์งํํ๊ณ ์์ด. ์์ผ๋ก ์ด๋ค ๋ฐฉํฅ์ผ๋ก ๋ฐ์ ํ ๊น? ๐ฎ์์๋๋ ๋ฐ์ ๋ฐฉํฅ
๐ ๋ ๊ฐ๋ ฅํ ํ์ ์์คํ
์์กด ํ์ (Dependent Types), ์ ํ ํ์ (Linear Types) ๋ฑ ๋ ์ ๊ตํ ํ์ ์์คํ ์ด ๋์ ๋ ๊ฐ๋ฅ์ฑ์ด ์์ด.
โก ์ฑ๋ฅ ์ต์ ํ
์์ ๊ถ ์์คํ ๊ฐ์ , ๋ ๊ณต๊ฒฉ์ ์ธ ์ต์ ํ ๋ฑ์ผ๋ก ์ฑ๋ฅ์ด ๊ณ์ ํฅ์๋ ๊ฑฐ์ผ.
๐ ํฌ๋ก์ค ํ๋ซํผ ํ์ฅ
Windows, Linux, WebAssembly ๋ฑ ๋ ๋ง์ ํ๋ซํผ ์ง์์ด ๊ฐํ๋ ๊ฑฐ์ผ.
๐ค AI/ML ํตํฉ
๋จธ์ ๋ฌ๋๊ณผ์ ํตํฉ์ด ๋์ฑ ๊ฐํ๋๊ณ , Swift for TensorFlow์ ์์ด๋์ด๊ฐ ๊ณ์ ๋ฐ์ ํ ๊ฑฐ์ผ.
Swift ์ฒ ํ์ ํต์ฌ ๊ตํ
Swift๋ฅผ ๊ณต๋ถํ๋ฉด์ ์ป์ ์ ์๋ ๊ฐ์ฅ ํฐ ๊ตํ์ ๋ญ๊น? ๐2. ๋ช ์์ ํํ: ์๋ฌต์ ์ธ ๊ฒ๋ณด๋ค ๋ช ์์ ์ธ ๊ฒ์ด ๋ซ๋ค
3. ๊ฐ ์๋ฏธ๋ก : ๊ฐ๋ฅํ๋ฉด ๊ฐ ํ์ ์ ์ฌ์ฉํ๋ผ
4. ํ๋กํ ์ฝ ์งํฅ: ์์๋ณด๋ค ์กฐํฉ์ ์ ํธํ๋ผ
5. ์ ๋ก ๋น์ฉ ์ถ์ํ: ๊ณ ์์ค ์ฝ๋๊ฐ ์ ์์ค ์ฑ๋ฅ์ ๊ฐ์ ธ์ผ ํ๋ค
6. ์ ์ง์ ๊ณต๊ฐ: ๊ฐ๋จํ ๊ฒ์ ๊ฐ๋จํ๊ฒ, ๋ณต์กํ ๊ฒ์ ๊ฐ๋ฅํ๊ฒ
7. ํ๋์ฑ: ์ต์ ํ๋ก๊ทธ๋๋ฐ ์ด๋ก ์ ์ ๊ทน ์์ฉํ๋ผ
๋น์ ์ Swift ์ฌ์
Swift๋ฅผ ๋ฐฐ์ฐ๋ ๊ฒ์ ๋จ์ํ ์๋ก์ด ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์ตํ๋ ๊ฒ์ด ์๋์ผ. ํ๋ ์ํํธ์จ์ด ๊ฐ๋ฐ์ ๋ชจ๋ฒ ์ฌ๋ก๋ฅผ ๋ฐฐ์ฐ๋ ๊ฒ์ด์ง. ๐Swift์ ์ฒ ํ์ ์ดํดํ๋ฉด ๋ค๋ฅธ ์ธ์ด๋ฅผ ๋ฐฐ์ธ ๋๋ ๋์์ด ๋ผ. ์๋ํ๋ฉด Swift๋ ์์ญ ๋ ๊ฐ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์ฐ๊ตฌ ์ฑ๊ณผ๋ฅผ ์ง๋์ฑํ๊ฑฐ๋ . Rust์ ์์ ๊ถ ๊ฐ๋ , Haskell์ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ, C++์ ์ ๋ค๋ฆญ, Objective-C์ ๋์ ๋์คํจ์น ๋ฑ ๋ค์ํ ์ธ์ด์ ์ฅ์ ์ ๋ฐฐ์ธ ์ ์์ด.
๊ฐ์ฅ ์ค์ํ ๊ฑด ์ค์ฒ์ด์ผ. ์ด ๊ธ์์ ๋ฐฐ์ด ์ฒ ํ๋ค์ ์ค์ ์ฝ๋์ ์ ์ฉํด๋ด. ์ฒ์์๋ ์ด์ํ ์ ์์ง๋ง, ์ ์ ์์ฐ์ค๋ฌ์์ง ๊ฑฐ์ผ. ๊ทธ๋ฆฌ๊ณ ์ด๋ ์๊ฐ "์, ์ด๋์ Swift๊ฐ ์ด๋ ๊ฒ ์ค๊ณ๋ ๊ฑฐ๊ตฌ๋!"ํ๊ณ ๊นจ๋ซ๋ ์๊ฐ์ด ์ฌ ๊ฑฐ์ผ. ๐ก
Swift๋ ๊ณ์ ์งํํ๊ณ ์์ด. ๋น์ ๋ ํจ๊ป ์ฑ์ฅํ๊ธธ ๋ฐ๋ผ! ๐
Swift์ ์ฒ ํ์ ์ดํดํ๋ ๊ฒ์ ๋จ์ํ ์ธ์ด๋ฅผ ๋ฐฐ์ฐ๋ ๊ฒ์ ๋์ด,
๋ ๋์ ์ํํธ์จ์ด๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ฐ๋ ๊ฒ์
๋๋ค. ๐
์์ ํ๊ณ , ๋น ๋ฅด๊ณ , ํํ๋ ฅ ์๋ ์ฝ๋๋ฅผ ์์ฑํ๋ ์ฌ์ ์
์ด ๊ธ์ด ์์ ๋์์ด ๋์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.