Programmer

en Swift (Swift 2.2)

Table des matires

Introduction 0
Bienvenue dans Swift 1
Dcouvrir Swift 2
Dmarrer avec Swift 3
Guide Du Langage 4
Les Bases 5

2
Programmer en Swift (Swift 2.2)

Projet de traduction du guide de programmation Swift en Franais

Introduction 3
Programmer en Swift (Swift 2.2)

Bienvenue Dans Swift

Bienvenue dans Swift 4

Programmer en Swift (Swift 2.2)

Dcouvrir Swift
Swift est un nouveau langage de programmation pour les applications iOS, OS X, watchOS
et tvOS qui a t conu avec le meilleur du C et de l'Objective-C, sans les contraintes de la
compatibilit avec le C. Swift propose un modle de programmation sr et scuris, ajout
des fonctionnalits modernes ayant pour but de rendre la programmation plus simple, plus
flexible et plus fun. Avec l'aide de Cocoa et Cocoa Touch, des frameworks matures et
populaires, Swift fait table rase de toutes les anciennes technologies et offre une opportunit
pour rinventer le dveloppement logiciel.

La construction de Swift a commenc il y a des annes. Chez Apple, nous avons pos ses
fondations en avanant nos compilateurs, dboggueurs et infrastructures de frameworks
existants. Nous avons simplifi la gestion de la mmoire avec Automatic Reference
Counting (ARC). Notre collection de frameworks, construits sur les bases solides que sont
Foundation et Cocoa, a t entirement modernise et standardise. L'Objective-C lui-
mme volu pour supporter les blocs, les collections et les modules ; rendant ainsi
possible une adoption sans interruption de frameworks contenant les technologies d'un
langage moderne. Grce ce travail de fond, nous pouvons maintenant introduire un
nouveau langage pour le futur du dveloppement de logiciels Apple.

Swift parat familier aux dveloppeurs Objective-C. Il adopte la facilit de lecture des
paramtres et la puissance du modle de gestion dynamique des objets propres ce
langage. Il fournit un accs continu aux frameworks Cocoa existants et la possibilit d'tre
mix avec du code Objective-C (interpolability). En plus de cette base commune, Swift
introduit de nombreuses nouvelles fonctionnalits et unit les procdures et les portions
orientes-objet du langage.

Swift est adapt aux nouveaux programmeurs. C'est le premier langage de programmation
pour des systmes distribus dans le monde entier qui est aussi expressif et plaisant
crire. Il supporte les Playgrounds, une fonctionnalit innovante qui permet aux
programmeurs de faire des expriences avec Swift et d'en voir le rsultat immdiatement,
sans avoir construire une app complte

Swift combine ce qu'il y a de mieux dans la philosophie des langages modernes avec la
sagesse de la grande culture technologique et de l'ingnierie d'Apple. Le compilateur est
optimis pour la performance, et le langage est optimis pour le dveloppement, sans que
l'un ne soit plus important que l'autre. Swift a t conu pour supporter toutes sortes de
programmes, sur une chelle allant du simple "hello, world" jusqu' un systme
d'exploitation tout entier. Tout ceci fait de Swift un investissement intressant dans l'avenir
pour les dveloppeurs et pour Apple.

Dcouvrir Swift 5
Programmer en Swift (Swift 2.2)

Swift est un moyen fantastique d'crire des apps pour iOS, OS X, watchOS, et tvOS, et va
continuer d'voluer avec de nouvelles fonctionnalits et possibilits. Nos objectifs pour Swift
sont ambitieux.

Nous avons hte de dcouvrir ce que vous aller crer avec lui.

Dcouvrir Swift 6
Programmer en Swift (Swift 2.2)

Dmarrer avec Swift

La tradition suggre que le premier programme dans un nouveau langage devrait afficher
les mots Hello, world! sur l'cran. En Swift, on peut le faire en une seule ligne :

1. print("Hello, world!")

Si vous avez dj crit du code en C ou en Objective-C, cette syntaxe vous est familire. En
Swift, cette ligne de code est un programme complet. Vous n'avez pas besoin d'importer une
bibliothque spare pour des fonctionnalits comme la gestion des entres/sorties ou des
chanes de caractre. Le code crit dans le champ global est utilis comme le point d'entre
du le programme, ce qui signifie que vous n'avez pas besoin d'une fonction main() . Par
ailleurs, les points-virgules la fin de chaque ligne ne sont pas obligatoires.

Note
Sur un Mac, tlchargez la Playground et double-cliquez sur le fichier pour l'ouvrir dans
Xcode : https://developer.apple.com/go/?id=swift-tour

Valeurs Simples
Utilisez let pour crer une constante et var pour crer une variable. La valeur d'une
constante n'a pas besoin d'tre dfinie au moment de la compilation, mais sa valeur ne peut
tre dfinie qu'une seule et unique fois. Ainsi, vous pouvez utiliser des constantes pour
nommer une valeur qui ne sera dclare qu'une seule fois mais que vous rutiliserez
plusieurs endroits.

1. var myVariable = 42
2. myVariable = 50
3. let myConstant = 42

Une constante ou une variable doivent avoir le mme type que celui de la valeur que vous
voulez lui donner. Toutefois, il n'est pas toujours ncessaire d'crire le type explicitement.
Donner une valeur une constante ou une variable quand vous la dclarez permet au
compilateur de dduire son type. Dans l'exemple ci-dessus, le compilateur dduit que
myVariable est de type "Entier" (Int) car sa valeur initiale est un entier (42). Si la valeur

initiale ne fournit pas assez d'informations (ou si il n'y a pas de valeur initiale), spcifiez le
type de la variable/constante en l'crivant aprs le symbole : .

Dmarrer avec Swift 7

Programmer en Swift (Swift 2.2)

1. let implicitInteger = 70
2. let implicitDouble = 70.0
3. let explicitDouble: Double = 70

Exprience
Crez une constante de type Float avec une valeur 4 .

Les valeurs ne peuvent jamais tre converties vers un autre type implicitement. Si vous avez
convertir une valeur vers un autre type, crez explicitement une instance du type dsir.

1. let label = "La largeur est de "

2. let width = 94
3. let widthLabel = label + String(width)

Exprience
Essayez de retirer la conversion vers le type String dans la dernire ligne. Quelle
erreur obtenez-vous ?

Il existe une manire encore plus simple d'inclure des valeurs dans du texte : crivez la
valeur entre parenthses et ajoutez un backslash ( \ ) avant les parenthses. Par exemple :

1. let apples = 3
2. let oranges = 5
3. let appleSummary = "J'ai \(apples) pommes."
4. let fruitSummary = "J'ai \(apples + oranges) morceaux de fruit."

Exprience

Utilisez \() pour inclure une opration entre deux nombres dcimaux dans une chane
de caractre, puis pour inclure un nom dans un message.

Vous pouvez crer des tableaux (Array) et des dictionnaires (Dictionary) en utilisant des
crochets ( [] ), et accder leurs lments en crivant leur index ou leur cl dans les
crochets. Une virgule peut tre place aprs le dernier lment.

1. var shoppingList = ["poisson-chat", "eau", "tulipes", "peinture bleue"]

2. shoppingList[1] = "bouteille d'eau"

4. var occupations = [
5. "Malcolm": "Capitaine",
6. "Kaylee": "Mcanicien",
7. ]
8. occupations["Jayne"] = "Relations Publiques"

Dmarrer avec Swift 8

Programmer en Swift (Swift 2.2)

Pour crer un tableau ou un dictionnaire vide, utilisez la syntaxe d'initialisation.

1. let emptyArray = [String]()

2. let emptyDictionary = [String: Float]()

Si le type peut tre suggr (par exemple lorsque vous changez la valeur d'une variable ou
passez un argument une fonction), un tableau vide s'crira [] et un dictionnaire vide
[:] .

1. shoppingList = []
2. occupations = [:]

Control Flow
Utilisez if et switch pour tester des conditions, et utilisez for - in , for , while , et
repeat - while pour ajouter des boucles. Il n'est pas obligatoire d'utiliser des parenthses

autour de la variable de la condition ou de la boucle. Des accolades autour du corps de ces

dernires sont obligatoires.

1. let individualScores = [75, 43, 103, 87, 12]

2. var teamScore = 0
3. for score in individualScores {
4. if score > 50 {
5. teamScore += 3
6. } else {
7. teamScore += 1
8. }
9. }
10. print(teamScore)

Dans une rgle if , la conditionnelle doit une une expression de type Boolean ce qui
signifie que du code comme if score { ... } est une erreur, et non une comparaison
implicite zro.

Vous pouvez combiner if et let pour traiter des valeurs qui peuvent tre manquantes.
Ces valeurs manquantes sont nommes optionnelles. Une valeur optionnelle contient soit
une valeur, soit nil dans le cas o la valeur est manquante. Ajoutez un point
d'interrogation ( ? ) aprs la dclaration du type d'une variable/constante pour la marquer
comme optionnelle.

Dmarrer avec Swift 9

Programmer en Swift (Swift 2.2)

1. var optionalString: String? = "Bonjour"

2. print(optionalString == nil)
3. //Affiche `false` : optionalString contient une valeur
4. var optionalName: String? = "John Appleseed"
5. var greeting = "Bonjour!"
6. if let name = optionalName {
7. greeting = "Hello, \(name)"
8. }

Exprience
Assignez nil optionalName . Quel message obtenez-vous ? Ajoutez un cas else
qui affiche in message diffrent si optionalName est gal nil

Si la valeur optionnelle vaut nil , alors la condition vrifie est false et le code entre
accolades est ignor. Dans le cas contraire, la valeur optionnelle est dballe (on parle
d'optionnal unwrapping) et assigne la constante aprs le mot-cl let , ce qui rend la
valeur optionnelle disponible au sein du bloc de code.

Il est galement possible de grer les valeurs optionnelles en leur fournissant une valeur par
dfaut, grce l'oprateur ?? . Si la valeur optionnelle est manquante, alors la valeur par
dfaut sera utilise la place.

1. let nickName: String? = nil

2. let fullName: String = "John Appleseed"
3. let informalGreeting = "Salut \(nickName ?? fullName)"

Les switchs supportent tous les types de donnes et une grande varit d'oprations de
comparaisons. Ils ne sont pas limits aux entiers ou aux tests d'galit.

1. let vegetable = "poivre rouge"

2. switch vegetable {
3. case "cleri":
4. print("Ajoutez des raisins et a fera des fourmis sur bche.")
5. case "concombre", "cresson":
6. print(`"Vivent les sandwiches.")
7. case let x where x.hasSuffix("poivre"):
8. print("Est-ce que ce \(x) est piquant ?")
9. default:
10. print("Tout passe dans une soupe.")
11. }

Exprience

Essayez d'enlever le cas default . Quelle erreur obtenez-vous ?

Dmarrer avec Swift 10

Programmer en Swift (Swift 2.2)

Remarque : let peut tre utilis pour assigner la valeur qui correspond un modle une
constante.

Aprs avoir excut le code contenu dans le cas correspondant, le programme quitte le
switch . L'excution ne se propage pas au cas suivant ; vous n'avez donc pas besoin

d'ajouter un break la fin du code de chaque cas.

Les boucles for - in servent rpter une action pour chaque item dans un Dictionnaire,
en fournissant une paire de noms de variables utiliser pour chaque paire cl-value. Un
dictionnaire n'est une collection ordonne, leurs cls et valeurs sont donc traites dans un
ordre arbitraire.

1. let interestingNumbers = [
2. "Premiers": [2, 3, 5, 7, 11, 13],
3. "Fibonacci": [1, 1, 2, 3, 5, 8],
4. "Carrs Parfaits": [1, 4, 9, 16, 25],
5. ]
6. var largest = 0
7. for (kind, numbers) in interestingNumbers {
8. for number in numbers {
9. if number > largest {
10. largest = number
11. }
12. }
13. }
14. print(largest)

Exprience
Ajoutez une variable qui enregistre quel tait le type du plus grand nombre, ainsi que sa
valeur.

On utilise while pour rpter un bloc de code jusqu' ce qu'une condition change. On peut
crire la condition en haut, ou en bas, ce qui permet d'tre sr que la boucle est excute
au moins une fois.

1. var n = 2
2. while n < 100 {
3. n = n * 2
4. }
5. print(n)

7. var m = 2
8. repeat {
9. m = m * 2
10. } while m < 100
11. print(m)

Dmarrer avec Swift 11

Programmer en Swift (Swift 2.2)

Vous pouvez ajouter un index une boucle -soit en utilisant ..< pour crer un intervalle
d'index ou en crivant une suite explicite "initialisation;condition;incrmentation".

Ces deux boucles font la mme chose :

1. var firstForLoop = 0
2. for i in 0..<4 {
3. firstForLoop += i
4. }
5. print(firstForLoop)

7. var secondForLoop = 0
8. for var i = 0; i < 4; ++i {
9. secondForLoop += i
10. }
11. print(secondForLoop)

Vous pouvez utiliser ..< pour dclarer un intervalle qui omet la valeur suprieure
(intervalle ferm), et utiliser ... pour un intervalle qui inclut les deux valeurs (intervalle
ouvert).

Fonctions et Closures
On utilise le mot-cl func pour dclarer une fonction. On lance (ou appelle) une fonction en
ajoutant une liste d'arguments entre parenthses aprs son nom. On spare les paramtres
du type retourn par la fonction par le symbole -> .

1. func greet(name: String, day: String) -> String {

2. return "Bonjour \(name), aujourd'hui c'est \(day)."
3. }
4. greet("Bob", day: "Mardi")

Exprience
Retirez le paramtre day . Ajoutez un paramtre qui inclut le plat du jour dans un
message.

Les tuples sont utiles pour crer une valeur compose - par exemple, pour retourner
plusieurs valeurs d'une fonction. Les lments d'un tuple se rfrencent soit par nombre ou
par nom.

Dmarrer avec Swift 12

Programmer en Swift (Swift 2.2)

1. func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
2. var min = scores[0]
3. var max = scores[0]
4. var sum = 0

6. for score in scores {

7. if score > max {
8. max = score
9. } else if score < min {
10. min = score
11. }
12. sum += score
13. }

15. return (min, max, sum)

16. }
17. let statistics = calculateStatistics([5, 3, 100, 3, 9])
18. print(statistics.sum)
19. print(statistics.2)

Les fonctions peuvent galement accepter un nombre variable d'arguments, qui seront
collects dans un tableau.

1. func sumOf(numbers: Int...) -> Int {

2. var sum = 0
3. for number in numbers {
4. sum += number
5. }
6. return sum
7. }
8. sumOf()
9. sumOf(42, 597, 12)

Exprience

crivez une fonction qui calcule la moyenne de ses arguments.

Les fonctions peuvent tre combines. Les fonctions combines ont accs aux variables
dclares dans les fonctions extrieures. Vous pouvez combiner des fonctions pour
organiser le code dans une fonction longue et complexe.

Dmarrer avec Swift 13

Programmer en Swift (Swift 2.2)

1. func returnFifteen() -> Int {

2. var y = 10
3. func add() {
4. y += 5
5. }
6. add()
7. return y
8. }
9. returnFifteen()

Les fonctions sont de type primaire. Cela signifie qu'une fonction peut retourner une autre
fonction.

1. func makeIncrementer() -> ((Int) -> Int) {

2. func addOne(number: Int) -> Int {
3. return 1 + number
4. }
5. return addOne
6. }
7. var increment = makeIncrementer()
8. increment(7)

Une fonction peut avoir une autre fonction comme argument.

1. func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {

2. for item in list {
3. if condition(item) {
4. return true
5. }
6. }
7. return false
8. }
9. func lessThanTen(number: Int) -> Bool {
10. return number < 10
11. }
12. var numbers = [20, 19, 7, 12]
13. hasAnyMatches(numbers, condition: lessThanTen)

Les fonctions sont en fait une forme spciale de closure : des blocs de code qui peuvent
tre excuts plus tard. Le code dans la closure ont accs des lments comme des
variables ou des fonctions disponibles dans le contexte o elle a t cre, mme si ce
contexte a chang lorsque cette dernire est excute. L'exemple des fonctions combines
illustre d'ailleurs ce principe.

Dmarrer avec Swift 14

Programmer en Swift (Swift 2.2)

Vous pouvez crire une closure sans lui donner de nom, en entourant son code avec des
accolades ( {} ). Utilisez in pour sparer les arguments et le type de l'lment retourn de
son corps.

1. numbers.map({
2. (number: Int) -> Int in
3. let result = 3 * number
4. return result
5. })

Exprience
R-crivez la closure de manire ce qu'elle retourne zro si number est impair.

Vous pouvez raccourcir les closures de plusieurs manires. Quand le type d'une closure est
dj connu, comme dans le cas d'un callback d'un delegate, vous pouvez retirer le type de
ses paramtres, du type de la valeur qu'elle retourne, o les deux. Les closures qui ne
dclarent qu'un seul lment retournent cet lment implicitement.

1. let mappedNumbers = numbers.map({ number in 3 * number })

2. print(mappedNumbers)

Vous pouvez utiliser les paramtres avec des nombres plutt qu'avec leur nom. Cette
approches est particulirement utile dans les closures trs courtes. Quand une closure est le
dernier argument d'une fonction, on peut l'crire directement aprs les parenthses. Quand
une closure est le seul argument d'une fonction, les parenthses ne sont plus ncessaires.

1. let sortedNumbers = numbers.sort { $0 > $1 }

2. print(sortedNumbers)

Objets et Classes
On cre une classe en utilisant class suivi du nom de la classe. On dclare une proprit
au sein d'une classe de la mme manire qu'on dclare des variables et des constantes,
seul le contexte change. Les mthodes (fonctions) sont galement dclares de la mme
manire.

1. class Shape {
2. var numberOfSides = 0
3. func simpleDescription() -> String {
4. return "Une forme avec \(numberOfSides) cts."
5. }
6. }

Dmarrer avec Swift 15

Programmer en Swift (Swift 2.2)

Exprience

Ajoutez Shape une proprit constante avec let et une mthode avec un argument.

On cr une instance de la classe en ajoutant des parenthses aprs le nom de la classe.

Utilisez un point pour accder ses mthodes et proprits.

1. var shape = Shape()

2. shape.numberOfSides = 7
3. var shapeDescription = shape.simpleDescription()

Il manque quelque chose d'important cette version de Shape : un initiateur qui permet de
paramtrer la classe quand l'instance est cre. Pour en crer un, on ajoute la mthode
init .

1. class NamedShape {
2. var numberOfSides: Int = 0
3. var name: String

5. init(name: String) {
6. self.name = name
7. }

9. func simpleDescription() -> String {

10. return "Une forme avec \(numberOfSides) cts."
11. }
12. }

On peut remarquer que self permet de distinguer la proprit name de l'argument name
de l'initiateur. Les arguments de l'initiateur sont passs de la mme manire que lors de
l'appel d'une fonction quand vous initialisez une classe. Toutes les proprits doivent avoir
t assignes une valeur, soit au moment de leur dclaration (comme c'est le cas pour
numberOfSizes ), ou dans l'initiateur (comme pour name ).

Vous pouvez ajouter la fonction deinit pour crer un d-initiateur si vous avez besoin de
faire des changements (comme du nettoyage) avant que l'objet soit d-allou de la
mmoire.

Les sous-classes se crent en ajoutant le nom de la super-classe aprs deux points ( : ).

Les classes ne sont pas obliges d'tre des sous-classes de classes standard. Vous pouvez
donc inclure ou non une super-classe en fonction de vos besoins.

Les mthodes d'une sous-classe qui ignorent l'implmentation de la super-classe sont

marques avec le mot-cl override . Ignorer une mthode par accident, sans override est
considr comme une erreur par le compilateur. Le compilateur dtecte galement les

Dmarrer avec Swift 16

Programmer en Swift (Swift 2.2)

mthodes marques override qui n'ignorent en rien les mthodes de la super-classe.

1. class Square: NamedShape {

2. var sideLength: Double

4. init(sideLength: Double, name: String) {

5. self.sideLength = sideLength
6. super.init(name: name)
7. numberOfSides = 4
8. }

10. func area() -> Double {

11. return sideLength * sideLength
12. }

14. override func simpleDescription() -> String {

15. return "Un carr de \(sideLength) de ct."
16. }
17. }
18. let test = Square(sideLength: 5.2, name: "mon exemple de carr")
19. test.area()
20. test.simpleDescription()

Exprience
Crez une autre sous-classe de NamedShape appele Circle qui est initialise avec un
rayon et un nom. Implmentez-y les mthode area et simpleDescription()

En plus du simple stockage de valeurs, les proprits permettent aussi d'ajouter un getter et
un setter.

Dmarrer avec Swift 17

Programmer en Swift (Swift 2.2)

1. class EquilateralTriangle: NamedShape {

2. var sideLength: Double = 0.0

4. init(sideLength: Double, name: String) {

5. self.sideLength = sideLength
6. super.init(name: name)
7. numberOfSides = 3
8. }

10. var perimeter: Double {

11. get {
12. return 3.0 * sideLength
13. }
14. set {
15. sideLength = newValue / 3.0
16. }
17. }

19. override func simpleDescription() -> String {

20. return "An equilateral triangle with sides of length \(sideLength)."
21. }
22. }
23. var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
24. print(triangle.perimeter)
25. triangle.perimeter = 9.9
26. print(triangle.sideLength)

Dans le setter de perimeter , la nouvelle valeur est implicitement nomme newValue . Vous
pouvez dfinir une valeur explicite entre parenthses aprs set .

On remarque que l'initialisation de EquilateralTriangle se fait en trois tapes :

1. Dfinition de la valeur des proprits de la sous-classe.

2. Appel de l'initiateur de la super-classe.
3. Changement de la valeur des proprits de la super-classe. Les tches qui utilisent des
mthodes, des getters ou des setters peuvent galement tre effectues ce moment.

Si vous avez besoin de calculer une proprit mais avez besoin de fournir du code qui sera
excut avant et aprs lui avoir attribu une nouvelle valeur, utilisez willSet et didSet . Ce
code est excut chaque fois que la valeur change en dehors de contexte d'initialisation.
Par exemple, la classe ci-dessous s'assure que la taille du ct de son triangle est toujours
gale celle de son carr.

Dmarrer avec Swift 18

Programmer en Swift (Swift 2.2)

1. class TriangleAndSquare {
2. var triangle: EquilateralTriangle {
3. willSet {
4. square.sideLength = newValue.sideLength
5. }
6. }
7. var square: Square {
8. willSet {
9. triangle.sideLength = newValue.sideLength
10. }
11. }
12. init(size: Double, name: String) {
13. square = Square(sideLength: size, name: name)
14. triangle = EquilateralTriangle(sideLength: size, name: name)
15. }
16. }
17. var triangleAndSquare = TriangleAndSquare(size: 10, name: "une autre forme de test")
18. print(triangleAndSquare.square.sideLength)
19. print(triangleAndSquare.triangle.sideLength)
20. triangleAndSquare.square = Square(sideLength: 50, name: "un carr plus large ")
21. print(triangleAndSquare.triangle.sideLength)

Lorsque vous utilisez des valeurs optionnelles, vous pouvez crire un ? avant des
oprations comme des mthodes, des proprits, ou d'indexation. Si la valeur avant ? est
gale nil , tout ce qui est crit aprs le ? sera ignor et la valeur de l'expression entire
sera gale nil . Dans le cas contraire, la valeur optionnelle et tout ce qui se trouve aprs
? se comportera comme une valeur optionnelle. Dans les deux cas, la valeur de

l'expression est optionnelle.

1. let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")

2. let sideLength = optionalSquare?.sideLength

Enumrations and Structures

Utilisez le mot-cl enum pour crer une numration. Comme les classes et d'autres types,
les numrations peuvent tre associes avec des mthodes.

Dmarrer avec Swift 19

Programmer en Swift (Swift 2.2)

1. enum Rank: Int {

2. case Ace = 1
3. case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
4. case Jack, Queen, King
5. func simpleDescription() -> String {
6. switch self {
7. case .Ace:
8. return "ace"
9. case .Jack:
10. return "jack"
11. case .Queen:
12. return "queen"
13. case .King:
14. return "king"
15. default:
16. return String(self.rawValue)
17. }
18. }
19. }
20. let ace = Rank.Ace
21. let aceRawValue = ace.rawValue

Exprience
crivez une fonction qui compare deux valeurs Rank grce leurs valeurs brutes

Dans l'exemple ci-dessus, le type de la valeur brute est Int . Cela vous permet donc de ne
spcifier la valeur brute que pour le premier cas. Les autres sont assignes dans l'ordre.
Vous pouvez galement utiliser des chanes de caractres ou des nombres dcimaux
comme type de valeurs brutes pour une numration. Utilisez la proprit rawValue pour
accder la valeur brute d'un cas d'une numration.

Utilisez l'initiateur init?(rawValue:) pour crer l'instance d'une numration partir d'une
valeur brute.

1. if let convertedRank = Rank(rawValue: 3) {

2. let threeDescription = convertedRank.simpleDescription()
3. }

Les cas d'une numration sont des valeurs part entire, et non une autre manire d'crire
leurs valeurs brutes. En fait, dans le cas o fournir une valeur brute une numration n'a
pas de sens particulier, il n'est pas ncessaire de la faire.

Dmarrer avec Swift 20

Programmer en Swift (Swift 2.2)

1. enum Suit {
2. case Spades, Hearts, Diamonds, Clubs
3. func simpleDescription() -> String {
4. switch self {
5. case .Spades:
6. return "spades"
7. case .Hearts:
8. return "hearts"
9. case .Diamonds:
10. return "diamonds"
11. case .Clubs:
12. return "clubs"
13. }
14. }
15. }
16. let hearts = Suit.Hearts
17. let heartsDescription = hearts.simpleDescription()

Exprience
Ajoutez la mthode color() Suit qui retourne black pour les cas Spades et Clubs ,
et retourne red pour les cas Hearts et Diamonds

On peut remarquer les deux manires de rfrencer le cas Hearts de l'numration.

Quand on assigne sa valeur la constante hearts , le cas Suit.Hearts est rfrenc dans
sa forme complte, car la constante n'a pas un type explicite. Vous pouvez utiliser la forme
abrge partir du moment o le type de la proprit est dj connue.

Utilisez struct pour crer une structure. Les structures sont en plusieurs points similaires
aux classes, comme par exemple au niveau des mthodes et des initiateurs. Une des
diffrences les plus importantes entre les structures et les classes est que les structures
sont toujours copies quand elles sont passes comme argument/valeur dans votre code,
alors que les classes le sont en tant que rfrence.

1. struct Card {
2. var rank: Rank
3. var suit: Suit
4. func simpleDescription() -> String {
5. return "Le \(rank.simpleDescription()) de \(suit.simpleDescription())"
6. }
7. }
8. let threeOfSpades = Card(rank: .Three, suit: .Spades)
9. let threeOfSpadesDescription = threeOfSpades.simpleDescription()

Dmarrer avec Swift 21

Programmer en Swift (Swift 2.2)

Exprience

Ajoutez une mthode Card qui cre un jeu de cartes complet, avec un carte de
chaque combinaison de couleur et de type.

L'instance d'un cas d'une numration peut tre associ des valeurs. Les instances d'un
mme cas peuvent avoir des valeurs associes diffrentes. Vous fournissez les valeurs
associes quand vous crez une instance. Les valeurs associes et les valeurs brutes sont
des notions diffrentes : la valeur brute d'un cas d'une numration est la mme pour toutes
les instances, et est fournie lorsque vous dfinissez/crivez l'numration.

Par exemple, considrez le cas o vous rcuprez l'heure de lever et de coucher du soleil
depuis un serveur. Le serveur renvoie soit une information, soit une erreur.

1. enum ServerResponse {
2. case Result(String, String)
3. case Error(String)
4. }

6. let success = ServerResponse.Result("6:00 am", "8:09 pm")

7. let failure = ServerResponse.Error("Out of cheese.")

9. switch success {
10. case let .Result(sunrise, sunset):
11. print("Le soleil se lvera \(sunrise) et se couchera \(sunset).")
12. case let .Error(error):
13. print("chec... \(error)")
14. }

Exprience

Ajoutez un troisime cas ServerResponse et au switch.

Retenez comment l'heure de lever et de coucher du soleil sont extraites de la valeur

ServerResponse et utilises comme des cas dans le switch.

Protocoles and Extensions

On dclare un protocole avec le mot-cl protocol .

1. protocol ExampleProtocol {
2. var simpleDescription: String { get }
3. mutating func adjust()
4. }

Les classes, les numrations et structures peuvent suivre des protocoles.

Dmarrer avec Swift 22

Programmer en Swift (Swift 2.2)

1. class SimpleClass : ExampleProtocol {

2. var simpleDescription: String = "A very simple class."
3. var anotherProperty: Int = 69105
4. func adjust() {
5. simpleDescription += " Now 100% adjusted."
6. }
7. }
8. var a = SimpleClass()
9. a.adjust()
10. let aDescription = a.simpleDescription

12. struct SimpleStructure : ExampleProtocol {

13. var simpleDescription: String = "A simple structure"
14. mutating func adjust() {
15. simpleDescription += " (adjusted)"
16. }
17. }
18. var b = SimpleStructure()
19. b.adjust()
20. let bDescription = b.simpleDescription

Exprience
crivez une numration qui est conforme ce protocole.

Remarquez l'utilisation du mot-cl mutating dans la dclaration de SimpleStructure pour

marquer une mthode qui modifie la structure. La dclaration de SimpleClass n'a pas
besoin de voir ses mthodes marques comme mutating , car les mthodes d'une classe
peuvent toujours la modifier.

L'utilisation d' extension permet d'ajouter des fonctionnalits un type existant, telles que
de nouvelles mthodes et des proprits calcules. Vous pouvez utiliser une extension pour
permettre un type dclar ailleurs d'tre conforme un protocole ; de mme pour les
types imports depuis une bibliothque ou un framework.

1. extension Int : ExampleProtocol {

2. var simpleDescription: String {
3. return "Le nombre \(self)"
4. }
5. mutating func adjust() {
6. self += 42
7. }
8. }
9. print(7.simpleDescription)

Exprience

crivez une extension pour le type Double qui ajoute une proprit absoluteValue .

Dmarrer avec Swift 23

Programmer en Swift (Swift 2.2)

Vous pouvez utiliser un protocole comme tout autre type. Par exemple, vous pouvez crer
une collection d'objets qui ont des types diffrents mais qui sont tous conformes au mme
protocole. Quand vous travaillez avec des valeurs dont le type est un protocole, il est
impossible de dclarer des mthodes en dehors du protocole.

1. let protocolValue: ExampleProtocol = a

2. print(protocolValue.simpleDescription)
3. // print(protocolValue.anotherProperty) // Enlevez le commentaire pour voir l'erreur

Mme si la variable protocolValue est de type SimpleClass au moment de l'excution, le

compilateur le traite comme une variable de type ExampleProtocol . Cela signifie que vous
ne pouvez pas accidentellement accder aux mthodes et aux proprits que la classe
implmente en plus du cadre de la conformit au protocole.

Gnriques
crivez un nom entre les symboles <> pour crer un type ou une fonction gnrique.

1. func repeatItem<Item>(item: Item, numberOfTimes: Int) -> [Item] {

2. var result = [Item]()
3. for _ in 0..<numberOfTimes {
4. result.append(item)
5. }
6. return result
7. }
8. repeatItem("knock", numberOfTimes:4)

Vous pouvez crer des gnriques partir de fonctions et mthodes, mais aussi partir de
classes, d'numrations et de structures.

1. // Recrez le type optionnel de la bibliothque standard Swift

2. enum OptionalValue<Wrapped> {
3. case None
4. case Some(Wrapped)
5. }
6. var possibleInteger: OptionalValue<Int> = .None
7. possibleInteger` = .Some(100)

Utilisez where aprs le nom du type pour spcifier une liste de pr-requis ; par exemple
pour que le type doivent imprativement respecter un protocole, que deux types soient
identiques, ou qu'une classe ait une super-classe particulire.

Dmarrer avec Swift 24

Programmer en Swift (Swift 2.2)

1. func anyCommonElements <T: SequenceType, U: SequenceType where T.Generator.Element: Equatable, T.

2. for lhsItem in lhs {
3. for rhsItem in rhs {
4. if lhsItem == rhsItem {
5. return true
6. }
7. }
8. }
9. return false
10. }
11. anyCommonElements([1, 2, 3], [3])

Exprience
Modifiez la fonction anyCommonElements(_:_:) pour qu'elle retourne un tableau des
lments que les deux squences ont en commun.

crire <T: Equatable> revient crire <T where T: Equatable> .

Dmarrer avec Swift 25

Programmer en Swift (Swift 2.2)

Language Guide

Guide Du Langage 26
Programmer en Swift (Swift 2.2)

Les Bases 27