์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿš€ Swift์˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŠน์ง•: ์ฝ”๋“œ๋ฅผ ๋” ์šฐ์•„ํ•˜๊ฒŒ ๋งŒ๋“œ๋Š” ๋งˆ๋ฒ• โœจ

๐Ÿš€ Swift์˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŠน์ง•: ์ฝ”๋“œ๋ฅผ ๋” ์šฐ์•„ํ•˜๊ฒŒ ๋งŒ๋“œ๋Š” ๋งˆ๋ฒ• โœจ

์•ˆ๋…•ํ•˜์„ธ์š”, ๊ฐœ๋ฐœ์ž ์—ฌ๋Ÿฌ๋ถ„! ์˜ค๋Š˜์€ 2025๋…„ 3์›” 6์ผ, Swift์˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŠน์ง•์— ๋Œ€ํ•ด ๊นŠ์ด ํŒŒํ—ค์ณ ๋ณผ๊ฒŒ์š”. ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด๋ผ๊ณ  ํ•˜๋ฉด ๋ญ”๊ฐ€ ์–ด๋ ต๊ณ  ๋ณต์žกํ•˜๊ฒŒ ๋А๊ปด์งˆ ์ˆ˜ ์žˆ์ง€๋งŒ, ์‹ค์ œ๋กœ๋Š” ์ฝ”๋“œ๋ฅผ ๋” ๊น”๋”ํ•˜๊ณ  ์•ˆ์ „ํ•˜๊ฒŒ ๋งŒ๋“ค์–ด์ฃผ๋Š” ๊ฐœ๋ฐœ์ž์˜ ๋ฒ ํ”„ ๊ฐ™์€ ์กด์žฌ๋ž๋‹ˆ๋‹ค! ๐Ÿ˜Ž

์ด ๊ธ€์„ ํ†ตํ•ด Swift์—์„œ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์–ด๋–ป๊ฒŒ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๋Š”์ง€, ๊ทธ๋ฆฌ๊ณ  ์™œ ์ด๊ฒŒ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ฝ”๋”ฉ ์ƒํ™œ์„ 180๋„ ๋ฐ”๊ฟ”๋†“์„ ์ˆ˜ ์žˆ๋Š”์ง€ ์•Œ์•„๋ณด๋„๋ก ํ• ๊ฒŒ์š”. ์žฌ๋Šฅ๋„ท์—์„œ Swift ๊ฐœ๋ฐœ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•˜๊ฑฐ๋‚˜ ์ฐพ๊ณ  ๊ณ„์‹ ๋‹ค๋ฉด, ์ด ๊ธ€์ด ์—ฌ๋Ÿฌ๋ถ„์˜ ์ฝ”๋”ฉ ์Šคํ‚ฌ์„ ํ•œ ๋‹จ๊ณ„ ์—…๊ทธ๋ ˆ์ด๋“œํ•˜๋Š” ๋ฐ ๋„์›€์ด ๋  ๊ฑฐ์˜ˆ์š”! ๐Ÿš€

๐Ÿ“š ๋ชฉ์ฐจ

  1. ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด๋ž€? Swift์™€์˜ ๋งŒ๋‚จ
  2. Swift์˜ ์ผ๊ธ‰ ๊ฐ์ฒด๋กœ์„œ์˜ ํ•จ์ˆ˜
  3. ์ˆœ์ˆ˜ ํ•จ์ˆ˜์™€ ๋ถ€์ˆ˜ ํšจ๊ณผ
  4. ๊ณ ์ฐจ ํ•จ์ˆ˜ ๋งˆ์Šคํ„ฐํ•˜๊ธฐ: map, filter, reduce
  5. ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ ๋ถˆ๋ณ€์„ฑ
  6. ํด๋กœ์ €์˜ ๋งˆ๋ฒ•: ์บก์ฒ˜์™€ ํƒˆ์ถœ
  7. ํ•จ์ˆ˜ ํ•ฉ์„ฑ๊ณผ ํŒŒ์ดํ”„๋ผ์ธ
  8. ์˜ต์…”๋„๊ณผ ํ•จ์ˆ˜ํ˜• ์ ‘๊ทผ๋ฒ•
  9. ์‹ค์ „ ์˜ˆ์ œ: ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋ฆฌํŒฉํ† ๋งํ•˜๊ธฐ
  10. Swift ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋ฏธ๋ž˜

1. ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด๋ž€? Swift์™€์˜ ๋งŒ๋‚จ ๐Ÿค

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Functional Programming, FP)์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŒจ๋Ÿฌ๋‹ค์ž„ ์ค‘ ํ•˜๋‚˜๋กœ, ํ•จ์ˆ˜๋ฅผ ์ค‘์‹ฌ์œผ๋กœ ์ฝ”๋“œ๋ฅผ ๊ตฌ์„ฑํ•˜๋Š” ๋ฐฉ์‹์ด์—์š”. ๊ทผ๋ฐ ๊ทธ๋ƒฅ ํ•จ์ˆ˜ ์“ฐ๋Š” ๊ฑฐ๋ž‘์€ ๋‹ค๋ฅด๋‹ต๋‹ˆ๋‹ค! ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ์ƒํƒœ ๋ณ€๊ฒฝ๊ณผ ๊ฐ€๋ณ€ ๋ฐ์ดํ„ฐ๋ฅผ ํ”ผํ•˜๊ณ , ํ•จ์ˆ˜๋ฅผ ์ผ๊ธ‰ ๊ฐ์ฒด๋กœ ์ทจ๊ธ‰ํ•˜๋Š” ํŠน์ง•์ด ์žˆ์–ด์š”.

Swift๋Š” 2014๋…„์— ์ฒ˜์Œ ๋“ฑ์žฅํ–ˆ์„ ๋•Œ๋ถ€ํ„ฐ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋งŽ์€ ๊ฐœ๋…์„ ํฌํ•จํ•˜๊ณ  ์žˆ์—ˆ์–ด์š”. ์• ํ”Œ์ด "์™€ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ฐœ์ฉ๋‹ค!" ํ•˜๋ฉด์„œ Swift๋ฅผ ์„ค๊ณ„ํ–ˆ๋‹ค๊ณ  ๋ณผ ์ˆ˜ ์žˆ์ฃ . ใ…‹ใ…‹ใ…‹ ๋ฌผ๋ก  Swift๋Š” ๋‹ค์ค‘ ํŒจ๋Ÿฌ๋‹ค์ž„ ์–ธ์–ด๋ผ์„œ ๊ฐ์ฒด์ง€ํ–ฅ, ํ”„๋กœํ† ์ฝœ ์ง€ํ–ฅ, ํ•จ์ˆ˜ํ˜• ๋“ฑ ์—ฌ๋Ÿฌ ์Šคํƒ€์ผ์„ ์„ž์–ด ์“ธ ์ˆ˜ ์žˆ์–ด์š”. ๊ทผ๋ฐ ํ•จ์ˆ˜ํ˜•์˜ ๋งค๋ ฅ์— ๋น ์ง€๋ฉด ํ—ค์–ด๋‚˜์˜ค๊ธฐ ํž˜๋“ค๋‹ค๋Š” ๊ฑฐ... ์•„์‹œ์ฃ ? ๐Ÿ˜

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ํ•ต์‹ฌ ์›์น™

  1. ๋ถˆ๋ณ€์„ฑ(Immutability): ํ•œ๋ฒˆ ๋งŒ๋“ค์–ด์ง„ ๋ฐ์ดํ„ฐ๋Š” ๋ณ€๊ฒฝํ•˜์ง€ ์•Š์•„์š”
  2. ์ˆœ์ˆ˜ ํ•จ์ˆ˜(Pure Functions): ๊ฐ™์€ ์ž…๋ ฅ์—๋Š” ํ•ญ์ƒ ๊ฐ™์€ ์ถœ๋ ฅ, ๋ถ€์ˆ˜ํšจ๊ณผ ์—†์Œ
  3. ์ผ๊ธ‰ ํ•จ์ˆ˜(First-class Functions): ํ•จ์ˆ˜๋ฅผ ๋ณ€์ˆ˜์ฒ˜๋Ÿผ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ์Œ
  4. ๊ณ ์ฐจ ํ•จ์ˆ˜(Higher-order Functions): ํ•จ์ˆ˜๊ฐ€ ๋‹ค๋ฅธ ํ•จ์ˆ˜๋ฅผ ์ธ์ž๋กœ ๋ฐ›๊ฑฐ๋‚˜ ๋ฐ˜ํ™˜ํ•  ์ˆ˜ ์žˆ์Œ
  5. ์„ ์–ธ์  ํ”„๋กœ๊ทธ๋ž˜๋ฐ(Declarative Programming): '์–ด๋–ป๊ฒŒ'๋ณด๋‹ค '๋ฌด์—‡์„' ์ค‘์‹ฌ์œผ๋กœ ์ฝ”๋“œ ์ž‘์„ฑ

Swift์—์„œ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ํ•˜๋ฉด ๋ญ๊ฐ€ ์ข‹๋ƒ๊ณ ์š”? ์ผ๋‹จ ์ฝ”๋“œ๊ฐ€ ๋” ์˜ˆ์ธก ๊ฐ€๋Šฅํ•˜๊ณ , ํ…Œ์ŠคํŠธํ•˜๊ธฐ ์‰ฌ์›Œ์ง€๊ณ , ๋™์‹œ์„ฑ ์ฒ˜๋ฆฌ๊ฐ€ ํŽธํ•ด์ ธ์š”. ๋ฒ„๊ทธ๋„ ์ค„์–ด๋“ค๊ณ ์š”! ํŠนํžˆ iOS/macOS ์•ฑ ๊ฐœ๋ฐœํ•  ๋•Œ UI ์ƒํƒœ ๊ด€๋ฆฌ๋‚˜ ๋„คํŠธ์›Œํฌ ์š”์ฒญ ๊ฐ™์€ ๋ณต์žกํ•œ ์ž‘์—…์„ ๋‹ค๋ฃฐ ๋•Œ ์ง„๊ฐ€๋ฅผ ๋ฐœํœ˜ํ•œ๋‹ต๋‹ˆ๋‹ค. ๐Ÿ”ฅ

Swift์˜ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŒจ๋Ÿฌ๋‹ค์ž„ ๊ฐ์ฒด์ง€ํ–ฅ ํด๋ž˜์Šค, ์ƒ์† ํ•จ์ˆ˜ํ˜• map, filter, reduce ํ”„๋กœํ† ์ฝœ ์ง€ํ–ฅ ํ”„๋กœํ† ์ฝœ, ํ™•์žฅ

Swift๊ฐ€ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์–ผ๋งˆ๋‚˜ ์‚ฌ๋ž‘ํ•˜๋Š”์ง€ ๋ณด์—ฌ์ฃผ๋Š” ์ฝ”๋“œ ํ•œ ์กฐ๊ฐ์„ ๋ณผ๊นŒ์š”? ์ด๊ฑด ๊ทธ๋ƒฅ ๋ง›๋ณด๊ธฐ์˜ˆ์š”!


// ๋ช…๋ นํ˜• ๋ฐฉ์‹ (์ ˆ์ฐจ์ )
var numbers = [1, 2, 3, 4, 5]
var doubled = [Int]()
for number in numbers {
    doubled.append(number * 2)
}

// ํ•จ์ˆ˜ํ˜• ๋ฐฉ์‹ (์„ ์–ธ์ )
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
      

์–ด๋•Œ์š”? ํ•จ์ˆ˜ํ˜•์ด ํ›จ์”ฌ ๊ฐ„๊ฒฐํ•˜๊ณ  ์ฝ๊ธฐ ์‰ฝ์ฃ ? ์ด๊ฒŒ ๋ฐ”๋กœ ํ•จ์ˆ˜ํ˜•์˜ ๋งค๋ ฅ์ด์—์š”! ๐Ÿ˜

2. Swift์˜ ์ผ๊ธ‰ ๊ฐ์ฒด๋กœ์„œ์˜ ํ•จ์ˆ˜ ๐Ÿ†

Swift์—์„œ ํ•จ์ˆ˜๋Š” ์ผ๊ธ‰ ๊ฐ์ฒด(First-class citizen)์˜ˆ์š”. ์ด๊ฒŒ ๋ฌด์Šจ ๋ง์ด๋ƒ๋ฉด, ํ•จ์ˆ˜๋ฅผ ๋ณ€์ˆ˜์— ํ• ๋‹นํ•˜๊ณ , ๋‹ค๋ฅธ ํ•จ์ˆ˜์˜ ์ธ์ž๋กœ ์ „๋‹ฌํ•˜๊ณ , ํ•จ์ˆ˜์—์„œ ๋ฐ˜ํ™˜ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๋œป์ด์—์š”. ์ง„์งœ ๋ณ€์ˆ˜๋ž‘ ๋˜‘๊ฐ™์ด ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ๋‹ค๋‹ˆ๊นŒ์š”! ๋Œ€๋ฐ•์ด์ฃ ? ใ…‹ใ…‹ใ…‹

ํ•จ์ˆ˜๋ฅผ ๋ณ€์ˆ˜์— ํ• ๋‹นํ•˜๋Š” ์˜ˆ์ œ๋ฅผ ๋ณผ๊นŒ์š”?


// ํ•จ์ˆ˜ ์ •์˜
func greet(name: String) -> String {
    return "์•ˆ๋…•, \(name)!"
}

// ํ•จ์ˆ˜๋ฅผ ๋ณ€์ˆ˜์— ํ• ๋‹น
let sayHello = greet
print(sayHello("Swift ๊ฐœ๋ฐœ์ž")) // ์ถœ๋ ฅ: ์•ˆ๋…•, Swift ๊ฐœ๋ฐœ์ž!
      

ํ•จ์ˆ˜๋ฅผ ๋‹ค๋ฅธ ํ•จ์ˆ˜์˜ ์ธ์ž๋กœ ์ „๋‹ฌํ•˜๋Š” ๊ฒƒ๋„ ๊ฐ€๋Šฅํ•ด์š”:


func performOperation(_ operation: (Int, Int) -> Int, on a: Int, and b: Int) -> Int {
    return operation(a, b)
}

func add(a: Int, b: Int) -> Int {
    return a + b
}

let result = performOperation(add, on: 5, and: 3) // ๊ฒฐ๊ณผ: 8
      

ํ•จ์ˆ˜์—์„œ ํ•จ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•  ์ˆ˜๋„ ์žˆ์–ด์š”. ์ด๊ฑด ์ข€ ๊ณ ๊ธ‰ ๊ธฐ์ˆ ์ด์ง€๋งŒ ํ•œ๋ฒˆ ๋ณผ๊นŒ์š”?


func makeMultiplier(factor: Int) -> (Int) -> Int {
    func multiply(number: Int) -> Int {
        return number * factor
    }
    return multiply
}

let timesFive = makeMultiplier(factor: 5)
print(timesFive(6)) // ์ถœ๋ ฅ: 30
      

์ด๋Ÿฐ ํŠน์„ฑ ๋•๋ถ„์— Swift์—์„œ๋Š” ํ•จ์ˆ˜๋ฅผ ๋ ˆ๊ณ  ๋ธ”๋ก์ฒ˜๋Ÿผ ์กฐ๋ฆฝํ•ด์„œ ๋ณต์žกํ•œ ๋กœ์ง์„ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์–ด์š”. ์žฌ๋Šฅ๋„ท์—์„œ Swift ๊ฐœ๋ฐœ์ž๋“ค์ด ์ด๋Ÿฐ ๊ธฐ๋ฒ•์„ ํ™œ์šฉํ•œ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŽ์ด ๊ณต์œ ํ•˜๋Š” ๊ฑธ ๋ณผ ์ˆ˜ ์žˆ์ฃ ! ๐Ÿงฉ

์‹ค์ „ ํ™œ์šฉ ์˜ˆ: ๋„คํŠธ์›Œํฌ ์š”์ฒญ ํ•ธ๋“ค๋Ÿฌ


typealias CompletionHandler = (Data?, Error?) -> Void

func fetchData(from url: URL, completion: @escaping CompletionHandler) {
    // ๋„คํŠธ์›Œํฌ ์š”์ฒญ ์ฝ”๋“œ
}

// ๋‹ค์–‘ํ•œ ์‘๋‹ต ์ฒ˜๋ฆฌ๊ธฐ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Œ
func logResponse(data: Data?, error: Error?) {
    if let error = error {
        print("์˜ค๋ฅ˜ ๋ฐœ์ƒ: \(error)")
    } else if let data = data {
        print("๋ฐ์ดํ„ฐ ๋ฐ›์Œ: \(data.count) ๋ฐ”์ดํŠธ")
    }
}

// ํ•จ์ˆ˜๋ฅผ ์ธ์ž๋กœ ์ „๋‹ฌ
fetchData(from: URL(string: "https://api.example.com")!) { data, error in
    logResponse(data: data, error: error)
}
        

Swift์—์„œ ํ•จ์ˆ˜๋ฅผ ์ผ๊ธ‰ ๊ฐ์ฒด๋กœ ๋‹ค๋ฃจ๋Š” ๋Šฅ๋ ฅ์€ ํŠนํžˆ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ ์ฝœ๋ฐฑ ํŒจํ„ด์—์„œ ๋น›์„ ๋ฐœํ•ด์š”. iOS ์•ฑ ๊ฐœ๋ฐœํ•  ๋•Œ ๋„คํŠธ์›Œํฌ ์š”์ฒญ์ด๋‚˜ ์• ๋‹ˆ๋ฉ”์ด์…˜ ๊ฐ™์€ ๋น„๋™๊ธฐ ์ž‘์—…์„ ์ฒ˜๋ฆฌํ•  ๋•Œ ์ •๋ง ์œ ์šฉํ•˜๋‹ต๋‹ˆ๋‹ค! ๐Ÿ’ฏ

Swift์—์„œ ํ•จ์ˆ˜๋ฅผ ์ผ๊ธ‰ ๊ฐ์ฒด๋กœ ๋‹ค๋ฃจ๊ธฐ ํ•จ์ˆ˜๋ฅผ ๋ณ€์ˆ˜์— ํ• ๋‹น let func1 = someFunc ํ•จ์ˆ˜๋ฅผ ์ธ์ž๋กœ ์ „๋‹ฌ doSomething(func1) ํ•จ์ˆ˜์—์„œ ํ•จ์ˆ˜ ๋ฐ˜ํ™˜ return { x in x * 2 } ํด๋กœ์ € ํ‘œํ˜„์‹ numbers.map { $0 * 2 }

3. ์ˆœ์ˆ˜ ํ•จ์ˆ˜์™€ ๋ถ€์ˆ˜ ํšจ๊ณผ ๐Ÿงช

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ํ•ต์‹ฌ ๊ฐœ๋… ์ค‘ ํ•˜๋‚˜๊ฐ€ ๋ฐ”๋กœ ์ˆœ์ˆ˜ ํ•จ์ˆ˜(Pure Functions)์˜ˆ์š”. ์ˆœ์ˆ˜ ํ•จ์ˆ˜๋ž€ ๋ญ๋ƒ๋ฉด:

  1. ๊ฐ™์€ ์ž…๋ ฅ์— ๋Œ€ํ•ด ํ•ญ์ƒ ๊ฐ™์€ ์ถœ๋ ฅ์„ ๋ฐ˜ํ™˜ํ•จ
  2. ๋ถ€์ˆ˜ ํšจ๊ณผ(Side Effects)๊ฐ€ ์—†์Œ - ํ•จ์ˆ˜ ์™ธ๋ถ€์˜ ์ƒํƒœ๋ฅผ ๋ณ€๊ฒฝํ•˜์ง€ ์•Š์Œ

์ˆœ์ˆ˜ ํ•จ์ˆ˜ vs ๋น„์ˆœ์ˆ˜ ํ•จ์ˆ˜์˜ ์˜ˆ๋ฅผ ๋ณผ๊นŒ์š”?


// ์ˆœ์ˆ˜ ํ•จ์ˆ˜ - ํ•ญ์ƒ ๊ฐ™์€ ์ž…๋ ฅ์— ๊ฐ™์€ ์ถœ๋ ฅ, ์™ธ๋ถ€ ์ƒํƒœ ๋ณ€๊ฒฝ ์—†์Œ
func add(a: Int, b: Int) -> Int {
    return a + b
}

// ๋น„์ˆœ์ˆ˜ ํ•จ์ˆ˜ - ์™ธ๋ถ€ ์ƒํƒœ(total)์— ์˜์กดํ•˜๊ณ  ๋ณ€๊ฒฝํ•จ
var total = 0
func addToTotal(value: Int) {
    total += value  // ๋ถ€์ˆ˜ ํšจ๊ณผ: ์™ธ๋ถ€ ๋ณ€์ˆ˜ ๋ณ€๊ฒฝ
}
      

์ˆœ์ˆ˜ ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ฝ”๋“œ๊ฐ€ ์˜ˆ์ธก ๊ฐ€๋Šฅํ•˜๊ณ  ํ…Œ์ŠคํŠธํ•˜๊ธฐ ์‰ฌ์›Œ์ ธ์š”. ๋””๋ฒ„๊น…๋„ ํ›จ์”ฌ ๊ฐ„๋‹จํ•ด์ง€๊ณ ์š”! ํ•จ์ˆ˜๊ฐ€ ์™ธ๋ถ€ ์ƒํƒœ์— ์˜์กดํ•˜์ง€ ์•Š์œผ๋‹ˆ๊นŒ ๋…๋ฆฝ์ ์œผ๋กœ ํ…Œ์ŠคํŠธํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ ์š”. ๐Ÿ‘จโ€๐Ÿ”ฌ

โš ๏ธ ๋ถ€์ˆ˜ ํšจ๊ณผ์˜ ํ•จ์ •

๋ถ€์ˆ˜ ํšจ๊ณผ๋Š” ํ•จ์ˆ˜๊ฐ€ ๋ฐ˜ํ™˜ ๊ฐ’ ์™ธ์— ๋‹ค๋ฅธ ์ƒํƒœ๋ฅผ ๋ณ€๊ฒฝํ•  ๋•Œ ๋ฐœ์ƒํ•ด์š”. ์˜ˆ๋ฅผ ๋“ค๋ฉด:

  1. ์ „์—ญ ๋ณ€์ˆ˜ ์ˆ˜์ •
  2. ํŒŒ์ผ ์‹œ์Šคํ…œ ๋ณ€๊ฒฝ
  3. ๋„คํŠธ์›Œํฌ ์š”์ฒญ ๋ณด๋‚ด๊ธฐ
  4. ํ™”๋ฉด์— ์ถœ๋ ฅํ•˜๊ธฐ
  5. ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ˆ˜์ •

์‹ค์ œ ์•ฑ์—์„œ๋Š” ๋ถ€์ˆ˜ ํšจ๊ณผ๋ฅผ ์™„์ „ํžˆ ํ”ผํ•  ์ˆ˜๋Š” ์—†์ง€๋งŒ, ์ตœ๋Œ€ํ•œ ๊ฒฉ๋ฆฌ์‹œํ‚ค๊ณ  ์ œํ•œํ•˜๋Š” ๊ฒƒ์ด ์ข‹์•„์š”!

Swift์—์„œ๋Š” ์ˆœ์ˆ˜ ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•˜๊ธฐ ์œ„ํ•ด ๋ช‡ ๊ฐ€์ง€ ํŒจํ„ด์„ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ์–ด์š”:


// ์ƒํƒœ ๋ณ€๊ฒฝ ๋Œ€์‹  ์ƒˆ ๊ฐ’ ๋ฐ˜ํ™˜ํ•˜๊ธฐ
struct User {
    let name: String
    let age: Int
    
    // ๋น„์ˆœ์ˆ˜ํ•œ ๋ฐฉ์‹: mutating func๋กœ ์ž์‹ ์„ ๋ณ€๊ฒฝ
    mutating func celebrateBirthday() {
        age += 1  // ์ปดํŒŒ์ผ ์˜ค๋ฅ˜! age๋Š” let์ด๋‹ˆ๊นŒ
    }
    
    // ์ˆœ์ˆ˜ํ•œ ๋ฐฉ์‹: ์ƒˆ๋กœ์šด ์ธ์Šคํ„ด์Šค ๋ฐ˜ํ™˜
    func afterBirthday() -> User {
        return User(name: name, age: age + 1)
    }
}
      

์‹ค์ œ๋กœ ์•ฑ์„ ๊ฐœ๋ฐœํ•  ๋•Œ๋Š” ์™„์ „ํ•œ ์ˆœ์ˆ˜ ํ•จ์ˆ˜๋งŒ์œผ๋กœ๋Š” ํž˜๋“ค์–ด์š”. UI ์—…๋ฐ์ดํŠธ๋‚˜ ๋„คํŠธ์›Œํฌ ์š”์ฒญ ๊ฐ™์€ ๋ถ€์ˆ˜ ํšจ๊ณผ๋Š” ํ•„์š”ํ•˜๋‹ˆ๊นŒ์š”. ๊ทธ๋ž˜์„œ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ๋Š” ๋ถ€์ˆ˜ ํšจ๊ณผ๋ฅผ ์™„์ „ํžˆ ์ œ๊ฑฐํ•˜๊ธฐ๋ณด๋‹ค ๊ด€๋ฆฌํ•˜๊ณ  ์ œํ•œํ•˜๋Š” ๋ฐฉํ–ฅ์œผ๋กœ ๊ฐ€์š”.

Swift์—์„œ๋Š” ์ด๋Ÿฐ ๋ถ€์ˆ˜ ํšจ๊ณผ๋ฅผ ๊ด€๋ฆฌํ•˜๊ธฐ ์œ„ํ•œ ์—ฌ๋Ÿฌ ํŒจํ„ด์ด ์žˆ์–ด์š”. ์˜ˆ๋ฅผ ๋“ค์–ด, Result ํƒ€์ž…์„ ์‚ฌ์šฉํ•ด ์˜ค๋ฅ˜ ์ฒ˜๋ฆฌ๋ฅผ ํ•จ์ˆ˜ํ˜•์œผ๋กœ ์ ‘๊ทผํ•˜๊ฑฐ๋‚˜, Combine ํ”„๋ ˆ์ž„์›Œํฌ๋กœ ๋น„๋™๊ธฐ ์ด๋ฒคํŠธ ์ŠคํŠธ๋ฆผ์„ ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ์ฃ . 2025๋…„ ํ˜„์žฌ๋Š” ์ด๋Ÿฐ ํŒจํ„ด๋“ค์ด ๋” ๋ฐœ์ „ํ•ด์„œ Swift ๊ฐœ๋ฐœ์ž๋“ค์˜ ์‚ถ์„ ํ›จ์”ฌ ํŽธํ•˜๊ฒŒ ๋งŒ๋“ค์–ด์ฃผ๊ณ  ์žˆ์–ด์š”! ๐Ÿš€

์ˆœ์ˆ˜ ํ•จ์ˆ˜ vs ๋น„์ˆœ์ˆ˜ ํ•จ์ˆ˜ ์ˆœ์ˆ˜ ํ•จ์ˆ˜ ๊ฐ™์€ ์ž…๋ ฅ = ๊ฐ™์€ ์ถœ๋ ฅ f(x) = x + 1 ์™ธ๋ถ€ ์ƒํƒœ ๋ณ€๊ฒฝ ์—†์Œ ์˜ˆ์ธก ๊ฐ€๋Šฅ & ํ…Œ์ŠคํŠธ ์šฉ์ด ๋น„์ˆœ์ˆ˜ ํ•จ์ˆ˜ ์™ธ๋ถ€ ์ƒํƒœ์— ์˜์กด ์ „์—ญ ๋ณ€์ˆ˜ ์‚ฌ์šฉ ๋ถ€์ˆ˜ ํšจ๊ณผ ๋ฐœ์ƒ ํŒŒ์ผ ์“ฐ๊ธฐ, ๋„คํŠธ์›Œํฌ ์š”์ฒญ ๋“ฑ

4. ๊ณ ์ฐจ ํ•จ์ˆ˜ ๋งˆ์Šคํ„ฐํ•˜๊ธฐ: map, filter, reduce ๐Ÿ”

Swift์˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ๊ฐ€์žฅ ๋งŽ์ด ์‚ฌ์šฉ๋˜๋Š” ๋„๊ตฌ๊ฐ€ ๋ฐ”๋กœ ๊ณ ์ฐจ ํ•จ์ˆ˜(Higher-order Functions)์˜ˆ์š”. ๊ณ ์ฐจ ํ•จ์ˆ˜๋ž€ ๋‹ค๋ฅธ ํ•จ์ˆ˜๋ฅผ ์ธ์ž๋กœ ๋ฐ›๊ฑฐ๋‚˜ ํ•จ์ˆ˜๋ฅผ ๊ฒฐ๊ณผ๋กœ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ๋งํ•ด์š”. Swift์—์„œ๋Š” ํŠนํžˆ ์ปฌ๋ ‰์…˜์„ ๋‹ค๋ฃฐ ๋•Œ ์œ ์šฉํ•œ ๊ณ ์ฐจ ํ•จ์ˆ˜๋“ค์ด ์žˆ๋‹ต๋‹ˆ๋‹ค!

๊ฐ€์žฅ ๋งŽ์ด ์“ฐ์ด๋Š” 3๋Œ€ ๊ณ ์ฐจ ํ•จ์ˆ˜๋ฅผ ์•Œ์•„๋ณผ๊ฒŒ์š”:

1. map - ๋ณ€ํ™˜์˜ ๋งˆ๋ฒ•์‚ฌ ๐Ÿง™โ€โ™‚๏ธ

map์€ ์ปฌ๋ ‰์…˜์˜ ๊ฐ ์š”์†Œ๋ฅผ ๋ณ€ํ™˜ํ•ด์„œ ์ƒˆ๋กœ์šด ์ปฌ๋ ‰์…˜์„ ๋งŒ๋“ค์–ด์š”.


let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
// ๊ฒฐ๊ณผ: [2, 4, 6, 8, 10]

let names = ["steve", "tim", "craig"]
let capitalized = names.map { $0.capitalized }
// ๊ฒฐ๊ณผ: ["Steve", "Tim", "Craig"]
        

2. filter - ์„ ๋ณ„์˜ ๋‹ฌ์ธ ๐Ÿ•ต๏ธโ€โ™€๏ธ

filter๋Š” ์กฐ๊ฑด์— ๋งž๋Š” ์š”์†Œ๋งŒ ๊ณจ๋ผ๋‚ด์„œ ์ƒˆ ์ปฌ๋ ‰์…˜์„ ๋งŒ๋“ค์–ด์š”.


let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let evens = numbers.filter { $0 % 2 == 0 }
// ๊ฒฐ๊ณผ: [2, 4, 6, 8, 10]

let team = ["๊ฐœ๋ฐœ์ž", "๋””์ž์ด๋„ˆ", "PM", "๊ฐœ๋ฐœ์ž", "QA"]
let developers = team.filter { $0 == "๊ฐœ๋ฐœ์ž" }
// ๊ฒฐ๊ณผ: ["๊ฐœ๋ฐœ์ž", "๊ฐœ๋ฐœ์ž"]
        

3. reduce - ํ•ฉ์‚ฐ์˜ ๊ณ ์ˆ˜ ๐Ÿงฎ

reduce๋Š” ์ปฌ๋ ‰์…˜์˜ ๋ชจ๋“  ์š”์†Œ๋ฅผ ํ•˜๋‚˜์˜ ๊ฐ’์œผ๋กœ ํ•ฉ์ณ์š”.


let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0) { $0 + $1 }
// ๊ฒฐ๊ณผ: 15 (0 + 1 + 2 + 3 + 4 + 5)

let words = ["Swift", "is", "awesome"]
let sentence = words.reduce("") { $0 + " " + $1 }.trimmingCharacters(in: .whitespaces)
// ๊ฒฐ๊ณผ: "Swift is awesome"
        

์ด ์„ธ ๊ฐ€์ง€ ํ•จ์ˆ˜๋งŒ ์ž˜ ํ™œ์šฉํ•ด๋„ ์ฝ”๋“œ๊ฐ€ ์—„์ฒญ ๊น”๋”ํ•ด์ ธ์š”! ์˜ˆ์ „์—๋Š” for ๋ฃจํ”„๋กœ ๊ธธ๊ฒŒ ์ž‘์„ฑํ–ˆ๋˜ ์ฝ”๋“œ๋ฅผ ํ•œ ์ค„๋กœ ์ค„์ผ ์ˆ˜ ์žˆ๋‹ต๋‹ˆ๋‹ค. ์ง„์งœ ๊ฐœ๋ฐœ์ž์˜ ์‚ถ์˜ ์งˆ์ด ํ™• ์˜ฌ๋ผ๊ฐ€๋Š” ๊ฑฐ์ฃ ! ใ…‹ใ…‹ใ…‹ ๐Ÿ˜Ž

์ด ์™ธ์—๋„ Swift์—๋Š” ์—ฌ๋Ÿฌ ์œ ์šฉํ•œ ๊ณ ์ฐจ ํ•จ์ˆ˜๋“ค์ด ์žˆ์–ด์š”:

๋” ๋งŽ์€ ๊ณ ์ฐจ ํ•จ์ˆ˜๋“ค

  1. flatMap/compactMap: ์ค‘์ฒฉ๋œ ์ปฌ๋ ‰์…˜์„ ํ‰ํƒ„ํ™”ํ•˜๊ฑฐ๋‚˜ nil์„ ์ œ๊ฑฐ
  2. forEach: ๊ฐ ์š”์†Œ์— ๋Œ€ํ•ด ์ž‘์—… ์ˆ˜ํ–‰ (๋ฐ˜ํ™˜๊ฐ’ ์—†์Œ)
  3. sorted/sort: ์š”์†Œ๋ฅผ ์ •๋ ฌ
  4. contains: ์กฐ๊ฑด์„ ๋งŒ์กฑํ•˜๋Š” ์š”์†Œ๊ฐ€ ์žˆ๋Š”์ง€ ํ™•์ธ
  5. first/last: ์กฐ๊ฑด์„ ๋งŒ์กฑํ•˜๋Š” ์ฒซ/๋งˆ์ง€๋ง‰ ์š”์†Œ ์ฐพ๊ธฐ

์‹ค์ œ ์•ฑ ๊ฐœ๋ฐœ์—์„œ ์ด๋Ÿฐ ๊ณ ์ฐจ ํ•จ์ˆ˜๋“ค์„ ์กฐํ•ฉํ•ด์„œ ์‚ฌ์šฉํ•˜๋ฉด ์ •๋ง ๊ฐ•๋ ฅํ•ด์š”. ์˜ˆ๋ฅผ ๋“ค์–ด, ์‚ฌ์šฉ์ž ๋ฐ์ดํ„ฐ๋ฅผ ํ•„ํ„ฐ๋งํ•˜๊ณ  ๋ณ€ํ™˜ํ•œ ๋‹ค์Œ ํ†ต๊ณ„๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ์ฝ”๋“œ๋ฅผ ๋ณผ๊นŒ์š”?


struct User {
    let id: Int
    let name: String
    let age: Int
    let isPremium: Bool
}

let users = [
    User(id: 1, name: "๊น€์ฝ”๋”ฉ", age: 25, isPremium: true),
    User(id: 2, name: "์ด์Šค์œ„ํ”„ํŠธ", age: 32, isPremium: false),
    User(id: 3, name: "๋ฐ•์•ฑ", age: 19, isPremium: true),
    User(id: 4, name: "์ตœ๊ฐœ๋ฐœ", age: 45, isPremium: false),
    User(id: 5, name: "์ •ํ”„๋กœ๊ทธ๋ž˜๋จธ", age: 28, isPremium: true)
]

// ํ”„๋ฆฌ๋ฏธ์—„ ์‚ฌ์šฉ์ž ์ค‘ 30์„ธ ๋ฏธ๋งŒ์ธ ์‚ฌ์šฉ์ž์˜ ์ด๋ฆ„ ๋ชฉ๋ก
let youngPremiumUsers = users
    .filter { $0.isPremium && $0.age < 30 }
    .map { $0.name }
// ๊ฒฐ๊ณผ: ["๊น€์ฝ”๋”ฉ", "๋ฐ•์•ฑ"]

// ๋ชจ๋“  ์‚ฌ์šฉ์ž์˜ ํ‰๊ท  ๋‚˜์ด
let averageAge = users.reduce(0) { $0 + $1.age } / users.count
// ๊ฒฐ๊ณผ: 29
      

์žฌ๋Šฅ๋„ท์—์„œ Swift ๊ฐœ๋ฐœ ํ”„๋กœ์ ํŠธ๋ฅผ ์ง„ํ–‰ํ•  ๋•Œ, ์ด๋Ÿฐ ๊ณ ์ฐจ ํ•จ์ˆ˜๋“ค์„ ํ™œ์šฉํ•˜๋ฉด ์ฝ”๋“œ๊ฐ€ ํ›จ์”ฌ ๊ฐ„๊ฒฐํ•˜๊ณ  ์ฝ๊ธฐ ์‰ฌ์›Œ์ ธ์š”. ํŠนํžˆ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ๋‚˜ UI ์—…๋ฐ์ดํŠธ ๋กœ์ง์—์„œ ๋น›์„ ๋ฐœํ•œ๋‹ต๋‹ˆ๋‹ค! โœจ

Swift ๊ณ ์ฐจ ํ•จ์ˆ˜์˜ ๋งˆ๋ฒ• ์›๋ณธ ๋ฐฐ์—ด 1 2 3 map 2 4 6 filter 2 ์ง์ˆ˜๋งŒ reduce: 6 { $0 * 2 } { $0 % 2 == 0 } { $0 + $1 }

5. ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ ๋ถˆ๋ณ€์„ฑ ๐ŸงŠ

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋˜ ๋‹ค๋ฅธ ํ•ต์‹ฌ ์›์น™์€ ๋ถˆ๋ณ€์„ฑ(Immutability)์ด์—์š”. ๋ถˆ๋ณ€์„ฑ์ด๋ž€ ํ•œ๋ฒˆ ์ƒ์„ฑ๋œ ๋ฐ์ดํ„ฐ๋Š” ๋ณ€๊ฒฝ๋˜์ง€ ์•Š๋Š”๋‹ค๋Š” ๊ฐœ๋…์ด์—์š”. ์ด๊ฒŒ ์™œ ์ค‘์š”ํ•˜๋ƒ๋ฉด, ๋ฐ์ดํ„ฐ๊ฐ€ ์˜ˆ์ธก ๋ถˆ๊ฐ€๋Šฅํ•˜๊ฒŒ ๋ณ€๊ฒฝ๋˜๋Š” ๊ฑธ ๋ฐฉ์ง€ํ•ด์„œ ํ”„๋กœ๊ทธ๋žจ์„ ๋” ์•ˆ์ •์ ์œผ๋กœ ๋งŒ๋“ค์–ด์ฃผ๊ฑฐ๋“ ์š”! ๐Ÿ›ก๏ธ

Swift์—์„œ๋Š” let๊ณผ var๋ฅผ ํ†ตํ•ด ๋ถˆ๋ณ€/๊ฐ€๋ณ€ ๋ณ€์ˆ˜๋ฅผ ๊ตฌ๋ถ„ํ•  ์ˆ˜ ์žˆ์–ด์š”:


// ๋ถˆ๋ณ€(immutable) ๋ณ€์ˆ˜ - ๊ฐ’์„ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์—†์Œ
let constantValue = 42
// constantValue = 43  // ์ปดํŒŒ์ผ ์˜ค๋ฅ˜!

// ๊ฐ€๋ณ€(mutable) ๋ณ€์ˆ˜ - ๊ฐ’์„ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์žˆ์Œ
var mutableValue = 42
mutableValue = 43  // ๊ฐ€๋Šฅ
      

๊ตฌ์กฐ์ฒด(struct)์™€ ํด๋ž˜์Šค(class)์—์„œ๋„ ๋ถˆ๋ณ€์„ฑ์˜ ์ฐจ์ด๊ฐ€ ์žˆ์–ด์š”:


// ๊ตฌ์กฐ์ฒด๋Š” ๊ฐ’ ํƒ€์ž… - ๋ณต์‚ฌ๋  ๋•Œ ์ƒˆ๋กœ์šด ์ธ์Šคํ„ด์Šค ์ƒ์„ฑ
struct Point {
    var x: Int
    var y: Int
}

// ํด๋ž˜์Šค๋Š” ์ฐธ์กฐ ํƒ€์ž… - ์—ฌ๋Ÿฌ ๋ณ€์ˆ˜๊ฐ€ ๊ฐ™์€ ์ธ์Šคํ„ด์Šค ์ฐธ์กฐ ๊ฐ€๋Šฅ
class Person {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}
      

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ๋Š” ๊ตฌ์กฐ์ฒด(struct)๋ฅผ ์„ ํ˜ธํ•˜๋Š” ๊ฒฝํ–ฅ์ด ์žˆ์–ด์š”. ์™œ๋ƒํ•˜๋ฉด ๊ฐ’ ํƒ€์ž…์ด๋ผ ๋ถˆ๋ณ€์„ฑ์„ ๋” ์‰ฝ๊ฒŒ ์œ ์ง€ํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ ์š”. ๊ฐ’์ด ๋ณต์‚ฌ๋˜๋‹ˆ๊นŒ ์›๋ณธ ๋ฐ์ดํ„ฐ๊ฐ€ ๋ณ€๊ฒฝ๋  ๊ฑฑ์ •์ด ์—†์ฃ !

๋ถˆ๋ณ€์„ฑ์˜ ์‹ค์ œ ์˜ˆ: ์ƒํƒœ ๊ด€๋ฆฌ


// ๋ณ€๊ฒฝ ๋Œ€์‹  ์ƒˆ ์ธ์Šคํ„ด์Šค ์ƒ์„ฑํ•˜๊ธฐ
struct User {
    let id: UUID
    let name: String
    let email: String
    
    // ์ด๋ฉ”์ผ ๋ณ€๊ฒฝ ์‹œ ์ƒˆ User ์ธ์Šคํ„ด์Šค ๋ฐ˜ํ™˜
    func withUpdatedEmail(_ newEmail: String) -> User {
        return User(id: id, name: name, email: newEmail)
    }
}

let user = User(id: UUID(), name: "๊น€๊ฐœ๋ฐœ", email: "dev@example.com")
let updatedUser = user.withUpdatedEmail("newdev@example.com")

// user๋Š” ๊ทธ๋Œ€๋กœ, updatedUser๋Š” ์ƒˆ ์ด๋ฉ”์ผ์„ ๊ฐ€์ง„ ์ƒˆ ์ธ์Šคํ„ด์Šค
        

๋ถˆ๋ณ€์„ฑ์„ ์œ ์ง€ํ•˜๋ฉด ์—ฌ๋Ÿฌ ์žฅ์ ์ด ์žˆ์–ด์š”:

  1. ์Šค๋ ˆ๋“œ ์•ˆ์ „์„ฑ: ๋ฐ์ดํ„ฐ๊ฐ€ ๋ณ€๊ฒฝ๋˜์ง€ ์•Š์œผ๋‹ˆ ์—ฌ๋Ÿฌ ์Šค๋ ˆ๋“œ์—์„œ ์•ˆ์ „ํ•˜๊ฒŒ ์ ‘๊ทผ ๊ฐ€๋Šฅ
  2. ๋””๋ฒ„๊น… ์šฉ์ด์„ฑ: ๋ฐ์ดํ„ฐ๊ฐ€ ์–ธ์ œ ์–ด๋””์„œ ๋ณ€๊ฒฝ๋˜์—ˆ๋Š”์ง€ ์ถ”์ ํ•˜๊ธฐ ์‰ฌ์›€
  3. ์˜ˆ์ธก ๊ฐ€๋Šฅ์„ฑ: ํ”„๋กœ๊ทธ๋žจ์˜ ๋™์ž‘์„ ๋” ์‰ฝ๊ฒŒ ์˜ˆ์ธกํ•  ์ˆ˜ ์žˆ์Œ
  4. ํ…Œ์ŠคํŠธ ์šฉ์ด์„ฑ: ๋ถ€์ˆ˜ ํšจ๊ณผ๊ฐ€ ์—†์–ด ํ…Œ์ŠคํŠธํ•˜๊ธฐ ์‰ฌ์›€

ํ•˜์ง€๋งŒ ๋ชจ๋“  ๊ฒƒ์„ ๋ถˆ๋ณ€์œผ๋กœ ๋งŒ๋“ค๋ฉด ์„ฑ๋Šฅ ๋ฌธ์ œ๊ฐ€ ์ƒ๊ธธ ์ˆ˜ ์žˆ์–ด์š”. ํŠนํžˆ ํฐ ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋ฅผ ์ž์ฃผ ๋ณต์‚ฌํ•ด์•ผ ํ•œ๋‹ค๋ฉด์š”. ๊ทธ๋ž˜์„œ Swift์—์„œ๋Š” Copy-on-Write ์ตœ์ ํ™”๋ฅผ ํ†ตํ•ด ์ด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋ ค๊ณ  ํ•ด์š”. ์‹ค์ œ๋กœ ๋ฐ์ดํ„ฐ๊ฐ€ ๋ณ€๊ฒฝ๋  ๋•Œ๋งŒ ๋ณต์‚ฌ๋ณธ์„ ๋งŒ๋“œ๋Š” ๊ฑฐ์ฃ !

Swift์˜ ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์ปฌ๋ ‰์…˜(Array, Dictionary, Set)์€ ์ด๋ฏธ Copy-on-Write๋ฅผ ๊ตฌํ˜„ํ•˜๊ณ  ์žˆ์–ด์š”. ๊ทธ๋ž˜์„œ ํ•จ์ˆ˜ํ˜• ์Šคํƒ€์ผ๋กœ ์ฝ”๋”ฉํ•ด๋„ ์„ฑ๋Šฅ ๊ฑฑ์ •์€ ๋œํ•ด๋„ ๋œ๋‹ต๋‹ˆ๋‹ค! ๐Ÿ‘

๋ถˆ๋ณ€์„ฑ(Immutability)์˜ ์„ธ๊ณ„ ๊ฐ€๋ณ€ ๋ฐ์ดํ„ฐ (Mutable) var data = [1, 2, 3] data.append(4) ์›๋ณธ ๋ฐ์ดํ„ฐ ๋ณ€๊ฒฝ๋จ ๋ถˆ๋ณ€ ๋ฐ์ดํ„ฐ (Immutable) let data = [1, 2, 3] let newData = data + [4] ์›๋ณธ ๋ฐ์ดํ„ฐ ๋ณด์กด๋จ ํ•จ์ˆ˜ํ˜• ์ ‘๊ทผ๋ฒ•

6. ํด๋กœ์ €์˜ ๋งˆ๋ฒ•: ์บก์ฒ˜์™€ ํƒˆ์ถœ ๐Ÿง™โ€โ™‚๏ธ

Swift์—์„œ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์ด์•ผ๊ธฐํ•  ๋•Œ ๋นผ๋†“์„ ์ˆ˜ ์—†๋Š” ๊ฒŒ ๋ฐ”๋กœ ํด๋กœ์ €(Closure)์˜ˆ์š”. ํด๋กœ์ €๋Š” ์ฝ”๋“œ ๋ธ”๋ก์„ ๋…๋ฆฝ์ ์ธ ๊ฐ์ฒด๋กœ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ฃผ๋Š” Swift์˜ ๊ฐ•๋ ฅํ•œ ๊ธฐ๋Šฅ์ด์—์š”. ํ•จ์ˆ˜๋„ ์‚ฌ์‹ค์€ ํด๋กœ์ €์˜ ํŠน๋ณ„ํ•œ ํ˜•ํƒœ๋ž๋‹ˆ๋‹ค! ๐Ÿคฏ

ํด๋กœ์ €์˜ ๊ธฐ๋ณธ ๋ฌธ๋ฒ•์€ ์ด๋ ‡๊ฒŒ ์ƒ๊ฒผ์–ด์š”:


// ํด๋กœ์ € ๋ฌธ๋ฒ•
let simpleClosure = { (parameters) -> ReturnType in
    // ์ฝ”๋“œ
    return something
}

// ์‹ค์ œ ์˜ˆ์ œ
let greet = { (name: String) -> String in
    return "์•ˆ๋…•, \(name)!"
}

print(greet("Swift ๊ฐœ๋ฐœ์ž"))  // ์ถœ๋ ฅ: ์•ˆ๋…•, Swift ๊ฐœ๋ฐœ์ž!
      

Swift๋Š” ํด๋กœ์ €๋ฅผ ๋” ๊ฐ„๊ฒฐํ•˜๊ฒŒ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๋Š” ๋ฌธ๋ฒ•์  ์„คํƒ•(Syntactic Sugar)์„ ์ œ๊ณตํ•ด์š”:


// ์ „์ฒด ๋ฌธ๋ฒ•
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map({ (number: Int) -> Int in
    return number * 2
})

// ํƒ€์ž… ์ถ”๋ก ์œผ๋กœ ๊ฐ„์†Œํ™”
let doubled = numbers.map({ number in
    return number * 2
})

// ์•”์‹œ์  ๋ฐ˜ํ™˜์œผ๋กœ ๋” ๊ฐ„์†Œํ™”
let doubled = numbers.map({ number in number * 2 })

// ๋‹จ์ถ• ์ธ์ž ์ด๋ฆ„์œผ๋กœ ๋”๋”์šฑ ๊ฐ„์†Œํ™”
let doubled = numbers.map({ $0 * 2 })

// ํ›„ํ–‰ ํด๋กœ์ € ๋ฌธ๋ฒ•์œผ๋กœ ์ตœ์ข… ๊ฐ„์†Œํ™”
let doubled = numbers.map { $0 * 2 }
      

ํด๋กœ์ €์˜ ๊ฐ€์žฅ ๊ฐ•๋ ฅํ•œ ํŠน์ง• ์ค‘ ํ•˜๋‚˜๋Š” ๊ฐ’ ์บก์ฒ˜(Capturing Values)์˜ˆ์š”. ํด๋กœ์ €๋Š” ์ž์‹ ์ด ์ •์˜๋œ ๋ฒ”์œ„์˜ ๋ณ€์ˆ˜์™€ ์ƒ์ˆ˜๋ฅผ ์บก์ฒ˜ํ•ด์„œ ๋‚˜์ค‘์— ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด์š”. ์ด๊ฒŒ ๋ฐ”๋กœ ํด๋กœ์ €๊ฐ€ ๋งˆ๋ฒ•๊ฐ™์ด ๋А๊ปด์ง€๋Š” ์ด์œ ์ฃ ! โœจ


func makeIncrementer(incrementAmount: Int) -> () -> Int {
    var total = 0
    
    let incrementer = {
        total += incrementAmount  // total๊ณผ incrementAmount๋ฅผ ์บก์ฒ˜
        return total
    }
    
    return incrementer
}

let incrementByTwo = makeIncrementer(incrementAmount: 2)
print(incrementByTwo())  // 2
print(incrementByTwo())  // 4
print(incrementByTwo())  // 6
      

์œ„ ์˜ˆ์ œ์—์„œ incrementer ํด๋กœ์ €๋Š” total๊ณผ incrementAmount ๊ฐ’์„ ์บก์ฒ˜ํ•ด์„œ, makeIncrementer ํ•จ์ˆ˜๊ฐ€ ๋ฐ˜ํ™˜๋œ ํ›„์—๋„ ์ด ๊ฐ’๋“ค์„ ๊ธฐ์–ตํ•˜๊ณ  ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด์š”. ์ด๋Ÿฐ ํŠน์„ฑ์€ ์ƒํƒœ๋ฅผ ์œ ์ง€ํ•˜๋ฉด์„œ๋„ ํ•จ์ˆ˜ํ˜• ์Šคํƒ€์ผ๋กœ ์ฝ”๋”ฉํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ค˜์š”!

โš ๏ธ ํด๋กœ์ €์™€ ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ

ํด๋กœ์ €๊ฐ€ ๊ฐ์ฒด๋ฅผ ์บก์ฒ˜ํ•  ๋•Œ ๊ฐ•ํ•œ ์ฐธ์กฐ ์ˆœํ™˜(Strong Reference Cycle)์ด ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์–ด์š”. ์ด๋ฅผ ๋ฐฉ์ง€ํ•˜๊ธฐ ์œ„ํ•ด ์บก์ฒ˜ ๋ชฉ๋ก(Capture List)์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด์š”:


class Person {
    let name: String
    var onNamePrinted: (() -> Void)?
    
    init(name: String) {
        self.name = name
        
        // ๊ฐ•ํ•œ ์ฐธ์กฐ ์ˆœํ™˜ ๋ฐœ์ƒ ๊ฐ€๋Šฅ!
        onNamePrinted = {
            print("์ด๋ฆ„: \(self.name)")
        }
        
        // ์บก์ฒ˜ ๋ชฉ๋ก์œผ๋กœ ์•ฝํ•œ ์ฐธ์กฐ ์‚ฌ์šฉ
        onNamePrinted = { [weak self] in
            guard let self = self else { return }
            print("์ด๋ฆ„: \(self.name)")
        }
    }
    
    deinit {
        print("\(name) ์ธ์Šคํ„ด์Šค๊ฐ€ ํ•ด์ œ๋จ")
    }
}
        

Swift์—์„œ๋Š” ํด๋กœ์ €๊ฐ€ ํƒˆ์ถœ(Escaping) ์—ฌ๋ถ€๋„ ์ค‘์š”ํ•ด์š”. ํ•จ์ˆ˜์˜ ์‹คํ–‰์ด ๋๋‚œ ํ›„์—๋„ ํด๋กœ์ €๊ฐ€ ์‚ด์•„์žˆ์„ ์ˆ˜ ์žˆ๋‹ค๋ฉด ์ด๋ฅผ 'ํƒˆ์ถœ ํด๋กœ์ €'๋ผ๊ณ  ํ•ด์š”. ๋น„๋™๊ธฐ ์ž‘์—…์ด๋‚˜ ์ฝœ๋ฐฑ์—์„œ ๋งŽ์ด ์‚ฌ์šฉ๋˜์ฃ .


// ํƒˆ์ถœ ํด๋กœ์ € - ํ•จ์ˆ˜ ์‹คํ–‰์ด ๋๋‚œ ํ›„์—๋„ ํด๋กœ์ €๊ฐ€ ํ˜ธ์ถœ๋  ์ˆ˜ ์žˆ์Œ
func fetchData(completion: @escaping (Data) -> Void) {
    DispatchQueue.global().async {
        // ๋„คํŠธ์›Œํฌ ์š”์ฒญ ๋“ฑ์˜ ๋น„๋™๊ธฐ ์ž‘์—…
        let data = Data()  // ์˜ˆ์‹œ ๋ฐ์ดํ„ฐ
        
        // ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ ์ฝœ๋ฐฑ ์‹คํ–‰
        DispatchQueue.main.async {
            completion(data)  // ํ•จ์ˆ˜๊ฐ€ ์ด๋ฏธ ๋ฐ˜ํ™˜๋œ ํ›„์— ํ˜ธ์ถœ๋จ
        }
    }
}

// ๋น„ํƒˆ์ถœ ํด๋กœ์ € - ํ•จ์ˆ˜๊ฐ€ ๋ฐ˜ํ™˜๋˜๊ธฐ ์ „์— ํด๋กœ์ €๊ฐ€ ์‹คํ–‰๋จ (๊ธฐ๋ณธ๊ฐ’)
func calculate(a: Int, b: Int, operation: (Int, Int) -> Int) -> Int {
    return operation(a, b)  // ํ•จ์ˆ˜ ๋‚ด์—์„œ๋งŒ ํด๋กœ์ € ์‚ฌ์šฉ
}
      

ํด๋กœ์ €๋Š” Swift์—์„œ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ๊ตฌํ˜„ํ•˜๋Š” ํ•ต์‹ฌ ๋„๊ตฌ์˜ˆ์š”. ํŠนํžˆ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ, ์ด๋ฒคํŠธ ์ฒ˜๋ฆฌ, ์ฝœ๋ฐฑ ๋“ฑ์—์„œ ์ •๋ง ์œ ์šฉํ•˜๊ฒŒ ์“ฐ์ธ๋‹ต๋‹ˆ๋‹ค. ์žฌ๋Šฅ๋„ท์—์„œ Swift ๊ฐœ๋ฐœ์ž๋“ค์ด ๊ณต์œ ํ•˜๋Š” ํ”„๋กœ์ ํŠธ๋ฅผ ๋ณด๋ฉด ํด๋กœ์ €๋ฅผ ํ™œ์šฉํ•œ ์šฐ์•„ํ•œ ์ฝ”๋“œ๋ฅผ ๋งŽ์ด ๋ณผ ์ˆ˜ ์žˆ์„ ๊ฑฐ์˜ˆ์š”! ๐Ÿš€

ํด๋กœ์ €์˜ ๋งˆ๋ฒ•: ๊ฐ’ ์บก์ฒ˜ ํ•จ์ˆ˜ ์ •์˜ func makeCounter() -> () -> Int { var count = 0 return { count += 1 return count } ํด๋กœ์ € ์ธ์Šคํ„ด์Šค let counter = makeCounter() counter() // 1 counter() // 2 counter() // 3 ์บก์ฒ˜๋œ count ๋ณ€์ˆ˜ ํ•จ์ˆ˜๊ฐ€ ๋๋‚˜๋„ ์œ ์ง€๋จ

7. ํ•จ์ˆ˜ ํ•ฉ์„ฑ๊ณผ ํŒŒ์ดํ”„๋ผ์ธ ๐Ÿ”„

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋˜ ๋‹ค๋ฅธ ๊ฐ•๋ ฅํ•œ ๊ฐœ๋…์€ ํ•จ์ˆ˜ ํ•ฉ์„ฑ(Function Composition)์ด์—์š”. ์—ฌ๋Ÿฌ ํ•จ์ˆ˜๋ฅผ ์กฐํ•ฉํ•ด์„œ ์ƒˆ๋กœ์šด ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“œ๋Š” ๊ธฐ๋ฒ•์ด์ฃ . ๋งˆ์น˜ ๋ ˆ๊ณ  ๋ธ”๋ก์„ ์กฐ๋ฆฝํ•˜๋“ฏ์ด ์ž‘์€ ํ•จ์ˆ˜๋“ค์„ ์—ฐ๊ฒฐํ•ด์„œ ๋ณต์žกํ•œ ๊ธฐ๋Šฅ์„ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์–ด์š”! ๐Ÿงฉ

Swift์—์„œ๋Š” ์—ฐ์‚ฐ์ž ์˜ค๋ฒ„๋กœ๋”ฉ์„ ํ†ตํ•ด ํ•จ์ˆ˜ ํ•ฉ์„ฑ ์—ฐ์‚ฐ์ž๋ฅผ ์ง์ ‘ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด์š”:


// ํ•จ์ˆ˜ ํ•ฉ์„ฑ ์—ฐ์‚ฐ์ž ์ •์˜
infix operator >>> : CompositionPrecedence
precedencegroup CompositionPrecedence {
    associativity: left
}

func >>> <A, B, C>(f: @escaping (A) -> B, g: @escaping (B) -> C) -> (A) -> C {
    return { a in g(f(a)) }
}

// ์‚ฌ์šฉ ์˜ˆ
let addOne = { $0 + 1 }
let double = { $0 * 2 }
let square = { $0 * $0 }

// ํ•จ์ˆ˜ ํ•ฉ์„ฑ: (x + 1) * 2์˜ ์ œ๊ณฑ
let complexOperation = addOne >>> double >>> square

print(complexOperation(3))  // ((3 + 1) * 2)ยฒ = 8ยฒ = 64
      

ํ•จ์ˆ˜ ํ•ฉ์„ฑ์„ ํ†ตํ•ด ๋ฐ์ดํ„ฐ ๋ณ€ํ™˜ ํŒŒ์ดํ”„๋ผ์ธ์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด์š”. ๋ฐ์ดํ„ฐ๊ฐ€ ์—ฌ๋Ÿฌ ๋‹จ๊ณ„์˜ ์ฒ˜๋ฆฌ๋ฅผ ๊ฑฐ์น˜๋Š” ๊ฒฝ์šฐ์— ํŠนํžˆ ์œ ์šฉํ•˜์ฃ :


// ๋ฌธ์ž์—ด ์ฒ˜๋ฆฌ ํŒŒ์ดํ”„๋ผ์ธ
let trim = { (str: String) -> String in str.trimmingCharacters(in: .whitespacesAndNewlines) }
let lowercase = { (str: String) -> String in str.lowercased() }
let removeSpecialChars = { (str: String) -> String in
    str.components(separatedBy: CharacterSet.alphanumerics.inverted).joined()
}

// ํ•จ์ˆ˜ ํ•ฉ์„ฑ์œผ๋กœ ํŒŒ์ดํ”„๋ผ์ธ ์ƒ์„ฑ
let normalizeString = trim >>> lowercase >>> removeSpecialChars

// ์‚ฌ์šฉ
let input = "  Hello, Swift 5.9! "
print(normalizeString(input))  // "helloswift59"
      

Swift 5.9๋ถ€ํ„ฐ๋Š” ํ•จ์ˆ˜ ๋นŒ๋”(Function Builders)๋ฅผ ํ™œ์šฉํ•ด ๋” ์„ ์–ธ์ ์ธ ๋ฐฉ์‹์œผ๋กœ ํŒŒ์ดํ”„๋ผ์ธ์„ ๊ตฌ์„ฑํ•  ์ˆ˜๋„ ์žˆ์–ด์š”. 2025๋…„ ํ˜„์žฌ๋Š” ์ด๋Ÿฐ ๊ธฐ๋Šฅ๋“ค์ด ๋” ๋ฐœ์ „ํ•ด์„œ ๋” ์šฐ์•„ํ•œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋˜์—ˆ์ฃ ! ๐Ÿ˜Ž

์‹ค์ „ ์˜ˆ์ œ: ์ด๋ฏธ์ง€ ์ฒ˜๋ฆฌ ํŒŒ์ดํ”„๋ผ์ธ


struct ImageProcessor {
    // ๊ฐœ๋ณ„ ์ด๋ฏธ์ง€ ์ฒ˜๋ฆฌ ํ•จ์ˆ˜๋“ค
    static func resize(to size: CGSize) -> (UIImage) -> UIImage {
        return { image in
            // ์ด๋ฏธ์ง€ ๋ฆฌ์‚ฌ์ด์ง• ๋กœ์ง
            return image // ์‹ค์ œ๋กœ๋Š” ๋ฆฌ์‚ฌ์ด์ง•๋œ ์ด๋ฏธ์ง€ ๋ฐ˜ํ™˜
        }
    }
    
    static func applyFilter(_ filter: CIFilter) -> (UIImage) -> UIImage {
        return { image in
            // ํ•„ํ„ฐ ์ ์šฉ ๋กœ์ง
            return image // ์‹ค์ œ๋กœ๋Š” ํ•„ํ„ฐ ์ ์šฉ๋œ ์ด๋ฏธ์ง€ ๋ฐ˜ํ™˜
        }
    }
    
    static func adjustBrightness(_ value: CGFloat) -> (UIImage) -> UIImage {
        return { image in
            // ๋ฐ๊ธฐ ์กฐ์ • ๋กœ์ง
            return image // ์‹ค์ œ๋กœ๋Š” ๋ฐ๊ธฐ ์กฐ์ •๋œ ์ด๋ฏธ์ง€ ๋ฐ˜ํ™˜
        }
    }
    
    // ํŒŒ์ดํ”„๋ผ์ธ ์ƒ์„ฑ
    static func createPipeline(
        size: CGSize,
        filter: CIFilter,
        brightness: CGFloat
    ) -> (UIImage) -> UIImage {
        return resize(to: size) >>> applyFilter(filter) >>> adjustBrightness(brightness)
    }
}

// ์‚ฌ์šฉ
let profileImageProcessor = ImageProcessor.createPipeline(
    size: CGSize(width: 100, height: 100),
    filter: CIFilter(name: "CISepiaTone")!,
    brightness: 1.2
)

let processedImage = profileImageProcessor(originalImage)
        

ํ•จ์ˆ˜ ํ•ฉ์„ฑ์€ ์ฝ”๋“œ์˜ ์žฌ์‚ฌ์šฉ์„ฑ๊ณผ ๋ชจ๋“ˆ์„ฑ์„ ๋†’์—ฌ์ค˜์š”. ์ž‘์€ ๊ธฐ๋Šฅ๋“ค์„ ๋…๋ฆฝ์ ์œผ๋กœ ๊ฐœ๋ฐœํ•˜๊ณ  ํ…Œ์ŠคํŠธํ•œ ๋‹ค์Œ, ์ด๋“ค์„ ์กฐํ•ฉํ•ด์„œ ๋ณต์žกํ•œ ๊ธฐ๋Šฅ์„ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ ์š”. ์ด๋Ÿฐ ์ ‘๊ทผ ๋ฐฉ์‹์€ ์ฝ”๋“œ๋ฅผ ๋” ์œ ์ง€๋ณด์ˆ˜ํ•˜๊ธฐ ์‰ฝ๊ฒŒ ๋งŒ๋“ค์–ด์ค๋‹ˆ๋‹ค! ๐Ÿ› ๏ธ

ํŠนํžˆ Swift UI๋‚˜ Combine ํ”„๋ ˆ์ž„์›Œํฌ์™€ ํ•จ๊ป˜ ์‚ฌ์šฉํ•  ๋•Œ ํ•จ์ˆ˜ ํ•ฉ์„ฑ์˜ ์ง„๊ฐ€๊ฐ€ ๋ฐœํœ˜๋ผ์š”. ๋ฐ์ดํ„ฐ ํ๋ฆ„์„ ๋ช…ํ™•ํ•˜๊ฒŒ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๊ณ , ์ƒํƒœ ๊ด€๋ฆฌ๋„ ๋” ์‰ฌ์›Œ์ง„๋‹ต๋‹ˆ๋‹ค. ์žฌ๋Šฅ๋„ท์—์„œ Swift ๊ฐœ๋ฐœ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•˜๊ฑฐ๋‚˜ ์ฐพ๊ณ  ์žˆ๋‹ค๋ฉด, ํ•จ์ˆ˜ ํ•ฉ์„ฑ ๊ธฐ๋ฒ•์„ ๋งˆ์Šคํ„ฐํ•˜๋Š” ๊ฒƒ์ด ํฐ ๊ฒฝ์Ÿ๋ ฅ์ด ๋  ์ˆ˜ ์žˆ์–ด์š”! ๐Ÿ’ช

ํ•จ์ˆ˜ ํ•ฉ์„ฑ ํŒŒ์ดํ”„๋ผ์ธ ์ž…๋ ฅ ๋ฐ์ดํ„ฐ ํ•จ์ˆ˜ 1 ํ•„ํ„ฐ๋ง ํ•จ์ˆ˜ 2 ๋ณ€ํ™˜ ํ•จ์ˆ˜ 3 ์ง‘๊ณ„ ๊ฒฐ๊ณผ let pipeline = function1 >>> function2 >>> function3

8. ์˜ต์…”๋„๊ณผ ํ•จ์ˆ˜ํ˜• ์ ‘๊ทผ๋ฒ• ๐ŸŽ

Swift์˜ ์˜ต์…”๋„(Optional)์€ ๊ฐ’์ด ์žˆ์„ ์ˆ˜๋„ ์žˆ๊ณ  ์—†์„ ์ˆ˜๋„ ์žˆ๋Š” ์ƒํ™ฉ์„ ์•ˆ์ „ํ•˜๊ฒŒ ์ฒ˜๋ฆฌํ•˜๊ธฐ ์œ„ํ•œ ํƒ€์ž…์ด์—์š”. ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ๋Š” ์ด๋Ÿฐ ์˜ต์…”๋„์„ ๋‹ค๋ฃจ๋Š” ํŠน๋ณ„ํ•œ ๋ฐฉ๋ฒ•๋“ค์ด ์žˆ์–ด์š”! ๐ŸŽฏ

๊ธฐ๋ณธ์ ์ธ ์˜ต์…”๋„ ์ฒ˜๋ฆฌ ๋ฐฉ๋ฒ•์„ ๋จผ์ € ์‚ดํŽด๋ณผ๊ฒŒ์š”:


// ์˜ต์…”๋„ ๊ฐ’
let possibleNumber: Int? = "123".isEmpty ? nil : Int("123")

// ๊ฐ•์ œ ์–ธ๋ž˜ํ•‘ (์œ„ํ—˜ํ•จ!)
let forcedNumber = possibleNumber!

// ์•ˆ์ „ํ•œ ์–ธ๋ž˜ํ•‘
if let number = possibleNumber {
    print("์ˆซ์ž๋Š” \(number)์ž…๋‹ˆ๋‹ค")
} else {
    print("์œ ํšจํ•œ ์ˆซ์ž๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค")
}

// ๊ฐ€๋“œ๋ฌธ ์‚ฌ์šฉ
func processNumber(_ number: Int?) {
    guard let number = number else {
        print("์œ ํšจํ•œ ์ˆซ์ž๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค")
        return
    }
    
    print("์ˆซ์ž๋Š” \(number)์ž…๋‹ˆ๋‹ค")
}
      

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ๋Š” ์˜ต์…”๋„์„ ๋ชจ๋‚˜๋“œ(Monad)์˜ ์ผ์ข…์œผ๋กœ ๋ณผ ์ˆ˜ ์žˆ์–ด์š”. ๋ชจ๋‚˜๋“œ๋ผ๋Š” ๋ง์ด ์–ด๋ ต๊ฒŒ ๋“ค๋ฆด ์ˆ˜ ์žˆ์ง€๋งŒ, ๊ฐ„๋‹จํžˆ ๋งํ•˜๋ฉด '๊ฐ’์„ ๋‹ด๋Š” ์ปจํ…Œ์ด๋„ˆ'๋ผ๊ณ  ์ƒ๊ฐํ•˜๋ฉด ๋ผ์š”. Swift์˜ ์˜ต์…”๋„์€ ๊ฐ’์ด ์žˆ๊ฑฐ๋‚˜ ์—†๋Š” ์ƒํƒœ๋ฅผ ๋‹ด๋Š” ์ปจํ…Œ์ด๋„ˆ์ธ ์…ˆ์ด์ฃ ! ๐Ÿ“ฆ

Swift์—์„œ๋Š” ์˜ต์…”๋„์„ ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋‹ค๋ฃจ๊ธฐ ์œ„ํ•œ ์—ฌ๋Ÿฌ ๋ฉ”์„œ๋“œ๋ฅผ ์ œ๊ณตํ•ด์š”:


// map - ์˜ต์…”๋„ ๊ฐ’์ด ์žˆ์„ ๋•Œ๋งŒ ๋ณ€ํ™˜ ํ•จ์ˆ˜ ์ ์šฉ
let possibleNumber: Int? = Int("42")
let possibleSquare = possibleNumber.map { $0 * $0 }
// possibleSquare๋Š” 1764๋ฅผ ๋‹ด์€ ์˜ต์…”๋„

// flatMap/compactMap - ์ค‘์ฒฉ๋œ ์˜ต์…”๋„ ํ‰ํƒ„ํ™”
let nestedOptional: Int?? = Int("42")
let flattenedOptional = nestedOptional.flatMap { $0 }
// flattenedOptional์€ 42๋ฅผ ๋‹ด์€ ์˜ต์…”๋„

// ์˜ต์…”๋„ ์ฒด์ด๋‹ - ์•ˆ์ „ํ•˜๊ฒŒ ์†์„ฑ๊ณผ ๋ฉ”์„œ๋“œ์— ์ ‘๊ทผ
let nameLength = user?.name?.count
      

์‹ค์ „ ์˜ˆ์ œ: ์˜ต์…”๋„ ์ฒด์ด๋‹๊ณผ ํ•จ์ˆ˜ํ˜• ์ ‘๊ทผ


struct User {
    let id: Int
    let name: String
    let email: String?
    let address: Address?
}

struct Address {
    let street: String
    let city: String
    let zipCode: String?
}

// ๋ช…๋ นํ˜• ๋ฐฉ์‹
func getZipCode(for user: User?) -> String {
    if let user = user {
        if let address = user.address {
            if let zipCode = address.zipCode {
                return zipCode
            }
        }
    }
    return "Unknown"
}

// ํ•จ์ˆ˜ํ˜• ๋ฐฉ์‹
func getZipCodeFunctional(for user: User?) -> String {
    return user?.address?.zipCode ?? "Unknown"
}

// map์„ ์‚ฌ์šฉํ•œ ๋ณ€ํ™˜
func formatZipCode(for user: User?) -> String {
    return user?.address?.zipCode.map { "์šฐํŽธ๋ฒˆํ˜ธ: \($0)" } ?? "์šฐํŽธ๋ฒˆํ˜ธ ์—†์Œ"
}
        

ํ•จ์ˆ˜ํ˜• ์ ‘๊ทผ๋ฒ•์„ ์‚ฌ์šฉํ•˜๋ฉด ์˜ต์…”๋„ ์ฒ˜๋ฆฌ ์ฝ”๋“œ๊ฐ€ ๋” ๊ฐ„๊ฒฐํ•˜๊ณ  ์ฝ๊ธฐ ์‰ฌ์›Œ์ ธ์š”. ํŠนํžˆ ์—ฌ๋Ÿฌ ๋‹จ๊ณ„์˜ ์˜ต์…”๋„ ์ฒด์ธ์ด ์žˆ์„ ๋•Œ ์ •๋ง ์œ ์šฉํ•˜์ฃ ! ๐Ÿ˜Š

Swift 5.7๋ถ€ํ„ฐ๋Š” ์˜ต์…”๋„ ํŒจํ„ด ๋งค์นญ๋„ ๋” ๊ฐ•๋ ฅํ•ด์กŒ์–ด์š”. 2025๋…„ ํ˜„์žฌ๋Š” ์ด๋Ÿฐ ๊ธฐ๋Šฅ๋“ค์ด ๋” ๋ฐœ์ „ํ•ด์„œ ์˜ต์…”๋„์„ ๋‹ค๋ฃจ๋Š” ๊ฒƒ์ด ํ›จ์”ฌ ํŽธ๋ฆฌํ•ด์กŒ๋‹ต๋‹ˆ๋‹ค!


// ์˜ต์…”๋„ ํŒจํ„ด ๋งค์นญ
func describeOptional(_ value: Int?) {
    switch value {
    case .none:
        print("๊ฐ’์ด ์—†์Šต๋‹ˆ๋‹ค")
    case .some(let x) where x > 10:
        print("10๋ณด๋‹ค ํฐ ๊ฐ’: \(x)")
    case .some(let x):
        print("10 ์ดํ•˜์˜ ๊ฐ’: \(x)")
    }
}
      

์˜ต์…”๋„๊ณผ ํ•จ์ˆ˜ํ˜• ์ ‘๊ทผ๋ฒ•์„ ๊ฒฐํ•ฉํ•˜๋ฉด null ์ฐธ์กฐ ์˜ค๋ฅ˜ ์—†์ด ์•ˆ์ „ํ•˜๊ณ  ์šฐ์•„ํ•œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์–ด์š”. ์žฌ๋Šฅ๋„ท์—์„œ Swift ๊ฐœ๋ฐœ ํ”„๋กœ์ ํŠธ๋ฅผ ์ง„ํ–‰ํ•  ๋•Œ ์ด๋Ÿฐ ํŒจํ„ด์„ ํ™œ์šฉํ•˜๋ฉด ์ฝ”๋“œ ํ’ˆ์งˆ์ด ํฌ๊ฒŒ ํ–ฅ์ƒ๋œ๋‹ต๋‹ˆ๋‹ค! ๐Ÿš€

์˜ต์…”๋„์˜ ํ•จ์ˆ˜ํ˜• ์ฒ˜๋ฆฌ Optional<T> .some(value) ๊ฐ’์ด ์กด์žฌํ•˜๋Š” ๊ฒฝ์šฐ map, flatMap ์ ์šฉ ๊ฐ€๋Šฅ .none (nil) ๊ฐ’์ด ์—†๋Š” ๊ฒฝ์šฐ ์—ฐ์‚ฐ ๋ฌด์‹œ, nil ๋ฐ˜ํ™˜ optionalValue.map { $0 * 2 }.flatMap { optionalFunc($0) } ?? defaultValue

9. ์‹ค์ „ ์˜ˆ์ œ: ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋ฆฌํŒฉํ† ๋งํ•˜๊ธฐ ๐Ÿ› ๏ธ

์ด์ œ ์‹ค์ œ ์ฝ”๋“œ๋ฅผ ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋ฆฌํŒฉํ† ๋งํ•˜๋Š” ์˜ˆ์ œ๋ฅผ ํ†ตํ•ด ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ์‹ค์ „ ์ ์šฉ์„ ์•Œ์•„๋ณผ๊ฒŒ์š”! ๋ช…๋ นํ˜•์œผ๋กœ ์ž‘์„ฑ๋œ ์ฝ”๋“œ๋ฅผ ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋ฉด ์–ด๋–ค ์žฅ์ ์ด ์žˆ๋Š”์ง€ ์ง์ ‘ ํ™•์ธํ•ด๋ด์š”. ๐Ÿ”„

๋จผ์ €, ์‚ฌ์šฉ์ž ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•˜๋Š” ๋ช…๋ นํ˜• ์ฝ”๋“œ๋ฅผ ๋ณผ๊ฒŒ์š”:


// ๋ช…๋ นํ˜• ๋ฐฉ์‹์œผ๋กœ ์ž‘์„ฑ๋œ ์ฝ”๋“œ
struct User {
    let id: Int
    let name: String
    let age: Int
    let isPremium: Bool
}

func getActiveUserNames(users: [User]) -> [String] {
    var activeUserNames = [String]()
    
    for user in users {
        if user.age >= 18 && user.isPremium {
            let formattedName = user.name.uppercased()
            activeUserNames.append(formattedName)
        }
    }
    
    return activeUserNames
}
      

์ด์ œ ์ด ์ฝ”๋“œ๋ฅผ ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋ฆฌํŒฉํ† ๋งํ•ด๋ณผ๊ฒŒ์š”:


// ํ•จ์ˆ˜ํ˜• ๋ฐฉ์‹์œผ๋กœ ๋ฆฌํŒฉํ† ๋ง
func getActiveUserNamesFunctional(users: [User]) -> [String] {
    return users
        .filter { $0.age >= 18 && $0.isPremium }
        .map { $0.name.uppercased() }
}
      

์™€์šฐ! ์ฝ”๋“œ๊ฐ€ ํ›จ์”ฌ ๊ฐ„๊ฒฐํ•˜๊ณ  ๋ช…ํ™•ํ•ด์กŒ์ฃ ? ์ด๊ฒŒ ๋ฐ”๋กœ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋งค๋ ฅ์ด์—์š”! ๐Ÿ˜

์ข€ ๋” ๋ณต์žกํ•œ ์˜ˆ์ œ๋ฅผ ๋ณผ๊นŒ์š”? ์ฃผ๋ฌธ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•˜๋Š” ์ฝ”๋“œ์˜ˆ์š”:


// ๋ช…๋ นํ˜• ๋ฐฉ์‹
struct Order {
    let id: String
    let customerName: String
    let items: [Item]
    let date: Date
    let isDelivered: Bool
}

struct Item {
    let name: String
    let price: Double
    let quantity: Int
}

func calculateTotalRevenue(orders: [Order]) -> Double {
    var totalRevenue = 0.0
    
    for order in orders {
        if order.isDelivered {
            for item in order.items {
                let itemTotal = item.price * Double(item.quantity)
                totalRevenue += itemTotal
            }
        }
    }
    
    return totalRevenue
}

// ํ•จ์ˆ˜ํ˜• ๋ฐฉ์‹
func calculateTotalRevenueFunctional(orders: [Order]) -> Double {
    return orders
        .filter { $0.isDelivered }
        .flatMap { $0.items }
        .map { $0.price * Double($0.quantity) }
        .reduce(0, +)
}
      

ํ•จ์ˆ˜ํ˜• ๋ฒ„์ „์€ ๋ฐ์ดํ„ฐ์˜ ํ๋ฆ„์ด ๋ช…ํ™•ํ•˜๊ฒŒ ๋ณด์—ฌ์š”. ๊ฐ ๋‹จ๊ณ„๊ฐ€ ๋ฌด์—‡์„ ํ•˜๋Š”์ง€ ํ•œ๋ˆˆ์— ํŒŒ์•…ํ•  ์ˆ˜ ์žˆ์ฃ :

  1. ๋ฐฐ๋‹ฌ๋œ ์ฃผ๋ฌธ๋งŒ ํ•„ํ„ฐ๋ง
  2. ๋ชจ๋“  ์ฃผ๋ฌธ์˜ ์•„์ดํ…œ์„ ํ•˜๋‚˜์˜ ๋ฐฐ์—ด๋กœ ํ‰ํƒ„ํ™”
  3. ๊ฐ ์•„์ดํ…œ์˜ ์ด ๊ฐ€๊ฒฉ ๊ณ„์‚ฐ
  4. ๋ชจ๋“  ๊ฐ€๊ฒฉ ํ•ฉ์‚ฐ

์ด๋ ‡๊ฒŒ ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋ฆฌํŒฉํ† ๋งํ•˜๋ฉด ์ฝ”๋“œ๊ฐ€ ๋” ์ฝ๊ธฐ ์‰ฝ๊ณ , ๋ฒ„๊ทธ๊ฐ€ ์ ๊ณ , ํ…Œ์ŠคํŠธํ•˜๊ธฐ ์‰ฌ์›Œ์ ธ์š”. ํŠนํžˆ ๋ณต์žกํ•œ ๋น„์ฆˆ๋‹ˆ์Šค ๋กœ์ง์„ ๋‹ค๋ฃฐ ๋•Œ ์ด๋Ÿฐ ์žฅ์ ์ด ๋” ๋‘๋“œ๋Ÿฌ์ง„๋‹ต๋‹ˆ๋‹ค! ๐Ÿš€

์‹ค์ „ ๋ฆฌํŒฉํ† ๋ง: ๋„คํŠธ์›Œํฌ ์š”์ฒญ ์ฒ˜๋ฆฌ


// ๋ช…๋ นํ˜• ๋ฐฉ์‹
func fetchUserData(userId: String, completion: @escaping (Result<User, Error>) -> Void) {
    let url = URL(string: "https://api.example.com/users/\(userId)")!
    
    URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            completion(.failure(APIError.invalidResponse))
            return
        }
        
        guard let data = data else {
            completion(.failure(APIError.noData))
            return
        }
        
        do {
            let user = try JSONDecoder().decode(User.self, from: data)
            completion(.success(user))
        } catch {
            completion(.failure(error))
        }
    }.resume()
}

// ํ•จ์ˆ˜ํ˜• ๋ฐฉ์‹
enum NetworkResult<T> {
    case success(T)
    case failure(Error)
}

func fetchData<T: Decodable>(from url: URL) -> (@escaping (NetworkResult<T>) -> Void) -> Void {
    return { completion in
        URLSession.shared.dataTask(with: url) { data, response, error in
            let result = validateResponse(data: data, response: response, error: error)
                .flatMap(decodeData:)
            
            completion(result)
        }.resume()
    }
}

func validateResponse(data: Data?, response: URLResponse?, error: Error?) -> NetworkResult<Data> {
    if let error = error {
        return .failure(error)
    }
    
    guard let httpResponse = response as? HTTPURLResponse,
          (200...299).contains(httpResponse.statusCode) else {
        return .failure(APIError.invalidResponse)
    }
    
    guard let data = data else {
        return .failure(APIError.noData)
    }
    
    return .success(data)
}

func decodeData<T: Decodable>(data: Data) -> NetworkResult<T> {
    do {
        let decoded = try JSONDecoder().decode(T.self, from: data)
        return .success(decoded)
    } catch {
        return .failure(error)
    }
}

// ์‚ฌ์šฉ
let fetchUser = fetchData<User>(from: URL(string: "https://api.example.com/users/123")!)
fetchUser { result in
    switch result {
    case .success(let user):
        print("์‚ฌ์šฉ์ž: \(user.name)")
    case .failure(let error):
        print("์˜ค๋ฅ˜: \(error)")
    }
}
        

ํ•จ์ˆ˜ํ˜•์œผ๋กœ ๋ฆฌํŒฉํ† ๋งํ•˜๋ฉด ๊ฐ ํ•จ์ˆ˜๊ฐ€ ํ•˜๋‚˜์˜ ์ฑ…์ž„๋งŒ ๊ฐ€์ง€๊ฒŒ ๋˜๊ณ , ์ฝ”๋“œ์˜ ์žฌ์‚ฌ์šฉ์„ฑ์ด ๋†’์•„์ ธ์š”. ์œ„ ์˜ˆ์ œ์—์„œ validateResponse์™€ decodeData ํ•จ์ˆ˜๋Š” ๋‹ค๋ฅธ ๋„คํŠธ์›Œํฌ ์š”์ฒญ์—์„œ๋„ ์žฌ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์ฃ !

์žฌ๋Šฅ๋„ท์—์„œ Swift ํ”„๋กœ์ ํŠธ๋ฅผ ๊ณต์œ ํ•˜๊ฑฐ๋‚˜ ์ฐพ์„ ๋•Œ, ํ•จ์ˆ˜ํ˜•์œผ๋กœ ์ž˜ ์ž‘์„ฑ๋œ ์ฝ”๋“œ๋Š” ๋‹ค๋ฅธ ๊ฐœ๋ฐœ์ž๋“ค์—๊ฒŒ ํฐ ๋„์›€์ด ๋  ์ˆ˜ ์žˆ์–ด์š”. ์ฝ”๋“œ์˜ ํ’ˆ์งˆ๊ณผ ๊ฐ€๋…์„ฑ์ด ๋†’์•„์ง€๋‹ˆ๊นŒ์š”! ๐Ÿ’ฏ

๋ช…๋ นํ˜• vs ํ•จ์ˆ˜ํ˜• ๋ฆฌํŒฉํ† ๋ง ๋ช…๋ นํ˜• ๋ฐฉ์‹ var result = [] for item in items { if condition(item) { let transformed = transform(item) result.append(transformed) } } ํ•จ์ˆ˜ํ˜• ๋ฐฉ์‹ items .filter(condition) .map(transform) ๋ฆฌํŒฉํ† ๋ง ๊ฐ„๊ฒฐ์„ฑ โ€ข ๊ฐ€๋…์„ฑ โ€ข ์žฌ์‚ฌ์šฉ์„ฑ โ€ข ํ…Œ์ŠคํŠธ ์šฉ์ด์„ฑ โ€ข ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ์„ฑ

10. Swift ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋ฏธ๋ž˜ ๐Ÿ”ฎ

2025๋…„ ํ˜„์žฌ, Swift์˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ๊ณ„์†ํ•ด์„œ ๋ฐœ์ „ํ•˜๊ณ  ์žˆ์–ด์š”. ์•ž์œผ๋กœ ์–ด๋–ค ๋ฐฉํ–ฅ์œผ๋กœ ๋‚˜์•„๊ฐˆ์ง€ ์‚ดํŽด๋ณผ๊นŒ์š”? ๐Ÿš€

Swift ์ปค๋ฎค๋‹ˆํ‹ฐ๋Š” ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ์žฅ์ ์„ ๊ณ„์†ํ•ด์„œ ์ˆ˜์šฉํ•˜๊ณ  ์žˆ์–ด์š”. ๋” ์•ˆ์ „ํ•˜๊ณ , ๋” ํ‘œํ˜„๋ ฅ ์žˆ๊ณ , ๋” ์œ ์ง€๋ณด์ˆ˜ํ•˜๊ธฐ ์‰ฌ์šด ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ธฐ ์œ„ํ•œ ๋…ธ๋ ฅ์ด ๊ณ„์†๋˜๊ณ  ์žˆ์ฃ ! ๐ŸŒŸ

์žฌ๋Šฅ๋„ท์—์„œ๋„ ์ด๋Ÿฐ ์ตœ์‹  Swift ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ธฐ๋ฒ•์„ ํ™œ์šฉํ•œ ํ”„๋กœ์ ํŠธ๋“ค์ด ์ ์  ๋” ๋งŽ์ด ๊ณต์œ ๋˜๊ณ  ์žˆ์–ด์š”. ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ์ด์ œ Swift ๊ฐœ๋ฐœ์ž์—๊ฒŒ ํ•„์ˆ˜ ์Šคํ‚ฌ์ด ๋˜์–ด๊ฐ€๊ณ  ์žˆ๋‹ต๋‹ˆ๋‹ค! ๐Ÿ’ช

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ๋งˆ์Šคํ„ฐํ•˜๋ฉด ์ฝ”๋“œ ํ’ˆ์งˆ์ด ํ–ฅ์ƒ๋˜๊ณ , ๋ฒ„๊ทธ๊ฐ€ ์ค„์–ด๋“ค๊ณ , ํ˜‘์—…์ด ๋” ์‰ฌ์›Œ์ ธ์š”. ํŠนํžˆ ๋Œ€๊ทœ๋ชจ ์•ฑ์„ ๊ฐœ๋ฐœํ•  ๋•Œ ์ด๋Ÿฐ ์žฅ์ ์ด ๋” ๋‘๋“œ๋Ÿฌ์ง„๋‹ต๋‹ˆ๋‹ค. ์•ž์œผ๋กœ Swift๋กœ ๊ฐœ๋ฐœํ•  ๋•Œ ํ•จ์ˆ˜ํ˜• ์ ‘๊ทผ๋ฒ•์„ ์ ๊ทน์ ์œผ๋กœ ํ™œ์šฉํ•ด๋ณด์„ธ์š”! ๐Ÿš€

Swift ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋ฏธ๋ž˜ ํ˜„์žฌ (2025) ๊ณ ์ฐจ ํ•จ์ˆ˜ ํด๋กœ์ € ๋ถˆ๋ณ€์„ฑ ํ•จ์ˆ˜ ํ•ฉ์„ฑ ๊ทผ๋ฏธ๋ž˜ ๋น„๋™๊ธฐ ํ•จ์ˆ˜ํ˜• ํ•จ์ˆ˜ํ˜• ๋ฆฌ์•กํ‹ฐ๋ธŒ ํ•จ์ˆ˜ํ˜• DSL ํƒ€์ž… ์•ˆ์ „ ํ•ฉ์„ฑ ๋จผ ๋ฏธ๋ž˜ AI ์ฝ”๋“œ ์ƒ์„ฑ ์ž๋™ ์ตœ์ ํ™” ์˜๋„ ๊ธฐ๋ฐ˜ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํ˜•์‹ ์ฆ๋ช…

๊ฒฐ๋ก : Swift ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋งค๋ ฅ ๐Ÿ’ซ

์ง€๊ธˆ๊นŒ์ง€ Swift์˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŠน์ง•์— ๋Œ€ํ•ด ๊นŠ์ด ์•Œ์•„๋ดค์–ด์š”. ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ๋‹จ์ˆœํžˆ ํŠธ๋ Œ๋””ํ•œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์Šคํƒ€์ผ์ด ์•„๋‹ˆ๋ผ, ๋” ์•ˆ์ „ํ•˜๊ณ  ์œ ์ง€๋ณด์ˆ˜ํ•˜๊ธฐ ์‰ฌ์šด ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ธฐ ์œ„ํ•œ ๊ฐ•๋ ฅํ•œ ๋„๊ตฌ๋ž๋‹ˆ๋‹ค! ๐Ÿ› ๏ธ

Swift๋Š” ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์œ„ํ•œ ๋‹ค์–‘ํ•œ ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•ด์š”:

  1. ์ผ๊ธ‰ ๊ฐ์ฒด๋กœ์„œ์˜ ํ•จ์ˆ˜: ํ•จ์ˆ˜๋ฅผ ๋ณ€์ˆ˜์ฒ˜๋Ÿผ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ์–ด์š”
  2. ๊ณ ์ฐจ ํ•จ์ˆ˜: map, filter, reduce ๋“ฑ์œผ๋กœ ๋ฐ์ดํ„ฐ ๋ณ€ํ™˜์„ ๊ฐ„๊ฒฐํ•˜๊ฒŒ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์–ด์š”
  3. ๋ถˆ๋ณ€์„ฑ: ๋ฐ์ดํ„ฐ ๋ณ€๊ฒฝ์œผ๋กœ ์ธํ•œ ๋ฒ„๊ทธ๋ฅผ ์ค„์ผ ์ˆ˜ ์žˆ์–ด์š”
  4. ์ˆœ์ˆ˜ ํ•จ์ˆ˜: ์˜ˆ์ธก ๊ฐ€๋Šฅํ•˜๊ณ  ํ…Œ์ŠคํŠธํ•˜๊ธฐ ์‰ฌ์šด ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์–ด์š”
  5. ํด๋กœ์ €: ํ•จ์ˆ˜๋ฅผ ๋” ์œ ์—ฐํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด์š”
  6. ํ•จ์ˆ˜ ํ•ฉ์„ฑ: ์ž‘์€ ํ•จ์ˆ˜๋“ค์„ ์กฐํ•ฉํ•ด ๋ณต์žกํ•œ ๋กœ์ง์„ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์–ด์š”

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ์ฒ˜์Œ์—๋Š” ์ต์ˆ™ํ•ด์ง€๊ธฐ ์–ด๋ ค์šธ ์ˆ˜ ์žˆ์ง€๋งŒ, ์ผ๋‹จ ๋งˆ์Šคํ„ฐํ•˜๋ฉด ์ฝ”๋“œ์˜ ํ’ˆ์งˆ์ด ํฌ๊ฒŒ ํ–ฅ์ƒ๋ผ์š”. ๋ฒ„๊ทธ๊ฐ€ ์ค„์–ด๋“ค๊ณ , ์ฝ”๋“œ๊ฐ€ ๋” ์ฝ๊ธฐ ์‰ฌ์›Œ์ง€๊ณ , ํ…Œ์ŠคํŠธํ•˜๊ธฐ ์‰ฌ์›Œ์ง„๋‹ต๋‹ˆ๋‹ค! ๐Ÿš€

ํŠนํžˆ Swift UI์™€ Combine ํ”„๋ ˆ์ž„์›Œํฌ๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ํ•จ์ˆ˜ํ˜• ์ ‘๊ทผ๋ฒ•์€ ์ •๋ง ํฐ ๋„์›€์ด ๋ผ์š”. ์ƒํƒœ ๊ด€๋ฆฌ์™€ ๋ฐ์ดํ„ฐ ํ๋ฆ„์„ ๋” ๋ช…ํ™•ํ•˜๊ฒŒ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ ์š”.

์žฌ๋Šฅ๋„ท์—์„œ Swift ๊ฐœ๋ฐœ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•˜๊ฑฐ๋‚˜ ์ฐพ๊ณ  ์žˆ๋‹ค๋ฉด, ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ธฐ๋ฒ•์„ ์ตํžˆ๋Š” ๊ฒƒ์ด ํฐ ๊ฒฝ์Ÿ๋ ฅ์ด ๋  ์ˆ˜ ์žˆ์–ด์š”. ํ•จ์ˆ˜ํ˜• ์Šคํƒ€์ผ๋กœ ์ž‘์„ฑ๋œ ์ฝ”๋“œ๋Š” ๋‹ค๋ฅธ ๊ฐœ๋ฐœ์ž๋“ค์ด ์ดํ•ดํ•˜๊ณ  ์œ ์ง€๋ณด์ˆ˜ํ•˜๊ธฐ ์‰ฝ๊ธฐ ๋•Œ๋ฌธ์ด์ฃ ! ๐Ÿ‘จโ€๐Ÿ’ป๐Ÿ‘ฉโ€๐Ÿ’ป

์ด์ œ ์—ฌ๋Ÿฌ๋ถ„๋„ Swift์˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŠน์ง•์„ ํ™œ์šฉํ•ด์„œ ๋” ์šฐ์•„ํ•˜๊ณ  ์•ˆ์ „ํ•œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด๋ณด์„ธ์š”! ์ฒ˜์Œ์—๋Š” ์–ด์ƒ‰ํ•  ์ˆ˜ ์žˆ์ง€๋งŒ, ์กฐ๊ธˆ์”ฉ ์—ฐ์Šตํ•˜๋‹ค ๋ณด๋ฉด ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ํ•จ์ˆ˜ํ˜• ์‚ฌ๊ณ ๋ฐฉ์‹์ด ๋ชธ์— ๋ฐฐ๊ฒŒ ๋  ๊ฑฐ์˜ˆ์š”. ํ™”์ดํŒ…! ๐Ÿ’ช

ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์—ฌ์ •์„ ์‹œ์ž‘ํ•ด๋ณด์„ธ์š”! ๐Ÿš€

Swift์˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํŠน์ง•์„ ํ™œ์šฉํ•˜๋ฉด ์ฝ”๋“œ๊ฐ€ ๋” ๊ฐ„๊ฒฐํ•˜๊ณ , ์•ˆ์ „ํ•˜๊ณ , ์œ ์ง€๋ณด์ˆ˜ํ•˜๊ธฐ ์‰ฌ์›Œ์ ธ์š”. ์žฌ๋Šฅ๋„ท์—์„œ ๋‹ค์–‘ํ•œ Swift ๊ฐœ๋ฐœ์ž๋“ค๊ณผ ํ•จ๊ป˜ ํ•จ์ˆ˜ํ˜• ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋งค๋ ฅ์„ ๊ฒฝํ—˜ํ•ด๋ณด์„ธ์š”!

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.