Collection Types

Groot·2022년 6월 7일
Swift Language Guide
0

Swift Language Guide

목록 보기
4/24
post-thumbnail

Swift Language Guide - Collection Types

  • Swift는 값 컬렉션을 저장하기 위해 Array, Set 및 Dictionary으로 알려진 세 가지 기본 컬렉션 유형을 제공합니다.
  • Swift의 Array, Set 및 Dictionary은 저장할 수 있는 값과 키의 유형에 대해 항상 명확합니다.
  • 이는 실수로 잘못된 유형의 값을 컬렉션에 삽입할 수 없음을 의미합니다. 또한 컬렉션에서 검색할 값 유형에 대해 확신할 수 있음을 의미합니다.

    Swift의 Array, Set 및 Dictionary 유형은 일반 컬렉션으로 구현됩니다. 제네릭 형식 및 컬렉션에 대한 자세한 내용은 제네릭을 참조하세요.

📌 Mutability of Collections

  • Array, Set 또는 Dictionary을 만들고 변수에 할당하면 생성된 컬렉션이 변경 가능합니다.

    컬렉션을 변경할 필요가 없는 모든 경우에 변경할 수 없는 컬렉션을 만드는 것이 좋습니다.
    그렇게 하면 코드에 대해 더 쉽게 추론할 수 있고 Swift 컴파일러가 생성한 컬렉션의 성능을 최적화할 수 있습니다.

📌 Arrays

  • Array은 정렬된 목록에 같은 유형의 값을 저장합니다. 동일한 값이 Array의 다른 위치에 여러 번 나타날 수 있습니다.

    Swift의 Array 유형은 Foundation의 NSArray 클래스에 연결됩니다.

📍 Array Type Shorthand Syntax

  • Swift Array의 유형은 전체가 "Array\"로 작성됩니다.
  • Array의 유형을 [Element]로 축약형으로 작성할 수도 있습니다. 두 형식이 기능적으로 동일하지만 축약 형식이 선호되며 이 가이드 전체에서 어레이 유형을 언급할 때 사용됩니다.

📍 Creating an Empty Array

  • 초기화 구문을 사용하여 특정 유형의 빈 Array을 만들 수 있습니다.

    var someInts: [Int] = []
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

  • 컨텍스트가 이미 함수 인수 또는 이미 유형이 지정된 변수 또는 상수와 같은 유형 정보를 제공하는 경우, 로 작성된 빈 Array Literal을 사용하여 빈 Array을 만들 수 있습니다

    someInts.append(3)
// someInts now contains 1 value of type Int
someInts = []
// someInts is now an empty array, but is still of type [Int]

📍 Creating an Array with a Default Value

  • Swift의 Array 유형은 모든 값이 동일한 기본값으로 설정된 특정 크기의 Array을 생성하기 위한 초기화 메서드를 제공합니다.
    var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]

📍 Creating an Array by Adding Two Arrays Together

  • 더하기 연산자(+)를 사용하여 호환되는 유형의 기존 Array 두 개를 함께 추가하여 새 Array을 만들 수 있습니다. 새 Array의 유형은 함께 추가하는 두 Array의 유형에서 유추됩니다.

    var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

📍 Creating an Array with an Array Literal

  • Array Literal로 Array을 초기화할 수도 있습니다. 이는 하나 이상의 값을 Array 컬렉션으로 쓰는 약식 방법입니다.
  • Array Literal은 한 쌍의 대괄호로 묶인 쉼표로 구분된 값 목록으로 작성됩니다.
    • 예) [value 1, value 2, value 3]
      var shoppingList: [String] = ["Eggs", "Milk"]
-> var shoppingList = ["Eggs", "Milk"]
// shoppingList has been initialized with two initial items

📍 Accessing and Modifying an Array

  • 메서드 및 속성을 통해 또는 아래 첨자 구문을 사용하여 Array에 액세스하고 수정합니다.

    print("The shopping list contains \(shoppingList.count) items.")
// Prints "The shopping list contains 2 items."

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list isn't empty.")
}
// Prints "The shopping list isn't empty."

shoppingList.append("Flour")
// shoppingList now contains 3 items, and someone is making pancakes

shoppingList += ["Baking Powder"]
// shoppingList now contains 4 items
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList now contains 7 items

var firstItem = shoppingList[0]
// firstItem is equal to "Eggs"

shoppingList[0] = "Six eggs"
// the first item in the list is now equal to "Six eggs" rather than "Eggs"

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList now contains 6 items

shoppingList.insert("Maple Syrup", at: 0)
// shoppingList now contains 7 items
// "Maple Syrup" is now the first item in the list

let mapleSyrup = shoppingList.remove(at: 0)
// the item that was at index 0 has just been removed
// shoppingList now contains 6 items, and no Maple Syrup
// the mapleSyrup constant is now equal to the removed "Maple Syrup" string

firstItem = shoppingList[0]
// firstItem is now equal to "Six eggs"

let apples = shoppingList.removeLast()
// the last item in the array has just been removed
// shoppingList now contains 5 items, and no apples
// the apples constant is now equal to the removed "Apples" string

📍 Iterating Over an Array

  • for-in 루프를 사용하여 Array의 전체 값 Set을 반복할 수 있습니다.
    for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas
  • 각 항목의 정수 인덱스와 해당 값이 필요한 경우 enumerated() 메서드를 사용하여 대신 Array을 반복합니다. Array의 각 항목에 대해 enumerated() 메서드는 정수와 항목으로 구성된 튜플을 반환합니다.
    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

📌 Sets

  • Set은 정의된 순서 없이 컬렉션에 동일한 유형의 고유한 값을 저장합니다.
  • 항목의 순서가 중요하지 않거나 항목이 한 번만 표시되도록 해야 하는 경우 Array 대신 Set을 사용할 수 있습니다.

📍 Hash Values for Set Types

  • 유형은 Set에 저장되기 위해 해시 가능해야 합니다. 즉, 유형은 자체적으로 해시 값을 계산하는 방법을 제공해야 합니다.
  • 모든 Swift의 기본 유형(예: String, Int, Double 및 Bool)은 기본적으로 해시 가능하며 설정 값 유형 또는 Dictionary 키 유형으로 사용할 수 있습니다.

📍 Set Type Syntax

  • Swift Set의 유형은 Set\로 작성되며, 여기서 Element는 Set이 저장할 수 있는 유형입니다. Array과 달리 Set에는 동등한 축약형이 없습니다.

📍 Creating and Initializing an Empty Set

  • 초기화 구문을 사용하여 특정 유형의 빈 Set을 만들 수 있습니다.
    var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")
// Prints "letters is of type Set<Character> with 0 items."
  • 컨텍스트가 함수 인수 또는 이미 입력된 변수 또는 상수와 같은 형식 정보를 이미 제공하는 경우 빈 Array Literal을 사용하여 빈 Set을 만들 수 있습니다.
    letters.insert("a")
// letters now contains 1 value of type Character
letters = []
// letters is now an empty set, but is still of type Set<Character>

📍 Creating a Set with an Array Literal

  • 하나 이상의 값을 Set 컬렉션으로 작성하는 약식 방법으로 Array Literal을 사용하여 Set을 초기화할 수도 있습니다.
    var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres has been initialized with three initial items
  • Array Literal만으로는 Set 유형을 유추할 수 없으므로 Set 유형을 명시적으로 선언해야 합니다.
  • Swift의 유형 추론 때문에 한 유형의 값을 포함하는 Array Literal로 초기화하는 경우 Set 요소의 유형을 작성할 필요가 없습니다.
    var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

📍 Accessing and Modifying a Set

  • 메서드와 속성을 통해 Set에 액세스하고 수정합니다.

    print("I have \(favoriteGenres.count) favorite music genres.")
// Prints "I have 3 favorite music genres."

if favoriteGenres.isEmpty {
    print("As far as music goes, I'm not picky.")
} else {
    print("I have particular music preferences.")
}
// Prints "I have particular music preferences."

favoriteGenres.insert("Jazz")
// favoriteGenres now contains 4 items

if let removedGenre = favoriteGenres.remove("Rock") {
    print("\(removedGenre)? I'm over it.")
} else {
    print("I never much cared for that.")
}
// Prints "Rock? I'm over it."

if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
} else {
    print("It's too funky in here.")
}
// Prints "It's too funky in here."

📍 Iterating Over a Set

  • for-in 루프를 사용하여 Set의 값을 반복할 수 있습니다.
    for genre in favoriteGenres {
    print("\(genre)")
}
// Classical
// Jazz
// Hip hop
  • Swift의 Set 유형에는 정의된 순서가 없습니다. 특정 순서로 Set의 값을 반복하려면 < 연산자를 사용하여 정렬된 Array로 Set의 요소를 반환하는 sorted() 메서드를 사용합니다.
    for genre in favoriteGenres.sorted() {
    print("\(genre)")
}
// Classical
// Hip hop
// Jazz

📌 Performing Set Operations

  • 두 Set을 함께 결합하거나, 두 Set이 공통적으로 갖는 값을 결정하거나, 두 Set에 동일한 값이 모두 포함되어 있는지, 일부가 포함되어 있는지 또는 전혀 포함되어 있지 않은지 확인하는 것과 같은 기본 Set 작업을 효율적으로 수행할 수 있습니다.

📍 Fundamental Set Operations

  • 아래 그림은 음영 영역으로 표시되는 다양한 Set 작업의 결과와 함께 두 개의 Set(a 및 b)을 보여줍니다.

  • Intersection(_:) 메서드를 사용하여 두 Set에 공통적인 값만 있는 새 Set을 만듭니다.

  • symmetricDifference(_:) 메서드를 사용하여 두 Set 중 하나에 값이 있는 새 Set을 만들 수 있습니다.

  • Union(_:) 메서드를 사용하여 두 Set의 모든 값을 사용하여 새 Set을 만듭니다.

  • 지정된 Set에 없는 값을 사용하여 새 Set을 만들려면 subtracting(_:) 메서드를 사용합니다.

    let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

📍 Set Membership and Equality

  • 아래 그림은 Set 간에 공유되는 요소를 나타내는 겹치는 영역이 있는 세 개의 Set(a, b, c)을 보여줍니다.

  • “is equal” 연산자(==)를 사용하여 두 Set에 동일한 값이 모두 포함되어 있는지 확인합니다.

  • isSubset(of:) 메서드를 사용하여 Set의 모든 값이 지정된 Set에 포함되어 있는지 확인합니다.

  • isSuperset(of:) 메서드를 사용하여 Set에 지정된 Set의 모든 값이 포함되어 있는지 확인합니다.

  • isStrictSubset(of:) 또는 isStrictSuperset(of:) 메서드를 사용하여 Set이 하위 Set인지 상위 Set인지 확인하지만 지정된 Set과 같지는 않습니다.

  • isDisjoint(with:) 메서드를 사용하여 두 Set에 공통 값이 없는지 확인합니다.

    let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

📌 Dictionaries

  • Dictionary은 정의된 순서가 없는 컬렉션에서 동일한 유형의 키와 동일한 유형의 값 간의 연관을 저장합니다.
  • 각 값은 Dictionary 내에서 해당 값의 식별자 역할을 하는 고유 키와 연결됩니다.
  • Array의 항목과 달리 Dictionary의 항목에는 지정된 순서가 없습니다.
  • 특정 단어에 대한 정의를 찾는 데 실제 Dictionary을 사용하는 것과 거의 동일한 방식으로 해당 Key값을 기반으로 값을 조회해야 할 때 Dictionary을 사용합니다.

📍 Dictionary Type Shorthand Syntax

  • Swift Dictionary의 유형은 전체가 Dictionary<Key, Value>로 작성됩니다. 여기서 Key는 Dictionary 키로 사용할 수 있는 값 유형이고 Value는 Dictionary이 해당 키에 대해 저장하는 값 유형입니다.

    Dictionary 키 유형은 Set의 값 유형과 같이 Hashable 프로토콜을 준수해야 합니다.

  • 딕셔너리의 종류를 [Key: Value]로 축약하여 작성할 수도 있습니다. 두 형식은 기능적으로 동일하지만 약어 형식이 선호되며 이 가이드 전체에서 Dictionary의 유형을 언급할 때 사용됩니다.

📍 Creating an Empty Dictionary

  • Array과 마찬가지로 초기화 구문을 사용하여 특정 유형의 빈 Dictionary을 만들 수 있습니다.
    var namesOfIntegers: [Int: String] = [:]
// namesOfIntegers is an empty [Int: String] dictionary
  • 키는 Int 유형이고 값은 String 입니다.
  • 문맥에서 이미 유형 정보를 제공하는 경우 [:](대괄호 쌍 안의 콜론)로 작성된 빈 dictionary litera 을 사용하여 빈 dictionary을 만들 수 있습니다.
    namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type [Int: String]

📍 Creating a Dictionary with a Dictionary Literal

  • 이전에 본 Array Literal과 유사한 구문을 가진 Dictionary Literal을 사용하여 Dictionary을 초기화할 수도 있습니다.
  • Dictionary Literal은 하나 이상의 키-값 쌍을 Dictionary 컬렉션으로 작성하는 약식 방법입니다.
  • 키-값 쌍은 키와 값의 조합입니다. Dictionary Literal에서 각 키-값 쌍의 키와 값은 콜론(:)으로 구분됩니다.
  • 키-값 쌍은 한 쌍의 대괄호로 묶인 쉼표로 구분된 목록으로 작성됩니다.

    [key 1: value 1, key 2: value 2, key 3: value 3]

    var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
  • 첫 번째 쌍은 키("YYZ")와 값("Toronto Pearson")이 있습니다.
  • 두 번째 쌍은 키("DUB")와 값("Dublin")이 있습니다.
  • Array과 마찬가지로 키와 값이 일관된 유형을 갖는 Dictionary Literal로 초기화하는 경우 Dictionary의 유형을 작성할 필요가 없습니다. 초기화는 대신 더 짧은 형식으로 작성할 수 있습니다.
    var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

📍 Accessing and Modifying a Dictionary

  • 메서드 및 속성을 통해 또는 아래 첨자 구문을 사용하여 Dictionary에 액세스하고 수정합니다.

    print("The airports dictionary contains \(airports.count) items.")
// Prints "The airports dictionary contains 2 items."

if airports.isEmpty {
    print("The airports dictionary is empty.")
} else {
    print("The airports dictionary isn't empty.")
}
// Prints "The airports dictionary isn't empty."

airports["LHR"] = "London"
// the airports dictionary now contains 3 items

airports["LHR"] = "London Heathrow"
// the value for "LHR" has been changed to "London Heathrow"

  • updateValue(_:forKey:) 메서드는 Dictionary 값 유형의 선택적 값을 반환합니다.

  • 이 메서드는 String? 또는 "선택적 String" 유형의 값을 반환합니다. 이 선택적 값은 업데이트 이전에 존재했다면 해당 키에 대한 이전 값을 포함하고, 값이 존재하지 않으면 nil을 포함합니다.

    if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}
// Prints "The old value for DUB was Dublin."

  • 아래 구문을 사용하여 특정 키에 대한 Dictionary에서 값을 검색할 수도 있습니다. 값이 존재하지 않는 키를 요청할 수 있기 때문에 Dictionary의 첨자는 Dictionary 값 유형의 선택적 값을 반환합니다.

    if let airportName = airports["DUB"] {
    print("The name of the airport is \(airportName).")
} else {
    print("That airport isn't in the airports dictionary.")
}
// Prints "The name of the airport is Dublin Airport."

  • 아래 구문을 사용하여 해당 키에 nil 값을 할당하여 Dictionary에서 키-값 쌍을 제거할 수 있습니다.

    airports["APL"] = "Apple International"
// "Apple International" isn't the real airport for APL, so delete it
airports["APL"] = nil
// APL has now been removed from the dictionary

  • removeValue(forKey:) 메소드를 사용하여 Dictionary에서 키-값 쌍을 제거할 수 있습니다.

  • 이 메서드는 키-값 쌍이 있으면 제거하고 제거된 값을 반환하거나 값이 없으면 nil을 반환합니다.

    if let removedValue = airports.removeValue(forKey: "DUB") {
    print("The removed airport's name is \(removedValue).")
} else {
    print("The airports dictionary doesn't contain a value for DUB.")
}
// Prints "The removed airport's name is Dublin Airport."

📍 Iterating Over a Dictionary

  • for-in 루프를 사용하여 Dictionary의 키-값 쌍을 반복할 수 있습니다.

  • Dictionary의 각 항목은 (키, 값) 튜플로 반환되며 반복의 일부로 튜플의 구성원을 임시 상수 또는 변수로 분해할 수 있습니다.

    for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}
// LHR: London Heathrow
// YYZ: Toronto Pearson

  • key 및 values 속성에 액세스하여 Dictionary의 키 또는 값의 반복 가능한 컬렉션을 검색할 수도 있습니다.

    for airportCode in airports.keys {
    print("Airport code: \(airportCode)")
}
// Airport code: LHR
// Airport code: YYZ

for airportName in airports.values {
    print("Airport name: \(airportName)")
}
// Airport name: London Heathrow
// Airport name: Toronto Pearson

  • Array 인스턴스를 사용하는 API와 함께 Dictionary의 키 또는 값을 사용해야 하는 경우 keys 또는 values 속성을 사용하여 새 Array을 초기화해야합니다.

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

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

  • Swift의 Dictionary 유형에는 정의된 순서가 없습니다. 특정 순서로 Dictionary의 키 또는 값을 반복하려면 해당 키 또는 값 속성에서 sorted() 메서드를 사용합니다.

profile
Groot
I Am Groot
이전 포스트

Strings and Characters

다음 포스트

Functions

0개의 댓글