โป ๋ณธ ํฌ์คํ ์ ์ ํ๋ธ Swift Programming Tutorial ๊ฐ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ ๊ฐ ์ง์ ์ ๋ฆฌํ Swift ๋ฌธ๋ฒ์ ๋ํ ๊ธ์ ๋๋ค.
Swift์ ๋ํด ์ฒ์ ๋ฐฐ์๋๊ฐ๋ ๊ณผ์ ์ ๋ธ๋ก๊ทธ์ ์ ๋ฆฌํ์์ต๋๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก ๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ๋ค๋ฃฌ ์ ์ด ์๊ธฐ์ ์ ๊ฐ ์๋ ๋ถ๋ถ์ ์๋ต๋ ์ ์์ต๋๋ค.
๊ฐ์๋ freeCodeCamp ์ฑ๋์ ์์์ธ๋ฐ, Vandad๋ผ๋ ๋ถ์ด ์งํํ๋ 7์๊ฐ ๋ถ๋์ full tutorial for beginners์ ๋๋ค. ํด๋น ๊ฐ์๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ Swift๋ก ์ฒ์ ์ ํ๋ ์ฌ๋๋ค์๊ฒ๋ ๋ค์ ์ด๋ ค์ธ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ ๋ ๊ธฐ์ด์ ์ธ ๋ถ๋ถ์ ๋ํ ์ผํ ์ค์์ฑ์ ๊น๊ฒ ์๋ ค์ฃผ๋ ๊ฒ ๊ฐ์์ ๊ฐ์๋ฅผ ํํ์ต๋๋ค. ์์ด ๊ฐ์์ด๋ฉฐ ์์ด์๋ง ๋๋ ์๋๋ฒ์ญ ๊ธฐ๋ฅ์ด ์ ๊ณต๋๊ธฐ์, ํน์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ๋ค๋ฃฌ ์ ์ด ์๋ ๋ถ๋ค ์ค Swift์ ๋ํด ์๋กญ๊ฒ ๋ฐฐ์ฐ๊ณ ์ ํ๋ค๋ฉด ๊ฐ์ถ๋๋ฆฝ๋๋ค!
< Variables >
Swift ๋ฌธ๋ฒ์ ๋ฐฐ์ด๋ค๋ฉด ์๋ง ๊ฐ์ฅ ์ฒ์ ์ ํ๊ฒ ๋ ๋ถ๋ถ์ ๋๋ค. ์ ๋ ์ค๋ ์ด ํํธ์ ๋ํด์ ๋จ์ํ "let์ ์์ var์ ๋ณ์๋ค" ๋ผ๋ ์ค๋ช ์ ํ๋ ๊ฒ ์๋๋ผ ๊ฐ์์์ ๊ฐ๋ฐ์๋ค์ด ๋ง์ด ํท๊ฐ๋ คํ๋ let ๊ณผ var ์ ์ฐจ์ด์ ์ ๋ํด ์ ์ด๋ณด๊ณ ์ ํฉ๋๋ค.
์ผ๋ฐ์ ์ผ๋ก `let`์ ๋ถ๋ณ์ฑ(immutability)์ ๊ฐ์ง ์์(Constant)๋ฅผ ์ ์ธํ ๋ ์ฌ์ฉํ๊ณ , `var`์ ๊ฐ๋ณ์ฑ(mutability)์ ๊ฐ์ง ๋ณ์(Variable)๋ฅผ ์ ์ธํ ๋ ์ฌ์ฉํฉ๋๋ค. ์ ๋ ๊ณต์๋ฌธ์์์, ๊ทธ๋ฆฌ๊ณ ํ๊ตญ์ด๋ก ๋ ๊ฐ์์์ ๋ฑ ์ด๋ ๊ฒ๊น์ง ์ธ์งํ๊ณ ์์์ต๋๋ค.
ํ์ง๋ง ํด๋น ๊ฐ์์์๋ let ๊ณผ var์ ์ฐจ์ด์ ์ ๋ฑ ํ ๊ฐ์ง๋ผ๊ณ ์ค๋ช ํฉ๋๋ค.
-> A let constant cannot be assigned to again whereas a var variable can be assigned to again
์ฌ์ค ์ด ๋ถ๋ถ์ ํน์ ์ํฉ์์ let constant๊ฐ internally mutate๊ฐ ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์ ์ผํ ์ฐจ์ด์ ์ด ์์ ๋ฌธ์ฅ์ด๋ผ๊ณ ์ค๋ช ํฉ๋๋ค. ๊ทธ๋ฌ๋๊น let์ผ๋ก ์ ์ธํ ์์๋ ์ฌํ ๋นํ ์ ์์ผ๋ฉฐ, var์ผ๋ก ์ ์ธํ ๋ณ์๋ ์ฌํ ๋น์ด ๊ฐ๋ฅํ๋ค๋ ๋ป์ ๋๋ค.
๋งจ ์ฒ์ ๊ฐ์๋ฅผ ๋ค์๋๋ ์ ๊ฐ ๋ฐฐ์ด ๊ฒ ํ๋ ธ๋ค๋ ๊ฒ ๊ฐ์์ต๋๋ค. ํ์ง๋ง ๊ฐ์๋ฅผ ํตํด ์ผ๋ฐ์ ์ธ ์ํฉ์์๋ ๋ฒ ์ด์งํ ์ ์๊ฐ ์ณ์ง๋ง ๋ํ ์ผํ๊ฒ ๋ค์ด๊ฐ๋ฉด ๋์ ๋จ์ง ๋ถ๋ณ vs ๋ณํจ์ผ๋ก ๊ตฌ๋ถํ๋ ๊ฒ์ ์ ํํ๊ฒ ๋งํ์๋ฉด ํ๋ฆฐ ์ ์์ ๋๋ค. ์ด์ ๋ํด ์ผ๋ฐ์ ์ธ let๊ณผ var์ ์ ์์ ๋ํด ๋จผ์ ๋งํ ํ ํ์ ์ ๋ฐ๋ฅธ let ์์์ ์์ฑ ๋ณ๊ฒฝ ์์๋ฅผ ๋ค์ด ์ค๋ช ํ๊ฒ ์ต๋๋ค.
1. ์ผ๋ฐ์ ์ ์
let myName = "Vandad"
let yourName = "Chaeon"
// ์๋๋ ์ปดํ์ผ๋ฌ ์ค๋ฅ ๋ฌธ์ฅ์
๋๋ค.
myName = yourName // Cannot assign to value: 'myName' is a 'let' constant
var names = [
myName,
yourName
]
names.append("Bar")
names.append("Baz")
// append ์ธ์๋ ์์ ํ ์๋กญ๊ฒ ๊ฐ์ ๋ฐฐ์ ํ ์ ์์.
names = ["Bla"]
์ฐ์ let ์์๋ฅผ ๋ณด๋ฉด myName์ด๋ผ๋ ์์๊ฐ ๋ง๋ค์ด์ง๊ณ , ์ด๊ธฐ๊ฐ์ด ํ ๋ฒ ํ ๋น๋๋ฉด ์๋ ์ฌํ ๋นํ๋ ค๋ ๋ฌธ์ฅ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค. myName = yourName ์์ ์ฃผ์์ฒ๋ฆฌ๋ก ์ ์ด๋ ๊ฒ์ฒ๋ผ Cannot assign to value๋ผ๋ ์ค๋ฅ๊ฐ ๋จ๊ฒ ๋ฉ๋๋ค.
๋ฐ๋๋ก, var ๋ณ์๋ก array๋ฅผ ๋ง๋ค์์ต๋๋ค. ์ด๊ฑด ๋ณ์(variable)์ด๊ธฐ ๋๋ฌธ์ ๋ด๋ถ์ ์ผ๋ก ๋ณ๊ฒฝ์ด ๊ฐ๋ฅํฉ๋๋ค.
๊ทธ ์์๋ก names๋ผ๋ variable array์ ๋ค๋ฅธ elements๋ค์ ์ถ๊ฐํด๋ ์ค๋ฅ๊ฐ ๋์ง ์์ต๋๋ค.
๋ํ, append์ธ์๋ ์์ ํ ์๋กญ๊ฒ ๊ฐ์ ์ฌํ ๋นํ ์ ์์ต๋๋ค.
์ฒ์ names๋ ["Vandad", "Chaeon"]์ผ๋ก ํ ๋น๋์์ต๋๋ค. ๊ทธ๋ค์ variable์ ๋ณ๊ฒฝ์ด ๊ฐ๋ฅํ๊ธฐ์ append๋ฅผ ํตํด ํด๋น array์ "Bar"๊ณผ "Baz"๋ฅผ ์ถ๊ฐํ์ต๋๋ค ["Vandad", "Chaeon", "Bar", "Baz"] 4๊ฐ์ ์์๊ฐ ๋๊ฒ์ด์ฃ .
์ด๋ ๊ฒ ๋ฉ์๋๋ฅผ ํตํด์ ๋ด๋ถ์ ์ธ ๋ณ๊ฒฝ์ ๊ฐ๋ฅํ๊ฒ๋ ํ์ง๋ง ์ด์ ๋ค๋ฅด๊ฒ ์์ ํ ์๋กญ๊ฒ ์ฌํ ๋น ๋ํ ๊ฐ๋ฅํ ๊ฒ์ด var์ ๋๋ค. names = ["Bla"] ๋ผ๋ ๋ฌธ์ฅ์ ๋ณด์๋ฉด names๋ผ๋ ๋ณ์์ "Bla"๋ผ๋ element๊ฐ ๋ค์ด์๋ ์๋ก์ด array๋ฅผ ํ ๋นํ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
๋ง์ฝ names๊ฐ let์ผ๋ก ์ ์ธ๋ array์๋ค๋ฉด append๋ฅผ ์ผ์ ๋ ์ค๋ฅ๊ฐ ๋๋ฉฐ, ์๋กญ๊ฒ ์ฌํ ๋น ํ๋ ๊ฒ๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค. ๊ทธ๋์ Swift์์ let์ผ๋ก ์์๋ฅผ ์ ์ธํ๋ฉด ๊ทธ ์์๊ฐ ์๋ก์ด ๊ฐ์ผ๋ก ์ฌํ ๋น๋๋ ๊ฒ์ ๋ง์ ๋ฟ๋ง ์๋๋ผ ๊ทธ ์์ ๋ด๋ถ์ ์ผ๋ก ๋ณํํ๋ ๊ฒ๋ ๋ง์ ์ ์์ต๋๋ค.
์ฌ๊ธฐ์ ์ ํฌ๋ ๋ ๊ฐ์ง ํฌ์ธํธ์ ๋ํด์ ์๊ณ ๊ฐ๊ฒ ์ต๋๋ค.
1. Mutation of the variable internally ๋ณ์์ ๋ด๋ถ์ ๋ณ๋
2. Assigning a new value to the variable to mutate ๋ณ์์ ์ฌํ ๋น
์ด ๋์ ์๋ฏธ๋ฅผ ๊ตฌ๋ถํ๋ ๊ฒ์ด ์ดํ ์ค๋ช ํ ํํธ์์ ์ค์ํฉ๋๋ค.
2. Value Type vs Reference Type
Swift์์๋ ๊ฐ ํ์ (value type)๊ณผ ์ฐธ์กฐ ํ์ (reference type)์ด๋ผ๋ ๋๊ฐ์ง ํ์ ๋ถ๋ฅ๊ฐ ์์ต๋๋ค. ๊ฐ์๊ธฐ ์ ์ด๊ฑธ ์ค๋ช ํ๋๊ฐ ์ถ๊ฒ ์ง๋ง ์ด ํ์ ์ ๋ฐ๋ผ์ let์ ์์ธ์ ์ธ mutable ํ ์ํฉ์ด ์ผ์ด๋๊ธฐ์ ๋ฏธ๋ฆฌ ์ค๋ช ํ๊ณ ๋์ด๊ฐ๊ฒ ์ต๋๋ค.
Value type์ ๊ฒฝ์ฐ ์์ ์ฝ๋๋ฅผ ๋ณด๊ฒ ์ต๋๋ค.
let foo = "Foo"
var foo2 = foo
// ์ง๊ธ foo ์ foo2๋ชจ๋ "Foo"๋ผ๋ String์ ๊ฐ์ง๊ณ ์๋ ์ํ์
foo2 = "Foo 2" //result : "Foo 2"
foo // result : "Foo"
foo2 // result : "Foo 2"
let์ผ๋ก foo ์์๋ฅผ ์ ์ธ (๊ฐ์ String type) / var์ผ๋ก foo2 ๋ณ์๋ฅผ ์ ์ธ -> foo ์ foo2๋ชจ๋ "Foo"๋ผ๋ String์ ๊ฐ์ง๊ณ ์๋ ์ํ์ ๋๋ค. ๊ทธ๋ฐ ๋ค์ foo2์ ์๋ก์ด ๊ฐ์ ํ ๋นํฉ๋๋ค. (variable์ด๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฅ) ๊ทธ๋ฌ๋ฉด foo2๋ "Foo 2"๋ผ๋ value๋ฅผ ๊ฐ์ง๊ฒ ๋ฉ๋๋ค.
์ด๋ foo2์ foo์ ๊ฐ์ ํ ๋นํ๊ธฐ์ foo2 ๋ณ์์ ๊ฐ์ด ๋ณํ๋ฉด foo์ ๊ฐ๋ ๋ณํด์ผ ํ๋ค๊ณ ์๊ฐํ์ค ์ ์์ต๋๋ค. ํ์ง๋ง foo๋ ๋ณ๊ฒฝ๋์ง ์๊ณ ๊ธฐ์กด์ ๊ฐ์ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์ด๋ String์ด value type์ด๊ธฐ์ ๊ทธ๋ ์ต๋๋ค.
foo2์ foo์ ๊ฐ์ ํ ๋นํ์ ๋ "๋ณต์ฌ์ ์ํ ์ ๋ฌ"(copy by value)๋ก ๋์ํ๊ธฐ ๋๋ฌธ์ ๊ฐ ์ธ์คํด์ค ๊ฐ์ ๊ฐ๊ฐ ๋ ๋ฆฝ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ํ ์ธ์คํด์ค์ ๊ฐ์ ๋ณ๊ฒฝํด๋ ๋ค๋ฅธ ์ธ์คํด์ค์ ์ํฅ์ ์ฃผ์ง ์์ต๋๋ค. ๊ทธ๋ ๊ธฐ์ foo์ ๊ฐ์ ๋ณต์ฌํ ์์ ํ ์๋ก์ด ์ธ์คํด์ค๊ฐ foo2์ ๊ฐ์ผ๋ก ์๊ธฐ๋ ๊ฒ์ ๋๋ค.
๋ ๋ค๋ฅธ ์์ ์ ๋๋ค.
let moreNames = [
"Foo",
"Bar"
]
var copy = moreNames
copy.append("Baz")
moreNames
copy
์์ ์ฝ๋๋ฅผ ๋ณด๋ฉด moreNames๋ผ๋ array๋ฅผ let์ผ๋ก ์ ์ธํ์์ต๋๋ค. array๋ structure์ด๋ฉด์ value type์ ๋๋ค. ๊ทธ๋ ๊ธฐ์ copy ๋ณ์๋ moreNames array์ ๋ฉ๋ชจ๋ฆฌ์ ์์น๊ฐ ์ฐ๊ฒฐ๋ ๊ฒ ์๋๊ณ array์ copy๋ฅผ ์๋กญ๊ฒ ํ ๋นํ ๊ฒ์ ๋๋ค. ๊ทธ๋ ๊ธฐ์ copy.append("Baz")๋ฅผ ํ๋ฉด moreNames๋ ๋ณ๊ฒฝ๋์ง ์๊ณ copy array๋ง ๋ณ๊ฒฝ๋ฉ๋๋ค.
๊ทธ๋ ๋ค๋ฉด Reference Type์ ์ด๋ป๊ฒ ๋์ํ ๊น์?
Reference type์ ๋ฐ์ดํฐ์ ์ฃผ์(reference)๋ฅผ ์ ๋ฌํ๊ฑฐ๋ ํ ๋นํ๋ ํ์ ์ ๋๋ค. ์๋ก์ด ์ธ์คํด์ค๊ฐ ๋ณต์ฌ๋์ด์ ํ ๋น๋๋ ๊ฒ์ด ์๋ ์ธ์คํด์ค ๊ธฐ์กด์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ ์ ๋ฌ๋๊ธฐ ๋๋ฌธ์ ์ฌ๋ฌ ๋ณ์ ๋๋ ์์๊ฐ ๋์ผํ ์ธ์คํด์ค๋ฅผ ์ฐธ์กฐํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ํ ์ธ์คํด์ค์ ๊ฐ์ด ๋ณ๊ฒฝ๋๋ฉด ํด๋น ์ธ์คํด์ค๋ฅผ ์ฐธ์กฐํ๋ ๋ค๋ฅธ ๋ณ์ ๋๋ ์์์๋ ๋ณ๊ฒฝ ์ฌํญ์ด ๋ฐ์๋ฉ๋๋ค.
class Person {
var name: String
init(name: String) {
self.name = name
}
}
var person1 = Person(name: "John")
var person2 = person1
person2.name = "Jane"
print(person1.name) // ์ถ๋ ฅ ๊ฒฐ๊ณผ: Jane
print(person2.name) // ์ถ๋ ฅ ๊ฒฐ๊ณผ: Jane
Reference Type์๋ ํด๋์ค(class), ํด๋ก์ (closure), ํจ์(function) ๋ฑ์ด ์์ต๋๋ค. ๊ทธ์ค ์์ ์์ ์ฝ๋๋ ํด๋์ค ์ฐธ์กฐํ์ ์ ๋ํ ์์ ์ ๋๋ค.
Person ํด๋์ค๋ name ์์ฑ์ ๊ฐ์ง๊ณ ์์ต๋๋ค. person1์ "John"์ด๋ผ๋ ์ด๋ฆ์ ๊ฐ์ง Person ์ธ์คํด์ค๋ฅผ ์ฐธ์กฐํ๊ณ ์์ต๋๋ค. person2๋ person1์ ์ฐธ์กฐํ๋ ๊ฒ๊ณผ ๋์ผํ ์ธ์คํด์ค๋ฅผ ์ฐธ์กฐํฉ๋๋ค.
person2์ name ์์ฑ์ "Jane"์ผ๋ก ๋ณ๊ฒฝํ๋ฉด person2๊ฐ ์ฐธ์กฐํ๋ ๊ฐ์ฒด์ ๋ด๋ถ ์ํ๊ฐ ๋ณ๊ฒฝ๋์ด person1์ด ์ฐธ์กฐํ๋ ์ธ์คํด์ค์๋ ๋ณ๊ฒฝ์ฌํญ์ด ๋ฐ์๋ฉ๋๋ค.
์ฆ, person1 ๊ณผ person2 ๋ ๋์ผํ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์์ผ๋ฏ๋ก ํ์ชฝ์์ ๋ณ๊ฒฝ์ด ๋ฐ์ํ๋ฉด ๋ค๋ฅธ ์ชฝ์์๋ ๋ณ๊ฒฝ๋ด์ฉ์ด ๋ฐ์๋ฉ๋๋ค. ์ด๋ฌํ ํน์ง์ ๊ฐ์ง๋ ๊ฒ์ด Reference type์ ๋๋ค.
3. let constant can mutate
let์ ์์์ด๊ธฐ์ immutable variables์ด๋ฉฐ ๋ด๋ถ์ ์ผ๋ก ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅํ๋ค๊ณ ๋งํ์ง๋ง ์ด๋ Swift์์ ์์ธ๊ฐ ์์ต๋๋ค.
let์ผ๋ก ์ ์ธ๋ ์์๊ฐ ์ฐธ์กฐ ํ์ ์ ์ธ์คํด์ค๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์์ ๋, ํด๋น ์ธ์คํด์ค์ ๋ด๋ถ์ ๊ฐ์ ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ฒด ๊ทธ ์์ฒด์๋ ์ํฅ์ ์ฃผ์ง ์์ต๋๋ค. (์ฌ์ ํ ๊ฐ์ ์ธ์คํด์ค๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฒ)
let oldArray = NSMutableArray(
array: [
"Foo",
"Bar"
]
)
oldArray.add("Baz")
// constant has changed internally
var newArray = oldArray
newArray.add("Qux")
oldArray // (4 elements) ["Foo", "Bar", "Baz", "Qux"]
newArray // (4 elements) ["Foo", "Bar", "Baz", "Qux"]
์์ ์์ ์์ let์ผ๋ก ์ ์ธํ oldArray๋ class instance๋ผ๊ณ ๋ณผ ์ ์์ต๋๋ค. ์ด๋ ์ฐธ์กฐํ์ ์ด๊ธฐ์ let ๋๋ var ์ด๋ ๊ฒ์ผ๋ก ์ ์ธํ๋๊ฐ์ ๊ด๊ณ์์ด class instance ๋ด๋ถ์ ์ธ ๋ณ๊ฒฝ์ด ๊ฐ๋ฅํฉ๋๋ค. ์์ ๊ฐ์ด oldArray.add("Baz")๋ฅผ ํ์ ๋ ์ค๋ฅ๊ฐ ๋์ง ์๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ๋ํ oldArray๋ฅผ ์ฐธ์กฐํ๋ new Array ๋ณ์๋ฅผ ๋ง๋๋ ๊ฒฝ์ฐ ๋ ์ค ํ๋์ ๋ด๋ถ์ ๋ณ๋์ฌํญ์ด ๋ค๋ฅธ ํ๋์ ๋ฐ์๋๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
๊ทธ๋ ๊ธฐ์ let์ ์ฐ๋ฉด ๋ฌด์กฐ๊ฑด์ ์ผ๋ก ์ ๋ ๋ณํ์ง ์์ ๊ฑฐ๋ผ๊ณ ๋ ์๊ฐํ๋ฉด ์ ๋ฉ๋๋ค. let์ ์ฐ๋๊ฒ์ด ์๋ฒฝํ๊ฒ mutability๋ฅผ ์์ ๋ ๊ฒ์ด ์๋๊ธฐ ๋๋ฌธ์, reference types๋ฅผ ๋ค๋ฃฐ๋๋ ์ฃผ์ํด์ผํฉ๋๋ค. ํนํ ์ธ์คํด์ค๋ฅผ ํจ์๋ก ์ ๋ฌํ ๋ ํจ์๋ ์ฐธ์กฐํ์ ์ด๊ธฐ ๋๋ฌธ์ ์์น ์๊ฒ ์ธ์คํด์ค๊ฐ ๋ณ๊ฒฝ๋ ์ ์์์ ์ฃผ์ํด์ผํฉ๋๋ค.
4. ๊ฒฐ๋ก
let constant๋ ์ฌํ ๋น์ value types์ด๋ reference types์ด๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค. ์ฆ, ์ฐธ์กฐ ํ์ ์ธ ๊ฒฝ์ฐ์๋ let์ผ๋ก ์ ์ธ๋์ด๋ ๊ฐ์ฒด์ ๋ด๋ถ์์ฑ์ ๋ณ๊ฒฝํ ์ ์์ง๋ง ์ฐธ์กฐ๋ฅผ ๋ณ๊ฒฝํ๊ฑฐ๋ ์๋ก์ด ๊ฐ์ฒด๋ฅผ ํ ๋นํ๋ ๊ฒ์ ํ์ฉ๋์ง ์์ต๋๋ค. ์ด๋ฌํ ๋์์ ํตํด constant์ ๋ถ๋ณ์ฑ์ ์ ์งํ๊ณ , ์ฝ๋์ ์์ ์ฑ๊ณผ ์์ธก ๊ฐ๋ฅ์ฑ์ ๋์ด๋ ๊ฒ์ด ๊ฐ๋ฅํฉ๋๋ค.
๊ทธ๋ ๊ธฐ์ Reference type์ let์ผ๋ก ์ ์ธํ๊ณ ๋ internally change๊ฐ ์ผ์ด๋ ์ ์์ผ๋ฉฐ, ์ด์ ๋ํ Swift ์ปดํ์ผ๋ฌ๋ ์๋ฌด๋ฐ ์๋ฌ๋ ๊ฒฝ๊ณ ์์ด ํ์ฉํ๋ค๋ ์ฌ์ค์ ์์ด์๋ ์๋ฉ๋๋ค.
ํด๋น ๊ฐ์ ์์์ ์๋์ ๊ฑธ์ด๋๊ฒ ์ต๋๋ค. ํน์ ํ๋ฆฐ ๋ถ๋ถ์ด๋ ์ถ๊ฐํ๊ณ ์ถ์ ๋ถ๋ถ์ด ์์ผ๋ฉด ์๋ ค์ฃผ์ธ์.
๊ฐ์ ์ ์ฒด๋ฅผ ์๋ฆฌ์ฆ๋ก ์ ์ ์ ์๋๋ก ๋ ธ๋ ฅํ๊ฒ ์ต๋๋ค.