[Swift] if case let ๋ฅผ ์ฌ์ฉํ์ฌ ๋ถํ์ํ ์ฝ๋ ์ค์ด๊ธฐ
์๋ ํ์ธ์๐ถ
์ด๋ฒ ์๊ฐ์๋ if case let ํจํด์ ์ฌ์ฉํด switch-case ๊ตฌ๋ฌธ์ boiler plate ๋ฅผ ์ค์ฌ๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
์ธ์ ์ฐ๋๊ฐ?
์ด๊ฑฐํ์ ์ฒ๋ฆฌํ ๋ ๋ณดํต ์ ๋ switch-case ๋ฅผ ์ฌ์ฉํ์์ต๋๋ค.
๋จ์ผ case ๋ง์ ์ฒ๋ฆฌํ๊ณ ์ถ์ด๋ ๊ฐ์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ต๋๋ค.
๋ก๋ณถ์ด ์ด๊ฑฐํ์ ์๋ก ํ ๋ฒ ๋ค์ด๋ณด์๋ฉด:
enum ๋ก๋ณถ์ด {
case ์ผ๋ฐ
case ์น์ฆ
}
let ๋ด๋ก๋ณถ์ด = ๋ก๋ณถ์ด.์น์ฆ
switch ๋ด๋ก๋ณถ์ด {
case .์น์ฆ:
์น์ฆํ ํ์น๊ธฐ()
case .์ผ๋ฐ:
break;
}
๋ง์ฝ ๋ ๋ง์ ์ผ์ด์ค๊ฐ ์๋๋ฐ ํ๋๋ง ์ฒ๋ฆฌํ๊ณ ์ถ์ ๊ฒฝ์ฐ๋ผ๋ฉด, default ๋ฌธ์ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
switch ๋ด๋ก๋ณถ์ด {
case .์น์ฆ:
์น์ฆํ ํ์น๊ธฐ()
default:
break
}
์ด๋ ๊ฒ ๋จ ํ๋์ case ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด switch ๋ฅผ ์ฌ์ฉํ๋ฉด,
๋๋จธ์ง case ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด break ๋ฑ์ ์๋ฏธ์๋ ์ฝ๋๋ฅผ ์ ์ด์ฃผ์ด์ผํฉ๋๋ค๐ญ
๊ทธ๋ฐ๋ฐ ๋ ์ข์ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
if let case ๋ฅผ ์ฌ์ฉํ๋ค๋ฉด
์๋์ ๊ฐ์ด ์ฐ๋ฆฌ๋ ๋ ๊ฐ๊ฒฐํ ์ฝ๋๋ก [case ์น์ฆ] ๋ฅผ ์ฒ๋ฆฌํ ์ ์๊ฒ ๋ฉ๋๋ค.
if case let .์น์ฆ = ๋ด๋ก๋ณถ์ด {
์น์ฆํ ํ์น๊ธฐ()
}
์ด๋ป๊ฒ ์ฌ์ฉํ๋๊ฐ?
if case let .์น์ฆ = ๋ด๋ก๋ณถ์ด {
์น์ฆํ ํ์น๊ธฐ()
}
๋ฌธ๋ฒ์ด ์กฐ๊ธ ํน์ดํฉ๋๋ค.
'๋ด๋ก๋ณถ์ด' ๊ฐ ํ ๋น ์ฐ์ฐ์(=) ์ค๋ฅธ์ชฝ์ ์์นํ๊ณ ์๊ณ ,
์ฒ๋ฆฌํ case ๊ฐ ์ผ์ชฝ์ ์์นํฉ๋๋ค.
์ ์ฝ๋์์ '๋ด๋ก๋ณถ์ด' ๋ผ๋ ๋ก๋ณถ์ด ์ด๊ฑฐํ ์ธ์คํด์ค๊ฐ [case ์น์ฆ] ๋ผ๋ฉด, if ๋ธ๋ญ์ ์คํ๋ฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ์์ ๊ฐ์ ๊ฒฝ์ฐ let ๋ ์ฌ์ค ์ ์ด์ค ํ์๊ฐ ์๋ต๋๋ค :)
๋ฐ๋ผ์ ์๋์ ๊ฐ์ด ์ ์ด์ฃผ์ด๋ ์ฌ๋ฐ๋ฅธ ๋ฌธ๋ฒ์ ๋๋ค.
// O.K
if case .์น์ฆ = ๋ด๋ก๋ณถ์ด {
์น์ฆํ ํ์น๊ธฐ()
}
๊ทธ๋ผ let ์ ์ธ์ ์ฌ์ฉํ๋ ๊ฒ์ผ๊น์?
let ์ ์ฐ๊ด๊ฐ์ ๋ฐ์ธ๋ฉ ํ ๋ ์ฌ์ฉํฉ๋๋ค.
์ฐ๊ด๊ฐ ๋ฐ์ธ๋ฉ์ ์ต์ํ์๋ค๋ฉด ์๋ ๋ ์ข ๋ฅ์ ์ฝ๋๊ฐ ๊ธ๋ฐฉ ์ดํด๋์ค ๊ฒ์ ๋๋ค.
์ด๋ฅผ ์ํด ๋ก๋ณถ์ด ์ด๊ฑฐํ์ [case ๋ฏน์ค] ๋ฅผ ์ถ๊ฐํด๋ณผ๊ฒ์!
enum ๋ก๋ณถ์ด {
...
case ๋ฏน์ค(๋ก๋น์จ: Double, ์ค๋
๋น์จ: Double)
...
}
[case ๋ฏน์ค] ๋ ๋ก๋ณถ์ด๋ฅผ ๊ตฌ์ฑํ๋ ๋ก๊ณผ ์ค๋ ์ ๊ตฌ์ฑ๋น์จ์ Double ํ ์ฐ๊ด๊ฐ์ผ๋ก ๊ฐ์ง๊ณ ์์ต๋๋ค.
๋ง์ฝ if-case-let ์ ์ฌ์ฉํ์ฌ ์ฐ๊ด ๊ฐ์ ์ฒ๋ฆฌํ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๋ฐ์ธ๋ฉ ํ ์ ์์ต๋๋ค.
let ๋๋ง์๋ก๋ณถ์ด์กฐํฉ = ๋ก๋ณถ์ด.๋ฏน์ค(๋ก๋น์จ: 0.64, ์ค๋
๋น์จ: 0.36)
if case let .๋ฏน์ค(๋ก์, ์ค๋
์) = ๋๋ง์๋ก๋ณถ์ด์กฐํฉ {
๋ก๋ฃ๊ธฐ(๋ก์)
์ค๋
๋ฃ๊ธฐ(์ค๋
์)
}
์ด๊ฒ์ ์ฐ๊ด๊ฐ ๋ฐ์ธ๋ฉ ๋ฐฉ์๊ณผ ๊ฐ์ต๋๋ค.
๋ง์ฝ ๋ก์์๋ ๊ด์ฌ์ด ์๋ค๋ฉด _ (์ธ๋์ค์ฝ์ด)๋ฅผ ์ฌ์ฉํ์ฌ ์์ผ๋์นด๋ ํจํด์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
if case .๋ฏน์ค(_, let ์ค๋
๋น์จ) = ๋๋ง์๋ก๋ณถ์ด์กฐํฉ {
๋ก๋ฃ๊ธฐ(1 - ์ค๋
๋น์จ)
์ค๋
๋ฃ๊ธฐ(์ค๋
๋น์จ)
}
์ถ๊ฐ์ ์ผ๋ก if ๋ฟ๋ง ์๋๋ผ guard ๋ฌธ์๋ ์ฌ์ฉํ ์๋ ์์ผ๋ฉฐ, ์กฐ๊ฑด๋ฌธ ๋ค์ ์ฐ๊ฒฐ๋๋ ํํ์์์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
// guard-case-let
guard case .์น์ฆ = ๋ด๋ก๋ณถ์ด else {
print("์ ์ ์น์ฆ๋ก ์์ฌ์ค๋๊ณ !")
return
}
// chained expressions
guard let ์ฃผ๋ฌธํ๋ก๋ณถ์ด = ๋ฐฐ๋ฏผ์ฃผ๋ฌธ(), case .์น์ฆ = ์ฃผ๋ฌธํ๋ก๋ณถ์ด else {
print("์ ์๋ชป์์ผฐ๋ค;;;")
return
}
์ค๋๋ ๋๋ ์ฑ์ฅํ๋ค!!๐ฅ
๐ค๐ข[์ฐ์งฑ์ iOS ๋ธ๋ก๊ทธ]๐ต๐ป
iOS๋ฅผ ๊ณต๋ถํ๋ฉด์ ๋ฐฐ์ด ๋ด์ฉ์ ๊ธฐ๋กํ๊ณ ์์ต๋๋ค.