IOS 개발자의 꿈에

한 걸음 더 다가가게 됐다!

애플 디벨로퍼 아카데미에 

합격😆

포항 생활 시작이다~

너무 기대 된다

하루하루 꾸준히 공부하는 습관을

들이는 것이 목표다

퇴근하고 공부하기가 너무 싫다ㅜㅜ

그래도 앞으로는 여유롭게 공부할 수 있으니

좀만 더 힘내자💪

열거형 구문 

• enum 키워드 사용하여 중괄호 안에 모든 정의를 함 
• case 키워드를 사용하여 열거형 나열 

1️⃣ 열거형 선언

enum CompassPoint {
    case north
    case south
    case east
    case west
}

🔎 값 할당 및 접근 

CompassPoint 이름을 통해 한번 값을 할당하면, 그 이후에는 이름을 생략해도 된다. 

var direction = CompassPoint.west
direction = .east

 2️⃣ switch 구문 사용

열거형 케이스에 대하여 switch 구문을 사용할 때, 모든 케이스에 대하여 조건이 명시되어 있어야 한다. 

direction = .south
switch direction = {
case .north:
    print("Lots of planets have a north")
case .south:
    print("Watch out for penguins")
}

//에러 발생

east와 west에 대한 케이스가 명시되어 있지 않으므로 컴파일 오류가 발생함. 

다 명시하는 것이 비효율적인 경우 default 케이스로 처리 

enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

let somePlanet = Planet.earth
switch somePlanet {
case .earth:
    print("Mostly harmless")
default:
    print("Not a safe place for humans")
}
// Prints "Mostly harmless"

3️⃣ 열거형 Iterable 

열거형의 모든 케이스를 수집하려고 할 때, enum 뒤에 : CaseIterable을 작성한다. 

CaseIterable은 allCases 프로퍼티를 통해 모든 케이스에 대한 정보를 수집한다. 

enum Beverage: CaseIterable {
    case coffee, tea, juice
}
let totalCount = Beverage.allCases.count
print("\(totalCount) 가능 음료")
// 3 가능 음료

🔎 반복문에서의 활용

for beverage in Beverage.allCases {
    print(beverage)
}
// coffee
// tea
// juice

4️⃣ 열거형 연관된 값 저장하기

UPC 바코드와 큐알 코드 바코드를 저장하는 Barcode 열거형

enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}

🔎 값 할당

var productBarcode = Barcode.upc(8, 83120, 45321, 3)

productBarcode에 qrCode 값 또한 할당할 수 있다.

productBarcode = .qrCode("ABCDEFGHIJKLMNOP")

5️⃣ 원시값(Raw Values) 저장

모두 동일한 타입의 값으로 채우고 싶다면 다음과 같이 enum 변수 옆에 타입을 설정한다.

enum ASCIIChar: Character {
    case tab = "\t"
    case lineFeed = "\n"
    case carriageReturn = "\r"
}

🔎 원시값의 암시적 할당

원시값이 저장된 열거형은 자동적으로 값이 할당된다. 

✅ 정수 원시값인 경우 

enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}

// 이 때, 첫번째 케이스 값 설정 안하면 초기값은 0임.

Planet.mercury의 값은 1
Planet.venus 는 자동으로 2가 됨

그 이후는 3,4,5 ...

✅ 문자열 원시값 경우 

enum CompassPoint: String {
    case north, south, east, west
}

문자열은 문자 그대로의 값을 원시값으로 가진다. 

rawValue를 사용하여 원시값에 접근할 수도 있다.  

let sunsetDirection = CompassPoint.west.rawValue
// sunsetDirection is "west"

혹은 rawValue를 활용한 값 할당

let possiblePlanet = Planet(rawValue: 7)
// possiblePlanet 에 7번째 값인 Planet.uranus 할당

6️⃣ 재귀 열거형 

열거형 케이스로 열거형 안에서 다른 인스턴스를 열거형으로 가지고 있는 것을 말한다. 

아래 예시를 보면, recursiveEnum에서 addtion의 케이스로 recursiveEnum의 인스턴스 중 number를 

열거형으로 갖고 있다. 

재귀 열거형을 사용하려면 indirect 키워드를 함께 써주면 된다. 

enum recursiveEnum {
    case number(Int)
    indirect case addition(recursiveEnum, recursiveEnum)
    indirect case multiplication(recursiveEnum, recursiveEnum)
}

let five = recursiveEnum.number(5)
let four = recursiveEnum.number(4)

// 재귀 열거형
let sum = recursiveEnum.addition(five, four)
let product = recursiveEnum.multiplication(sum, recursiveEnum.number(2))

전체를 모두 재귀 열거형으로 만들고 싶을 때 -> enum 시작 전에 indirect 작성 

indirect enum recursiveEnum {
    case number(Int)
    indirect case addition(recursiveEnum, recursiveEnum)
    indirect case multiplication(recursiveEnum, recursiveEnum)
}

이를 활용한 재귀 함수 

func evaluate(_ expression: recursiveEnum) -> Int {
    switch expression {
    case let .number(value):
        return value
    case let .addition(left, right):
        return evaluate(left) + evaluate(right)
    case let .multiplication(left, right):
        return evaluate(left) * evaluate(right)
    }
}

print(evaluate(product))
// Prints "18"

출처 : https://bbiguduk.gitbook.io/swift/language-guide-1/enumerations

제어 변경 구문

1️⃣ continue

다음 반복을 실행하라고 알림

아래 예시는 모음이나 빈칸이 나왔을 때, 바로 다음 반복으로 넘어가라고 지시한다. 

let sentance = "easy example"
var result = ""
let charactersToRemove: [Character] = ["a", "e", "i", "o", "u", " "]
for character in sentance {
    if charactersToRemove.contains(character) {
        continue
    }
    result.append(character)
}
print(result)
// syxmpl

2️⃣ break

루프의 실행을 즉시 종료한다.

즉, switch 구문을 즉시 빠져나와 실행을 종료한다. 

let symbol: Character = "三"  
var val: Int?
switch symbol {
case "1", "一", :
    val = 1
case "2", "٢", "二", :
    val = 2
case "3",  "三", :
    val = 3
case "4", "٤", "四",:
    val = 4
default:
    break
}

print(val)
// 3 출력

3️⃣ Fallthrough

continue와 다른 점 : continue는 바로 다음 반복으로 넘어가지만, Fallthrough는 다음 경우(다음 조건) 로 넘어감 

case 5인 경우와 그 다음 케이스인 default 구문으로 넘어가 다음과 같이 출력된다. 

let num = 5
var description = "The number \(num) is"
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
    description += " a prime number, and also"
    fallthrough
default:
    description += " an integer."
}
print(description)
// 다음과 같이 출력됨 "The number 5 is a prime number, and also an integer."

4️⃣ 라벨 구문 

예제를 보며 살펴보자 

let finalSquare = 25
var board = [Int](repeating: 0, count: finalSquare + 1)
board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
var square = 0
var diceRoll = 0

while 루프에 gameLoop 라는 라벨을 붙였다. 

만약 gameLoop 라벨 없이 그냥 break만 걸었다면, switch 구문만 빠져나오고 while구문은 빠져나오지 않는다. 

아래 예시는 break를 통해 gameLoop 자체를 빠져나온다. 

gameLoop: while square != finalSquare {
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    switch square + diceRoll {
    case finalSquare:
        // diceRoll will move us to the final square, so the game is over
        break gameLoop
    case let newSquare where newSquare > finalSquare:
        // diceRoll will move us beyond the final square, so roll again
        continue gameLoop
    default:
        // this is a valid move, so find out its effect
        square += diceRoll
        square += board[square]
    }
}
print("Game over!")

5️⃣ guard - else

조건을 만족하면(수식이 참이면) 다음 코드로 계속 진행하고, 만족하지 않으면(false 일 때) else 안의 구문을 

실행하고 종료한다.

if와 다르게 else 절을 항상 붙여주어야 한다. 또한, 함수 혹은 반복문 안에서만 사용 가능하다. 

guard [expression] else {
	// false일 때 실행되는 부분
}

func greet(person: [String: String]) {
	// 1. 
    guard let name = person["name"] else {
        return
    }
    
	// 2.
    print("Hello \(name)!")

	// 3.
    guard let location = person["location"] else {
        print("I hope the weather is nice near you.")
        return
    }
	
    // 4. 
    print("I hope the weather is nice in \(location).")
}

🔎 ex 1)

greet(person: ["name": "John"])

1. name 값이 존재하므로 2번 코드로 넘어감

2. Hello John 출력

3. location은 존재하지 않으므로 else 구문 실행하고 해당 함수 종료

결과 

Hello John!
I hope the weather is nice near you.

🔎 ex 2)

greet(person: ["name": "Jane", "location": "Cupertino"])

1. name이 존재하므로 2번 코드로 넘어감

2. location 또한 존재하므로 그 다음으로 넘어감

3. 4번 출력 후 함수 종료

결과 

Hello Jane!
I hope the weather is nice in Cupertino.

예외사항만을 처리하고 싶을 때 guard를 사용하면 가독성이 좋아진다. 

guard는 ~이 아니면 끝내라 라는 의미이기 때문이다. 

📌 딕셔너리(Dictionaries)

• 순서와 상관없이 콜렉션에 같은 타입의 키(key)와 같은 타입의 값(value)를 저장함.
• 특정 순서를 갖고 있지 않음
• 식별자를 기준으로 값을 찾을 때 유용

1️⃣ 딕셔너리 생성

Dictionary<Key, Value>로 적으며, Key는 딕셔너리 키로 사용되고 Value는 딕셔너리에 저장될 값의 타입임

혹은 아래와 같이

[Key : Value] 와 같이 짧은 형식으로 작성할 수도 있음 (짧은 형식 더 선호❗)

var dic = [Int:String]()

2️⃣ 값 넣기

dic[16] = "sixteen"
// key가 16이고 value는 sixteen


dic = [:]
// 빈 dictionary로 초기화

3️⃣ 딕셔너리 리터럴로 딕셔너리 생성

키-값 쌍으로 콜론으로 구분하여 딕셔너리 작성

집합과 다르게 타입 생략 가능

var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]


// 타입 생략 딕셔너리 초기화 
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

4️⃣ 값 추가 혹은 수정 

airports["LHR"] = "London"


// 값 수정
airports["LHR"] = "London Heathrow"

⭐ updateValue를 통한 값 수정

updateValue는 값을 업데이트 하지만 업데이트 되기 전 값을 반환한다. 

updateValue 메서드 : 해당 키에 값이 존재하지 않으면 값을 설정하고 
                     값이 존재하면 값을 업데이트 함
                     
                     * 업데이트 수행 후 이전 값을 반환함

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {

    print("수정 전 값 :  \(oldValue).")
    
}
// 수정 전 값 :  Dublin. 출력

5️⃣ 해당 키에 대한 값이 존재하는 지 확인

if let isValueIn = airports["DUB"] {

	print("공항 이름은 \(isValueIn) 입니다.")
    
}else{

	print("존재하지 않습니다.")
    
 }

6️⃣ 딕셔너리 값 삭제

APL - Apple International 이라는 키- 값 쌍을 제거하고 싶으면 

딕셔너리의 해당 키에 nil을 할당하면 된다. 

// APL 키- 값 생성
airports["APL"] = "Apple International"


// 잘못된 추가로 삭제원할 때 : nil 할당 
airports["APL"] = nil

⭐ removeValue를 통한 값 삭제 

removeValue 매서드 : 키 - 값 쌍이 존재하면 삭제하고, 삭제된 값을 반환
                     존재하지 않으면 nil 반환

if let remove_val = airports.removeValue(forKey: "DUB") {

    print("삭제된 공항의 이름은 :  \(remove_val).")
    
} else {

    print("해당 정보가 없습니다.")
    
}
// 삭제된 공항의 이름은 : Dublin  출력됨

7️⃣ 딕셔너리 반복

for (code, name) in airports {
	print("\(code) : \(name)")
}

키 혹은 값만 출력하고 싶을 때, 

/* 키 혹은 값만 출력*/

// key만 출력
for airportCode in airports.keys{
	print("\(airportCode)")
}

// LHR
// YYZ


// value만 출력
for airportName in airports.values {
	print("\(airportName)")
}

// London Heathrow
// Toronto Pearson

8️⃣ 딕셔너리 키-값 뽑아서 배열에 넣기 

let airportCodes = [String](airports.keys)
// airportCodes is ["LHR", "YYZ"]


let airportNames = [String](airports.values)
// airportNames is ["London Heathrow", "Toronto Pearson"]

딕셔너리는 순서를 보장하지 않기 때문에, 

정렬하고 싶다면 sorted() 매서드를 사용하자 

출처 : https://bbiguduk.gitbook.io/swift/language-guide-1/control-flow

📌 집합(Sets)

순서와 상관없이 같은 타입의 다른 값을 저장한다. 

타입은 반드시 hashable(String, Int, Double, Bool) 이어야 한다.

1️⃣ 집합 생성(초기화)

Set<Element> 으로 작성한다. 저장할 값의 타입을 Element에 지정하면 된다. 

var letters = Set<Character>()

배열 리터럴로 집합 생성

집합 타입 Set을 명시해주지 않으면 안된다. 하지만 값 타입은 생략 가능(하나 이상의 값으로 초기화 할 경우)

var genres : Set<String> = ["Rock", "Classic", "Hip Hop"]

// 값 타입 생략
var genres : Set = ["Rock", "Classic", "Hip Hop"]

2️⃣ 집합 요소 추가

letters.insert("a")

// 빈 집합으로 초기화
letters = []

3️⃣ 집합 요소 삭제 

remove 사용 

/* genres에 Rock이 있으면 제거하고 아니면 nil 반환 */

if let removeGenre = genres.remove("Rock"){
	print("\(removeGenre)")
}else{
	print("nothing")
}

4️⃣ 집합 특정 요소 포함 확인 

contains 사용 

if genres.contains("Funk"){
	print("Y")
}else{
	print("N")
}

// N 출력

5️⃣ 집합 요소 출력 및 정렬

for genre in genres{
	print("\(genre)")
}
// Rock
// Classic
// Hip hop

for genre in genres.sorted() {
	print("\(genre)")
}
// Classic
// Hip hop 
// Rock

6️⃣ 집합 연산 수행

1. 교집합

a.intersection(b)

2. 대칭 차집합

A - B + B - A

a.symmetricDifference(b)

3. 합집합

a.union(b)

4. 차집합

A - B

a.subtracting(b)

let odd: Set = [1, 3, 5, 7, 9]
let even: Set = [0, 2, 4, 6, 8]
let prime: Set = [2, 3, 5, 7]

odd.union(even).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
odd.intersection(even).sorted()
// []
odd.subtracting(prime).sorted()
// [1, 9]
odd.symmetricDifference(prime).sorted()
// [1, 2, 9]

👇 아래는 true or false를 반환하는 집합 연산자이다. 

5. 부분집합 

a가 b의 부분집합인지

a.isSubset(of:b)

6. 초집합

a가 b를 포함하는지

a.isSuperset(of:b)

7. 교집합

a와 b의 공통 값이 있는 지

a.isDisjoint(with:b)

📌collections : 배열(Array), 집합(Set), 딕셔너리(Dictionary) 

◼ 배열 : 값들에 대해 순서를 가지고 있음

◼ 집합 : 반복되지 않은 값(중복 X) 에 순서 또한 없음

◼ 딕셔너리 : 키-값 쌍으로 구성되며 순서가 없음

🔹 콜렉션의 가변성

배열, 집합, 딕셔너리를 변수에 할당하면 생성 이후 변경 가능하다(mutable)

즉, 아이템의 추가, 삭제 및 변경이 가능하다는 뜻이다. (상수에 할당할 시 X)

⭐ 배열(Array)

같은 타입의 값을 순서대로 저장함

1️⃣ 배열 생성하기

Array<Element> //Element에는 저장할 배열의 타입을 작성함

//or [Element]로 작성 가능

var IntArray : [Int] = []
print("count items : \(IntArray.count)")
//count items : 0 출력

//혹은 string 배열 생성 및 초기화
var shoppingList = ["Eggs", "Milk"]

2️⃣ 배열에 값 추가

IntArray.append(3)

//혹은 대입 연산자 사용
shoppingList += ["Baking Powder"]

3️⃣ 배열의 크기와 값을 고정

//repeating : 초기화 할 값 , count : 배열 크기  
var threeArray = Array(repeating:0.0, count:3) 

//type : [Double] , [0.0, 0.0, 0.0]

4️⃣ 배열 더하기 

var appendArray = Array(repeating: 2.5, count: 3)

var newArr = threeArray + appendArray
//newArr = [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

5️⃣ 배열 인덱스로 접근하기

var shoppingList = ["Eggs", "Milk", "Baking Powder", "Chocolate", "Cheese", "Butter"]

var item = shoppingList[0]

shoppingList[0] = "Six eggs"

값 한꺼번에 바꾸기

//4번과 5번 인덱스의 값을 변경함 -> 6번 전까지  
shoppingList[4...6] = ["Bananas", "Apples"]

특정 인덱스에 추가 및 삭제 

at: 에 추가 혹은 삭제 하고자 할 인덱스 값을 넣어주면 된다.

//추가
shoppingList.insert("Maple Syrup", at:0)

//삭제
shoppingList.remove(at: 0)

//마지막 아이템 삭제
shoppingList.removeLast()

6️⃣ 배열 반복 

for item in shoppingList {
	print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

enumerated를 사용하여 index와 값 모두 얻기

for(index, value) in shoppingList.enumerated(){
	print("Item \(index + 1) : \(value)")
}

// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

출처 : https://bbiguduk.gitbook.io/swift/language-guide-1/collection-types

1️⃣ Character 배열 및 문자 합치기 

하나의 문자를 넣고싶다면 Character 형을 다음과 같이 선언한다.

let mark : Character = "!"     // 하나

배열에 넣고 싶다면 다음과 같다. 

요소를 합치고 싶다면 string 으로 감싼다. 

let word : [character] = ["c","a","t"]  //배열 
let fullstring = string(word)

print(fullstring)
//cat

2️⃣ 괄호 및 수식 값 계산 출력

괄호와 \를 그대로 출력하고 싶다면 따옴표 양 옆에 #을 붙인다. 

print(#"Swift using \(multiplier)."#)
// "Swift using \(multiplier)." 이 출력됨

수식의 결과 값을 출력하고 싶으면 수식을 괄호로 감싼다음 #을 붙인다. 

print(#"6 times 7 is \#(6 * 7)."#)
//6 times 7 is 42

3️⃣ 인덱스를 통한 문자열 접근 

◼ 문자열의 처음과 끝 

startIndex는 문자열이 시작하는 첫번째 문자를 반환한다. 

let greeting = "Hello World!"

greeting[greeting.startIndex]
//H

endIndex는 String에 마지막 문자가 아닌 그 다음 위치를 반환한다

before를 통해 해당 인덱스 전 요소를 반환하고, after를 통해 해당 인덱스 다음 요소를 반환한다. 

greeting[greeting.index(before: greeting.endIndex)]
//!

greeting[greeting.index(after: greeting.startsIndex)]
//e

◼ 특정 문자열 접근

특정한 위치의 문자열에 접근하고 싶으면 offsetBy를 사용한다. 

let index = greeting.index(greeting.startIndex, offsetBy: 7)]
greeting[index]
// 시작 위치 : startIndex, 찾고 싶은 위치 : 7
// o

◼ 문자열에 있는 개별 문자 접근하여 출력하기

for index in greeting.indices {
	print("\(greeting[index])", terminator: "")
}
//H e l l o  w o r l d !

terminator: "" ->  옆으로 한칸씩 띄어쓰기 되면서 한줄에 출력 

4️⃣ 문자열 삽입 

◼ 하나 문자 삽입

var welcome = "hello"

welcome.insert("!", at:welcome.endIndex)

◼ 여러 요소 혹은 문자열 삽입

welcome.insert(contentsOf: "there", at : welcome.index(before : welcome.endIndex))
//"hello there!" 이 된다.

var numbers = [1,2,3,4,5]
numbers.insert(contentsOf: [1,2,3], at: 3)
print(numbers) // [1, 2, 3, 1, 2, 3, 4, 5]

5️⃣ 문자열 삭제 

welcome.remove(at:welcome.index(before: welcome.endIndex))
// welcome은 !가 삭제되어 hello there이 된다.

◼ 특정 범위 문자열 삭제

removeSubrange 사용 

let range = welcome.index(welcome.endIndex, offsetBy: -6) .. < welcome.endIndex

welcome.removeSubrange(range)
//welcome은 hello

◼ 부분문자열 

firstIndex(of:) 는 배열에서 해당 값과 일치하는 요소의 가장 첫번째 index를 반환하고 

lastIndex(of:) 는 해당 값과 일치하는 요소의 가장 마지막 index를 반환한다. 

let greeting = "Hello, world!"
let index = greeting.firstIndex(of: ",") ?? greeting.endIndex
let beginning = greeting[..<index]
// beginning is "Hello"

// Convert the result to a String for long-term storage.
let newString = String(beginning)

firstIndex와 lastIndex에 대한 자세한 예시 

var arr: [String] = ["a", "b", "c", "d", "b", "e]


if let firstIndex = arr.firstIndex(of: "b") {
    print(firstIndex)  // 1
}

if let lastIndex = arr.lastIndex(of: "b") {
    print(lastIndex)  // 4
}

📌 범위 연산자

◼ 닫힌 범위 연산자

범위가 (a...b) 일 때, a부터 b까지(b를 포함❗) 범위를 실행한다.  (점 세개)

for index in 1...5 {
	print("\(index) x  5 is \(index * 5)")
    //1부터 5까지 실행된다. 
}

파이썬과는 좀 다른 느낌이다

헷갈리지 말자..

그렇다면 5 이전까지만 실행하고 싶다면.. ? 아래에 답이 있다.

◼ 반 열림 범위 연산자

< 연산자를 사용하면 된다. (a..< b) 는 b가 포함되지 않은 a부터 b까지의 범위를 실행한다. (점 두개)  

0부터 시작하는 배열을 탐색할 때 사용하면 용이하다. 

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    print("Person \(i + 1) is called \(names[i])")
}

◼ 단 - 방향 범위 

인덱스를 사용하여 배열의 원하는 인덱스 부터 혹은 까지 실행할 수 있다. 

let names = ["Anna", "Alex", "Brian", "Jack"]

for name in names[2...]{
	//배열 인덱스 2부터 시작한다. 
    //Brian
    //Jack
	print(name)
}

for name in names[...2] {
   //배열 인덱스 2까지 수행한다. 
   //Anna
   //Alex
   //Brian
	print(name)
}

단 방향 범위에서 반 열림 연산자를 사용할 수 있다. 

for name in names[..<2]{
    //인덱스 2전 까지 즉, 인덱스 1까지만 실행
    //Anna
    //Alex
	print(name)
}

다음과 같이 범위에서 값이 들어있는 지 체크할 수 있다. 

let range = ...5   // 5까지의 범위 (음수 포함) 

range.contains(7)   //false
range.contains(4)   //true
range.contains(-1)  //true

📌 논리 연산자 

◼ 논리적 NOT 연산자

!a는 부울 값을 true 면 false 로 false 면 true 로 값을 반대로 만든다. 

let allowEdit = false
if !allowEdit {
	print("Can not Edit")
 }

뭔가 헷갈린다...

아래를 보면 이해하기 쉽다 

!isCat은 false 이다. 

if !isCat 이라 함은 false 일 때, 아래 구문을 실행한다는 뜻이다. 

let isCat = true;

if isCat {
	print("😺")
}

if !isCat {
	// 고양이가 아닐 때,
	// 즉, false 일 때 실행
   	print("👽")
	
 }

참고 : https://bbiguduk.gitbook.io/swift/language-guide-1/basic-operators