Introduction à swift

Swift est un nouveau langage de programmation pour le développement d’application iOS, watchOS et
Mac OS X. Néanmoins, certaines parties du langage Swift seront familière si vous avez déjà une
expérience dans le développement C et Objective-C.

Swift fourni tous ses propres versions des types fondamentaux du C et de l’Objective-C, incluant Int pour
les intégrales, Double and Float pour les nombres à virgule flottante, Bool pour les valeurs booléennes et
String pour les données textuelles. Swift fourni aussi une version puissante des deux principaux types de
collection, Array et Dictionary pour les tableaux et les dictionnaires.

Comme le C, Swift utilise les variables pour stocker et se référer aux valeurs identifiées par leur nom.
Swift permet aussi l’utilisation des variables dont les valeurs ne peuvent pas être changées. Aussi
appelée constantes, elles sont plus puissantes que dans la langage C. Les constantes sont utilisées
partout avec Swift pour obtenir un code clair et sans faille de sécurité dans la mesure où vous travaillez
avec des valeurs qui n’ont pas besoin d’être modifiées.

En supplément des types familiers, Swift introduit d’autres types avancés que ne possède pas l’Objective-
C. Il s’agit notamment de tuples (listes non-mutables), qui vous permettent de créer et de passer par des
regroupements de valeurs. Les Tuples peuvent retourner de multiples valeurs depuis une fonction
comme une valeur unique composée.

Swift introduit aussi les types optionnels, qui acceptent l’absence de valeur. Les types optionnels
fonctionnent de la façon suivante : « Il y a une valeur et elle est égale à x (ou x est une inconnue) » ou « Il
n’y a pas de valeur du tout ». Utiliser un type optionnel revient à utiliser nil avec des pointeurs en
Objective-C, mais cette fois ils marchent avec n’importe quel type, pas juste les classes. Ils sont plus
sécurisés et plus expressifs que les pointeurs nil en Objective-C et sont le coeur de nombreuses
fonctionnalités plus puissantes les unes que les autres du langage Swift.

Les types optionnels sont un exemple qui définit Swift comme un langage aux types sécurisés. Swift vous
aide à être clair dans le typage des valeurs qui sont attendues pour un code fonctionnel. Si une partie de
votre code attend une chaine de caractère (String), le typage sécurisé vous prévient si par erreur vous
avez typé votre variable comme un Int. Cela permet de déceler et de réparer les erreurs très rapidement
dans votre processus de développement.

>

  Les constantes et les variables

Les constantes et les variables sont associées à un nom (comme nombreMaxLogin ou welcomeMessage
par exemple) avec une valeur et un type particulier (comme le nombre 10 ou la chaîne de caractères
"Hello"). La valeur d’une constante ne peut être modifiée une fois définie, sinon il s’agit d’une variable et
elle pourra prendre différentes valeurs dans le futur.

Déclarer les constantes et les variables

Les constantes et les variables doivent être déclarées avant d’être utilisées. On déclare les constantes
avec le mot-clé let et les variables avec var. Voici un exemple qui montre comment les constantes et les
variables peuvent être utilisées pour vérifier le nombre de tentatives de connexion d’un utilisateur sur
votre application :

1 let tentativesMaxLogin = 10

2 var tentativesLogin = 0

Ce bout de code peut être lu de la façon suivante : “Déclare une nouvelle constante appelée
tentativesMaxLogin, et attribue lui la valeur 10.” “Ensuite, déclare une nouvelle variable appelée
tentativesLogin, et donne lui la valeur initiale 0.”

Dans cet exemple, le nombre maximum de connexions autorisées est déclaré en tant que constante,
parce-que ce nombre ne devra pas être amené à être changé. En revanche le compteur du nombre de
tentatives de connexion est déclaré en tant que variable, puisque sa valeur sera incrémentée
positivement après chaque échec de connexion.

Vous pouvez déclarer plusieurs constantes ou plusieurs variables en même temps sur une seule ligne en
les séparant par des virgules :

var x = 0.0, y = 0.0, z = 0.0

Note : Si vous stockez une valeur dans votre code qui ne sera pas amenée à changer, déclarez la
toujours en tant que constante avec le mot-clé let. Utilisez les variables uniquement pour stocker des
valeurs qui auront besoin de changer.

Annotation des types

Vous pouvez indiquer le type de votre constante ou votre variable lorsque vous la déclarez, pour être
clair avec les sortes de valeurs que vous souhaitez stocker. Pour indiquer le type d’une constante ou
d’une variable, écrivez le type juste après son nom séparé par deux points et d’un espace.

Cet exemple montre une annotation de type pour une variable appelée messageBienvenue pour
indiquer qu’il s’agit d’une chaîne de caractère (String) :

var messageBienvenue: String

Les deux points dans la déclaration veulent dire : ”…du type…“, du coup le code ci-dessus peut-être lu
comme ceci :

“Déclare une variable appelée messageBienvenue qui est du type String.”

La phrase “du type String” veut dire “peut stocker une valeur de type chaîne de caractères”. C’est le
“type de chose” qui peut être stocké. La variable messageBienvenue peut maintenant accueillir
n’importe quelle chaîne de caractère sans erreur :

messageBienvenue = "Hello"

Note : En réalité il est rare dans la pratique que vous ayiez à indiquer le type d’une variable ou
d’une constante. En fournissant une valeur lors de la déclaration de votre constante ou de votre variable,
Swift est capable de deviner son type. Les annotations de typages interviennent uniquement dans le cas
d’une conversion ou de l’enregistrement d’une donnée ambigüe. Dans l’exemple ci-dessus avec la
variable messageBienvenue, aucune valeur initiale n’est fournie, le type de la variable est alors spécifié
avec une annotation, mais cette annotation aurait été inutile en fournissant une valeur initiale à la
variable.

Nommage des constantes et des variables

Vous pouvez utiliser n’importe quel caractère pour vos noms de variables et de constantes, même les
caractères spéciaux et unicode :

1 let π = 3.14159

2 let 你好 = "你好世界"

3 let 💋💖 = "bisoucoeur"

Les noms des constantes et des variables ne peuvent pas contenir de symboles mathématiques, de
flèches, de code Unicode invalide ni de points. Ils ne peuvent pas non plus commencer par un chiffre
mais il est possible d’inclure des chiffres dans le nom de variables et des constantes n’importe où ailleurs
dans leurs noms.

Une fois que vous avez déclaré une contante ou une variable d’un certain type, vous ne pouvez plus
utiliser son nom pour en déclarer une autre ou changer le type de valeur qui y sont stockées. Vous ne
pouvez pas non plus changer une constante en variable et une variable en constante.

Note : Si vous avez besoin de donner à une constante ou une variable le même nom qu’un mot-
clé Swift réservé, vous pouvez le faire en entourant le mot-clé avec des guillemets inversés quand vous
l’utilisez en tant que nom. Néanmoins vous ne devriez utiliser cette solution que dans la mesure où vous
n’avez vraiment pas le choix.

Vous pouvez change la valeur d’une variable existante par une autre valeur d’un type compatible. Dans
l’exemple ci-dessous, la valeur de bonjourAmical est passée de "Hello!" à "Bonjour!" :
1 var bonjourAmical = "Salut!"

2 bonjourAmical = "Bonjour!"

3 // bonjourAmical vaut maintenant "Bonjour!"

Contrairement aux variables, la valeur d’une constante ne peut pas être modifiée une fois qu’elle a été
définie. Si vous tentez de changer la valeur d’une constante vous vous exposez à une erreur au moment
de la compilation :

1 let nomLangage = "Swift"

2 nomLangage = "Swift 2"

3 // Error - nomLangage cannot be changed

Afficher les constantes et les variables

Vous pouvez afficher la valeur courante d’une constante ou d’une variable avec la fonction print(_:) :

1 print(bonjourAmical)

2 // Affichera à l'écran "Bonjour!"

print(_:) est une fonction globale qui affiche une valeur, suivie d’un retour à la ligne, à la sortie
appropriée. Si vous travaillez depuis Xcode, par exemple, print(_:) affichera la valeur demandée dans la
console Xcode. Une fonction liée, print(_:appendNewline:), réalise exactement la même opération mais
sans le retour à la ligne après l’affichage de la valeur.

La fonction print(_:) affiche n’importe quelle chaîne de caractères qu’on lui fournit :

1 print("Ceci est une chaîne de caractères")

2 // Affiche "Ceci est une chaîne et caractères"

La fonction print(_:) peut afficher des messages de logs plus complets. Ces messages peuvent inclure les
valeurs de contantes ou de variables.

Swift convertit systématiquement les valeurs incluses dans les variables et les constantes en chaîne de
caractères pour s’afficher dans la console Xcode avec print(_:). Il est possible d’afficher une chaîne de
caractères avec une variable ou une constante en précédant son nom d’un anti-slash et en l’entourant de
parenthèses :

1 print("La valeur actuelle de bonjourAmical est \(bonjourAmical)")

2 // Affiche "La valeur actuelle de bonjourAmical est Bonjour!"

Note : Toutes les options que vous pouvez utiliser sont expliquées plus en détails dans la partie
Interpolation des chaînes de caractères.

Les commentaires

Utilisez les commentaires pour inclure du texte non-exécutable dans votre code, comme une note à vous
même, pour ne pas oublier. Les commentaires sont ignorés par Swift lorsque que le code est compilé.

Les commentaires dans Swift sont très similaires aux commentaires en C. Pour les commentaires sur une
seule ligne, ils commencent par deux slashs (//) :

// Ceci est un commentaire

Vous pouvez aussi écrire des commentaires plus longs sur plusieurs lignes, qui commencent par un slash
suivi d’une astérisque (/) et finissent par une astérisque suivie d’un slash (/) :

1 /* Ceci est aussi un commentaire,

2 mais écrit sur plusieurs lignes */

Contrairement aux commentaires multi-lignes en C, les commentaires multi-lignes de Swift peuvent être
imbriqués à l’intérieur d’autres commentaires multi-lignes. Vous devez simplement commencer votre
commentaire comme s’il allait s’étendre sur plusieurs lignes et imbriquer chaque commentaires multi-
lignes de la même façon :

/* Ceci est le commencement de mon commentaire,

il s'étend sur plusieurs lignes

/* Je peux imbriquer un nouveau commentaire à l'intérieur,

qui peut lui-même s'étendre sur plusieurs lignes */

Ensuite je termine mon commentaire principal ici,

Et je n'oublie pas de le fermer */

Les commentaires multi-lignes imbriqués de la sorte permettent de commenter de larges blocs de code
rapidement et facilement, même si le code contient déjà d’autres commentaires multi-lignes.
Les points virgules

Contrairement à de nombreux langages, Swift n’a pas besoin qu’on lui indique la fin d’une action dans le
code par un point virgule, néanmoins vous pouvez le rajouter si cela vous fait plaisir !

Les points virgules ne sont pas requis pour les lignes simples qui ne comprennent qu’une seule action
mais sont indispensables pour séparer plusieurs actions que l’on souhaite mettre sur la même ligne.

1 let chat = "félin"; print(chat)

2 // affiche "félin"

Par soucis de lisibilité il est plus judicieux d’écrire un code plus aéré en sautant une ligne après chaque
action. Ainsi vous évitez de surcharger votre code avec des caractères inutiles et vous vous assurez une
lisibilité optimale. C’est également une recommandation à prendre en compte lorsque vous travaillez sur
des projets collaboratifs.

les entiers

Les entiers sont des nombres non-fractionnés comme 42 et -23. Les entiers possèdent un signe (positif,
zéro ou négatif) ou n’en possèdent pas si ils sont positifs ou égaux à zéro.

Swift prévoit des entiers avec ou sans signes sous la forme 8, 16, 32 et 64 bits. Ces entiers suivent des
conventions de nommage similaires au langage C, un entier sans signe en 8 bits est du type UInt8, et un
entier en 32 bits dont le signe est connu est du type Int32. Comme tous les types dans Swift, les types
d’entiers commencent par une lettre en majuscule.

Les limites des entiers

Vous pouvez accéder aux valeurs minimales et maximales de chaque type d’entier avec leurs propriétés
min et max :

1 let minValue = UInt8.min //minValue vaut 0 et est du type UInt8

2 let maxValue = UInt8.max //maxValue vaut 255 et est du type UInt8

Les valeurs de ces propriétés sont taillées en fonction du type du nombre entier (UInt8 dans l’exemple ci-
dessus) et peuvent être utilisées dans des expressions à côté de valeurs du même type.
Int

Dans la plupart des cas, vous n’aurez pas besoin de spécifier une taille spécifique pour vos entiers à
l’intérieur de votre code. Swift propose un type d’entier additionnel, Int, qui possèdent la même taille
que le système d’exploitation que vous utilisez :

• Sur les plateformes 32 bits, Int possède la même taille que Int32.

• Sur les plateformes 64 bits, Int possède la même taille que Int64.

Si vous n’avez pas besoin, de travailler avec une taille spécifique d’entier, utilisez toujours Int pour les
valeurs de vos entiers dans votre code. Cela facilite la cohérence et l’interopérabilité. Même si vous
travaillez dans un environnement 32 bits, avec Int vous pouvez stocker une valeur entre -2 147 483 648
et 2 147 483 647, et c’est surement largement assez grand pour la grande majorité des besoins !

UInt

Swift permet aussi d’avoir des entiers sans signe du type UInt, qui possède la même taille que le système
d’exploitation que vous utilisez :

• Sur les plateformes 32 bits, UInt possède la même taille que UInt32.

• Sur les plateformes 64 bits, UInt possède la même taille que UInt64.

Note : Utilisez UInt uniquement quand vous avez spécialement besoin d’un entier sans signe
avec la taille de votre plateforme (32 ou 64 bits). Si ce n’est pas le cas préférez Int même si vous savez
que la valeur ne sera jamais négative.

Les nombres à virgule flottante

Les nombres à virgule flottante sont des nombres avec une part fractionné comme 3.14159 ou -273.15.
La virgule est en en fait un point puisqu’on utilise ici la nomenclature anglo-saxonne pour séparer les
décimales de l’entier. On les appelle aussi plus communément les nombres à virgules.

Les types des nombres à virgules représentent une beaucoup plus large palette de valeurs possibles par
rapport aux types des entiers, et peuvent stocker des nombres beaucoup plus longs mais surtout
beaucoup plus petits que ce que peut faire le type Int. Swift propose deux types de nombres à virgules
dont le signe est connu :
 • Le type Double représente un nombre à virgule en 64 bits. Utilisez-le quand votre nombre à
virgule doit être très grand ou particulièrement précis.

• Le type Float représente un nombre à virgule en 32 bits. Utilisez-le quand votre nombre à
virgule ne requiert pas la précision d'un nombre en 64 bits.

Note : Le type Double possède une précision pouvant aller jusqu’à 15 décimales alors que le type
Float n’accepte que 6 chiffres après la virgule. le type de vos nombres à virgule dépend de vos besoins,
de la plateforme sur laquelle vous travaillez et de votre code.

Sécurité et déduction des types

Swift est un langage aux types sécurisés. Ce qui signifie qu’il vous encourage a être clair sur les types des
valeurs qui doivent intervenir dans votre code. Si un bout de votre code attend une chaîne de caractères
(String), vous ne pourrez pas passer avec un nombre entier (Int) par mégarde.

Parce-que Swift est un langage au type sécurisé, il vérifie tous les types lorsqu’il compile votre code et
vous indique les problèmes de types comme étant des erreurs. Cela vous permet de corriger le problème
rapidement et le plus tôt possible dans votre processus de développement.

La vérification des types vous aide à éviter les erreurs lorsque vous travaillez sur différents types de
valeurs. Cependant, cela ne veut pas dire que vous devez forcement spécifier le type de chaque
constante et de chaque variable que vous déclarez. Si vous ne spécifiez pas le type de vos valeurs, Swift
est capable de déduire le type approprié. La déduction des types permet au compileur de deviner le type
d’une expression particulière automatiquement lorsqu’il compile votre code, simplement en examinant
les valeurs que vous avez fourni.

À cause de la déduction des types, Swift requiert beaucoup moins de déclarations de type que des
langages comme le C ou l’Objective-C. Les constantes et les variables sont toujours explicitement typées,
et il n’est plus nécessaire de passer trop de temps là-dessus maintenant.

La déduction des types est particulièrement utile lorsque vous déclarez une constante ou une variable
avec une valeur initiale. Cela fonctionne aussi en assignant une valeur factice au moment de la
déclaration. Par exemple si votre variable est prédestinée à être et rester un entier (Int), vous pouvez la
déclarer avec un entier factice pour que le compileur déduise simplement son type tout au long de son
existence.

var variableTest = 42 // Le compileur déduit que variableTest est un Int

De même, si vous ne spécifiez pas le type d’une constante mais que vous lui donnez une valeur avec une
virgule, Swift comprendra qu’il s’agit d’un Double :

let pi = 3.14159 // pi est une constante de type Double

Swift choisi toujours le type Double pour les nombres à virgule flottante dont le type n’est pas spécifié
(plutôt que Float) pour permettre des extensions plus larges.

Si vous combinez une valeur factice comprenant un entier et un nombre à virgule, le type de l’expression
sera déduit comme étant un Double en fonction du contexte :

let autrePi = 3 + 0.141559 // autrePi est un Double

La valeur 3 n’a pas de type explicite et comme elle est additionnée avec une valeur comprenant un
nombre à virgule, autrePi est automatiquement défini comme un Double après avoir obtenu le résultat
de l’addition.

Les nombres littéraux

Une valeur littérale est une valeur qui contient des lettres représentant des chiffres. En général il s’agit
d’un code pouvant être interprété différemment en fonction ce que l’on souhaite obtenir.

Les entiers littéraux peuvent être écrits de différentes manières :

• Un nombre décimal, sans aucun préfixe

• Un nombre binaire, avec un préfixe 0b

• Un nombre octal, avec un préfixe 0o

• Un nombre hexadécimal, avec un préfixe 0x

Tous ces entiers littéraux correspondent à la valeur décimale de 17 :

1 let decimalEntier = 17

2 let binaireEntier = 0b10001 // 17 en binaire

3 let octalEntier = 0o21 // 17 en octal

4 let hexadecimalEntier = 0x11 // 17 en hexadécimal

Les nombres à virgule littéraux peuvent être décimaux (sans préfixe), ou hexadécimaux (avec le préfixe
0x). Ils doivent juste toujours avoir un nombre décimal (ou hexadécimal) de chaque côté de la virgule. Ils
peuvent aussi avoir un exposant optionnel, indiqué avec un e majuscule ou minuscule pour les nombres
décimaux et un p majuscule ou minuscule pour les nombres hexadécimaux.

Pour les nombres décimaux avec un exposant, la base du nombre est multipliée par 10exp :

• 1.25e2 signifie 1.25 x 10² ou 125.0

• 1.25e-2 signifie 1.25 x 10⁻² ou 0.0125

Pour les nombres hexadécimaux avec un exposant, la base du nombre est multipliée par 2exp :

• 0xFp2 signifie 15 x 2² ou 60.0

• 0xFp-2 signifie 15 x 2⁻² ou 3.75

Tous les nombres à virgule ci-dessous ont une valeur décimale de 12.1875 :

1 let decimalDouble = 12.1875

2 let exposantDouble = 1.21875e1

3 let hexadecimalDouble = 0xC.3p0

Les nombres littéraux peuvent contenir un formatage supplémentaire afin de les rendre plus lisibles.
Entiers comme nombres à virgule, peuvent être rembourrés avec des zéros supplémentaires et des
underscores pour aider à la lecture. En aucun cas, le formatage n’affecte la valeur du nombre littéral :

1 let decimalDouble = 000123.456

2 let unMillion = 1_000_000

3 let plusdunMillion = 1_000_000.000_000_1

N’oubliez pas cette astuce, elle peut s’avérer très pratique lorsque vous serez amené à manipuler des
nombres très très grands. Bien sur la technique des puissances et des exposants est une bonne manière
de réduire le nombre de caractères de votre code et d’utiliser la puissance des machines qui exécuteront
votre code, mais au moins vous êtes au courant !

Conversions entre types

Utilisez au maximum le type Int pour tous les nombres entiers de vos constantes et vos variables dans
votre code, même si vous êtes certain qu’il ne seront jamais négatif. Utilisez le type par défaut des
entiers dans chaque situation où vos constantes et vos variables sont immédiatement opérationnelles
avec votre code et que le compileur peut interpréter leurs types, même pour les valeurs littérales.

Utilisez un autre type d’entier uniquement quand vous en avez expressément besoin pour réaliser une
tâche particulière. Parce-qu’il s’agit d’un typage imposé par une source extérieure ou un autre langage,
pour la performance, l’utilisation de la mémoire ou d’autres optimisations nécessaires. Utiliser les types
explicites dans ces situations évite d’voir des types de valeurs accidentelles qui ne pourront pas
fonctionner avec le reste de votre code.

Conversions d’entiers

Le nombre total de chiffres qui peuvent être stocké dans un entier constant ou variable est différent en
fonction du type numérique. Une constante ou un variable du type Int8 peut stocker des nombres entre
-128 et 127 alors qu’une constante ou une variable du type UInt8 pourra stocker des nombres entre 0 et
255. Un nombre qui ne sera pas amené à rentrer dans cette fourchette autorisé par le typage numérique
des valeurs provoquera une erreur lors de la compilation :

1 let nonNegatif: UInt = -1

2 // UInt8 ne peut pas stocker de nombre négatif

3 let tropGros: Int8 = Int8.max + 1

4 // UInt8 ne peut pas stocker de nombre plus grand que sa valeur maximale

Parce-que chaque type numérique peut stocker une quantité différente de valeurs, vous devrez parfois
optez pour une conversion du type numérique au cas par cas. Cette approche vous aidera à convertir de
façon claire et explicite vos valeurs et ainsi éviter certaines erreurs dans votre code.

Pour convertir un type spécifique de nombre vers un autre, vous devez initialiser un nouveau nombre du
type désiré avec la valeur existante. Dans l’exemple suivant, la constante deuxMille est du type UInt16 et
l’autre constante un est du type Uint8. Elles ne peuvent pas être additionnée ensemble directement
parce-qu’elle ne possèdent pas le même type numérique. Du coup, cet exemple appelle Uint16(un) pour
créer un nouveau entier du type UInt16 initialisé avec la valeur de un et utilisant sa valeur à la place de
l’original :

1 let deuxMille: UInt16 = 2_000

2 let un: UInt8 = 1

3 let deuxMilleUn = deuxMille + UInt16(un)

Comme les deux côtés de l’addiction sont maintenant du type UInt16, l’opération est permise. Le résultat
en sortie de la constante deuxMilleUn est du type UInt16 parce-qu’elle est le résultat d’une addition
entre deux valeurs de type UInt16.

Dans Swift, Type(valeurInitiale) est le format par défaut pour initialiser une valeur et la passer dans un
autre type. Derrière le rideau, UInt16 possède un convertisseur qui accepte les valeurs du type UInt8, et
ce convertisseur est utilisé pour créer une nouvelle valeur en UInt16 depuis un typage UInt8 existant.
Vous ne pouvez pas passer n’importe quel type ici, uniquement les types qui sont prévus pour être
convertis avec UInt16. Il est possible de passer outre cette limitation en utilisant ou en développant des
extensions.

Conversion des entiers et des nombres à virgule

Les conversions entre les entiers et les nombres à virgules sont réalisés très simplement :

1 let trois = 3

2 let zeroPoint = 0.14159

3 let pi = Double(trois) + zeroPoint

4 // pi vaudra 3.14159 et son type sera convertit en "Double"

Ici, la valeur de la constante trois est utilisée pour créer une nouvelle valeur du type Double, du coup
l’addition est possible avec deux parties du même type. Sans cette conversion, l’opération n’aurait pas
été permise.

Il est également possible de faire l’inverse et de transformer le nombre à virgule en entier à condition de
lui fournir une valeur du type Double ou Float :

1 let entierPi = Int(pi)

2 // entierPi sera alors égal à 3 et du type Int

Les nombres à virgules sont toujours tronqués lorsqu’on les convertis de cette façon en créant un nouvel
entier. Ce qui veut dire que 4.75 devient 4, et -3.9 devient -3.

Note : Les règles pour combiner une constante ou une variable numérique sont différentes des
règles concernant les constantes et les variables littérales. La valeur littérale 3 peut directement être
ajoutée à la valeur littérale 0.14159, parce-que les nombres littéraux n’ont pas de type explicite. Leur
type est déterminé uniquement lors de la compilation.

Alias de types
Les alias de types permettent de définir un nom alternatif pour un type existant. Vous définissez votre
alias avec la fonction typealias.

Les alias de types sont utiles quand vous souhaitez vous référer à un type existant en utilisant un nom
qui est contextuellement plus approprié, par exemple quand vous travaillez sur des données possédants
une taille spécifique et provenant d’une source extérieure :

typealias AudioSample = UInt16

Une fois l’alias du type défini, vous pouvez utiliser cet alias n’importe où, à la place de l’endroit original
qui accueillait avant le type de la variable ou de la constante :

1 var amplitudeMax = AudioSample.min

2 // amplitudeMax vaut maintenant 0

Ici, AudioSample a été défini comme un alias du type UInt16, ce qui est plus clair pour le milieu de la
musique. Comme c’est un alias, appeler AudioSample.min revient en fait à appeler UInt16.min, ce qui
donne à la variable amplitudeMax la valeur 0.

Booléens et tuples

Swift possède un type de base, les Booléens, appelés Bool. Les valeurs booléennes sont définies comme
logiques, parce-qu’elles ne peuvent qu’être vraies ou fausses. Swift possède deux valeurs booléennes
constantes, true et false :

1 let orangeEstOrange = true

2 let navetEstDelicieux = false

Le type de orangeEstOrange et navetEstDelicieux a été définit comme Bool du fait que les deux
contantes ont été initialisées avec un valeur littérale booléenne. Comme pour les Int et les Double que
nous avons vu précédemment, vous n’avez pas besoin de déclarer vos variables ou vos constantes en
tant que Bool si vous leur attribuez la valeur true ou false lors de leur création. La déduction de type de
Swift vous aide à obtenir un code plus concis et lisible lorsque vous initialisez une constante ou une
variable avec une valeur dont le type est déjà connu.

Les valeurs booléennes sont particulièrement utiles quand vous travaillez avec des conditions, comme
c’est le cas par exemple avec if :

1 if navetEstDelicieux {

2 println("Mmmh ! Les navets gouteux !")

3 } else {

4 println("Beurk ! Les navets sont horribles !")

5}

6 // Le programme affichera "Beurk ! Les navets sont horribles !"

Les conditions comme le if sont expliquées plus en détails dans la partie “Flux de contrôle”.

La sécurisation des types de Swift empêche les valeurs non-booléennes de se substituer au type Bool.
L’exemple suivant provoque une erreur à la compilation :

1 let i = 1

2 if i {

3 // Cet exemple ne pourra pas être compilé !

4}

Cependant l’exemple alternatif ci-dessous est valide :

1 let i = 1

2 if i == 1 {

3 // Cet exemple pourra être compilé !

4}

Le résultat de i == 1 est une comparaison de type Bool, et dans ce second exemple, la vérification des
types ne posera pas de problème. Pour plus de détails référez-vous à la partie “Opérateurs de base”.

Comme avec les autres exemples sur la sécurisation des types du langage Swift, cette approche permet
d’éviter les erreurs accidentelles et assure que vos intentions sont toujours parfaitement retranscrites
dans chaque section de votre code.
Les tuples

Les Tuples servent à regrouper de nombreuses valeurs en un seule valeur composée unique. Les valeurs
d’un tuple peut être de n’importe quel type et n’ont pas forcement besoin d’être du même type les unes
par rapport aux autres.

Dans cet exemple, (404, "Introuvable") est un tuple décrivant un code d’erreur HTTP. Ce code d’erreur
HTTP est une valeur spéciale retournée par un serveur web lorsque vous souhaitez charger une page. Le
code 404 Introuvable est retourné si la page web demandée n’existe pas.

1 let erreur404Http = (404, "Introuvable")

2 // le code d'erreur est du type (Int, String) et égale à (404, Introuvable)

Le tuple (404, "Introuvable") regroupe ensemble un entier et une chaine de caractères pour produire un
code d’erreur HTTP composé de deux valeurs : un nombre pour la machine et une description
compréhensible pour l’homme. On dit que le type du tuple est (Int, String).

Vous pouvez créer des tuples avec n’importe quelle combinaison de types, ils peuvent contenir
beaucoup plus de deux valeurs et elles ne doivent pas nécessairement avoir le même type. Rien ne vous
empêche cependant d’avoir un tuple du type (Int, Int, Int), ou (String, Bool). Toutes les combinaisons
sont possibles.

Vous pouvez décomposer le contenu d’un tuple en plusieurs constantes ou variables séparées,
auxquelles vous accédez comme d’habitude :

1 let (codeErreur, messageErreur) = erreur404Http

2 println("Le code d'erreur est \(codeErreur)")

3 // Affiche "Le code d'erreur est 404"

4 println("Le message d'erreur est \(messageErreur)")

5 // Affiche "Le message d'erreur est Introuvable"

Si vous avez juste besoin de récupérer une partie des valeurs d’un tuple, vous pouvez ignorer les autres
parties en utilisant un underscore lors de la décomposition du tuple :

1 let (justeCodeErreur, _) = erreur404Http

2 println("Le code d'erreur est \(justeCodeErreur)")

3 // Affiche "Le code d'erreur est 404"

De façon alternative, vous pouvez accéder à la valeur d’un élément individuellement en utilisant son
index (commençant à zéro) :
1 println("Le code d'erreur est \(erreur404Http.0)")

2 // Affiche "Le code d'erreur est 404"

3 println("Le message d'erreur est \(erreur404Http.1)")

4 // Affiche "Le message d'erreur est 404"

Vous pouvez nommer chacun des éléments d’un tuple de façon individuelle lorsque vous initialisez votre
constante :

let erreur200Http = (codeErreur: 200, messageErreur: "OK")

Si vous nommez les éléments d’un tuple, vous pouvez utilisez le nom de ces éléments pour accéder à
leur valeur respective :

1 println("Le code d'erreur est \(erreur200Http.codeErreur)")

2 // Affiche "Le code d'erreur est 200"

3 println("Le message d'erreur est \(erreur200Http.messageErreur)")

4 // Affiche "Le message d'erreur est OK"

Les tuples sont particulièrement utile pour retourner des valeurs de fonctions. Une fonction qui essaie
de récupérer une page web pourrait retourner un tuple du type (Int, String) pour décrire si le
chargement de la page a été couronné de succès ou non. En retournant un tuple avec deux valeurs
distinctes, chacune d’un type différent, la fonction reçoit des informations beaucoup plus pertinente
qu’elle n’aurait pas forcement pu traiter efficacement s’il avait s’agit uniquement de valeurs du type
String. Pour plus d’informations, reportez-vous à la partie “Fonctions aux multiples valeurs”.

Note : Les tuples sont utiles pour stocker temporairement un groupe de valeurs. Elles ne sont
pas là pour créer une structure de données complexes. Si la structure de vos données requiert un
stockage sur la long terme, préférez une structure de vos données architecturées autour des classes,
plutôt qu’autour des tuples. Pour plus d’informations, référez-vous à la partie “Classes et structures”.

  Les optionnelles
On utilise les optionnelles dans une situation où une valeur pourrait venir à manquer. On utilise les
optionnelles quand :

• Il y a une valeur et elle est égale à x (où x est une inconnue)

• Il n'y a pas de valeur du tout

Note : Le concept des optionnelles n’existe pas en C ou en Objective-C. Ce qui s’en rapproche le
plus en Objective-C, c’est la possibilité de retourner une valeur nil depuis une méthode qui normalement
doit renvoyer un objet, et où nil signifie l’absence d’objet valide. Cependant cela ne marche qu’avec des
objets. Pour les autres types, l’Objective-C retourne une valeur spéciale (comme NSNotFound) pour
indiquer l’absence de valeur. Cette approche assume que lorsqu’on appelle une méthode, on connait à
l’avance ce qu’elle retourne où alors on doit effectuer des tas de tests manuels. Les optionnelles dans
Swift vous permettent d’indiquer l’absence de valeur dans n’importe quel cas et pour n’importe quel
type, sans avoir besoin de constantes spéciales.

Voici un exemple. Le type String de Swift possède une méthode appelée toInt, qui tente de convertir la
valeur d’une chaine de caractère en nombre entier de type Int. Néanmoins, toutes les chaines de
caractères ne peuvent pas forcement être traduites en nombre entier. La chaine "123" peut être
convertie en la valeur numérique 123, mais la chaine "hello, world" ne contenant aucun chiffre, ne
pourra pas être convertie.

L’exemple ci-dessous utilise la méthode toInt pour tenter la conversion d’une chaine de caractère (String)
en entier (Int) :

1 let nombreProbable = "123"

2 let nombreConverti = nombreProbable.toInt()

3 // la constante nombreProbable sera du type "Int?", ou "optional Int"

Comme la méthode toInt peut échouer, elle retourne un Int optionnel, plutôt qu’un Int. Un Int optionnel
sera écrit Int?, et non pas Int. Le point d’interrogation indique que la valeur que contient cette
optionnelles peut surrement contenir un Int, mais ce c’est pas une certitude. Elle pourra contenir
n’importe quoi d’autre comme une valeur booléenne ou une chaine de caractère. C’est soit un Int, soit
rien du tout.

Identifier le type d’une optionnelle avec if

Vous pouvez utiliser les conditions if, pour savoir si une optionnelle contient une valeur. Si une
optionnelle possède une valeur, elle est true, si elle n’en a pas, elle est false.

Une fois que vous êtes sûr que l’optionnelle contient une valeur vous pouvez forcer le changement de
son type en rajoutant un point d’exclamation à la fin du nom de l’optionnelle. Ce point d’exclamation
veut dire “Je suis sûr que cette optionnelle contient une valeur et je voudrais l’utiliser”. Cela permet en
quelque sorte de convertir le type de l’optionnelle en type définitif :
1 if nombreConverti {

2 println("\(nombrePossible) est un entier pour \(nombreConverti!)")

3 } else {

4 println("La valeur \(nombrePossible) ne peut pas être convertie")

5}

6 // Affiche "123 est un entier pour 123"

Pour plus d’informations sur les conditions avec if, reportez-vous à la partie “Flux de control”.

Note : Essayer d’utiliser le point d’exclamation pour accéder à une valeur optionnelle non-
existante causera une erreur de lecture. Assurez-vous que la valeur contient systématiquement autre
chose qu’une valeur nil avant d’utiliser le point d’exclamation pour forcer le type d’une valeur.

Les liaisons optionnelles

On utilise les liaisons optionnelles pour découvrir si une optionnelle contient une valeur, et si c’est le cas,
pour rendre cette valeur disponible à travers une constante ou une variable. Les liaisons optionnelles
peuvent être utilisées avec les conditions if et while afin de vérifier la présence de valeur à l’intérieur
d’une optionnelle, et pour extraire son contenu vers une variable ou une constante en une seule action.

Pour écrire une liaison optionnelle, procédez comme ceci (en utilisant if) :

1 if let nomConstante = uneOptionnelle {

2 actions

3}

Réutilisons l’exemple ci-dessus mais cette fois-ci en utilisant les liaisons optionnelles pour forcer le type
d’une optionnelle :

1 if let nombreActuel = nombrePossible.toInt() {

2 println("\(nombrePossible) est un entier pour \(nombreActuel!)")

3 } else {

4 println("La valeur \(nombrePossible) ne peut pas être convertie")

5}

6 // Affiche "123 est un entier pour 123"

Ce qui peut être lu : “Si l’entier optionnel retourné par nombrePossible.toInt contient une valeur, créer
une nouvelle constante appelée nombreActuel et contenant sa valeur.”

Si la conversion se passe bien, la constante nombreActuel deviendra disponible pour être utilisée dans la
première branche de la condition if. Elle a déjà été initialisée avec la valeur contenu dans l’optionnelle, et
donc il n’y a plus besoin d’ajouter de point d’exclamation pour accéder à la valeur. Dans cette exemple,
nombreActuel est simplement utilisé pour afficher le résultat de la conversion.

Vous pouvez utiliser aussi bien les constantes que les variables avec les liaisons optionnelles. Si vous
cherchez ensuite à manipuler la valeur de nombreActuel dans la première branche de la condition if,
vous pouvez utiliser une variable plutôt qu’une constante. Souvenez-vous, la valeur des constantes ne
peut pas être modifiée une fois définie.

nil

Vous pouvez créer une variable optionnelle en lui assignant la valeur spéciale nil :

1 var codeReponseServeur: Int? = 404

2 // codeReponseServeur contient la valeur 404 de type Int

3 codeReponseServeur = nil

4 // codeReponseServeur ne contient maintenant plus de valeur

Note : nil ne peut pas être utilisé si les variables ou les constantes ne sont sont pas des
optionnelles. Si une constante ou une variable dans votre code requiert l’absence de valeur, vous devez
toujours la déclarer comme optionnelle et du type approprié.

Si vous définissiez une contante ou une variable optionnelle sans lui donner de valeur par défaut, votre
constante ou votre variable se verra automatiquement attribuer la valeur nil :

1 var reponseSondage: String?

2 // reponseSondage vaut automatiquement nil

Note : Le nil de Swift n’est pas le même que le nil d’Objective-C. En Objective-C, nil est un
pointeur pour les objets non-existants. Dans Swift, nil c’est pas un pointeur, c’est l’absence de valeurs
pour un certain type. Les optionnelles de tous les types peuvent être déclaré avec la valeur nil, pas juste
les types d’objets.

Optionnelles implicites

Comme décrit plus haut, les optionnelles permettent à des constantes et des variables d’exister sans
avoir de valeur. On peut vérifier si une optionnelle contient une valeur avec la condition if, et grâce à ces
conditions il est possible de dévoiler leur contenus en utilisant les liaisons optionnelles.

Parfois, il est clair que depuis la structure du programme, une optionnelle aura forcement une valeur
après avoir été définie. Dans ce cas, il est utile de supprimer la possibilité de vérifier si l’optionnelle
contient ou non une valeur à chaque fois qu’on souhaite y accéder, parce-qu’on peut confirmer
l’existante d’une valeur à chaque fois.

Ces types d’optionnelles sont dites implicites. Une optionnelle implicite se déclare grâce au point
d’exclamation en remplacement du point d’interrogation à la fin de son type.

Les optionnelles implicites sont utilisées quand l’existence de la valeur d’une optionnelle est confirmée
immédiatement après avoir été définie. Dès lors on assume que son type et sa valeur existeront jusqu’à
la fin de l’exécution d’un programme. L’utilisation principale des optionnelles implicites dans Swift est fait
lors de l’initialisation des classes, comme expliqué dans la partie “Références inconnues et propriétés
des optionnelles implicites”.

Une optionnelle implicite ressemble en tout point à une optionnelle classique, sauf qu’elle peut être
utilisé en tant que valeur non-optionnelle, sans avoir besoin de dévoiler son contenu à chaque fois qu’on
y accède. L’exemple suivant montre la différence entre une chaine de caractères optionnelle et une
chaine de caractère implicitement non-optionnelle :

1 let chaineProbable: String? = "Une chaine optionnelle."

2 println(chaineProbable!) // Requiert un point d'exclamation

3 // Affiche "Une chaine optionnelle."

1 let chaineCertitude: String! = "C'est une chaine de caractères."

2 println(chaineCertitude) // Pas besoin de point d'exclamation

3 // Affiche "C'est une chaine de caractères."

Une fois que votre optionnelle est déclarée come implicite, vous pouvez l’utiliser comme une non-
optionnelle automatiquement. Plutôt que de placer un point d’exclamation à chaque fois que vous
souhaitez utiliser le nom de votre optionnelle, pensez à la déclarer directement avec ce point
d’exclamation si vous êtes sur de ce que vous faite.

Note : Si vous essayez d’accéder à une optionnelle déclarée implicite mais ne possédant aucune
valeur, le programme ne fonctionnera pas. Le résultat sera exactement le même en plaçant un point
d’exclamation derrière une optionnelle sans valeur.

Vous pouvez toujours traiter les optionnelles implicites comme des optionnelles classiques et vérifier si
elle contiennent une valeur :

1 if chaineCertitude {

2 println(chaineCertitude)

3}
4 // Affiche "C'est une chaine de caractères."

Vous pouvez aussi utiliser les optionnelles implicites avec les liaisons optionnelles pour vérifier leur
valeur en une seule action :

1 if let chaineDefinitive = chaineCertitude {

2 println(chaineDefinitive)

3}

4 // Affiche "C'est une chaine de caractères."

Note : Les optionnelles implicites ne devrait pas être utilisées lorsqu’il y a la possibilité qu’une
variable prenne la valeur nil plus tard dans le programme. Utilisez toujours les types optionnels si vous
pensez qu’une variable prendra à une moment la valeur nil.

  Les assertions

Les optionnelles vous autorisent à vérifier des valeurs qui peuvent exister ou ne pas exister, et à écrire du
code qui fonctionne sans problème même lorsqu’il n’y a pas de valeurs.

Dans certains cas néanmoins, il n’est simplement pas possible que votre code puisse continuer son
exécution si aucune valeur n’existe, ou si vous n’avez pas fourni de valeur adéquate. Dans ces situations,
vous pouvez déclencher une assertion dans votre code pour terminer son exécution et vous donner
l’opportunité de le debugger à l’endroit où elle détecte une valeur manquante ou invalide.

Debugger avec les assertions

Une assertion est une condition logique qui va stopper l’exécution de votre programme tant qu’elle ne
sera pas true. Littéralement, écrire une assertion signifie qu’elle doit être forcement vraie. Vous utiliserez
une assertion pour vous assurer qu’une condition est satisfaite avant d’exécuter la suite de votre
programme. Si la condition est évaluée à true, l’exécution du code continue de façon totalement
transparente. Si la condition est évaluée à false, l’exécution du code prend fin et votre application est
stoppée.

Si votre code déclenche une assertion alors qu’il s’exécute dans un environnement de débogage, comme
quand vous développez et testez votre application depuis Xcode, vous pourrez détecter exactement
l’endroit précis qui pose problème, là où une valeur manquante ou invalide a été détecté pendant
l’exécution du programme. Le message d’erreur provoqué par une assertion peut-être personnalisé et
vous aider à corriger plus rapidement les problèmes.

Vous écrivez une assertion en appelant la fonction globale assert. Donnez ensuite à la fonction assert
une expression à évaluer à true ou false, ainsi qu’un message qui ne sera affiché que lorsque que la
condition sera à false.
1 let age = -3

2 assert(age >= 0, "Une personne ne peut pas avoir un âge inférieur à zéro")

3 // Déclenche une assertion car l'âge est inférieur à 0

Dans cet exemple, l’exécution du code ne continuera uniquement que si age >= 0 est évalué à true, en
gros, si la valeur de age c’est pas négative. Si la valeur de age est négative, comme dans le bout de code
ci-dessus, alors la condition age >= 0 est évaluée à false et l’assertion est déclenchée, l’application est
stoppée.

Les messages d’assertion ne peuvent pas utiliser l’interpolation de chaînes de caractères. Le message
d’assertion n’est pas obligatoire et peut-être oublié si désiré :

1 assert(age >= 0)

Quand utiliser les assertions ?

Utilisez les assertions lorsqu’une condition peu potentiellement être fausse et doit forcement être vraie
pour que votre code puisse continuer de s’exécuter. Les scénarios appropriés à l’utilisation des assertions
sont :

• La valeur fournie peut être trop basse ou trop élevée

• Une valeur est fournie à une fonction, mais la valeur est invalide

• Une valeur optionnelle actuellement à nil, mais une valeur non nulle est requise

Note : Les assertions arrêtent votre application mais ne doivent pas être utilisées dans votre
application finale, elles sont là uniquement durant le processus de développement pour accélérer les
choses.

Introduction aux opérateurs de base

Un opérateur est un symbole spécial ou une phrase qui vous permet de vérifier, changer ou combiner
des valeurs. Par exemple, le signe + est un opérateur d’addition qui permet d’ajouter deux nombres
ensemble (comme dans let i = 1 + 2). Il est également possible d’utiliser des opérateurs plus complexes,
comme par exemple l’opérateur logique ET que l’on écrit && (comme dans if codePorte && scanRetine)
ou l’opérateur d’incrémentation ++i, qui est un raccourci pour ajouter la valeur 1 à i.

Swift supporte la plupart des opérateurs standards du langage C en améliorant certaines capacités pour
les rendre plus pratique et éliminer certaines erreurs récurrentes de codage. L’opérateur d’assignement =
ne retourne aucune valeur, pour éviter qu’il soit utilisé par erreur lorsque l’opérateur d’égalité == est
attendu. Les opérateurs arithmétiques (+, -, *, /, % et beaucoup d’autres) détectent et empêchent les
débordements de valeurs, pour prévenir de tout résultat inattendu lorsque l’on travaille avec des
nombres qui deviennent plus grands ou plus petits que ce qu’autorise leurs types respectifs. Vous pouvez
travaillez avec les débordements de valeurs en utilisant les opérateurs de débordement, décrit dans la
partie Opérateurs de débordement.

Contrairement au langage C, Swift permet de calculer le reste (%) d’une division entre nombres à virgule.
Swift propose aussi deux opérateurs de plage (a..b et a...b), dont le C ne dispose pas pour exprimer un
raccourci entre une plage de valeurs.

Ce cours décrit les opérateurs communs du langage Swift. Les opérateurs avancés, présentés dans la
partie Opérateurs avancés, vous permettent de définir vos propres opérateurs personnalisés et
d’implémenter les opérateurs standards pour vos propres types personnalisés.

Terminologie

Les opérateurs sont unaires, binaires ou ternaires :

• Les opérateurs unaires interviennent sur une cible seule (comme dans -a). Les opérateurs
unaires apparaissent immédiatement avant la cible (comme dans !b), et immédiatement après leur cible
(comme dans i++).

• Les opérateurs binaires interviennent sur deux cibles (comme dans 2 + 3) et apparaissent entre
ces deux cibles.

• Les opérateurs ternaires interviennent sur trois cibles. Comme en C, Swift n'a qu'un seul
opérateur ternaire, l'opérateur ternaire de condition (a ? b : c).

Les valeurs que ces opérateurs affectent sont des opérandes. Dans l’expression 1 + 2, le symbole + est un
opérateur binaire et les deux opérandes sont les valeurs 1 et 2.

L'opérateur d'assignement

L’opérateur d’assignement (a = b) initialise ou met à jour la valeur de a avec la valeur de b. La partie à

gauche de l’opérateur prend la valeur de la partie à sa droite :

1 let b = 10

2 var a = 5

3a=b

4 // a est maintenant égal à 10

Si la partie droite de l’assignement est un tuple avec plusieurs valeurs, ses éléments peuvent être
décomposés à l’intérieur de multiples contantes ou variables à la fois :

1 let (x, y) = (1, 2)

2 // x est égal à 1, et y est égal à 2

Contrairement à l’opérateur d’assignement en C et en Objective-C, l’opérateur d’assignement du langage

Swift ne se retourne aucune valeur. Le bout de code ci-dessous n’est pas valide :

1 if x = y {

2 // Ce n'est pas valide, x = y ne retourne aucune valeur

3}

Cette fonctionnalité empêche l’opérateur d’assignement d’être utilisé accidentellement alors que
l’opérateur d’égalité est attendu. En rendant invalide l’opération if x = y, Swift vous aide à éviter ce type
d’erreur dans votre code.

>

Opérateurs arithmétiques

Swift supporte quatre opérateurs arithmétiques standards pour tous les types de nombres :

• Les additions (+)

• Les soustractions (-)

• Les multiplications (*)

• Les divisions (/)

11+2 // égal à 3

25-3 // égal à 2

32*3 // égal à 6

4 10.0 / 2.5 // égal à 4.0

Contrairement aux opérateurs arithmétiques en C et en Objective-C, les opérateurs arithmétiques du

langage Swift ne permettent pas aux valeurs de déborder par défaut. Pour réaliser ce type d’opération,
vous devrez utiliser les opérateurs de débordement (comme dans a &+ b). Voir la partie Opérateurs de
débordement.

L’opérateur d’addition est aussi supporté pour la concaténation entre chaîne de caractères :

"hello, " + "world" // égal à "hello, world"

Il est possible d’utiliser des valeurs de types character, comme des émoticones avec les opérateurs
numériques. Ils répondent aux même règles que les chaînes de caractères.

La division avec reste

L’opérateur numérique qui sert a effectuer des divisions avec reste correspond au signe pourcentage sur
votre clavier (%). dans l’opération a % b, la division avec reste permet de calculer combien de multiple de
b se trouve dans a et ensuite de retourner le restant indivisible (le reste).

Note : L’opérateur de division avec reste est aussi connu sous le nom d’opérateur modulo dans
d’autres langages. Toutefois, son comportement dans Swift pour les nombres négatifs signifie qu’il est à
proprement parlé, un reste plutôt qu’une opération de type modulo.

Voilà comment la division avec reste fonctionne. Pour calculer 9 % 4, la première chose à faire de savoir
combien de fois le chiffre 4 rentre entièrement dans l’entier 9 :

On peut mettre deux fois 4 à l’intérieur 9, et il reste 1, indivisible par le chiffre 4 (en orange). Dans Swift
on pourrait l’écrire :

9 % 4 // égal à 1

Pour déterminer la réponse de a % b, l’opérateur de division avec reste calcule l’équation ci-dessous et
retourne le reste :

a = ( b * multiplicateur ) + reste

Lorsque le multiplicateur est le nombre le plus large des multiples de b il est indiqué dans a. Insérez 9
dans l’équation pour vérifier :
9=(4*2)+1

La même méthode est appliquée lorsque vous calculez le reste d’une valeur négative de a :

-9 % 4 // égal à -1

-9 = ( 4 * -2 ) + -1 // le reste vaut -1

Le signe de b est ignoré pour les valeurs négatives de b. Ce qui signifie que a % b et a % -B donneront
toujours le même résultat.

Calculer le reste avec des nombres à virgule

Contrairement à l’opérateur de division avec reste en C et en Objective-C, Swift permet d’effectuer ce

genre d’opération avec des nombres à virgule :

8 % 2.5 // égal à 0,5

Dans cet exemple, 8 divisé par 2.5 vaut 3, et il reste 0.5. L’opérateur numérique retourne une valeur du
type Double.

Opérateurs d’incrémentation et de décrémentation

Comme en C, Swift dispose d’un opérateur d’incrémentation (++) un d’un opérateur de décrémentation
(--) agissant comme des raccourcis pour augmenter ou diminuer la valeur d’une variable numérique par
1. Vous pouvez utiliser ces opérateurs avec des variables de n’importe n’importe quel type numérique.

1 var i = 0

2 ++i // i vaut maintenant 1

Chaque fois que vous appelez i++, la valeur de i est incrémentée de 1. Essentiellement, i++ est un
raccourcis pour l’opération i = i + 1. Du coup, i-- peut être utilisé comme raccourcis pour i = i - 1.

Les symboles ++ et -- peuvent être utilisés comme préfixe ou comme suffixe. ++i et i++ sont deux
solutions valides pour incrémenter la valeur de i par 1. Idem avec l’opérateur --, qui peut se placer avant
ou après la variable concernée pour décrémenter une valeur.

Notez que ces opérateurs modifient i et retournent systématiquement une valeur. Si vous voulez juste
incrémenter ou décrémenter la valeur stockée dans i, vous pouvez ignorer la nouvelle valeur retournée.
Il faut aussi savoir que si l’opérateur est placé avant la variable, il incrémente la variable avant de
retourner sa valeur. S’il est placé après, il incrémente la variable après avoir retourné sa valeur. Par
exemple :

1 var a = 0
2 letb = ++a

3 // a et b valent maintenant tous les deux 1

4 letc = a++

5 // a est maintenant égal à 2, mais c a été initialisé avec la valeur 1

Dans l’exemple ci-dessus, let b = ++a incrémente a avant de retourner sa valeur. Voilà pourquoi a et b
valent tous les deux 1.

Cependant, let c = a++ incrémente a après avoir retourné sa valeur. Donc c est initialisé avec l’ancienne
valeur de a et récupère la valeur 1. Ensuite a est incrémenté et vaut au final 2.

A moins que vous en ayiez vraiment besoin, il est recommandé d’utiliser ++i et --i dans tous les cas, afin
d’éviter les confusions et les erreurs de valeurs.

Opérateur unaire “Moins”

Le symbole numérique - utilisé normalement pour les opérations numériques comme la soustraction
peut aussi être utilisé comme opérateur unaire devant une variable ou une constante de type numérique
:

1 let trois = 3

2 let moinsTrois = -trois // moinsTrois vaut -3

3 let plusTrois = -moinsTrois // plusTrois vaut 3 (--3)

Cet opérateur unaire est mit directement avant la valeur sur laquelle il faut opérer, sans espace.

Opérateur unaire “Plus”

Comme l’opérateur unaire précédent, il existe aussi la version normalement utilisée avec les additions
qui, devant une variable ou une constante de type numérique, retourne simplement la valeur sans aucun
changement :

1 let moisHuit = -8

2 let tjsMoinsHuit = +moinsHuit // tjsMoinsHuit vaut -8 (+-8)

L’opérateur unaire + ne sert pas à grand chose en fait. Vous pouvez l’utiliser pour permettre une
meilleure compréhension de votre code mais il est totalement facultatif.

Opérateurs d'affectation combinés

Comme en C, Swift possède des opérateurs d’affectation qui combinent le signe d’assignement (=) avec
une autre opération. Voyons un exemple avec le signe de l’addition (+) :

1 var a = 1

2 a += 1 // a vaut maintenant 3

L’expression a += 2 est un raccourcis pour a = a + 2. L’addition et l’assignement sont combinés en un seul

opérateur qui effectue les deux taches en même temps.

Note : L’opérateur d’affectation combiné ne retourne pas de valeur. Vous ne pouvez pas écrire let
b = a += 2, pour cet exemple. C’est différent de l’opérateur d’incrémentation dont nous avons parlé plus
haut.

Vous pouvez retrouver la liste complète des opérateurs d’assignement dans la partie “Expressions”.

>

Opérateurs de comparaison

Swift supporte tous les opérateurs de comparaison standards que l’on retrouve aussi dans le langage C :

• Égal à (a == b)

• Non égal à (a != b)

• Plus grand que (a > b)

• Plus petit que (a < b)

• Plus grand ou égal à (a >= b)

• Plus petit ou égal à (a <= b)

Note : Swift apporte aussi deux opérateurs d’identité (=== et !==), qui sont utilisé pour tester les
cas où deux références d’objets réfèrent tous les deux à la même instance. Pour plus d’informations,
consultez le chapitre “Classes et structures”.

Chaque opérateur de comparaison retourne une valeur booléenne pour indiquer si la comparaison est
vraie ou fausse :
1 1 == 1 // "true", 1 est égal à 1

2 2 != 1 // "true", 2 n'est pas égal à 1

32>1 // "true", 2 est plus grand que 1

41<2 // "true", 1 est plus petit que 2

5 1 >= 1 // "true", 1 est plus grand ou égal à 1

6 2 <= 1 // "false", 2 n'est pas plus petit ou égal à 1

Les opérateurs de comparaisons sont aussi utilisés avec les conditions, comme par exemple avec if :

1 let nom = "world"

2 if nom == "world" {

3 println("hello, world")

4 } else {

5 println("Désolé \(nom), je ne vous reconnait pas")

6}

7 // Affiche "hello, world", car nom est égal à "world"

  Opérateur conditionnel ternaire

L’opérateur conditionnel ternaire est un opérateur spécial avec trois parties et qui prend la forme
suivante : question ? réponse1 : réponse2. C’est raccourcis pour évaluer deux expressions en même
temps avec une seule question. Si la question est true, il renvoie des valeurs pour réponse1 et réponse2.

L’opérateur conditionnel ternaire sert à raccourcir les bouts de code comme celui-ci :

1 if question {

2 reponse1

3 } else {

4 reponse2
5}

Voici un exemple pour calculer la hauteur en pixel de la colonne d’un tableau. La colonne doit être 50
pixels plus haute que la hauteur de son contenu, uniquement si elle possède une en-tête, et 20 pixels
plus haute si elle n’en possède pas :

1 let hauteurContenu = 40

2 let enTete = true

3 let hauteurColonne = hauteurContenu + (enTete ? 50 : 20)

4 // hauteurColonne vaut maintenant 90

C’est beaucoup plus court que la version sans opérateur conditionnel ternaire :

1 let hauteurContenu = 40

2 let enTete = true

3 var hauteurColonne = hauteurContenu

4 if enTete {

5 hauteurColonne = hauteurColonne + 50

6 } else {

7 hauteurColonne = hauteurColonne + 20

8}

9 // hauteurColonne vaut maintenant 90

Le premier exemple utilise l’opérateur conditionnel ternaire pour régler correctement la valeur de
hauteurColonne en une seule ligne de code. C’est beaucoup plus court que dans le second exemple, et
ça évite d’initialiser hauteurColonne comme une variable.

L’opérateur conditionnel ternaire permet de raccourcir considérablement votre code dans ce type de cas
précis. Prenez néanmoins conscience qu’il ne facilite pas forcement la lecture du code et pourra poser
problème si vous travaillez à plusieurs sur le même projet.

Opérateur d'union nil

L’opérateur d’union nil (a ?? b) déclare une optionnelle a si elle contient une valeur, ou retourne par
défaut la valeur de b si a est nil. L’expression a est toujours du type optionnel. L’expression b doit
coïncider avec le type qui est stocké à l’intérieur de a.

L’opérateur d’union nil est présenté de façon raccourci pour le code suivant :

a != nil ? a! : b

Le code ci-dessus utilise l’opérateur conditionnel ternaire et force l’ouverture (a!) pour accéder à la
valeur à l’intérieur de a quand a n’est pas nil, et à retourner b le cas échéant. L’opérateur d’union nil
permet d’une façon plus élégante de combiner la vérification conditionnelle tout en dévoillant les
valeurs d’une manière concise et plus simple à lire.

Note : Si la valeur de a est non-nil, la valeur de b n’est pas prise en compte. C’est une évaluation
en circuit court.

L’exemple suivant utilise l’opérateur d’union nil pour choisir entre une couleur par défaut et une couleur
optionnelle sélectionnée par l’utilisateur :

1 let couleurDefaut = "rouge"

2 var couleurUtilisateur: String? // nil par défaut

4 var couleurDefinitive = couleurUtilisateur ?? couleurDefaut

5 /* L'utilisateur n'a pas définit de couleur

6 couleurUtilisateur vaut nil

7 du coup couleurDefinitive est fixée à "rouge" */

La variable couleurUtilisateur est définie en tant qu’optionnelle de type String, avec une valeur par
défaut à nil. C’est parce-que couleurUtilisateur est du type optionnel que l’on peut utiliser ici l’opérateur
d’union nil afin d’obtenir à coup sur une valeur pour couleurDefinitive.

Comme couleurUtilisateur est nil, l’expression couleurUtilisateur ?? couleurDefaut retourne la valeur de

couleurDefaut, soit “rouge”.

Si vous assignez une valeur non-nil à couleurUtilisateur et utilisez l’opérateur d’union à nouveau, la
valeur par défaut deviendra alors celle définie par l’utilisateur :

1 couleurUtilisateur: "vert"

2 couleurDefinitive = couleurUtilisateur ?? couleurDefaut

3 /* couleurUtilisateur ne vaut plus nil

4 du coup couleurDefinitive est fixée à "vert" */

  Opérateurs d'intervalles

Swift inclut deux opérateur d’intervalles, qui sont des raccourcis pour exprimer une fourchette de
valeurs.

Opérateur d’intervalle fermé

L’opérateur d’intervalle fermé (a...b) définit une intervalle de valeurs entre a et b en incluant également
les valeurs de a et de b.

L’opérateur d’intervalle fermé est très utile pour agir sur une plage de valeur sans avoir besoin de toutes
les citer. Il est très utilisé dans les boucles de type for-in :

1 for index in 1...5 {

2 println("\(index) multiplié par 5 vaut \(index * 5)")

3}

4 // 1 multiplié par 5 vaut 5

5 // 2 multiplié par 5 vaut 10

6 // 3 multiplié par 5 vaut 15

7 // 4 multiplié par 5 vaut 20

8 // 5 multiplié par 5 vaut 25

Pour plus d’information sur les boucles for-in, reportez-vous à la rubrique “Contrôle de flux”.

Opérateur d’intervalle semi-fermé

L’opérateur d’intervalle semi-fermé (a..b) définit une intervalle de valeurs entre a et b démarrant et
incluant a, mais n’incluant pas b. Voilà pourquoi on dit qu’il est semi-fermé.

Les intervalles semi-fermées sont particulièrement utiles lorsque vous travaillez avec des tableaux
(array), dont la première clé d’index commence à zéro. Dans ce cas précis, vous savez où la liste démarre
mais vous ne savez pas où elle se termine :

1 let noms = ["Anna", "Alex", "Brian", "Jack"]

2 let compteur = noms.count

3 for i in 0..compteur {

4 println("La personne n° \(i + 1) est appelée \(noms[i])")

5}

6 // La personne n°1 est appelée Anna

7 // La personne n°2 est appelée Alex

8 // La personne n°3 est appelée Brian

9 // La personne n°4 est appelée Jack

Notez que le tableau contient 4 objets, mais 0..compteur ne compte que jusqu’à 3 (la clé du dernier
objet dans le tableau), comme il s’agit d’une intervalle semi-fermée. Pour plus d’informations reportez-
vous à la section “tableaux”.

Les opérateurs logiques

Les opérateurs logiques modifient ou combinent deux valeurs booléennes logiques true et false. Swift
supporte les trois opérateurs logiques standards que l’on retrouve dans les langages basés sur le C :

• L'opérateur logique NOT (!a)

• L'opérateur logique AND (a && b)

• L'opérateur logique OR (a || b)

Opérateur logique NOT

L’opérateur logique NOT (!a) inverse la valeur d’un booléen, true devient false et false devient true.

L’opérateur logique NOT est toujours un préfixe, il apparait immédiatement avant la valeur sur laquelle il
opère, sans ajouter d’espace. Il peut être lu de la façon suivante : “n’est pas a“, comme vous pouvez le
voir dans l’exemple ci-dessous :

1 let entreeAutorise = false

2 if !entreeAutorise {
3 println("ACCÈS REFUSÉ")

4}

5 // Affiche "ACCÈS REFUSÉ"

La phrase if !entreeAutorise peut être lue “Si l’entrée n’est pas autorisé”. La ligne suivante est exécutée
uniquement si l’entrée non autorisée est true. Dans cet exemple choisissez bien le nom de vos variables
et de vos constantes booléennes, pour obtenir un code plus lisible et compréhensible, pour prévenir les
doubles négatives ou les confusions.

Opérateur logique AND

L’opérateur logique AND (a && b) crée une expression logique ou les deux valeurs doivent être true pour
que l’ensemble de l’expression soit aussi true. Si l’une des deux valeurs est false, l’expression devient
aussi false. En réalité, si la première valeur est false, la seconde valeur n’est même pas évaluée, car il est
impossible qu’au final l’expression puisse être true.

Cet exemple initialise deux constantes booléennes et n’autorise l’accès que si elles sont toutes les deux à
true :

1 let codePorte = true

2 let scanRetinien = false

3 if codePorte && scanRetinien {

4 println("Welcome !")

5 } else {

6 println("ACCÈS REFUSÉ")

7 }// Affiche "ACCÈS REFUSÉ"

Opérateur logique OR

L’opérateur logique OR (a || b) se place toujours entre deux valeurs et correspond à barres parallèles
adjacentes. Ce caractère est facile à trouver sur un clavier Windows, pour Mac il faudra presser les
touches ALT + SHIFT + L.

L’opérateur logique OR permet de créer une expression logique où l’une ou toutes les valeurs de
l’expression valent true. Si c’est le cas alors l’expression complète vaut elle aussi true.

Comme pour l’opérateur logique AND vu ci-dessus, l’opérateur logique OR n’analysera pas les autres
valeurs de l’expression si la première est déjà à true. Il est évident que du coup toute l’expression sera
forcement à true.
Dans l’exemple ci-dessous, le premier booléen est false mais la seconde valeur est true. L’expression
complète est évaluée à true et l’accès est autorisé :

1 let clePorte = false

2 let reinitialisationCode = true

3 if clePorte || reinitialisationCode {

4 println("Welcome !")

5 } else {

6 println("ACCÈS REFUSÉ")

7 }// Affiche "Welcome !"

Combiner les opérateurs logiques

Vous pouvez combiner de nombreux opérateurs logiques pour créer de plus longues expressions à faire
vérifier par votre code :

1 if codePorte && scanRetinien || clePorte || reinitialisationCode {

2 println("Welcome !")

3 } else {

4 println("ACCÈS REFUSÉ")

5 }// Affiche "Welcome !"

Cet exemple utilise de nombreux opérateurs logiques comme && et || pour créer une expression plus
longue. Cependant, les opérateurs && et || n’opèrent chacun uniquement que sur deux valeurs, du
coup il s’agit ici en fait de trois plus petites expressions collées les unes aux autres.

L’expression peut être lue : “Si j’ai entré correctement le code de la porte et passé avec succès le scan
rétinien; ou si j’ai la clé de la porte; ou je sais réinitialiser le code, alors je suis autorisé à entrer”.

En se basant sur les valeurs des constantes que nous avons initié dans nos exemples, la première
expression est false. Cependant je sais réinitialiser le code d’entrée, du coup l’expression complète est
true. La suite de l’expression n’a pas besoin d’être analysée puisqu’elle sera forcement true.

En ajoutant des parenthèses

Si le cours des opérations de vérifications effectuées par les opérateurs logiques ne vous convient pas,
vous pouvez ajouter des parenthèses pour séparer les expressions de l’expressions globale comme bon
vous semble. Même si vos parenthèses ne modifient pas la façon dont est interprétée l’expression
globale, elles peuvent faciliter la lecture de votre code. Dans l’exemple des portes de de leur code
d’accès, il peut être utile d’ajouter des parenthèses pour faciliter la compréhension de l’expression
globale :

1 if (codePorte && scanRetinien) || clePorte || reinitialisationCode {

2 println("Welcome !")

3 } else {

4 println("ACCÈS REFUSÉ")

5 }// Affiche "Welcome !"

Les parenthèses montrent plus clairement que les deux premières constantes sont considérée comme
une expression à part entière de l’expression globale. Le résultat n’est pas affecté pour autant,
l’expression est toujours true, néanmoins l’expression globale est beaucoup lisible ainsi.

Introduction aux chaînes de caractères

Une chaîne est une suite ordonnée de caractères, tel que “Hello, world” ou “Albatros”. Les chaînes dans
Swift sont représentées par le type String (chaîne), qui à son tour représente une collection de valeurs du
type Character.

Les chaînes de caractères fournissent un moyen rapide de travailler avec du texte brut dans votre code.
La syntaxe pour la création et la manipulation des chaînes avec Swift est similaire à la syntaxe en langage
C. Les chaînes de caractères peuvent être facilement concaténées les unes à la suite des autres grâce au
symbole + et stockée dans une variable ou une constante comme n’importe quelle autre valeur en Swift.

En plus de la simplicité de sa syntaxe, l’implémentation des chaines en Swift est moderne et rapide.
Chaque chaîne est composée de plusieurs caractères Unicode indépendants, et fournit le moyen accéder
à ces caractères un par un de différente façon.

Les chaînes peuvent aussi être utilisées avec les constantes, les variables, les littéraux, et d’autres
expressions via un procédé d’interpolation. Ceci rend plus facile la création de valeurs personnalisées
pour l’affichage, le stockage, et l’impression.

Note : Le type String en Swift ressemble beaucoup à la classe NSString de Foundation. Si vous
travaillez avec le framework Foundation pour Cocoa et Cocoa Touch, l’API complète NSString est
accessible lorsque vous appelez ou créez une valeur de type String. Vous pouvez aussi utiliser une valeur
String avec n’importe quelle API qui requiert une instance NSString.
Les chaînes de caractères littérales

Vous pouvez prédéfinir à l’avance les valeurs de type String en indiquant une suite de chiffre ou de
lettres entourées par des guillemets (" ").

Une chaîne de caractères peut être utilisée pour fournir une valeur initiale à une constante ou une
variable :

var uneChaine = "Une chaine de caractères"

Noter que Swift devine le type String pour la variable uneChaine parce qu’elle a été initialisée avec une
chaîne de caractères littérale.

Les chaînes de caractères peuvent inclure les caractères spéciaux suivants :

• Les caractères spéciaux "échappés" : \0 (caractère nul), \\ (antislash), \t (tabulation

horizontale), \n (saut de ligne), \r (retour en début de ligne), \" (guillemet) et \' (apostrophe)

• Un octet scalaire Unicode, écrit comme \xnn, où nn sont deux chiffres hexadécimaux.

• Deux octets scalaires Unicode, écrit comme \unnnn, où nnnn son quatre chiffres
hexadécimaux.

• Quatre octets scalaires Unicode, écrit comme \Unnnnnnnn, où nnnnnnnn son huit chiffres
hexadécimaux.

Le code ci-dessous montre un exemple de chaque sorte de caractères spéciaux. La constante motSavant
contient deux caractères spéciaux “échappés”. Les constantes signeDollar, coeurNoir et coeurScintillant
montrent que les trois formats différents de caractères scalaires Unicode :

1 let motSavant = "\"L'imagination est plus importante que la connaissance\" - Einstein"

2 let signeDollar = "\x24" // scalaire Unicode $ (U+0024)

3 let coeurNoir = "\u2666" // scalaire Unicode ♥ (U+2666)

4 let coeurScintillant = "\U0001F476" // scalaire Unicode (U+1F476)

Note : Pour plus d’information sur les Octets scalaires, nous vous renvoyons sur le site :
http://www.ascii-code.com ou vous trouverez tous les caractères spéciaux au format Decimal, Octal
(celui que nous venons de voir), Hexadecimal, Binaire, Symbolique et HTML.
Initialiser une chaîne vide

Pour créer une valeur de type String en tant que point de départ, vous pouvez assigner une chaîne vide à
une variable ou initialiser votre instance directement avec cette syntaxe :

1 var chaineVide = ""

2 var autreChaineVide = String()

3 // Ces deux chaînes sont vides et sont équivalentes.

Vous pouvez deviner si la valeur d’une chaîne est vide en utilisant la propriété booléenne isEmpty :

1 if chaineVide.isEmpty {

2 println("la chaine est vide")

3}

Modifier une chaîne de caractères

Pour indiquer si une chaîne peut être modifiée assignez-là à une variable (dans ce cas elle peut être
modifiée), ou à une constante (dans ce cas là ne peut pas être modifiée) :

1 var chaineVariable = "Chevaux"

2 chaineVariable += " et poneys"

3 // chaineVariable vaut maintenant "Chevaux et poneys"

5 let chaineConstante = "Timon"

6 chaineConstante += " et Pumba"

7 // Le compilateur rapporte une erreur : un constante ne peut pas être modifiée

 Note : Cette approche est différente des chaînes modifiables en Objective-C et Cocoa, ou vous
pouviez choisir entre deux classes (NSString et NSMutableString) pour indiquer si une chaîne peut être
modifiée.

Les chaînes sont des types de valeurs

Le type String dans Swift est un type de valeur. Si vous créez une nouvelle valeur String, cette valeur est
copiée quand elle est passée à une fonction ou une méthode, ou quand elle est assignée à une constante
ou une variable. Dans chaque cas, une nouvelle copie de la valeur est créée, et la nouvelle copie est
passée ou assignée, mais pas la version originale. Les types de valeurs sont décrites dans Structure et
Enumérateur, types de valeurs.

Note : Ce comportement diffère de celui de NSString dans Cocoa. Quand vous créez une instance
NSString dans Cocoa, et la passez dans une fonction, une méthode ou une variable, vous assignez
toujours une référence au même NSString. Aucune copie de la chaîne ne prend sa place, à moins que
vous ne l’ayez spécifiquement demandé.

Dans Swift, le comportement des chaînes de caractères est toujours strictement respecté. Lorsque vous
envoyez une valeur de type String à une fonction ou une méthode, c’est strictement la valeur que vous
avez entré qui est utilisée et jamais autre chose.

Certains langages modifient légèrement les chaînes pour les adapter aux spécificités du langages, ce qui
peut parfois provoquer certains comportements inattendu.

Le compileur Swift optimise l’utilisation des chaînes, et ne prend jamais de ressources supperflues pour
leur gestion. Ce qui signifie que vous obtiendrez toujours de bonnes performances lorsque vous
travaillerez avec des valeurs de type String.

>

Travailler avec les caractères

Vous pouvez accéder individuellement à chaque caractère d’une chaîne de type String grâce à la boucle
for-in.

1 for caractere in "Lune!🌙".characters {

2 print(caractere)

3}

4 // L

5 // u

6 // n

7 // e

8 // !

9 // 🌙

Alternativement, vous pouvez créer une constante ou une variable du type Character en l’initialisant
exactement comme une chaîne de type String, mais en lui attributant le type Character :

let pointExclamation: Character = "!"

Les chaînes de caractères peuvent être construite en leur fournissant un tableau de valeurs de type
Character lors de leur initialisation :

let luneCaracteres: [Character] = ["L", "u", "n", "e", "!", "🌙"]

let luneChaine = String(luneCaracteres)

print(luneChaine)

// Affiche dans la console "Lune!🌙"

Concaténer les chaînes et les caractères

Les valeurs des chaînes peuvent être ajoutées ensemble (ou concaténées) avec l’opérateur d’addition (+)
pour créer une nouvelle chaîne.

1 let chaine1 = "salut"

2 let chaine2 = " toi"

3 var bienvenue = chaine1 + chaine 2

4 // bienvenue vau maintenant "salut toi"

Vous pouvez aussi ajouter la valeur d’une chaîne à une variable de type String existante avec l’opérateur
d’affectation et d’addition (+=) :

1 var instruction = "regarde"

2 instruction += chaine2

3 // instruction vaut maintenant "regarde toi"

Vous pouvez aussi ajouter un caractère à une variable de type String grâce à la méthode append() :

1 let pointExclamation: Character = "!"

2 bienvenue.append(pointExclamation)

3 // bienvenue vau maintenant "salut toi!"

Note : Vous ne pouvez pas ajouter une chaîne ou un caractère à une variable de type Character
existante, parce-que ce type de variable (ou de constante) ne doit contenir qu’un seul caractère
uniquement.

  L'Unicode

L’Unicode est un standard internationnal de l’encodage dans différents systèmes d’écriture. Il vous
autorise à utiliser pratiquement tous les caractères depuis n’importe quelle langue dans une forme
standardisée, et à lire et écrire ces caractères, pour et depuis, une source externe, comme un fichier
texte ou une page web.

Les chaînes et les caractères en Swift sont totalement comformes avec l’Unicode, comme nous allons le
voir dans cette section.

Les valeurs scalaires en Unicode

Dans les rouages du langage, le type String natif de Swift a été construit depuis les valeurs de l’Unicode
scalaire. Un scalaire Unicode est un nombre unique écrit en 21-bits et qui correspond à un seul caractère
à la fois, comme par exemple U+0061 pour LATIN MINUSCULE A (“a”), ou U+1F425 pour POUSSIN DE
FACE (“🐥”).

Note : Les scalaires Unicode sont compris entre U+0000 et U+D7FF inclus ou U+E000 et
U+10FFFF inclus. Ils ne sont en revanche pas inclus entre U+D800 et U+DFFF inclus.

Notez que tout les scalaires Unicode 21-bits n’ont pas forcément de caractères assignés, et certains sont
réservés pour de futurs assignements. Les scalaires qui ont été assignés à un caractère on aussi un nom
comme dans l’exemple vu ci-dessus.

Les caractères spéciaux dans les chaînes

Les chaînes de caractères peuvent inclure les caractères spéciaux suivants :

• Les caractères d’échappement spéciaux \0 (caractère vide), \\ (anti-slash), \t (tabulation

horizontale), \n (retour à la ligne), \r (retour chariot), \" (guillemet double), \' (guillemet simple)

• Un scalaire Unicode arbitraire, écrit \u{n}, où n est un nombre hexadecimal composé de 1 à 8

chiffres avec une valeur Unicode valide.

Le code ci-dessous montre 4 exemples avec ce type de caractères spéciaux. La constante citation
contient deux caractères d’échappement afin d’y inclure des guillemets doubles. Les trois constantes
suivantes intègrent un scalaire au format Unicode :

1 let citation = "\" L'imagination est plus importante que la connaissance\" - Einstein"

2 // "L'imagination est plus importante que la connaissance" - Einstein

3 let symboleDollar = "\u{24}"

4 // $, scalaire Unicode U+0024

5 let coeurNoir = "\u{2665}"

6 // ♥, scalaire Unicode U+2665

7 let simleyCoeur = "\u{1F496}"

8 // 💖, scalaire Unicode U+1F496

Les combinaisons Unicode

Dans Swift, chaque caractère représente une combinaison Unicode unique. Les combinaisons Unicode
sont des séquences d’un ou plusieurs scalaire(s) Unicode, qui, lorsqu’ils sont combinés forment un
caractère lisible pour l’homme.

Voici un exemple. La lettre é est représentée par le scalaire Unicode é (LATIN MINUSCULE E AVEC
ACCENT, ou U+00E9). Cependant la même lettre peut aussi être représentée avec une paire de scalaires :
la lettre standard e (LATIN MINUSCULE E, ou U+0065), suivie de l’accent (U+0301). La combinaison est
graphiquement appliquée au scalaire précédent, faisant ainsi de notre e standard un é avec accent,
lorsque le rendu système est appliqué.

Dans les deux cas, la lettre é est représentée comme une valeur unique de type Character, c’est à dire
une combinaison Unicode. Dans le premier cas, la combinaison ne contient qu’un seul scalaire; dans le
second cas, la combinaison en contient deux :

1 let eAccent: Character = "\u{E9}"

2 // é

3 let eCombinaison: Character = "\u{65}\u{301}"

4 // e suivi de ´

5 // eAccent vaut é, eCombinaison vaut aussi é

Les combinaisons Unicode sont une façon plus flexible de représenter tout un tas de caractères
complexes sans déborder de la valeur Character. Par exemple, les syllables de l’alphabet Coréen peuvent
être représentée de plusieurs séquences recomposées ou décomposées. Dans les cas, ces
représentations n’occuperont en mémoire que la place d’un seul caractère avec le langage Swift :

1 let reCompose: Character = "\u{D55C}"

2 // 한

3 let deCompose: Character = "\u{1112}\u{1161}\u{11AB}"

4 // ᄒ, ᅡ, ᆫ

Il est possible de créer vos propres combinaisons Unicode avec certains scalaires (comme par exemple le
CERCLE D'ENTOURAGE COMBINÉ, ou U+20DD), pour obtenir une nouvelle valeur de type Character :

1 let eAccentCercle: Character = "\u{E9}\u{20DD}"

2 // eAccentCercle vaut maintenant ⃝ é

Les scalaires Unicode pour les indicateurs régionaux sont la combinaison d’une paire de deux valeurs
simples de type Character, comme la combinaison de SYMBOL INDICATEUR REGIONNAL U (U+1F1FA) et
SYMBOL INDICATEUR REGIONNAL S (U+1F1F8) :

1 let regionnalUS: Character = "\u{1F1FA}\u{1F1F8}"

2 // e suivi de ´

3 // regionnalUS vaut maintenant 🇺🇸

  L'Unicode

L’Unicode est un standard internationnal de l’encodage dans différents systèmes d’écriture. Il vous
autorise à utiliser pratiquement tous les caractères depuis n’importe quelle langue dans une forme
standardisée, et à lire et écrire ces caractères, pour et depuis, une source externe, comme un fichier
texte ou une page web.

Les chaînes et les caractères en Swift sont totalement comformes avec l’Unicode, comme nous allons le
voir dans cette section.

Les valeurs scalaires en Unicode

Dans les rouages du langage, le type String natif de Swift a été construit depuis les valeurs de l’Unicode
scalaire. Un scalaire Unicode est un nombre unique écrit en 21-bits et qui correspond à un seul caractère
à la fois, comme par exemple U+0061 pour LATIN MINUSCULE A (“a”), ou U+1F425 pour POUSSIN DE
FACE (“🐥”).

Note : Les scalaires Unicode sont compris entre U+0000 et U+D7FF inclus ou U+E000 et
U+10FFFF inclus. Ils ne sont en revanche pas inclus entre U+D800 et U+DFFF inclus.

Notez que tout les scalaires Unicode 21-bits n’ont pas forcément de caractères assignés, et certains sont
réservés pour de futurs assignements. Les scalaires qui ont été assignés à un caractère on aussi un nom
comme dans l’exemple vu ci-dessus.

Les caractères spéciaux dans les chaînes

Les chaînes de caractères peuvent inclure les caractères spéciaux suivants :

• Les caractères d’échappement spéciaux \0 (caractère vide), \\ (anti-slash), \t (tabulation

horizontale), \n (retour à la ligne), \r (retour chariot), \" (guillemet double), \' (guillemet simple)

• Un scalaire Unicode arbitraire, écrit \u{n}, où n est un nombre hexadecimal composé de 1 à 8

chiffres avec une valeur Unicode valide.

Le code ci-dessous montre 4 exemples avec ce type de caractères spéciaux. La constante citation
contient deux caractères d’échappement afin d’y inclure des guillemets doubles. Les trois constantes
suivantes intègrent un scalaire au format Unicode :

1 let citation = "\" L'imagination est plus importante que la connaissance\" - Einstein"

2 // "L'imagination est plus importante que la connaissance" - Einstein

3 let symboleDollar = "\u{24}"

4 // $, scalaire Unicode U+0024

5 let coeurNoir = "\u{2665}"

6 // ♥, scalaire Unicode U+2665

7 let simleyCoeur = "\u{1F496}"

8 // 💖, scalaire Unicode U+1F496

Les combinaisons Unicode

Dans Swift, chaque caractère représente une combinaison Unicode unique. Les combinaisons Unicode
sont des séquences d’un ou plusieurs scalaire(s) Unicode, qui, lorsqu’ils sont combinés forment un
caractère lisible pour l’homme.

Voici un exemple. La lettre é est représentée par le scalaire Unicode é (LATIN MINUSCULE E AVEC
ACCENT, ou U+00E9). Cependant la même lettre peut aussi être représentée avec une paire de scalaires :
la lettre standard e (LATIN MINUSCULE E, ou U+0065), suivie de l’accent (U+0301). La combinaison est
graphiquement appliquée au scalaire précédent, faisant ainsi de notre e standard un é avec accent,
lorsque le rendu système est appliqué.

Dans les deux cas, la lettre é est représentée comme une valeur unique de type Character, c’est à dire
une combinaison Unicode. Dans le premier cas, la combinaison ne contient qu’un seul scalaire; dans le
second cas, la combinaison en contient deux :

1 let eAccent: Character = "\u{E9}"

2 // é

3 let eCombinaison: Character = "\u{65}\u{301}"

4 // e suivi de ´

5 // eAccent vaut é, eCombinaison vaut aussi é

Les combinaisons Unicode sont une façon plus flexible de représenter tout un tas de caractères
complexes sans déborder de la valeur Character. Par exemple, les syllables de l’alphabet Coréen peuvent
être représentée de plusieurs séquences recomposées ou décomposées. Dans les cas, ces
représentations n’occuperont en mémoire que la place d’un seul caractère avec le langage Swift :

1 let reCompose: Character = "\u{D55C}"

2 // 한

3 let deCompose: Character = "\u{1112}\u{1161}\u{11AB}"

4 // ᄒ, ᅡ, ᆫ

Il est possible de créer vos propres combinaisons Unicode avec certains scalaires (comme par exemple le
CERCLE D'ENTOURAGE COMBINÉ, ou U+20DD), pour obtenir une nouvelle valeur de type Character :

1 let eAccentCercle: Character = "\u{E9}\u{20DD}"

2 // eAccentCercle vaut maintenant ⃝ é

Les scalaires Unicode pour les indicateurs régionaux sont la combinaison d’une paire de deux valeurs
simples de type Character, comme la combinaison de SYMBOL INDICATEUR REGIONNAL U (U+1F1FA) et
SYMBOL INDICATEUR REGIONNAL S (U+1F1F8) :

1 let regionnalUS: Character = "\u{1F1FA}\u{1F1F8}"

2 // e suivi de ´

3 // regionnalUS vaut maintenant 🇺🇸