제어 변경 구문

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

📌 타입 별칭

Type aliases 이며, 이미 존재하는 타입에 다른 이름을 붙이는 것.

typealias 키워드를 사용함

typealias AudioSample = UInt16

var maxFound = AudioSample.min

📌튜플

튜플 값은 어떠한 타입도 가능하며, 서로 같은 타입일 필요는 없다. 

let httpError = (404, "Not Fount")
//튜플의 타입은 (Int, String)

🔎 튜플 값 접근하기

1. 개별 요소로 접근하기

let (statusCode, statusMessage) = httpError

print("statusCode : \(statusCode)")
// statusCode : 404 

print("statusMessage : \(statusMessage)")
// statusMessage : Not Found

1.2 일부만 필요한 경우

필요하지 않은 부분은 언더바(_) 처리를 하여 무시한다. 

let (justTheStatusCode, _) = httpError
print("statusCode : \(justTheStatusCode)")
// statusCode : 404

2. 인덱스 사용하여 접근하기 

처음에 선언한 튜플 httpError의 인덱스를 사용하여 접근한다. 

httpError.0 , httpError.1 

print("statusCode : \(httpError.0)")
// statusCode : 404 

print("TstatusMessage : \(httpError.1)")
// statusMessage : Not Found

3. 이름 요소를 정해 접근하기 

튜플을 정의할 때, 요소에 이름을 정할 수 있다. 

let httpStatus = (statusCode: 200, description: "OK")

print("statusCode : \(httpStatus.statusCode)")
// statusCode : 200
print("statusMessage : \(httpStatus.description)")
// statusMessage : OK

👉함수의 반환 값이 여러개일 때, 사용하면 용이하다. 하지만 데이터 구조가 복잡하면 사용 X

+ 크기가 같은 튜플은 비교할 수 있다. 

(1, "zebra") < (2, "apple")   // 각각 튜플의 첫번째 요소를 비교하여 2는 1보다 크다 
(3, "apple") < (3, "bird")    // 첫번째 요소는 같지만, b는 a 보다 크다 
(4, "dog") == (4, "dog")

< 혹은 > 연산자로 비교 불가능한 경우는 다음과 같다. 

("blue", false) < ("purple", true)  //에러. boolean 값은 비교 불가능함

string과 Int 값만 < 혹은 > 연산자를 사용하여 비교 가능하다 

📌옵셔널과 nil 

값이 없는 경우 혹은 값이 있지만 옵셔널을 풀어서 값에 접근할 경우 옵셔널(optionals)을 사용한다. 

혹은 옵셔널 변수에 특수 값 nil로 지정하여 값이 없는 상태를 나타낼 수 있다. 

var surveyAnswer: String?

var ResponseCode: Int? = 404
ResponseCode = nil

옵셔널 바인딩을 사용하여 if 혹은 while 구문에서 옵셔널 값이 있는 지 체크할 수 있다. 

let num = "123"

if let convertNum = Int(num) {
	print("The string has an integer value of \(convertNum)")
    } else {
    print("The string could not be converted to an integer")
}

에러 처리에 대해서는

나중에 자세하게 알아보겠다..

공식 문서(번역본)를 보고 하나씩 정리하며 

공부할 예정!

📌 상수와 변수

• 사용하기 전 반드시 선언 되어야 함
• 상수 선언 : let 
• 변수 선언 : var 

let maxLogintimes = 10
var userAttemps = 0

최대 로그인 횟수 같이 정해져서 변경되지 않는 값은 상수로 선언 

사용자의 현재 로그인 횟수는 실패 시 값이 증가되어야 하므로 변수로 선언

◼  여러 개 변수 선언 시

var x = 1, y = 2, z = 3

⭐ 세미콜론 사용 여부 

swift에서는 세미콜론(;)을 사용하지 않아도 된다. 즉, 생략 가능하다. 

하지만 다음과 같이 한 줄에 여러 코드를 작성하려면 세미콜론 생략은 불가능하다. (세미콜론 꼭 필요❗❗)

let word = "Hello, Swift!"; print(word)

📌 타입명시

상수 혹은 변수를 선언할 때, 다음과 같이 타입을 명시해 줄 수 있다. 

var message : string

message는 어떠한 문자열 값을 저장할 수 있는 것이다. 

다음과 같이 여러 변수 한줄에서 선언 가능 

var red, blue, green: double

*️⃣ 초기값을 지정하지 않은 경우 타입명시를 한다. 

상수 혹은 변수에 초기화를 하면 타입추론으로 해당 타입을 자동으로 유추함 

👉 타입 명시가 꼭 필요하지 않음 

📌 변수 값 변경

var language = "korean"
language = "English"
//language는 English, 하지만 let 으로 선언 시에는 변경 불가능

변수는 위와 같이(var로 선언된 경우) 값 변경이 가능하지만 let으로 선언된 경우 불가능하다.

🔎 변수 포함하여 출력 

변수 포함해 출력하기 위해서는 백슬래쉬 \ 와 소괄호() 사이에 해당 변수를 넣어 출력한다.

print("My language is \(language)")
// My language is English 가 출력된다.

📌 형변환

다음과 같이 형이 다른 상수(혹은 변수) 끼리 연산을 할 때, 

형을 맞춰줘야 한다. 

let three = 3
let point = 0.14159
let pi = Double(three) + point

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