Collections

Introduction

Modifiable – immuable

Tableau

// Let's create an empty array.
var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

Créer un tableau avec une valeur par défaut

var threeDoubles = Array(repeating: 0.0, count: 3)
print(threeDoubles)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]

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

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

Créer un tableau à l'aide d'un littéral de tableau

/*
We have defined a variable named catList, 
and with the [String] statement we specified 
that its type is an Array containing String elements.
*/
var catList: [String] = ["Garfield", "Tom"]
print(catList)
/*
It will understand that the array is an Array containing
String statements, since we assign a value that 
defines the variable. (Swift type inference)
*/
var shoppingList = ["Eggs", "Milk"]
print(shoppingList)

Accéder à la valeur d'un tableau

// We have defined an array with 3 elements of type Int.
var numbers:[Int] = [1, 5, 21]

// Arrays start from Index 0. For example, in order to reach the value 5, which is the 2nd element, we need to access the 1st index.
var a = numbers[1]
print( "Value of numbers at index 1 is \(a)" )

Ajouter de nouveaux éléments à un tableau

// The Array named catList was defined with 1 initial element.
var catList = ["Tom"]


/*
We are adding a new item with a Garfield 
value using the append method.
*/
catList.append("Garfield")
// Our array will now have 2 elements.


/*
With the + = operator, we can do the 
work that the append method does.
*/
catList += ["Sylvester"]

Ajouter des données à un indice précis du tableau

var catList = ["Tom"]

catList.insert("Garfield", at: 1)

print(catList)

Supprimer un élément précis du tableau

var shoppingList = ["Apple", "Cherry", "Cheese"]

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

let shoppingListTwo = shoppingList.removeLast()
// the last item in the array has just been removed

print(shoppingListTwo)

Itération d’un tableau

var shoppingList = ["Banana", "Orange", "Milk"]

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

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

Ensembles

Créer un ensemble vide

var catSet = Set<Character>()

Créer des ensembles avec un littéral de tableau

var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]

Avertissement

var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

Méthodes des ensembles

var favoriteGenres = ["Funk"]

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

if favoriteGenres.isEmpty {
    print("favoriteGenres is empty")
} else {
    print("I have particular music preferences.")
}

if favoriteGenres.contains("Funk") {
    print("Funk")
} 

Parcourir l’ensemble

let favoriteGenres = ["Classical","Jazz", "Hip hop"]

for genre in favoriteGenres {
    print("\(genre)")
}
// Classical
// Jazz
// Hip hop

Dictionnaire

var namesOfIntegers = [Int: String]()
// namesOfIntegers is an empty [Int: String] dictionary

namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type [Int: String]

Méthodes d’accès à un dictionnaire

var airports = ["LHR": "London", "IST": "Istanbul"]

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 is not empty.")
}
// Prints "The airports dictionary is not empty."

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

Indice

var airports = ["DUB":"Dublin"]

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



//Deletion
airports["APL"] = nil

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

Mettre à jour un dictionnaire

var airports = ["DUB": "Dublin"]

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."

Exemple de conversion d’un dictionnaire en tableau ci-dessous

let airports = ["IST":"Istanbul Airport", "DUB":"Dublin Airport"]

let airportCodes = [String](airports.keys)
print(airportCodes)

let airportNames = [String](airports.values)
print(airportNames)

Félicitations