swift

LANGAGE SWIFT

  • Plan

 

  • Environnement du travail
  • Les principes du langage Swift
  • Eléments de syntaxe

¤ Operateurs
¤ Format des Strings
¤ Variables
¤ Conditions Boucles

  • La classe String
  • Héritage simple
  • Classes & Instances (Objets)
  • Méthodes de classes
  • Méthodes d’instances

 

  • iOS
  • Présentation générale
    Xcode – Structure d’un projet
    Debugger
    Interface Utilisateur
    MVC
    Storyboard
    Vues&Conteneur
    Delegate
    NotificationCenter
    Composants&Evénements
    AutoLayout
  •  Web Services
    Données
    Librairie externe
    Parsing XML
    Core Data
    Media
    Caméra
    Audio
    Vidéo
    Géolocalisation

 

  • Environnement du travail
  • Swift (ne peut se faire que sur des Mac)
    • versions du système d’exploitation Mac OS X Mojave
    • IOS 12(4 juin 2018)
    • aucune solution sous Windows ou sous Linux n’est prévue.
  • Swift online sandBox

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

  • Xcode 10 (17Sep2018), 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

Variables, constantes

 

  • let nomConstante = 3.14
  • var nomVariable    = 0

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

  • var message: String

message = ” Allo ”

¨      let   π = 3.14159

  • print(message)
  • print(“La valeur actuelle du message est \(message)”)

 

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 */

 

Variables, constantes et opérateurs Les
variables

  • Les opérateurs :

   Opérateurs d’affectation

   Opérateurs arithmétiques

 

  • Opérateurs d’affectation:

 

  • Opérateurs arithmétiques

Soustraction ou inversion de signe

+ Addition

  • Soustraction

* Multiplication

/ Division

% Modulo (reste de la division entière)

  • Exemples

 

var  var1 = 10, var2 = 15,result : int result = var1 * var2;

result = 15 % 10

 

Types de données:

 

 

  • Les variables utilisées jusqu’ici étaient de type entier (int) et à virgule (float)

 

Booléens

  • Utilisé lorsque vous devez manipuler des informations de type

vrai/faux,

  • Exemple:

var  booleen3  : Bool

booleen3 = true

var  booleen4 = false

 

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

 

Caractères

 

  • Le type char permet de manipuler des chaînes composées d’un et d’un seul caractère

Exemple :var  monCaractere : Character

monCaractere = ” g ”

String

 

Var  str: String =    “ABC”

str.append(“DE”)   // On obtient donc “ABCDE” print(str)

print(str.characters.count)

Types Alias

Syntaxe :

  • typealias newname = type

Exemple :

Typealias   Entier = Int

Var var1 : Entier = 1 Print(var1)

Les tuples

 

let   tuple = (valeur1, valeur2, …)

// 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

 

 

 

 

38

 

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 \(temperature )”)

}

var temperature : Int?

Var nom : String ?

var temperature : Int? = nil

Var nom : String ? = “Alami”

 

Concaténer des variables et convertir un type

 

let ch1 = ” Bonjour,”

let ch2= ” tout le monde!” let ch= ch1 + ch2

print(ch) print(ch1 + ch2)

let nombre1 = 1 let nombre2 = 2

let nombre = “\(nombre1)” + “\(nombre2)” print(nombre)

print(la somme est : \(nombre) !”)

let    monTexte = “Mon nombre est : ” + String(nombre)

 

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”)    }

 

CondiTons mulTples

 

itrue {     print(“Ce message s’affichera …”) }

ifalse {     print(“Ne s’exécutera jamais.« ) }

var varBool : Bool = true

ivarBool == true {   print(“La variable booleen vaut vrai !”) }

if varBool  {  

print(“La variable booleen vaut vrai ! ” )}

if !varBool  { print(“La variable booleen vaut fausse ! “ )}

 

// CeYe parTe est idenTque à…

 

let age: Int = 20

let naTonalite: String = “FR ”

if (age >= 21 && naTonalite == “Mar”) || (age >= 18 && naTonalite == “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 condiTons

 

let note = 18 switch note { case 10:

print(« MenTon Passable.”)

case 12  ,   13:

print(« MenTon assez bien.”)

case 1416:

print(« MenTon bien.”)

case 16 ..< 18:

print(“Vous avez obtenu la menTon très bien.”)

case 1820:

print(“Vous avez les félicitaTons du jury !”)

default:

print(“Navré, il faut avoir une de ces notes pour avoir une menTon.”)

}

 

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

 

Syntaxe  :

Les boucles

 

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)”)

 

Syntaxe  :

Les Tableaux

 

var  noms = [“Alami”, “Farah” , “Hadi”, “Losi”]

Var        tableauEnTers: [Int] print(noms[2])

noms =  noms + [“Talbi”]              // ajout à la n

print( noms)

noms = [“Talbi”] noms               // ajout au début noms.append(“HaTm”)    noms.insert(“Samadi”,at : 2)

noms += [“Talbi”]

noms [2] =  “Salami”                 // Modier

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,  atI  :  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”, “Losi”] for item in noms.reversed() {

print(“nom :\(item)”)

}

for (index, item) in noms.reversed().enumerated() { print(“nom \(item) at posiTon \(index)”)

}

//   si on écrit  noms.enumerated().reversed() ???

 

Les DicTonnaires

Déclarer un dicfonnaire   :

 

var personne = [“Nom”: “Alami”, “Prénom”: “Ahmed”, “Adresse”: “n 5 rue Izmir “, “Ville”: “Rabat”]

var dicTonnaire: [type1: type2] var dicTonnaire: [String: Int]

var Jours: DicTonary = [“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 ”                                                        //Modier une valeur personne[Ville] = nil            //reArer la ville                                                          du dicAonnaire Personne. removeValue(forKey: “Ville”)     //reTrer 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)

}

 

Syntaxe:

Les FuncTons et Closures

 

 

func nomFoncTon(parametre1: Type, parametre2: Type, …) -> TypeRetour {

// InstrucTons

return laValeurARetourner

}

 

 

func nomFoncTon(para1 : [Int] ) -> (min: Int, max: Int, total: Int) {

// InstrucTons

return (min,max,total)

}

func  maFoncTon(maFoncTonParametre: (Int, Int) -> Bool) {

//instrucTons

maFoncTonParametre(12, 123)

}

 

Les Functions et Closures

Exercice:

 

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

 

func somme(              nombres: Int… ) -> Int { var somme = 0

for nombre in nombres {

somme += nombre

}

return somme

}

somme()

somme(nombres : 2, 5, 12)

func fonctionMain() -> Int { var y = 10

func ajouter() { y += 5

}

ajouter()

return y

}

print( fonctionMain())

Exemple:

func premierPlusGrandQueDeuxieme(nb1: Int, nb2: Int) -> Bool {  return nb1 > nb2  // nb1 > nb2 retourne un booléen si c’est vrai ou non

}

func maFoncTon(maFoncTonParametre: (Int, Int) -> Bool) { if maFoncTonParametre(4, 3) {

print(“CondiTon validée.”)

}

}

maFoncfon(premierPlusGrandQueDeuxieme)

// Affichera “CondiTon validée”

 

func maFoncfon(maFoncfonParametre: (Int, Int) -> Bool)  { maFoncfonParametre(12, 123)     // On peut u)liser la fonc)on passé

//en paramètre comme ceci

}

 

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

if max < nb2 { max = nb2    } return max

}

func maFoncTon(maFoncfonParametre: (Int, Int) -> Int) { print(“Le max est : \(maFoncfonParametre(12, 73))”)

}

maFoncTon(max)

 

Une foncfon comme paramètre :

Une foncfon comme type de retour :

 

func maFoncTon(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 !”

 

Syntaxe:

Les Closures

 

{ (parametres) -> TypeRetour in

// Instrucfons

}

func maFoncfon(maFoncfonParametre: (Int, Int) -> Int) { print(“Le max est : \(maFoncfonParametre(12, 73))”)

}

maFoncfon(       {( nb1 : Int, nb2: Int) -> Int in

var max = nb1

if max < nb2 { max = nb2    }

return max

}

)

UInt64                                 8bytes                                             0 to 18446744073709551615

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

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

 

Leave a Reply

Your email address will not be published. Required fields are marked *

Close