1์ผ์ฐจ
Coursera ๊ฐ์์ ๊ฒน์น๋ ๋ถ๋ถ์ด ๋ง์์ ๊ณต๋ถํ๋ ๋ฐ์ ํฌ๊ฒ ์๊ฐ์ด ๊ฑธ๋ฆฌ์ง ์์๋ค. ๊ทธ๋๋ ์๋กญ๊ฒ ์๊ฒ ๋ ๊ฐ๋ ๋ ์์ผ๋ ์ ๋ฆฌ๋ฅผ ํด๋ณด์.
- Multi-line strings
var str2 = """
This goes \
over multiple \
lines
"""
//output: This goes over multiple lines
=> / ๋ฅผ ํ์ฉํด ๋ฌธ์ฅ์ด ๋๋์ง ์๊ณ ํ ๋ฌธ์ฅ์ผ๋ก ๋ฌธ์์ด์ ๋ํ๋ผ ์ ์๋ค. ๋ฌธ์์ด์ด ๊ธธ ๋ ๊น๋ํ ์ฝ๋๋ฅผ ์์ฑํ ๋ ์ข์ ๊ฒ ๊ฐ๋ค.
var str1 = """
This goes
over multiple
lines
"""
//output:
// This goes
// over multiple
// lines
=> ์ด ์์ด๋ ์ ๋ ฅํ ๊ทธ๋๋ก ๋ฌธ์์ด์ด ์ฐ์ถ๋๋ค.
2์ผ์ฐจ
์ค๋์ tuple, Set, array ์ ๊ฐ๋ ์ ์ ๋ฆฌํ์๊ณ ์ด๋ค์ด ์ด๋ค ์ํฉ์์ ์ฃผ๋ก ์ฌ์ฉ๋๋ ์ง์ ๋ํด ๋ฐฐ์ ๋ค. ๊ทธ๋ฆฌ๊ณ Enumeration(์ด๊ฑฐ)๋ผ๋ ์๋ก์ด ๊ฐ๋ ์ ๋ฐฐ์ ๋ค. 1์ผ์ฐจ์๋ ๋ฌ๋ฆฌ ์๋กญ๊ฒ ์ ํ ๊ฐ๋ ์ด ์์ด์ ๋ฐ๋ณตํด์ ๊ฐ์๋ฅผ ๋ฃ๊ธฐ๋ ํ์๋ค.
- Tuple
let address = (house: 555, street: “Taylor”, city: “Mexico”)
=> ์๋ก ๊ด๋ จ์๋ value๋ผ๋ฆฌ ๋ฌถ์ ๋ ์ฌ์ฉ. collection์ด ๊ณ ์ ๋๊ณ ํน์ ๊ฐ์ด ์ ํด์ ธ ์์ ๋ ์ฌ์ฉํ๋ค.
- Set
let colors = Set(["red", "blue", "green"]) // output: {"green", "blue", "red"} : unordered(random)
let colors2 = Set(["red", "blue", "green", "green", "blue", "red"]) // ๋ฐ๋ณต ์ ๊ฑฐ๋๊ณ random ํ๊ฒ ๋ฐฐ์ด
=> ํน์ ๊ฐ์ด ๋ฐฐ์ด์ ์๋์ง ๋น ๋ฅด๊ฒ ํ์ธํ ๋ ์ฌ์ฉ
- Array
=> ์ค๋ณต๊ฐ์ ๊ฐ์ง๊ณ ์๊ฑฐ๋ ๋ฐฐ์ด ๋ด ์์๊ฐ ์๊ด์ด ์์ ๋ ์ฌ์ฉ. ๊ฐ์ฅ ํํ๊ฒ ์ฌ์ฉํจ.
- Dictionaries
let heights = [
// key : value
“Taylor Swift”: 1.78,
“Ed Sheeran”: 1.73
]
=> ์ฌ๊ธฐ์ ์กด์ฌํ์ง ์๋ key๊ฐ์ ๋ํ value๋ฅผ ์ฐพ์ ๊ฒฝ์ฐ nil ์ด ์ฐ์ถ๋จ. ์ด๋ ๊ฒ ํ๊ธฐ ์ซ์ผ๋ฉด favoriteIceCream[“Charlotte”, default:”Unknown”] ์ฒ๋ผ ์กด์ฌํ์ง ์๋ key ๊ฐ์ ๋ํ default ๊ฐ์ ์ง์ ํด์ฃผ๋ฉด ๋จ.
- Enumerations(์ด๊ฑฐ)
enum Result {
case success
case failure
}
let result4 = Result.failure // output: failure
let result = Result(rawValue: 1) // output: failure (์์ ์ง์ ๋ ๊ฐ๋ฅ)
=> rawValue๋ฅผ ๋ฐ๋ก ์ง์ ํด์ฃผ์ง ์์ผ๋ฉด ์๋์ผ๋ก 0๋ถํฐ ์์.
3์ผ์ฐจ
- Ternary Operator
let firstCard = 11
let secondCard = 10
print(firstCard == secondCard ? “Cards are the same” : “Cards are different)
=> print(์กฐ๊ฑด ? true value : false value)
- Switch Case
let weather = "sunny"
switch weather {
case "rain":
print("Bring an umbrella")
case "snow":
print("Wrap up warm")
case "sunny":
print("Wear sunscreen")
fallthrough
default:
print("Enjoy your day")
}
// output:
// Wear sunscreen
// Enjoy your day
=> switch case์๋ default ๊ฐ์ด ๋ฌด์กฐ๊ฑด ํฌํจ๋์ด ์์ด์ผ ํ๋ค.
* fallthrough: ์ด์ด์ ๋ค์ case๋ฌธ์ ์ฝ๋๊น์ง ์คํ๋๋ค.
4์ผ์ฐจ
- While loop ์ repeat ๋ฐ๋ณต๋ฌธ์ ์ฐจ์ด
=> While loop์ ๊ฒฝ์ฐ ์กฐ๊ฑด์ ๋จผ์ ์ฒดํฌํ ๋ค ๋ฐ๋ณต๋ฌธ์ ์คํํ์ง๋ง repeat์ ๊ฒฝ์ฐ ์ผ๋จ ๋จผ์ ์คํํ๋ค.
- Continue
=> skip ์ ์๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
- Infinite loop
=> ๋ฌดํ๋ฃจํ๋ผ๊ณ ํ๋ฉฐ while true ๋ฅผ ์ด์ฉํด์ ๋ง๋ ๋ค.
- break outer์ ์๋ฏธ
outer: for i in 1...5 {
for j in 1...5 {
let product = i * j
print("Product is \(product).")
break outer
}
} // output: Product is 1.
=> ๋ฐ๊นฅ์ชฝ ๋ฐ๋ณต๋ฌธ์ break ํ๋ค๋ ์๋ฏธ์ด๋ค.
5์ผ์ฐจ
- Accepting parameters
func square(number: Int) {
print(number * number)
}
square(number: 8) //64
=> ํจ์๋ฅผ ์ด์ฉํด ์ ์ํ ํ๋ผ๋ฏธํฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ์ถ๋ ฅํ๋ ํจ์์ด๋ค.
- Returning values
func square(number: Int) -> Int {
return number * number
}
let result = square(number: 8)
print(result) // 64
=> ์ ๋ ฅ๋ฐ์ ํ๋ผ๋ฏธํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก value ๊ฐ์ return ํ ํ print ํ๋ ํจ์์ด๋ค.
- Parameter label
func sayhello(to name: String) {
print("Hello \(name)")
}
sayhello(to: "Gina") // output: Hello Gina
=> ์ฌ๊ธฐ์ ํ๋ผ๋ฏธํฐ๋ to name์ด๊ณ ์ธ๋ถ์ ์ผ๋ก๋ to ๋ผ๊ณ ๋ถ๋ฆฌ์ง๋ง ๋ด๋ถ์ ์ผ๋ก๋ name์ด๋ผ๊ณ ๋ถ๋ฆฌ๋ ํ๋ผ๋ฏธํฐ์ด๋ค.
- Default Parameter
func greet(_ person: String, nicely: Bool = true) {
if nicely == true {
print("Hello,\(person)!")
} else {
print("Oh no, it's \(person)!")
}
}
greet("Taylor") // Hello, Taylor!
greet("Taylor", nicely: false) // Oh no, it's Taylor!
=> ํ๋ผ๋ฏธํฐ ์์ ๋ถ์ _๋ฅผ ์ฌ์ฉํ๋ฉด 'ํ๋ผ๋ฏธํฐ:'๋ฅผ ์ฌ์ฉํ์ง ์์๋ ๋๋ค.
- variadic functions
func square(numbers: Int...){
for number in numbers {
print("\(number) squared is \(number * number)")
}
}
square(numbers: 1, 2, 3, 4, 5)
// output:
// 1 squared is 1
// 2 squared is 4
// 3 squared is 9
// 4 squared is 16
// 5 squared is 25
=> Int... ๊ฐ์ ๊ฒ์ธ variadic functions์ธ๋ฐ ์ด๋ ์ฌ๋ฌ๊ฐ์ ๊ฐ์ ์ ๋ ฅํ ์ ์๊ฒ ํด์ค๋ค.
- throw, do, try, catch
// enumํ์ผ๋ก error ํ์
๋ช
์ ์
enum PasswordError: Error {
case obvious
}
// ์ค๋ฅ ๋๋ ์กฐ๊ฑด์ throws ์ ํจ๊ป ๋ฐฐ์น
func checkPassword(_ password: String) throws ->
Bool {
if password == "password" {
throw PasswordError.obvious
}
return true
}
do {
try checkPassword("password")
print("That password is good!")
} catch {
print("You can't use them")
} // output: You can't use them
=> throws ๋ฅผ ์ ์ธํด์ฃผ์ด์ผ๋ง throw๋ฅผ ์ฌ์ฉํ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ ์์ ๊ฒฝ์ฐ ์ค๋ฅ๊ฐ์ throwํ๊ธฐ ๋๋ฌธ์ "You can't use them"์ด ์ถ๋ ฅ๋๋ค. ์ด์ ๊ฐ์ด ์์ธ ์ฒ๋ฆฌ๊ฐ ํ์ํ ์ด์ ๋ optional ํ์ ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ ๋ ์ค๋ฅ์ ๋ํ ์ ๋ณด๋ฅผ ์ธ๋ถ๋ก ์ ๋ฌํ ๋ฐฉ๋ฒ์ด ์๊ธฐ ๋๋ฌธ์ด๋ค.
- inout ๋งค๊ฐ๋ณ์
func doubleInPlace(number: inout Int){
number *= 2
}
var myNum = 10
doubleInPlace(number: &myNum) // 20
=> swift์์ ํจ์์ ๋ฉ์๋์ ๋งค๊ฐ๋ณ์๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์์๋ก ์ ๋ฌ์ด ๋๊ณ , ํด๋น ๊ฐ์ ์ง์ ์์ ํ ์ ์๋ค. ์์ ์ ํ๋ ค๋ฉด ๋ด๋ถ์์ ๋ณ๋์ ์ง์ญ๋ณ์๋ฅผ ์ ์ธํด์ ๋์ ํ๋ ๊ณผ์ ์ด ํ์ํ๋ค. inout ๋งค๊ฐ๋ณ์๋ ๋ฉ์๋ ๋ด์์ ๋ณ๊ฒฝ๋๋ฉด ๊ทธ ๊ฒฐ๊ณผ๊ฐ ์๋ณธ ๋ณ์๊ฐ์๋ ์ ์ฉ๋ ์ ์๋ค.
=> ์ด๋ฆ ์์ &(์ฐํผ์๋)๋ฅผ ์ฌ์ฉํด์ผํ๋ค
6์ผ์ฐจ
- Closure (์ต๋ช ํจ์)
- ํด๋ก์ ๋ฅผ ํธ์ถํ ๋๋ ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ์ง ์๋๋ค.
let driving = { (place: String) in
print(“I’m going to \(place) In my car”)
}
driving(“London”)
'iOS > Swift' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ARC ์์๋ณด๊ธฐ (0) | 2024.07.06 |
---|---|
Struct / Class ๋ ๋ฌด์์ธ๊ฐ? (1) | 2024.04.25 |
Design Pattern in Swift [ ์์ฑ ํจํด ] (0) | 2023.04.17 |
[Swift] ์ด๋ฏธ์ง๋ฅผ ์ํ ์ด๋ฏธ์ง๋ก ๋ณ๊ฒฝํ๊ณ ํ ๋๋ฆฌ ์ค์ ํ๋ ๋ฐฉ๋ฒ (0) | 2022.07.05 |
[3/18 - 3/22 TIL] Coursera - LearnQuestIntroduction to Programming in Swift 5 (0) | 2022.03.22 |