์๋ ํ์ธ์ ๊ฐ์์ ๋๋ค! ์ค๋์ swift ์ธ์ด์์ ์ ๋ ฅ์ ๋ฐ๋ ๋ฉ์๋์ธ readLine()์ ๋ํด์ ์์๋ณด๊ฑฐ์์. ์ฝ๋ฉํ ์คํธ๋ฅผ ์ค๋น์ค์ธ๋ฐ ํ๋ก๊ทธ๋๋จธ์ค๋ ๋ต์์ func๋ก ์์ฑํ๋ฉฐ ๋์ง๋ง, ๋ฐฑ์ค์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ๋ชจ๋ ์ ๋ ฅํด์ผํด์! ๊ทธ๋์ ๋ฐฑ์ค์ผ๋ก ๊ณต๋ถํ ๋ ๊ฐ ์ธ์ด๋ณ๋ก input์ ๋ฐ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ตํ๊ณ ์๋๊ฒ์ด ํ์์ธ๋ฐ์,
์ ๋ ฅ์ ๊ทธ๋ฅ ์ ํ๋๋ง ๋ฐ๋๊ฒ ์๋๋ผ, ํ๋ ฌ๋ก ๋ฐ๊ธฐ๋ ํ๊ณ , ๋ฐฐ์ด๋ก ๋ฐ๊ธฐ๋ํ๊ณ , ์ฌ๋ฌ์ค๋ก ๋ฐ๊ธฐ๋ํ๊ณ ์ ๋ง ๋ค์ํ ๋ฐฉ๋ฒ์ผ๋ก input์ ๋ฐ์์์! ์ด๊ฒ์ ๋ชจ๋ ์ตํ๋์ผ ๋์ค์ ์๊ณ ๋ฆฌ์ฆ ํ๋ ๋งํ์ง ์๊ธฐ ๋๋ฌธ์ ์ฐจ๊ทผ์ฐจ๊ทผ ์ ๋ฆฌํด๋ณด๋๋ก ํ ๊ฒ์.
์ฌ์ค ์ ๊ฐ ํท๊ฐ๋ฆฌ๊ณ ์ ๊ฐ ์ธ์๋๊ธฐ(?) ์ํด์ ์ ๋๊ฑฐ๋๋๋ค ํํ ๊ทธ๋ผ go
readLine()
Swift์์ ์ ๋ ฅ์ readLine()์ ํตํด์ ํ ์ ์๋ค. readLine()์ ์ ๋ ฅ์ ๋ชจ๋ optional Stringํ์ผ๋ก ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ๋๋ค๋ฅธ ์ฒ๋ฆฌ๊ฐ ํ์ํ๋ค. ๋ํ Swfit์์ readLine์ EOF๊ฐ ๋ค์ด์ค๊ธฐ์ ์ ์ ๋ ฅ์ return ํ๊ฒ ๋๋๋ฐ, EOF๋ End Of File ์ ๋ป์ผ๋ก ์ํฐ๊ฐ ์ ๋ ฅ๋๋ ๊ฒ์ EOF์ฒ๊ธฐ๊ฐ ๋๋ค~ ๋ผ๊ณ ๋งํ๋ค. ์ฆ, ์ํฐ๊ฐ ํ๋ฒ ์ ๋ ฅ๋๋ฉด readLine() ํ๊ฐ๊ฐ ๋๋๋ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ Swift์์๋ ์ ๋ ฅ์ ์ฌ๋ฌ์ค ๋ฐ์ ๋ readLine()์ ์ฌ๋ฌ๋ฒ ์จ์ฃผ๋ฉด ๋๋ ๊ฒ์ด๋ค!
1. ์ ์ ์ ๋ ฅ๋ฐ๊ธฐ
์์ readLine์ ๋ชจ๋ ๊ฐ์ optional string์ ํํ๋ก returnํ๋ค๊ณ ํ๋ค. ๋ฐ๋ผ์ ์ถ๊ฐ์ ์ธ ์ฒ๋ฆฌ๋ฅผ ํด์ค์ผ, ์ ์ ์ ๋ ฅ์ด ๊ฐ๋ฅํ๋ค. ๊ฐ์ ๋ก ์ต์ ๋์ ๋ฒ๊ธฐ๋ ๊ธฐ๋ฅ๊ณผ , INT๋ก ํ๋ณํ์ด ํ์ํ๋ค.
let input = readLine()
print(type(of:input))
// prints "Optional<String>"
let inputOut = input!
print(type(of:inputOut))
//prints "String"
let intvar = Int(InputOut)
print(type(of:intvar))
//prints "Optional<Int>"
let result = intvar!
print(type(of:result))
//prints "Int"
์ ์ฝ๋๋ฅผ ๋ณด๋ฉด, readLine์ผ๋ก ์ ๋ ฅ๋ฐ์ input์ optional string ๊ฐ์ด๋ค. (string? ๊ฐ)
๊ทธ๋์ ์ด๋ฅผ inputOut์ ๋ณ์์ ์ธ๋ํํ์ฌ ์ ์ฅํ์๋๋, ์ผ๋ฐ Stringํ์ด ์ถ๋ ฅ๋๋ค. ๊ทธ๋ผ ๋ค์ ์ด๋ฅผ ์ซ์๋ก ๋ฐ๊พธ๊ณ ์ถ๋ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น.
intvar ๋ณ์์ Int() ๋ฅผ ํ์ฉํ์ฌ ํ๋ณํ์ ์๋ํ๋ค. ํ์ง๋ง, ๋ค์ Optional Int ๊ฐ์ผ๋ก ์ถ๋ ฅ๋์๊ณ , ์ต์ ๋์ด ์ธ๋ํ ๋์ง ์์๋ค. ์ ์๋์ผ๋ก ๋ค์ ์ต์ ๋๋ก ๋ํ๋๋ ๊ฒ์ผ๊น? ๊ทธ ์ด์ ๋, string์ผ๋ก ์ ๋ ฅ๋ 1,2,3,4 ์ ๊ฐ์ ์ซ์๋ค์ int๋ก ํ๋ณํ์ด ๊ฐ๋ฅํ์ง๋ง, ๋ง์ฝ์ ์ ๋ ฅ๋ฐ์ string์ด ์ซ์๊ฐ ์๋ a,b,c,d ์ ๊ฐ์ ๋ฌธ์๋ผ๋ฉด, int๋ก ํ๋ณํ์ ์๋ํ๋ฉด nil์ด ๋๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋์ ์์ ํ ์ธ์ด์ธ Swift๋ ์ด๋ฅผ ๋ค์ ๋ํํ์ฌ optional๋ก ์ถ๋ ฅํ๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ ์ ์๋ก ์ถ๋ ฅํ๊ธฐ ์ํด์๋ ๋ง์ง๋ง์ ๋ค์ํ๋ฒ ๊ฐ์ ๋ก ์ธ๋ํ ํด์ฃผ์ด์ผ ํ๋ค. (result๋ฅผ ๋ด๋ผ. ๋ค์ ์ธ๋ํ ํด์ฃผ๋๊น ์ฐ๋ฆฌ๊ฐ ์ํ๋ ์ ์ํ์ด ๋๋์ด ์ถ๋ ฅ๋์๋ค.)
์ด๋ฅผ ํ๋ฒ์ ์ ๋ ฅํ๊ณ ์ถ๋ค๋ฉด ์๋์ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํ๋ฉด ๋๋ค.
let n = Int(readLine()!)!
2. ๋ฌธ์์ด ํ๋ ์ ๋ ฅ ๋ฐ๊ธฐ
์์์ ์ ์๋ฅผ ์ ๋ ฅํ๊ธฐ ์ํด์๋ ์ต์ ๋์ ๋๋ฒ ๋ฒ๊ฒจ์ฃผ์ด์ผ ํ๋ค. ํ์ง๋ง ์ด๋ฏธ string ํํ๋ก ์ ๋ ฅ์ ๋ฐ๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด ํ๋๋ฅผ ์ ๋ ฅ๋ฐ๊ธฐ ์ํด์๋ readLine์ ์ต์ ๋์ ํ๋ฒ๋ง ๊ฐ์ ๋ก ๋ฒ๊ฒจ์ฃผ๋ฉด ๋๋ค.
let text = readLine()!
3. ๋์ด์ฐ๊ธฐ๋ก ๊ตฌ๋ถํ์ฌ ์ ๋ ฅ๋ฐ๊ธฐ, ๋ฐ๋ก ๋ฐฐ์ด๋ก ์ ๋ ฅ๋ฐ๊ธฐ
import Foundation
let input = readLine()! // h e l l o ๋ผ๊ณ ์
๋ ฅ
print(type(of: input))
print(input)
// prints "String"
// prints "h e l l o"
let result = input.components(separatedBy: " ")
print(type(of: result))
print(result)
// prints "Array<String>"
// prints ["h", "e", "l", "l", "o"]
fountdation ํ๋ ์์ํฌ์ ํฌํจ๋์ด์๋ components ๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ ๋์ด์ฐ๊ธฐ๋ก ๊ตฌ๋ถํด์ฃผ์๋ค. ์ด๋ ๊ฒ ์ฐ๊ฒ ๋๋ฉด ๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด์ด "๋ฐฐ์ด" ๋ก ๋ฐ๋ก return๋๋ค. ์ ์ฉํ ๊ฒ ๊ฐ๋ค!
4. ๋์ด์ฐ๊ธฐ๋ก ์ ์ ์ฌ๋ฌ๊ฐ ์ ๋ ฅ ๋ฐ๊ธฐ
์ ์๋ฅผ ์ฌ๋ฌ๊ฐ ์ ๋ ฅ๋ฐ๊ธฐ ์ํด์๋, split ๊ณผ map์ ์ด์ฉํด ์ค๊ฒ์ด๋ค. ์ฝ๋๋ ์๋์ ๊ฐ๋ค.
let input = readLine()!.split(separator: " ").map { Int(String($0))! }
// ์
๋ ฅ: 1 2 3
// Array<Int>
// [1, 2, 3]
map() ๋ฉ์๋๋ฅผ ํด๋ก์ ๋ก ์ฌ์ฉํ ์ผ์ด์ค์ด๋ค. ๋ฐฐ์ด ํ๋ํ๋์ ์์ดํ ์ map ํด๋ก์ ์์ ์ฝ๋๋ฅผ ์ ์ฉ์ํจ๋ค๋ ๋ป์ผ๋ก, ํ๋ํ๋ Int๋ก ๋ฐ๊ฟ์ฃผ์ด ๋ฐฐ์ด์ ๋งคํ์์ผ์ค๋ค๊ณ ์ดํดํ๋ฉด ํธํ ๊ฒ์ด๋ค.
5. (๋์ด์ฐ๊ธฐ์์ด) ํ ๋ฒ์ ์ ๋ ฅ ๋ฐ์์ ๋ฐฐ์ด๋ก returnํ๊ธฐ
let input = Array(readLine()!) //์
๋ ฅ; hello
print(input)
print(type(of:input))
//prints ["h", "e", "l", "l", "o"]
// prints Array<String>
ํํ์ง ์์ง๋ง, ๊ฐํน ๋์ด์ฐ๊ธฐ ์์ด ์ ๋ ฅ์ ๋ฐ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ๊ทธ๋ด ๋ ์์ ๊ฐ์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ์ข๋ค. ์์์ ์ ์ ๋ก ํ๊ธ์์ฉ ๋ฐฐ์ด์ ํ ์ธ๋ฑ์ค์ ์ ์ฅํด์ค๋ค. ํธํ๊ฒ ๊ฐ๋ค. ์ด๋ฅผ intํ์ผ๋ก ์ ๋ ฅ๋ฐ๊ณ ์ถ๋ค๋ฉด ์๋์ ๊ฐ์ด ์์ฑํ์.
let result = input.map { Int(String($0))! }
print(result)
print(type(of: result))
//prints [1,2,3,4,5] ๋ง์ฝ, ์
๋ ฅ์ด "12345" ์๋ค๋ฉด ์ด๋ ๊ฒ ์ถ๋ ฅ,
//prints Array<Int>