DÉVELOPPEMENT D’APPLICATIONS

IOS

02/2020 BALOUKI Youssef

Objectifs du cours
 Découvrir l'écosystème iOS
 Comprendre ce qu'est le développement iOS
 Découvrir le logiciel Xcode, iOS SDK
 Prendre en main le simulateur
 Composer une interface avec le storyboard
 Application simple;
 Application mono-vues;
 Application multi-vues;
 Guide de survie Swift
 Découvrir la base du langage Swift
 Connecter le code et l'interface
 Etre autonome grâce à la documentation
 Visualiser et résoudre ses erreurs
Plan
 Environnement du travail
 Les principes du langage Swift
 Eléments de syntaxe
 Operateurs
 Format des Strings
 Variables
 Conditions Boucles
 La classe String
 Classes & Instances (Objets)
 Méthodes de classes
 Méthodes d’instances
 Appel de fonction
 Self
 Héritage simple
Plan
 iOS
 Présentation générale
 Xcode - Structure d’un projet
 Debugger
 Interface Utilisateur
 MVC
 Storyboard
 Vues&Conteneur
 Delegate
 NotificationCenter
 Composants&Evénements
 AutoLayout
Plan
 iOS
 Web Services
 Données
 Librairie externe
 Parsing XML
 Core Data

 Media
 Caméra
 Audio
 Vidéo
 Géolocalisation
Le terminal mobile
 Ordinateur miniature (Système embarqué)
• Impact sur les ressources
 Système réactif
• Basé sur l’interface user
 Smartphone ou tablette
• Taille de l’écran
 Processeur
• ARM(basse consommation)
 Disque
• Mémoire flash
 Mémoire vive
• RAM
 Périphériques
• Capteurs diverses
• Cartes réseaux
• …
iOS vs Android
 Même principes
 Java/Objective-C ou Swift
 Eclipse+plug-in / Xcode

 Brevets
 L’écosystème
 L’écosystème ?
 Offre ? Nombre de développeurs? Nombre d’applications?
→ Attirer les développeurs
→ Générer de nouvelles utilisations

Apple Google

Nombre d’applications 1,2 millions 1,4 millions d’app

d’applications
Téléchargements 100 millions 200 millions

Développeurs 500 à 1000$ /mois/app 100 à 200$ /mois/app

163 milliards de $ 149 milliards de $
Programmation embraquée
 Contraintes :
 Mémoire, CPU, énergie…
 Compilation croisée (souvent)
 Programmation sur plateformes mobiles
 Programmation embraquée
 Programmation centrée sur l’interface User

-Modèle MVC
 Programmation réactive
Contraintes et enjeux en programmation
 Mémoire
- Android : garbage collector
-iOS : ARC (Automatic Reference Counting)
 Consommation d’ énergie
périphériques gourmands : GPS, caméra/HDR/Flash,..
 CPU (lié à la consommation d’énergie)
-Algorithmes couteux (jeux)
 Les événements urgents
- Appel téléphonique
 Ergonomie
-Facilité d’utilisation
-Respecter le modèle de réactivité( look and feel)
 Charte graphique
 Mécanismes dédiés
Contraintes et enjeux en programmation

 Fiabilité
- Problème de plantage et mémoire
 Sécurité
- Protection des données personnelles
 Accès contrôlé par des API à certains éléments
 Rapidité
-aspects algorithmiques
Processus de réalisation d’une application iOS

Développement Exécution
(Terminal)

Exécution
(Simulation)
Déploiement
 L’environnement de développement:
Xcode
 Environnement de développement des applications
iOS et MacOs (version 10- 2018)
 Evolue au même rythme que les versions des OS (Mac,
iOS)
 Xcode propose un GUI + SDK
 Graphic User Interface
 Concevoir l’interface
 Sogware Development Kit
 Environnement intégré de développement
 L’environnement de développement:
Xcode
 Il existe toujours une possibilité de faire l’hybride
 Titanium

 Phonegap

 Ionic

 Il est aussi possible de faire du HTML5

 Comment déployer une application
iOS
 Tester et/ou déployer l'application sur un matériel
(iPhone ou iPad) : Enregistrer auprès de l'iOS Developer
Program.

 Il existe 3 types d'inscription :

 iOS Developer Program – Individual 99$
 iOS Developer Program – Company 99$
 iOS Developer Enterprise Program 299$
Les programmes de développement
 Les différents types de déploiement
 Localement en utilisant un câble USB
 Requiert un abonnement à Provisioning Profile
 Possibilité d’utiliser un University program
 Via l’AppStore
 Validation d’Apple
 Apple prélève 30% de votre CA
 Nécessite un abonnement  Distribution profile
 Via Intranet + Itunes
 Génération d’un fichier .ipa
 Peut être déployé sur un serveur local
 Certification entreprise  Distribution profile
 Les différents types de déploiement
Vous souhaitez développer : Distribution Distribution Distribution
App Store Ad Hoc In-House

une application pour votre matériel X

personnel.
une application pour les matériels d'un X X

ensemble de personnes (jusqu'à 100

matériels).

une application pour les matériels d'un X

ensemble de personnes (au delà de 100

matériels).

une application et vous ne connaissez pas X

les matériels sur lesquels elle sera installée.

 Déploiement d'une application via App
Store
 Configurez une entrée pour votre application dans iTunes
Connect pour téléchargement.

 Préparez votre application pour le déploiement .

 Générez un fichier archive d'application (.ipa) pour votre

application.

 Chargez votre application dans l'App Store.

 Signature et distribution

A quoi ça sert ?

 Certifier l’identité du développeur

 Gérer des droits d’accès

 Limiter l'exécution d’applications (programme payant)

 Préparation de la signature du code
de votre application
Pour distribuer ou exécuter votre application sur un périphérique iOS :
1. Rejoindre l'un des programmes Développeur iOS.
les certificats et les outils nécessaires auprès d'Apple
exécuter et déployer les applications à destination des périphériques iOS.
2. Acquérir un certificat Développeur iOS
nécessaire pour signer votre application.

3. A pprovisionner votre application

l’exécuter sur vos périphériques iOS.
Signature et distribution
 Avantages
 Une protection certaine
- Contre les malveillances(virus,etc.)
 Un contrôle qualité
-Limiter les erreurs
 Inconvénients
 Une forme de protection
- Contre la concurrence
 Un mécanisme de déploiement complexe
LANGAGE SWIFT
WWDC 2014
Plan
 Environnement du travail
 Les principes du langage
 Eléments de syntaxe
 La classe String
 Héritage simple
 Classes & Instances (Objets)
 Méthodes de classes
 Méthodes d’instances
 Environnement de travail
 Swift (ne peut se faire que sur des Mac)
 versions du système d’exploitation Mac OS X Catalina 7 Octobre 2019
 IOS 13.3.1(28 Janvier 2020)
 aucune solution sous Windows ou sous Linux n’est prévue.

• Swift online playGround

 le kit de développement (SDK, Software Development Kit) :

Xcode 11.3.1 (13Janvier2020), l’interface où vous programmerez vos applications,

Associée un excellent compilateur llvm (Low Level Virtual Machine)

Interface Builder, l’outil de design et de conception,

le simulateur d’iPhone ou Ipad pour tester vos programmes,

le playground dans lequel vous allez tester entre autre vos méthodes et vos classes.
Etapes de création d’un projet

 Choix du type d’application

 Choix du type du terminal

 Choix du langage

 Sélection d’Identifiant

 …
Partie I

LES BASES
DE LA PROGRAMMATION
SWIFT
 Variables et constantes.

 Un programme manipulent des données. Certaines

sont connues dès le départ, d’autres sont calculées
lors de son exécution.

 Pour pouvoir manipuler ces données il faut garder

leurs valeurs en mémoire.

 C’est le rôle des variables et constantes.

 Variables.

Variable :

 Nom désignant une donnée (nombre, texte…)

susceptible de changer de valeur.

 Une variable possède un type, ce qui permet à

l’ordinateur de savoir quelles valeurs elle peut prendre et
quelles opérations on peut effectuer avec.
 Les types de variables.

Types “élémentaires” en Swift :

 Nombres : Int, Float, Double.

 Textes : String, Character.

 Booléan: Bool.
 Types de données
32

Type Typical Bit Width Typical Range

Int8 1byte -127 to 127
UInt8 1byte 0 to 255
Int32 4bytes -2147483648 to 2147483647

UInt32 4bytes 0 to 4294967295

Int64 8bytes -9223372036854775808 to
9223372036854775807

UInt64 8bytes 0 to 18446744073709551615

Float 4bytes 1.2E-38 to 3.4E+38

Double 8bytes 2.3E-308 to 1.7E+308

Youssef BALOUKI 2015/2016 28/03/2020
 Spécificités du Swift.

Typage dynamique :

Avant d’utiliser une variable on n’a pas besoin de déclarer

explicitement son type, c’est l’interpréteur qui s’en charge.

Cela sera fait dès que l’on attribuera une valeur à notre
variable.
 Spécificités du Swift.

Typage fort :

 Les opérations possibles sur une variable dépendent

intégralement de son type.

Les conversions de types implicites afin de réaliser

certaines opérations sont donc interdites.
 Affectation de variables.

 Syntaxe : affectation simple

Var maVariable = valeur

let maConstante = valeur

 Syntaxe : affectation multiple

Var var1= val1, var2 = val2 , ...

let var1= val1, var2 = val2 , ...
 Affectation de variables.

Remarques :

Comme mentionné précédemment, lorsque l’on veut utiliser

une variable il n’y a donc pas besoin de déclarer son type.
C’est lors de son initialisation que ce typage s’effectue.

 On peut toujours vérifier le type d’une variable avec

l’instruction “type(of:)” :

type(of :maVariable)
 Affectation de variables et Constantes.
Exemple :
 let nomConstante = 3.14
 var nomVariable = 0

,
 var x = 0.0 y = 0.0 , z = 0.0
 var message: String
message = " Allo "
 print(message)
 print("La valeur actuelle du message est \(message)")

 let π = 3.14159
 var booleen3 : Bool
booleen3 = true
var booleen4 = false
 Conversions de types.
Opérations de conversions :

Opération Contrainte / Résultat

Int(x) x est un décimal (qui sera tronqué) ou une chaîne
Int(x,base) x est une chaîne et base un entier
Float(x) x est un entier ou une chaîne
Bool(x) x est un nombre ou un booléen
Vaut False uniquement si x vaut 0 ou ‘ ‘
String(x) x est un nombre ou un booléen
 Conversions de types.

Exemple :

let x = 666.6
let y = Int(x)
print(y) // 666
let base2 = Int("10101",radix:2)!
print(base2) // 21
print(String(y)) // 666
 Les commentaires

 Commentaire sur une seule ligne

print("Hello, World !") // Affichera "Hello, World !"
 Commentaire sur deux ligne
/* Voici un exemple
d'un commentaire sur plusieurs lignes */
 Commentaire imbriqué
/* Voici un exemple
/*d'un commentaire */
sur plusieurs lignes */
 Affichage et saisie.
Syntaxe de la fonction “print” :

print(_itemes:separator:terminator:)

 Paramètres
 Items : Zéro ou plusieurs éléments à imprimer.
 Separator : Une chaîne à imprimer entre chaque élément. La
valeur par défaut est un espace unique ( " ").
 Terminator : Chaîne à imprimer une fois tous les éléments
imprimés. La valeur par défaut est une nouvelle ligne ( "\n").
 Affichage et saisie.

Exemple :

let age = 30
print("J'ai",age,"ans et dans deux ans
j'aurais",age+2,"ans")
//J'ai 30 ans et dans deux ans j'aurais 32 ans
 Affichage et saisie.

Exemple : (suite)

print("des","traits","bas","pour","séparer",
separator: "_")
print("et","des","plus","à","la","suite",
separator:"_",terminator: "+++")
print("et la fin")
 Affichage et saisie.

Remarque

 Tabulation et retour à la ligne s’obtiennent avec ‘\t’ et ‘\n’ :

print("The \tRolling Stones")

The Rolling Stones
print("The Rolling\nStones")
The Rolling
Stones
 Variables, constantes et opérateurs
45

• Les opérateurs :
• Opérateurs d'affectation
• Opérateurs arithmétiques

Youssef BALOUKI 28/03/2020

 Opérations arithmétiques.
46

• Opérateurs arithmétiques
- Soustraction ou inversion Exemples
var var1 = 10, var2 = 15,result : int
de signe

+ Addition result = var1 + var2

* Multiplication result = var1 * var2

/ Division result = var1/ var2

% Modulo (reste de la division entière) result = 15 % 10

Youssef BALOUKI 28/03/2020

 Opérations arithmétiques.
47

• Opérateurs d'affectation

Youssef BALOUKI 28/03/2020

 Opérations arithmétiques.

Précisions :

 Si les deux opérandes des opérations +, -, * sont entiers

(resp. réels) le résultat est entier (resp. réel).

 Si un des deux opérandes est réel, le résultat est réel.

 Le résultat de l’opération / est toujours un réel.

 Strings

let ch1 = "Hello"

var ch2 = "Salutations"

let ch3 = """

Q: Combien de lignes?
A: Deux lignes!
"""
print(ch3)

Q: Combien de lignes?
A: Deux lignes!
 Strings basics

let greeting = "Dans la pg on commence par \" Bonjour tout le monde! \ ""

Escape Description

\" Double quote

\\ Backslash

\t Tab

\r Carriage return (return to beginning of the next line)

Strings basics
Empty strings:
var myString = ""
if myString.isEmpty {
print("The string is empty")
}

Characters:
let a = "a" // 'a' is a string

let b: Character = "b" // 'b' is a Character

Strings basics
Concatenation:
let string1 = "Hello"
let string2 = ", world!"
var myString = string1 + string2 // "Hello, world!
myString += " Hello!" // "Hello, world! Hello!«
string1.append(« Ahmed !!") // On obtient donc "Hello, Ahmed! "

convertir un type
var nombre = 12
Let monTexte = "Mon nombre est : " + String(nombre)
Strings basics

Interpolation:
let name = “Alami"
let age = 30
print("\(name) a \(age) ans")

Alami a 30 ans
Strings basics

Interpolation
Expressions
let a = 8
let b = 5
print("Si = \(a) et b = \(b),alors a + b = \(a+b)")

Si a = 8 et b = 5,alors a + b = 13
Strings basics
Egalité et comparaison
let mois1 = "Janvier"
let mois2 = "Janvier"
let lowercaseMois= “janvier"

if mois1 == mois2 {
print(“Ils sont les mêmes")
}

if mois1 != lowercaseMois {
print(“Ils sont différents.")
}
Ils sont les mêmes
Ils sont différents.
Egalité et comparaison

Ignorer la casse.
let name = “Farah Ahmed"
if name.lowercased() == “farah aHmed".lowercased() {
print("Les deux noms sont égaux.")

Les deux noms sont égaux.

Egalité et comparaison

Prefix and suffix

.
let greeting = "Hello, world!"

print(greeting.hasPrefix("Hello"))
print(greeting.hasSuffix("world!"))
print(greeting.hasSuffix("World!"))

True
True
False
Egalité et comparaison

Recherche de sous-chaînes
. let greeting = “Salut, je m’appelle Ahmed."
if greeting.contains("my name is") {
print("Faire une introduction")
}

Faire une introduction

Egalité et comparaison

Vérification de la longueur.
let name = "Ryan Mears"
let count = name.count
let newPassword = "1234"

if newPassword.count < 8 {
print("Ce mot de passe est trop court. Les mots de passe doivent comporter au
moins 8 caractères.")
}

Ce mot de passe est trop court. Les mots de passe doivent comporter au
moins 8 caractères
Egalité et comparaison

Utilisation de Switch
let someCharacter: Character = "e"
switch someCharacter {
case "a", "e", "i", "o", "u":
print("\(someCharacter) est une voyelle")
default:
print("\(someCharacter) n’est pas une voyelle")
}

e est une voyelle

 Unicode
61

let cow = "Ö "

let credentials = "résumé"

let myBook = "私の本"

print("∞".characters.count)

Youssef BALOUKI 2015/2016 28/03/2020

 Types Alias
62

Syntaxe :
• typealias newname = type

Exemple :
Typealias Entier = Int

Var var1 : Entier = 1

Print(var1)

Youssef BALOUKI 2015/2016 28/03/2020

Les tuples
Syntaxe :
let tuple = (valeur1, valeur2, ...)
63
// Ou
var tuple = (valeur1, valeur2, ...)

Exemple :
let msg = (404, "Not Found")

let (code, message) = msg

// Ou
var (code, message) = msg

let (code, _) = msg

let msg= (code: 404, message: "Not Found")
let val1 = msg.code
let val2 = msg.message Youssef BALOUK 2016 28/03/2020
Les Optionnelles
var nonOptional : String
var optional : String ?
Les Optionnelles
Les Optionnelles

var temperature : Int?

var nom : String?

var temperature : Int? = nil

Var nom : String ? = "Alami"
Les Optionnelles

var temperature : Int?

print("temperature est \(temperature)")
temperature = 0
If temperature != nil {
print("temperature est \(temperature! )") }
var ville = ["A" : "Agadir" , "R" : "Rabat"]
var resul = ville ["B"] //resul = nil
If let result = ville ["B"] {
print("temperature est \(result )")
}
Conditions de Contrôle
 Condition : if... Else
let note = 16
if note >= 16{
print("Vous êtes excellant !")
}

 Condition if... else if.. else

let note = 11
if note >= 16 { print("Mention : Excelant !")}
else if note >= 14 { print("Mention : bien .") }
else if note >= 12 { print("Mention : Assez Bien" ) }
else if note >= 10 { print("Mention : Passable") }
 Conditions multiples
if true { print("Ce message s'affichera …") }
if false { print("Ne s'exécutera jamais.« ) }

var varBool : Bool = true

if varBool == true { print("La variable booleen vaut vrai !") }
// Cette partie est identique à...
if varBool { print("La variable booleen vaut vrai ! " )}
if !varBool { print("La variable booleen vaut fausse ! " )}

let age: Int = 20

let nationalite: String = "FR "
if (age >= 21 && nationalite == "Mar") || (age >= 18 && nationalite == "FR")
{
print("Vous êtes majeur.")
}
la priorité la plus haute à la priorité la plus
basse
Signification Opérateur
Parenthèses (, )

Non !

Multiplication, division, modulo *, /, %

Addition soustraction +, -

Inférieur, inférieur ou égal, supérieur, <, <=, >, >=

supérieur ou égal

Égal, différent de ==, !=

Et &&

Ou ||
 Switch : plus de conditions
let note = 18
switch note {
case 10:
print(« Mention Passable.")

case 12 , 13:
print(« Mention assez bien.")

case 14…16:
print(« Mention bien.")

case 16 ..< 18:

print("Vous avez obtenu la mention très bien.")

case 18…20:
print("Vous avez les félicitations du jury !")

default:
let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {

case let (x, y) where x == y:

print("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
print("(\(x), \(y)) is on the line x == -y")
case let (x, y):
print("(\(x), \(y)) is just some arbitrary point")
}
Switch : plus de conditions

let note = 12
var moyenne: Bool
if note < 10 { moyenne = false }
else { moyenne = true }
// Est identique à cette partie
moyenne = note < 10 ? false : true
 Les boucles
Syntaxe :
var nbFois: Int = 1
while nbFois <= 10 { print(" La ligne numéro :\(nbFois) ")
nbFois += 1}

repeat { print (" La ligne numéro :\(nbFois) ")

nbFois++ } while nbFois <= 10

for i in 1…10 { print (" La ligne numéro :\(i) ") }

let base = 3 , power = 10

var answer = 1
for _ in 1...power { answer *= base }
print("\(base) to the power of \(power) is \(answer)")
Collections
Tableau
Dictionnaire
Tableaux
Defintion
[value1, value2, value3]
var names: [String] = ["Anne", "Gary", "Keith"]
Tableaux
 Defining
[value1, value2, value3]
var names = ["Anne", "Gary", "Keith"]
Tableaux
 Definition
var numbers = [1, -3, 50, 72, -95, 115]
Tableau
 Definition
var numbers: [Int8] = [1, -3, 50, 72, -95, 115]
Tableaux
 contains
let numbers = [4, 5, 6]
if numbers.contains(5) {
print("Il y a un 5")
}
Il y a un 5
Types de ableau
var myArray: [Int] = []
var myArray: Array<Int> = []
var myArray = [Int]()
Utilisation des tableaux
Repeating

var myArray = [Int](repeating: 0, count: 100)

let count = myArray.count
if myArray.isEmpty { }
Utilisation des tableaux
Accéder ou définir un élément spécifique

var names = ["Ahmed", "Said", "Kamal"]

let firstName = names[0]
print(firstName)
Ahmed

names[1] = "Karim"
print(names)

["Ahmed", "KARIM", "Kamal]

Utilisation des tableaux
Ajout
var names = ["Ahmed"]
names.append("Joe")
names += ["Kamal", "Jane"]
print(names)

["Ahmed", "Joe", "Kamal", "Jane"]

Utilisation des tableaux
Insertion
var names = ["Amy", "Brad", "Chelsea", "Dan"]
names.insert("Bob", at: 0)
print(names)

["Bob", "Amy", "Brad", "Chelsea", "Dan"]

Utilisation des tableaux
Removing
var names = ["Ahmed", "Karim", "Charaf", "Man"]
let charaf = names.remove(at:2)
let man = names.removeLast()
print(names)

["Ahmed ", "Karim"]

names.removeAll()
print(names)

[]
Utilisation des tableaux

var myNewArray = firstArray + secondArray

Utilisation des tableaux
Tableau dans les tableau
let array1 = [1,2,3]
let array2 = [4,5,6]
let containerArray = [array1, array2]
let firstArray = containerArray[0]
let firstElement = containerArray[0][0]
print(containerArray)
print(firstArray)
print(firstElement)

[[1, 2, 3], [4, 5, 6]]

[1, 2, 3]
1
 Dictionaries
[key1 : value1, key2: value2, key3: value3]

var scores = ["Racha": 500, "Laki": 400, "Chal": 80]

var myDictionary = [String: Int]()

var myDictionary = Dictionary<String, Int>()
var myDictionary: [String: Int] = [:]
Ajouter / supprimer / modifier un
dictionnaire
Ajout ou modification

var scores = ["Racha": 500, "Laki": 400, "Chal": 80]

scores["Oli"] = 399

let oldValue = scores.updateValue(100, forKey: "Racha")

 Ajouter/supprimer/modifier un
dictionnaire
Ajout ou modification
var scores = ["Racha": 500, "Laki": 400, "Chal": 80]
scores["Oli"] = 399
if let oldValue = scores.updateValue(100, forKey: "Racha") {
print("L'ancienne valeur de Richard était \(oldValue)")
}

L'ancienne valeur de Racha était 500

Ajouter / supprimer / modifier un
dictionnaire
 Suppression
var scores = ["Racha": 500, "Laki": 400, "Chal": 80]]
scores["Racha"] = nil
print(scores)
if let oldValue = scores.removeValue(forKey: "Laki") {
print("Le score de Luke était \ (oldValue) avant qu'il ne cesse de
jouer")
}
print(scores)

["Chal": 80, "Laki": 400]

Le score de Luke était 400 avant qu'il ne cesse de jouer
["Chal": 80]
Accéder à un dictionnaire

var scores =["Racha": 500, "Laki": 400, "Chal": 80]]

let players = Array(scores.keys) //["Racha", "Laki", "Chal"]
let points = Array(scores.values) //[500, 400, 80]
if let myScore = scores["Laki"] {
print(myScore)
}

400
if let henrysScore = scores["Henry"] {
print(henrysScore)
}
 Les Tableaux
Syntaxe :
var noms = ["Alami", "Farah" , "Hadi", "Lotfi"]
Var tableauEntiers: [Int]
print(noms[2])
noms = noms + ["Talbi"] // ajout à la fin
print( noms)
noms = ["Talbi"] + noms // ajout au début
noms.append("Hatim")
noms.insert("Samadi",at : 2)
noms += ["Talbi"]
noms [2] = "Salami" // Modifier
noms.remove(at :1) // suprimer
Les Tableaux
Exemple :

var tableau: [Int] = [1, 2, 3, 4, 5, 6, 7]

var dictionnaire: [Int: String] = [1: "Un", 2: "Deux", 3: "Trois"]
tableau.count
dictionnaire.count
tableau.append(8)
tableau.first
tableau.last
Tableau.index(of : 3)
if tableau.isEmpty {
print("Le tableau est vide")
}
tableau.insert(9, at : 2) // [1, 2, 9, 3, 4, 5, 6, 7, 8]
tableau.removeLast() // [1, 2, 9, 3, 4, 5, 6, 7]
tableau.remove( at : 2) // [1, 2, 3, 4, 5, 6, 7]
var tableauReverse = tableau.reversed() // [7, 6, 5, 4, 3, 2, 1]
Tableau.removeAll()
 Les Tableaux
PARCOURIR UN TABLEAU :
let noms = ["Alami", "Farah" , "Hadi", "Lotfi"]
for item in noms.reversed() {
print("nom :\(item)")
}

for (index, item) in noms.reversed().enumerated() {

print("nom \(item) at position \(index)")
}
// si on écrit noms.enumerated().reversed() ???
 Les Dictionnaires
Déclarer un dictionnaire :
var personne = ["Nom": "Alami", "Prénom": "Ahmed",
"Adresse": "n 5 rue Izmir ", "Ville": "Rabat"]

var dictionnaire: [type1: type2]

var dictionnaire: [String: Int]
var Jours: Dictionary = ["jeu": "jeudi", "ven": "vendredi"]

let nom = personne["Nom"] // accéder à la valeur d’un dict

personne["Pays"] = "Maroc" // ajout d’une nouvelle clé & Valeur associée
personne["Prénom"] = "Khalil " //Modifier une valeur
personne[Ville] = nil //retirer la ville du
dictionnaire
Personne. removeValue(forKey: "Ville") //retirer la ville du Dict
 Les Dictionnaires

Parcourir un dictionnaire :

let personne = ["Nom": "Alami", "Prénom": "Ahmed", "Adresse": "n 5

rue Izmir ", "Ville": "Rabat"]
for (cle, valeur) in personne {
print(cle + " - " + valeur)
}
 Les Functions
Syntaxe:
func nomFonction(parametre1: Type, parametre2: Type, ...) -> TypeRetour {
// Instructions
return laValeurARetourner
}

func multiply(firstNumber: Int, secondNumber: Int) {

let result = firstNumber * secondNumber
print(“le resultat est \(result).")
}
multiply(firstNumber: 10, secondNumber: 5)

Le resultat est 50.

 Les Functions
Syntaxe:

func multiply(firstNumber: Int, secondNumber: Int) {

let result = firstNumber * secondNumber
return result
}

let myResult = multiply(firstNumber: 10, secondNumber: 5)

print(“Le resultat est \(myResult)“)

print("Le resultat est \(multiply(firstNumber: 10, secondNumber: 5)“)

Le resultat est 50.

 Les Functions

Exercice:

Écrivez une fonction qui retourne le max, min et total d’un tableau.

func nomFonction(para1 : [Int] ) -> (min: Int, max: Int, total: Int) {
// Instructions
return (min,max,total)
}
 Les Functions
Argument labels:

func sayHello(to :String, and: String) {

print("Hello \(to) and \(and)")
}

sayHello(to: “Karim", and: “Ahmed")

func sayHello(to personne :String, and autPersonne: String) {

print("Hello \(personne) and \(autPersonne)")
}

sayHello(to: “Karim", and: “Ahmed")

 Les Functions
Argument labels:
Omitting labels:

print("Hello, world!")

func add( _ firstNumber: Int, to secondNumber: Int) -> Int {

return firstNumber + secondNumber
}
let total = add(14, to: 6)
 Les Functions
Argument labels:
Valeurs par défaut:

func display(nomEquipe: String, score: Int = 0) {

print("\(nomEquipe): \(score)")
}

display(nomEquipe: “EstG", score: 100)

display(nomEquipe: “EstG“)

EstG: 100
EstG: 0
Les fonctions
func somme( nombres: Int... ) -> Int {
var somme = 0
for nombre in nombres {
somme += nombre
}
return somme
}
somme()
somme(nombres : 2, 5, 12)
 Les fonctions
func fonctionMain() -> Int {
var y = 10
func ajouter() {
y += 5
}
ajouter()
return y
}
print( fonctionMain())
 Les Functions
Une fonction comme paramètre :
func maFonction(maFonctionParametre: (Int, Int) -> Bool) {
maFonctionParametre(12, 123) // On peut utiliser la fonction passé
//en paramètre comme ceci
}

func max( nb1: Int, nb2: Int) -> Int {

var max = nb1
if max < nb2 { max = nb2 }
return max
}

func maFonction(maFonctionParametre: (Int, Int) -> Int) {

print("Le max est : \(maFonctionParametre(12, 73))")

}
maFonction(max)
 Les Functions
Exemple:
func premierPlusGrandQueDeuxieme(nb1: Int, nb2: Int) -> Bool {
return nb1 > nb2 // nb1 > nb2 retourne un booléen si c'est vrai ou
non
}

func maFonction(maFonctionParametre: (Int, Int) -> Bool) {

if maFonctionParametre(4, 3) {
print("Condition validée.")
}
}

maFonction(premierPlusGrandQueDeuxieme)

// Affichera "Condition validée"

 Les Functions
Une fonction comme type de retour :

func maFonction(param1: Int, param2: Bool) -> (Int, Int) -> Bool {
// ...
}

func Bonjour(debutMessage: String) -> (String) -> String {

func Salam(finMessage: String) -> String {

return "\(debutMessage) \(finMessage)"
}
return salam
}

print(Bonjour(“H ello")(“World!"))
// Affichera "Hello World !"
 Les Closures
Définition:

Une closure est une partie de code, avec paramètres et sorties, qui
peut être encapsulé dans une variable, et exécutée à la demande.

Syntaxe:

{ (parametres) -> TypeRetour in

// Instructions
}
 Les Closures
Exemples:

let maClosure = {
print( "Bonjour, Je suis une closure") }
maClosure() // le code est exécuté

let complexClosure = {(name:String, age:Float) -> Bool in

// Code
return false
}
let success = complexClosure("Louis",32)
print("Louis has \(success)")
 Les Closures
Exemples:
func maFonction(maFonctionParametre: (Int, Int) -> Int)
{
print("Le max est : \(maFonctionParametre(12, 73))")
}
maFonction( maFonctionParametre: {( nb1 : Int, nb2: Int) -> Int in
if nb1 < nb2 { return nb2 }
else{
return nb1
}
}
)
let tab = [1,5,2,7,13,1]

print(tab.sorted{(b:Int,a:Int)->Bool in
return b<a
})
 Partie II

LA PROGRAMMATION
ORIENTÉE OBJET EN SWIFT