<TIL>
์ค๋์ swift ๋ฌธ๋ฒ ๊ณต๋ถ์ todoList ๋ง๋ค๊ธฐ์์
ํ์ ๊ตฌํ ์ด์ธ์ ์ถ๊ฐ๋ก ๊ตฌํํด ๋ณด๊ณ ์ถ์ ๋ด์ฉ ์๋ํด ๋ณด๋ ์๊ฐ์ ๊ฐ์ก๋ค.
todoList ๋ฐ์ดํฐ ์ ์ฅํ๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํ๊ณ ์ถ์ด์
UserDefault์ ๋ํด์ ์ฐพ์๋ดค๋๋ฐ,
struct ํ์
์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ด ๋ณต์กํด์
์๋๋ง ํด๋ณด๊ณ , ์์ฑ์ ๋ชปํ๋ค..๐ญ
๋์ ์ Int ํ์
์ด๋ ๋ฌธ์์ด ๋ฐฐ์ด ํ์
์ ์ ์ฅํ๋ ์ฐ์ต์ ํด๋ดค๋ค.
UserDefault๋ฅผ ์ฌ์ฉํด์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ ๋ํด์๋
๋์ค์ ๊ณต๋ถ๋ฅผ ์ข ๋ ํด๋ณด๊ณ ์ ๋ฆฌํ๋ ค ํ๋ค.
์ค๋์ ๊ณต๋ถํ๋ Swift ๋ฌธ๋ฒ ๊ด๋ จํด์
๊ฐ๋ตํ๊ฒ ์ ๋ฆฌํด ๋ณผ ์๊ฐ์ด๋ค.
components & split
components
์ฃผ์ด์ง ๊ตฌ๋ถ ๊ธฐํธ(separator)๋ก ๋๋์ด์ง ์์ ์์ ํ์ ๋ฌธ์์ด์ ํฌํจํ ๋ฐฐ์ด์ ๋ฐํํ๋ ํจ์์ด๋ค.
์.. ์ฝ๊ฒ ๋งํด์ ๋ฌธ์์ด์ ํด๋น separator๋ฅผ ๊ธฐ์ค์ผ๋ก ์ชผ๊ฐ์ฃผ๋ ๋ฉ์๋๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค.
์์๋ฅผ ๋ณด๋ฉด, ๋ฐ๋ก ์ดํด๊ฐ ๊ฐ๋ฅํ ๊ฑฐ๋ค!
์ฌ์ฉํ ์์์ฒ๋ผ ์ฌ๋ฌ๊ฐ์ separator๋ฅผ ์ฌ์ฉํ ์ ์๋ค!
split
spilt๋ components์ ๋ง์ฐฌ๊ฐ์ง๋ก ํน์ ๋ฌธ์๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ์ชผ๊ฐค ๋ ์ฌ์ฉํ๋ ํจ์์ด๋ค.
๊ทธ๋ ๋ค๋ฉด, ์ ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋ ํจ์์ธ๋ฐ ์ ๋ ๊ฐ์ง๋ก ๊ตฌ๋ถํด๋จ์๊น?๐ง
components์ spilt์ ์ฐจ์ด์ ์ ๋ํด์ ์์๋ณด์!
์ฒซ ๋ฒ์งธ, ํ๋ ์์ํฌ/๋ผ์ด๋ธ๋ฌ๋ฆฌ
Components๋ 'import Foundation’์ ์ ์ธํด์ผํจ
๋ฐ๋ฉด์, split๋ ํ์์์
๋ ๋ฒ์งธ, ๋ฆฌํด๊ฐ
Components์ ๋ฆฌํด๊ฐ -> [String]
split์ ๋ฆฌํด๊ฐ -> [SubString]
์ธ ๋ฒ์งธ, ์ธ์์
Components : ’separatedBy’
split : 'separator’, ‘maxSplits’, ‘omittingEmptySubsequences’
๋ค ๋ฒ์งธ, ๋น๋ฐฐ์ด ํฌํจ ๋ฆฌํด ์ฌ๋ถ
Components๋ separator๊ฐ ์ฐ์์ผ๋ก ๋ฑ์ฅํ ๊ฒฝ์ฐ ๋น๋ฌธ์์ด ํจ๊ป ๋ฆฌํด
(๋จ, ๋น๋ฌธ์์ด ์์ ๋ ์ถ๊ฐ์ฝ๋๊ฐ ํ์ํจ)
split๋ ‘omittingEmptySubsequences’๋ผ๋ ์ธ์์ ๊ธฐ๋ณธ๊ฐ์ด true ์ธ๋ฐ, ์ด
๊ฒ ๋ฐ๋ก ๋น๋ฌธ์์ด์ ๊ฑธ๋ฌ์ค์ง ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํจ
์ด๋ ๊ฒ ํฌ๊ฒ 4๊ฐ์ง ์ฐจ์ด์ ์ด ์๋ค.
์ฌ๊ธฐ์ ์ฃผ์ํด์ผํ ์ ์ ๋ฆฌํด๊ฐ์ด ๋ค๋ฅด๋ค๋ ๊ฒ!
(๊ทธ๋์ ๋ ๊ฐ์ ์๋ก ๋น๊ตํ ๋, error๊ฐ ๋ฐ์ํ๋ค.)
<componets & split ํ ๋์ ์ ๋ฆฌํ๊ธฐ>
sort & sorted
sort๋ ์ ๋ ฌ์ ํด์ฃผ๋ ๋ฉ์๋์ด๋ค!
sort(), sort(by: ), sorted(), sorted(by:) ๊ฐ ์๋ค.
sort( )
sort() ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ์ํค๋ ํจ์์ด๋ค.
๊ทธ๋ฆฌ๊ณ ์๋ณธ ๋ฐฐ์ด์ ๊ฐ์ ‘์ ์๋ฆฌ์์(in place)’ ์ ๋ ฌํ๊ธฐ ๋๋ฌธ์ ๋ฆฌํด๊ฐ์ด ์๋ค.
var numbers: [Int] = [3, 2 ,4, 1, 6, 5, 7, 8]
var words: [String] = [“Brain”, “Apple”, “Camera”, “Evening”, “Door”, “Fail”, “Guess”]
<↑์์๋ก ์ฌ์ฉํ ์ ์ ๋ฐฐ์ด & ๋ฌธ์์ด ๋ฐฐ์ด↑>
numbers.sort()
words,sort()
print(numbers)
print(words)
-> ๊ฒฐ๊ณผ: [“1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”]
-> ๊ฒฐ๊ณผ: [“Apple”, “Brain”, “Camera”, “Door”, “Evening”, “Fail”, “Guess”]
sort(by: )
์ํ๋ ๋ฐฉ์์ผ๋ก ์ ๋ ฌ์ ์ปค์คํ
ํด์ฃผ๊ณ ์ถ์ ๋๋, ์ด ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
by ๋ค์ ๋ถ๋ฑํธ๋ฅผ ํตํด ๋ด๋ฆผ์ฐจ์, ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ์ ์๋ค.
numbers.sort(by: >)
words.sort(by: <)
-> ๊ฒฐ๊ณผ: [“8”, “7”, “6”, “5”, “4”, “3”, “2”, “1”]
-> ๊ฒฐ๊ณผ: [“Apple”, “Brain”, “Camera”, “Door”, “Evening”, “Fail”, “Guess”]
โ๏ธ (by: ) ์ด๋ ๊ฒ ํด๋ก์ ํํ๋ก ๋์ด์๊ธฐ ๋๋ฌธ์ ์๋์ ๊ฐ์ด ๋น๊ต ์กฐ๊ฑด์ ์์ฑํ์ฌ ์ฌ์ฉํ ์๋ ์๋ค!
numbers.sort { aStart, Bstart in aStart < bStart }
์ด๋ ๊ฒ ์จ๋ ๋๊ณ !!
numbers.sort(by: <) ์ด๋ ๊ฒ ์จ๋ ๋๋ค.
์ปค์คํ
์ ๋ ฌ ์กฐ๊ฑด์ ๊ฒฝ์ฐ์๋ ์ ์ ๊ฐ์ด ํด๋ก์ ๋ฅผ ์ฌ์ฉํ๋ฉด ์์ฑํ๊ธฐ ์ข ๋ ์ฌ์ธ ๊ฒ ๊ฐ๋ค!!
sorted( )
sorted( )๋ sort( ) ์ ๋ค๋ฅด๊ฒ ๋ฆฌํด๊ฐ์ด ์๋ค.
์ด๊ฒ ๋ฌด์จ ๋ง์ด๋!๐ง
sort( )๋ ๋ฆฌํด๊ฐ์ด ์๊ณ , ์ ์๋ฆฌ ์ ๋ ฌ์ ํ๊ธฐ ๋๋ฌธ์ ์๋ณธ ๋ฐฐ์ด์ ๊ฐ์ด ์ ๋ ฌ์ด ๋์ด ์๋ค.
๊ทธ๋ฌ๋, sorted()๋ ์๋ณธ ๋ฐฐ์ด์ ๊ฑด๋๋ฆฌ์ง ์๊ณ ์ ๋ ฌํ ์์๋ค์ sequence๋ฅผ ๋ฆฌํดํด์ฃผ๋ ๋ฉ์๋์ด๊ธฐ ๋๋ฌธ์!!
์๋ณธ ๋ฐฐ์ด์ด ๊ทธ๋๋ก ์กด์ฌํ๋ค.
๊ทธ๋์ sorted()๋ ์๋ ์์์ฒ๋ผ ๋ณ์๋ฅผ ํ๋ ๋ ์ ์ธํด์ผํ๋ค.
(์ด๋ ๊ฒ ๋ฆฌํด๊ฐ์ numbers์ ๋์
ํด์ค์ผํจ)
numbers = numbers.sorted()
sorted(by: )
๋ง์ฐฌ๊ฐ์ง๋ก sort(by: )์ ์ฐจ์ด์ ์ ๋ฆฌํด๊ฐ์ ์ ๋ฌด์ด๋ค!
sorted(by: ) ๋ํ by ๋ค์ ๋ถ๋ฑํธ๋ฅผ ๋ฃ์ด ์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ์ ํ ์ ์๋ค.
<sort & sorted ํ ๋์ ์ ๋ฆฌํ๊ธฐ>