[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๋ฅผ ๊ณต๋ถํ๋ฉด์ ๋ฐฐ์ด ๋ด์ฉ์ ๊ธฐ๋กํ๊ณ ์์ต๋๋ค.
[์ฐธ๊ณ ๋งํฌ]
https://goshdarnifcaseletsyntax.com
How Do I Write If Case Let in Swift?
if case let is an abbreviated form of switch case let immediately precedes the candidate pattern in both versions. Confusingly though, when using if case let, the value comes after the = operator. So if case let Puppy.mastiff(droolRating, weight) = fido {
goshdarnifcaseletsyntax.com