{"id":1065,"date":"2014-07-09T10:23:45","date_gmt":"2014-07-09T14:23:45","guid":{"rendered":"http:\/\/tim.cstj.qc.ca\/cours\/xcode\/wp\/?page_id=1065"},"modified":"2014-07-09T10:23:45","modified_gmt":"2014-07-09T14:23:45","slug":"swift-introduction","status":"publish","type":"page","link":"https:\/\/ve2cuy.com\/xcode\/swift-introduction\/","title":{"rendered":"Swift – Introduction"},"content":{"rendered":"

Note\u00a0– Article en cours de r\u00e9vision – version du 2015.09.30<\/span><\/p>\n

Contenu<\/strong><\/h3>\n
    \n
  1. Le langage de programmation Swift<\/a><\/li>\n
  2. Le ‘playground’<\/a><\/li>\n
  3. Concepts et syntaxe<\/a><\/li>\n
  4. Les variables et constantes<\/a><\/li>\n
  5. Traitements sur les cha\u00eenes de caract\u00e8res<\/a><\/li>\n
  6. Interpolation de cha\u00eenes<\/a><\/li>\n
  7. Conversion de types<\/a><\/li>\n
  8. Les tableaux<\/a><\/li>\n
  9. Les dictionnaires<\/a><\/li>\n
  10. Les boucles<\/a><\/li>\n
  11. Les tests (if, switch)<\/a><\/li>\n
  12. Les fonctions<\/a><\/li>\n
  13. Les structures de donn\u00e9es<\/a><\/li>\n
  14. Les classes<\/a><\/li>\n
  15. \u00c9num\u00e9rations – enum<\/li>\n
  16. Observation de valeurs vs temps<\/li>\n
  17. Protocoles – voir le projet Aquarium<\/a><\/li>\n<\/ol>\n
    \n

    <\/a><\/p>\n

    Le langage de programmation\u00a0Swift<\/h1>\n

    \"Apple_Swift_Logo\"<\/a>
    \nPr\u00e9sent\u00e9 \u00e0 la conf\u00e9rence de la WWDC du printemps 2014, \u00a0Swift est un langage de programmation d\u00e9velopp\u00e9 par la soci\u00e9t\u00e9 Apple. \u00a0Il est destin\u00e9 \u00e0 la programmation d’applications sur les syst\u00e8mes d’exploitation iOS (iPhone, iPad) et OS X (MAC).
    \nSwift peut coexister avec l’Objective-C, langage actuel de programmation pour les syst\u00e8mes d’exploitation d’Apple. \u00a0Selon la firme de Cupertino\u00a0, ce nouveau langage est rapide, moderne, s\u00e9curis\u00e9 et interactif. \u00a0Il contribuera probablement \u00e0 att\u00e9nuer la courbe d’apprentissage du d\u00e9veloppement d’application pour iOS entre autre gr\u00e2ce au module \u00ab\u00a0playGround\u00a0\u00bb
    \n 
    \n <\/p>\n

    \n

    <\/a><\/p>\n

    Un langage interactif – PlayGround<\/h1>\n

    Mise \u00e0 part la simplicit\u00e9 de la syntaxe du langage, une des nouveaut\u00e9s contribuant \u00e0 l’apprentissage du langage est le module ‘PlayGround’.
    \nPlayGround est un environnement o\u00f9 il est possible d’\u00e9crire des instructions Swift et d’obtenir des r\u00e9sultats en temps r\u00e9el.
    \nUne des fa\u00e7ons d’obtenir ce ‘terrain de jeu’ est de cr\u00e9er un nouveau projet Xcode et de choisir l’option ‘Get started with a playground<\/strong>‘:
    \nAction<\/span> <\/strong>– D\u00e9marrons Xcode et s\u00e9lectionnions ‘Get started with a playground’:
    \n 
    \n\"new.xcode.projet\"
    \n 
    \nNommons \u00a0le projet:
    \n\"new.playground.projet.nommer\"
    \nVoici le terrain de jeux:
    \n\"Intro_au_terrain_de_jeux_playground\"
    \nR\u00e9f\u00e9rence     Apple<\/a><\/p>\n

    \n

    <\/a><\/p>\n

    Concepts et syntaxe de Swift<\/h1>\n

    Note<\/strong>: Ceci n’est pas un document d’introduction \u00e0 la programmation. \u00a0Nous prenons pour acquis que vous ma\u00eetrisez des\u00a0concepts tel que: variables, boucles, tests, fonctions, objet, m\u00e9thodes, propri\u00e9t\u00e9s, …<\/em>
    \n    <\/a><\/p>\n

    Les variables<\/h1>\n

    Types de base<\/h2>\n

    [table]
    \nType, Exemple
    \nInt – UInt – UInt32,<\/span><\/em><\/strong>\u00a0 0 ; 1 ; 55 ; 32767 ; -2
    \nFloat – CGFloat –<\/span><\/em><\/strong>\u00a0Double,<\/span><\/strong><\/em><\/span>\u00a02.345; 3.141592 ; -105678.999
    \nBool,<\/span><\/strong><\/em>\u00a0true ; false
    \nString<\/span><\/strong><\/em>\u00a0, ‘Paul’ ; \u00ab\u00a0CSTJ.qc.ca\u00a0\u00bb
    \nClassName,<\/span><\/em><\/strong>\u00a0UIButton ; UIColor ; UIImage ; Personnage ; \u2026
    \n[\/table]
    \n
    \nSyntaxe:<\/strong><\/p>\n

    var<\/span>\u00a0nom:Type<\/span>\u00a0= valeur<\/span><\/p><\/blockquote>\n


    \nExemples<\/strong> :<\/p>\n

    var unEntier:Int = 99\nvar unReel:Float = 3.1415\nvar unDouble:Double = 3.1415920123456789087654321\nvar unBooleen:Bool = true\nvar uneChaine:String = \"CSTJ.TIM\"\nvar uneVue:UIView = UIView(frame : CGRectMake(0,0,50,50))<\/pre>\n
     <\/p>\n
    D\u00e9claration inf\u00e9r\u00e9e (le type sera d\u00e9duit par Xcode)<\/h2>\n
    var unEntier = 99\nvar unReel = 3.1415\nvar unDouble = 3.1415920123456789087654321\nvar unBooleen = true\nvar uneChaine = \"CSTJ.TIM\"\nvar uneVue = UIView(frame : CGRectMake(0,0,50,50))<\/pre>\n
     <\/p>\n
    Variables versus Constantes<\/h2>\n
    var uneVariableMutable = 2.2    \/\/ anglais : mutable\nuneVariableMutable = 1.4241\nlet uneVariableImmutable = 9.9  \/\/ anglais : immutable\nuneVariableImmutable = 123      \/\/ erreur de compilation<\/pre>\n
    Note: \u00a0Apple recommande l’utilisation de contantes \u00e0 la place de variables lorsque possible.<\/p>\n
    Variables avec valeur non optionnelle<\/h2>\n
    var uneChaineAvecValeurNonOptionnelle :String\nprintln(uneChaineAvecValeurNonOptionnelle) \/\/ produira une erreur \u00e0 l\u2019ex\u00e9cution\nuneChaineAvecValeurNonOptionnelle = nil \/\/ produira une erreur \u00e0 l\u2019ex\u00e9cution<\/pre>\n
     <\/p>\n
    Variables avec valeur optionnelle<\/h2>\n
    var uneChaineAvecValeurOptionnelle:String?\nIf let uneChaineAvecValeurOptionnelleValidee = uneChaineAvecValeurOptionnelle {\nprintln(uneChaineAvecValeurOptionnelleValidee)\n} else {\nprintln(\"La variable \u2018uneChaineAvecValeurOptionnelle\u2019 n\u2019est pas initialis\u00e9e.\")\n}<\/pre>\n
     <\/p>\n
    \n
    <\/a><\/p>\n
    Traitements sur les chaines de caract\u00e8res<\/h1>\n
    Concat\u00e9nation<\/h2>\n
    let tim = \"\u00c9tudiants et \u00e9tudiantes de CSTJ.TIM\"\nlet cours = \"Introduction \u00e0 Xcode\"\nvar msgBienvenue = tim + \", bienvenue au cours : \" + cours\nmsgBienvenue += \"!\"<\/pre>\n
    <\/a><\/p>\n
    Interpolation de chaines<\/h2>\n
    Syntaxe:<\/strong>
    \n\u00ab\u00a0… \\(votre code) …\u00a0\u00bb
    \n <\/p>\n
    let anneeCours = 2014\nmsgBienvenue = \"\\(tim), bienvenue au cours : \\(cours) de l'ann\u00e9e \\(anneeCours)\"\nlet nbSemaines = 15\nlet heuresSemaine = 4\nlet msg = \"\u00c0 \\(heuresSemaine) heures de cours par semaine pendant \\(nbSemaines) semaines, le cours a une dur\u00e9e de \\(nbSemaines * heuresSemaine) heures.\"<\/pre>\n
     <\/p>\n
    Comparaison de chaines<\/h2>\n
    let perso1 = \"Fred \" + \"LeToff\"\nlet perso2 = \"Fred LeToff\"\nif perso1 == perso2 {\n  println(\"\\(perso1) et \\(perso2) sont une seule et m\u00eame personne\")\n} else {\n  println(\"Il n'y d\u00e9finitivement aucun lien de parent\u00e9 entre \\(perso1) et \\(perso2)\")\n}<\/pre>\n
     <\/p>\n
    Chaines – Test insensible \u00e0 la casse<\/h2>\n
    let perso1 = \"Fred \" + \"Letoff\"\nlet perso2 = \"Fred LeToff\"\nif perso1.lowercaseString == perso2.lowercaseString {\n  println(\"\\(perso1) et \\(perso2) sont une seule et m\u00eame personne\")\n} else {\n  println(\"Il n'y d\u00e9finitivement aucun lien de parent\u00e9 entre \\(perso1) et \\(perso2)\")\n}<\/pre>\n
     <\/p>\n
    Tester des chaines vides<\/h2>\n
    let jeSuisUneChaineVide = \"\"\nlet moiAussi = String()\nif jeSuisUneChaineVide.isEmpty && moiAussi.isEmpty {\n  println(\"Il n'y a que du vide ici...\")\n}<\/pre>\n
     <\/p>\n
    \n
    <\/a><\/p>\n
    Conversion de types<\/h1>\n
    let prix:Float = 12.67\nlet quant = \"2\"\nvar total = prix * Float(quant.toInt()!)\nlet i = String(99)\nlet peutEtreunNombre = \"\".toInt()\nif let unNombre = peutEtreunNombre {\n    println(\"unNombre vaut \\(unNombre)\")\n} else\n{\n    println(\"Meilleur chance la prochaine fois...\")\n}\n\/\/ Note: pas encore de m\u00e9thode String.toDouble() avec la beta3 de Xcode 6\n\/\/ Conversion en utilisant un pond vers NSString\n\/\/ Note pas \u00e0 tester 'nil', si chaine invalide alors retourne 0.0\nlet UnDouble = (\"1.618\" as NSString).floatValue\nlet famille = \"MAISONNEUVE.TIM\"\nif (famille as NSString).containsString(\"TIM\")\n{\n    println(\"Membre de la famille...\")\n}\n\/\/ Un autre exemple de m\u00e9thodes disponibles avec la Class NSString\nlet motCache = \"swilfkjnsljfswjftswiftswjkfswftfdf\" as NSString\nmotCache.substringWithRange(NSMakeRange(7, 7))\nprintln(\"Le mot cach\u00e9 est '\\(motCache.substringWithRange(NSMakeRange(17, 5)))'\")<\/pre>\n
     <\/p>\n
    \n
    <\/a><\/p>\n
    Les tableaux<\/h1>\n
    \/\/ D\u00e9finition<\/p>\n
    D\u00e9finition implicite<\/h2>\n
    let jeSuisUnTableauDeChaine = [\"Tintin\", \"Milou\", \"Tournesol\"]<\/pre>\n
     <\/p>\n
    D\u00e9finition explicite<\/h2>\n
    let jeSuisUnTabloDeChaine:Array<String> = jeSuisUnTableauDeChaine<\/pre>\n
     <\/p>\n
    D\u00e9finition explicite courte<\/h2>\n
    var personnages:[String] = jeSuisUnTableauDeChaine\nvar tableauVideDesChaines:[String] = []<\/pre>\n
     <\/p>\n
    Tableau – Utilisation<\/h2>\n
    let perso = personnages[0]\nlet dernierPerso = personnages[personnages.count - 1]\nif !personnages.isEmpty {\nprintln(\"Il y a \\(personnages.count) personnage(s) dans le tableau\")\n}<\/pre>\n
     <\/p>\n
    Chercher la position d’un item dans un tableau<\/h2>\n
    \/\/ Note: retourne nil si pas trouv\u00e9. Utiliser la syntaxe 'if let'\nif let trouve = find(personnages, \"Milou\") {\nprintln(\"Nous avons trouv\u00e9 Milou \u00e0 la position \\(trouve) dans le tableau des personnages\")\n}<\/pre>\n
     <\/p>\n
    Ajouter un item dans un tableau<\/h2>\n
    personnages+=\"Haddock\"  \/\/ Ne fonctionne plus \u00e0 partir de la beta 5, il faut utiliser la syntaxe de la ligne suivante\npersonnages.append(\"Haddock\")<\/pre>\n
     <\/p>\n
    Retirer un item du tableau<\/h2>\n
    let retrait = personnages.removeAtIndex(1)\nprintln(retrait)<\/pre>\n
     <\/p>\n
    Vider un tableau<\/h2>\n
    personnages.removeAll(keepCapacity: true)<\/pre>\n
     <\/p>\n
    Ins\u00e9rer un item dans un tableau<\/h2>\n
    personnages.insert(\"Malice\", atIndex: 1)\n\/\/ Remplacer un (1) ou des items du tableau\n\/\/ Dans l'exemple suivant: remplacer items 0 \u00e0 1 par ...\npersonnages[0...1] = [\"Tuntun\", \"MunLun\", \"UnDun\", \"SunSun\"] \/\/ ou 0..<2\npersonnages<\/pre>\n
     <\/p>\n
    Trier un tableau<\/h2>\n
    personnages.sort {a, b in a < b} \/\/ voir 'closure'\npersonnages<\/pre>\n
     
    \n <\/p>\n
    \n
    <\/a><\/p>\n
    Les dictionnaires<\/h1>\n
    D\u00e9finition: une collection de paires cl\u00e9\/valeur
    \n\/\/ Syntaxe:
    \n\/\/ … = [ cl\u00e91:valeur1, cl\u00e92:valeur2, …]<\/p>\n
    Dictionnaire – D\u00e9claration implicite<\/h2>\n
    var personnage01 = [ \"Nom\": \"Fred\", \"Force\": \"99\", \"Rang\":\"Novice\"]\n\/\/ Acc\u00e8s simple\npersonnage01[\"Nom\"]\n\/\/ Acc\u00e8s avec test de la cl\u00e9\nvar nom = \"\"\nlet cle = \"Nom\"\nif let temp = personnage01[cle] {\n    nom = temp\n} else\n{\n  println(\"Erreur:Cl\u00e9 '\\(cle)' invalide\")\n}\nnom\n\/\/ ********************************\nvar dict:[String:String]\ndict = [\"Nom\":\"Fred\"]\ndict[\"Age\"] = \"44\"\ndict\n<\/pre>\n
     <\/p>\n
    Dictionnaire – D\u00e9claration explicite<\/h2>\n
    let personnage02:Dictionary<String, AnyObject> = [ \"Nom\": \"Tom\", \"Force\": 34, \"Rang\":\"Expert\"]<\/pre>\n
     <\/p>\n
    D\u00e9clarer un Dictionnaire vide<\/h2>\n
    let dictioVide = Dictionary<String, String>()<\/pre>\n
     <\/p>\n
    Utilisation d’un dictionnaire<\/h2>\n
    let nomPerso1 = personnage01[\"Nom\"]\nvar tabloPerso = [personnage01, personnage02]\n\/\/ let forcePerso2 = tabloPerso[1][\"Force\"] as Int\n\/\/ Note: Il est recommand\u00e9 d'utiliser la syntaxe 'if set'. Un champ non d\u00e9fini retournera 'nil'\nlet force = \"Force\"\nif let forcePerso1 = personnage01[force]?.toInt() {\nprintln(\"La \\(force) de Perso1 = \\(forcePerso1)\")\n} else {\nprintln(\"Erreur: Impossible d'obtenir la \\(force) du personne...\")\n}\n\/\/ Utilisation d'un dictionnaire avec des \u00e9l\u00e9ments de type 'AnyObject'\nlet personnage02:Dictionary<String, AnyObject> = [ \"Nom\": \"Tom\", \"Force\": 34, \"Rang\":\"Expert\"]\nlet force \u00a0 = personnage02[\"Force\"] \u00a0 \u00a0 as NSNumber\nlet nom \u00a0 \u00a0 = personnage02[\"Nom\"] \u00a0 \u00a0 \u00a0 as NSString\nprintln(\"Mon nom est: \\(nom) et j'ai une force de: \\(force)\")\n<\/pre>\n
    <\/h2>\n
    Un tableau de dictionnaires<\/h2>\n
    let personnage001\/*:Dictionary<String, AnyObject>*\/ = [ \"Nom\": \"Le petit\", \"Force\": 3, \"Rang\":\"novice\"]\nlet personnage002:Dictionary<String, AnyObject> = [ \"Nom\": \"Tom\", \"Force\": \"34\", \"Rang\":\"Expert\"]\nvar personnages02:Array<Dictionary<String, AnyObject>> = Array()\npersonnages02.append(personnage001)\npersonnages02.append(personnage002)\npersonnages02[0][\"Rang\"]\npersonnages02[1][\"Force\"]\nlet total = 22 + personnages02[1][\"Force\"]  \/\/ erreur!\n\/\/ Solution\nif let fp = personnages02[1][\"Force\"] as? Int {\n    let i = fp + 22\n    i\n} else\n{\n    println(\"Erreur sur le type du champ 'force'\")\n}\n<\/pre>\n
    <\/h2>\n
    Un tableau d’AnyObject<\/h2>\n
    let personnage0001 = [ \"Nom\": \"Le petit\", \"Force\": 3,  \"Rang\":\"novice\", \"Amis\": [\"Moi\",\"Toi\",\"Lui\"]]\nlet personnage0002 = [ \"Nom\": \"Le grand\", \"Force\": 78, \"Rang\":\"Expert\", \"Amis\": [\"Eux\",\"Nous\",\"Ils\"]]\nlet personnage0003 = [ \"Nom\": \"Le Boss\",  \"Force\": 99, \"Rang\":\"Expert\", \"Amis\": [\"Monstre rouge\"]]\n\/\/ AnyObject = classe de type NS\nvar personnages3:Array<AnyObject> = Array()\npersonnages3.append(personnage0001)\npersonnages3.append(personnage0002)\npersonnages3.append(personnage0003)\nprintln(personnages3)\npersonnages.count\nlet nom3 = personnages3[1][\"Nom\"] as! String\nlet nbAmisPerso3 = (personnages3[2][\"Amis\"] as! NSArray).count\n\/\/ Bloucler sur les \u00e9l\u00e9ments du tableau (voir 'for in')\n\/\/ for (key,value)\nfor perso in personnages3 {\n    let nomPerso = perso[\"Nom\"] as! String\n    println(\"Amis de \\(nomPerso): \")\n    for ami in perso[\"Amis\"] as! NSArray {\n        println(\"    \\(ami)\")\n    }\n    println(\"-------------\")\n}\n<\/pre>\n
     <\/p>\n
    Ins\u00e9rer une cl\u00e9\/valeur<\/h2>\n
    Note: Ne fonctionne qu’avec <String, String>.<\/p>\n
    personnage01[\"Vies\"] = \"4\"<\/pre>\n
     <\/p>\n
    Retirer une cl\u00e9\/valeur<\/h2>\n
    Note: Ne fonctionne qu’avec <String, String><\/p>\n
    personnage01[\"Rang\"] = nil\npersonnage01.removeValueForKey(\"Rang\")<\/pre>\n
     <\/p>\n
    NSSet –\u00a0Tableau sans doublon<\/h3>\n
    let personnages4 = [\"Tintin\", \"Milou\", \"Tournesol\", \"Haddock\", \"Allan\", \"Rastapopoulos\", \"Dupont\", \"Dupond\", \"Muller\", \"Lampion\", \"Tapioca\" ]\nlet unEnsemble = NSMutableSet()  \/\/ Un tableau sans doublon\nvar nbIterations = 0\nwhile unEnsemble.count <= 3 {\n    let unNombreAuHasard = arc4random_uniform(UInt32(count(personnages)))\n    let unPersonnage = personnages[Int(unNombreAuHasard)]\n    println(unPersonnage)\n    unEnsemble.addObject(unPersonnage)\n    nbIterations++\n} \/\/ while unEnsemble.count <= 3\nprintln(\"It\u00e9rations: \\(nbIterations), contenu de l'ensemble: \\(unEnsemble)\")<\/pre>\n
     <\/p>\n
    NSCountedSet – calcule des doublons<\/h3>\n
    let personnages5 = [\"Tintin\", \"Milou\", \"Tournesol\", \"Haddock\", \"Allan\", \"Rastapopoulos\", \"Dupont\", \"Dupond\", \"Muller\", \"Lampion\", \"Tapioca\" ]\nlet unEnsemble2 = NSCountedSet()  \/\/ Un tableau sans doublon\nvar nbIterations2 = 0\nwhile unEnsemble2.count <= 3 {\n    let unNombreAuHasard = arc4random_uniform(UInt32(count(personnages)))\n    let unPersonnage = personnages[Int(unNombreAuHasard)]\n    println(unPersonnage)\n    unEnsemble2.addObject(unPersonnage)\n    nbIterations++\n}\nfor x in unEnsemble2 {\n    println(\"Personnage: \\(x), nb d'insertions: \\(unEnsemble2.countForObject(x))\")\n}<\/pre>\n
     
    \nR\u00e9sultat:<\/p>\n
    Lampion\nTintin\nLampion\nDupond\nMilou\nHaddock\nMuller\nDupond\nMuller\nMuller\nTournesol\nAllan\nHaddock\nHaddock\nLampion\nDupont\nLampion\nTapioca\nPersonnage: Dupond, nb d'insertions: 2\nPersonnage: Muller, nb d'insertions: 3\nPersonnage: Lampion, nb d'insertions: 4\nPersonnage: Tintin, nb d'insertions: 1\nPersonnage: Allan, nb d'insertions: 1\nPersonnage: Milou, nb d'insertions: 1\nPersonnage: Tournesol, nb d'insertions: 1\nPersonnage: Dupont, nb d'insertions: 1\nPersonnage: Tapioca, nb d'insertions: 1\nPersonnage: Haddock, nb d'insertions: 3<\/pre>\n
     <\/p>\n
    NSIndexSet – Un ensemble d’indices<\/h3>\n
    let personnages = [\"Tintin\", \"Milou\", \"Tournesol\", \"Haddock\", \"Allan\", \"Rastapopoulos\", \"Dupont\", \"Dupond\", \"Muller\", \"Lampion\", \"Tapioca\" ]\nlet indexSet = NSMutableIndexSet()\nindexSet.addIndex(0)\nindexSet.addIndex(2)\nindexSet.addIndex(4)\n(personnages as NSArray).objectsAtIndexes(indexSet) \/\/ retourne; Tintin, Tournesol et Allan<\/pre>\n
     
    \n 
    \n 
    \n <\/p>\n
    \n
    Contr\u00f4le de la s\u00e9quence d’ex\u00e9cution<\/h1>\n
    <\/a><\/p>\n
    Les boucles<\/h1>\n
    Syntaxe<\/p>\n
    for in range (…, ..<)<\/p><\/blockquote>\n
    for inclusif in 0...5 {\nprintln(\"La valeur de inclusif 'closed range' est \\(inclusif)\")\n}\nfor exclusif in 0..<5 {\nprintln(\"La valeur de exclusif 'half-open range' est \\(exclusif)\")\n}\nfor car in \"Bonjour le monde\" {\n  println(car)\n}\nlet aventuresTintin = [\"Tintin\", \"Milou\", \"Tournesol\"]\nfor indice in 0..<aventuresTintin.count{\nlet msg = \"Le nom du personnage \\(indice + 1) est \\(aventuresTintin[indice])\"\n}\nfor personnage in aventuresTintin {\n let unPersonnage = personnage\n println(unPersonnage)\n}<\/pre>\n
     <\/p>\n
    for<\/strong> \u00a0(affectation; condition; incr\u00e9mentation) {}<\/p><\/blockquote>\n
     <\/p>\n
    for var compteur = 0, x = 2 ; compteur < aventuresTintin.count ; compteur++ {\n x*=2\n println(\"Le nom du personnage \\(compteur + 1) est \\(aventuresTintin[compteur]) et x vaut \\(x)\")\n}<\/pre>\n
     <\/p>\n
    while et do while<\/h2>\n
    Syntaxe<\/p>\n
    …<\/p><\/blockquote>\n
    var multiplesDeDeux = 2\nwhile multiplesDeDeux < 16 {\nmultiplesDeDeux*=2\nprintln(multiplesDeDeux)\n}\nlet dernierePosition = 1\nvar nouvellePosition:Int\ndo {\nnouvellePosition = Int(arc4random()) % 2 \/\/ un nombre entre 0 et 1\nprintln(nouvellePosition)\n} while nouvellePosition == dernierePosition<\/pre>\n
     <\/p>\n
    \n
    <\/a><\/p>\n
    Bris de s\u00e9quences (tests)<\/h1>\n
    if<\/h2>\n
    Syntaxe<\/p>\n
    if else (if else)<\/p><\/blockquote>\n
    case<\/h2>\n
    Syntaxe<\/p>\n
    switch valeurATester {
    \ncase valeur1: code \u00e0 ex\u00e9cuter pour valeur1 …
    \ncase valeur2, valeur 3: code \u00e0 ex\u00e9cuter pour valeur2 et valeur3 …
    \ndefault: code si aucunes des valeurs
    \n}<\/p><\/blockquote>\n
     <\/p>\n
    let unPersonnage = \"Jean Valjean\"\nprint(unPersonnage)\nswitch unPersonnage {\n  case \"Tintin\", \"Milou\": println(\" fait partie des Aventures de Tintin\")\n  case \"Jean \" + \"Valjean\": println(\" est mis\u00e9rable!\")\n  default: println(\" ne fait partie de rien...\")\n}\nprintln(\"\\n\\n\")\n\/\/\/ switch sur tous les \u00e9lements d'un tableau de chaines\nlet expressionsHaddock = [\n\"Bachi-bouzouk\",\n\"Mille millions de mille sabords\",\n\"Bougres de faux jetons \u00e0 la sauce tartare\",\n\"Esp\u00e8ce de porc-\u00e9pic mal embouch\u00e9\",\n\"Patagon de zoulous\",\n\"Bougre d\u2019extrait de cornichon\",\n\"Simili-martien \u00e0 la graisse de cabestan\",\n\"Sombre oryct\u00e9rope\",\n\"Tra\u00eene-potence\",\n\"Bougres d\u2019extrait de cr\u00e9tins des Alpes\",\n]\nfor expression in expressionsHaddock {\n  print(\"'\\(expression)', est une expression \")\n  switch count(expression) {\n    case 1...15: print(\"facile\")\n    case 16..<33: print(\"difficile\")\n    default: println(\"impossible\")\n  } \/\/ switch\n  println(\" \u00e0 retenir.\")\n} \/\/ for\nprintln(\"\\n\\n\")\n\/\/ boucle sur les \u00e9l\u00e9ments contenant le mot 'Bougre'\nfor expression in expressionsHaddock {\n  \/\/ N\/A \u00e0 partir de beta5: if expression.bridgeToObjectiveC().containsString(\"Bougre\")\n  if (expression as NSString).containsString(\"Bougre\")\n{\n    print(\"'\\(expression)', est une expression \")\n    switch count(expression) {\n      case 1...15: print(\"facile\")\n      case 16..<33: print(\"difficile\")\n      default: println(\"impossible\")\n    } \/\/ switch\n    println(\" \u00e0 retenir.\")\n  } \/\/ if bougre\n} \/\/ for<\/pre>\n
     
    \n <\/p>\n
    \n
    <\/a><\/p>\n
    Les fonctions<\/h1>\n
    Syntaxe
    \nfunc nomDeLaFonction (nomParam1:sonType, nomParm2:sonType, …) -> typeValeurDeRetour {
    \ninstruction1
    \ninstruction…n
    \nreturn expression
    \n}<\/p><\/blockquote>\n
    func sommeDeDeuxNombres(nb1: Double, nb2: Double ) -> Double {\n  \/\/ Note: nb1 et nb2 sont des constantes. Par exemple, nb++ = erreur de compilation.\n  \/\/ Il est possible de d\u00e9clarer avec 'Var', Var nb1: Double.\n  return nb1 + nb2\n} \/\/ sommeDeDeuxNombres()\nsommeDeDeuxNombres(3, 0.1415 )\nsommeDeDeuxNombres(1, 2)\n\/\/ Fonction sans param\u00e8tre et retour\nfunc minimaliste() ->() {\n  println(\"Je suis minimaliste)\")\n} \/\/ minimaliste()\n\/\/ ou bien\nfunc mini() {\n  println(\"minimaliste)\")\n} \/\/ mini()<\/pre>\n
     <\/p>\n
    Noms externes pour les param\u00e8tres<\/h2>\n
    Prenons le cas de la fonction suivante:<\/p>\n
    func d\u00e9placerPersonnage(unPerso:Personnage, vitesse:Float, x:Float, y:Float){
    \n…
    \n}<\/p><\/blockquote>\n
    \u00c0 la lecture de la ligne suivante par une tierce partie, les valeurs inscrites ne seront pas claires.<\/p>\n
    d\u00e9placerPersonnage(bob, 5, 50, 200)<\/p><\/blockquote>\n
    Swift permet de donner des noms externes aux param\u00e8tres (un concept import\u00e9 d’Ojective-C’)<\/p>\n
    func deplacerPersonnage(nomPersonnage unPerso:String, aLaVitesse vitesse:Float, vers_x x:Float, et_y y:Float) {\n  let intro = \"Pour votre plus grand plaisir, nous d\u00e9placons le personnage \"\n  println(\"\\(intro) \\(unPerso) \u00e0 la position x: \\(x), y: \\(y) \u00e0 la vitesse \\(vitesse)\")\n}  \/\/ deplacerPersonnage()\ndeplacerPersonnage(nomPersonnage: \"Bob\", aLaVitesse: 99.9, vers_x: 50, et_y: 200)\n<\/pre>\n
    Si nous voulons avoir comme nom externe, le nom du param\u00e8tre il suffit alors de le pr\u00e9c\u00e9der de ‘#’
    \nPar exemple,<\/p>\n
    func deplacerPerso(#nomPersonnage:String, #aLaVitesse:Float, #vers_x:Float, #et_y:Float) {\n  let intro = \"Au risque de nous r\u00e9p\u00e9ter, nous d\u00e9placons encore une fois, le personnage \"\n  println(\"\\(intro) \\(nomPersonnage) \u00e0 la position x: \\(vers_x), y: \\(et_y) \u00e0 la vitesse \\(aLaVitesse)\")\n}\ndeplacerPerso(nomPersonnage: \"Fred\", aLaVitesse: 23, vers_x: 100, et_y: 100)<\/pre>\n
     <\/p>\n
    Proposer, aux param\u00e8tres, une valeur par d\u00e9faut<\/h2>\n
    Note: Il faut placer les param\u00e8tres facultatifs \u00e0 la fin de la d\u00e9claration. Un nom externe sera automatiquement attribu\u00e9 aux param\u00e8tres avec une valeur par d\u00e9faut.<\/p>\n
    func deplacerSimplement(nomPersonnage:String, aLaVitesse:Float = 50, vers_x:Float = 0, et_y:Float = 0) {\n  let intro = \"Avec les valeurs par d\u00e9faut, le personnage \"\n  println(\"\\(intro) \\(nomPersonnage) reviendra \u00e0 la maison \u00e0 la vitesse \\(aLaVitesse)\")\n}\ndeplacerSimplement(\"Milou\")\n\/\/ *************\nfunc aPlusBC(nb1:Int = 10, nb2:Int = 20, nb3:Int = 0) -> Int {\n return nb1 + nb2 + nb3\n}\naPlusBC(nb2: 3)\naPlusBC(nb3:2, nb2: 3, nb1:4)\n<\/pre>\n
     <\/p>\n
    Fonction avec un nombre variable de param\u00e8tres (variadiques)<\/h2>\n
    func unGrandMerci(#listeDesParticipants:String...){\n  let debutMessage = \"Nous tenons \u00e0 remercier \"\n  let finMessage = \"pour leur participation \u00e0 cette d\u00e9monstration.\"\n  var lesParticipants:String = \"\"\n  for participant:String in listeDesParticipants {\n    lesParticipants += participant + \",\"\n  } \/\/ for\n  println(\"\\(debutMessage) \\(lesParticipants), \\(finMessage)\")\n} \/\/ unGrandMerci()\nunGrandMerci()\nunGrandMerci(listeDesParticipants: \"Tintin\", \"Milou\", \"Tounesol\")<\/pre>\n
    Tester la pr\u00e9sence des param\u00e8tres variadiques<\/h2>\n
    func aditionnerLesNombresEntiersSuivants(desNombres:Int...) -> Int?{\nif desNombres.count == 0 {\n  return nil\n} \/\/ if\nvar total = 0\nfor nombre in desNombres {\n  total += nombre\n} \/\/ for\n  return total\n}\nlet peutEtreUnTotal = aditionnerLesNombresEntiersSuivants(23,66, 123)\nif let total = peutEtreUnTotal {\n  println(\"La somme des nombres donne \\(total)\")\n} else {\n  println(\"Attention, pour obtenir un total, il faut fournir des nombres...\")\n} \/\/ if\n<\/pre>\n
     <\/p>\n
    Modification de la source du param\u00e8tre<\/h2>\n
    func changerNom(unNom:String) {\n  unNom = \"Ne fait pas cela!\" \/\/ Produit une erreur car par d\u00e9faut la d\u00e9claration est de type 'let'.\n}  \/\/ changerNom()\nfunc ajouterAppel(var unNom:String, appel:String) {\n  unNom = appel + \" \" + unNom \/\/ Changera la copie du param\u00e8tre.\n} \/\/ ajouterAppel()\nvar nomNomEst = \"Jean le marin\"\najouterAppel(nomNomEst, \"Monsieur\")\nprintln(\"Mon nom est \\(nomNomEst)\")\nfunc ajouterAppel2(inout unNom:String, appel:String) {\n  unNom = appel + \" \" + unNom \/\/ Changera la variable originale.\n} \/\/ ajouterAppel2()\nvar nomNom = \"Gille Valiquette\"\najouterAppel2(&nomNom, \"Monsieur\")\nprintln(\"Mon nom est \\(nomNom)\")<\/pre>\n
     <\/p>\n
    \n
    <\/a><\/p>\n
    Les ‘tuples’<\/h1>\n
    let ami = (\"Fred\", \"33\", \"Bon\")\nami.0\nlet ami2 = (Nom:\"Toto\", Age:\"99\", Type:\"Ancien\")\nami2.Nom\n\/\/  Note, une fonction peut retourner un 'tuple'\nfunc uneFonction() -> (String, Double){\n...\n  return (\"PI\", 3.141592)\n}\nlet (nom,valeur) = uneFonction()\n<\/pre>\n
     <\/p>\n
    \n
    Les structures de donn\u00e9es<\/h1>\n
    Syntaxe<\/p>\n
    …<\/p><\/blockquote>\n
    struct StructurePersonnage {\n  var nom = \"Non d\u00e9finie\"\n  var niveau = 0\n  var force = 0.0\n  var positionX = 0.0\n  var positionY = 0.0\n  var vies:Int = 0\n} \/\/ StructurePersonnage\nvar jeSuisDeTypePersonnage = StructurePersonnage()\nvar moiAussiJeSuisDeTypePersonnage = StructurePersonnage(nom: \"Bozo le clown\", niveau: 3, force: 55, positionX: 0, positionY: 0, vies: 3)\njeSuisDeTypePersonnage.vies -= 1\nprintln(\"jeSuisDeTypePersonnage = \\(jeSuisDeTypePersonnage)\")<\/pre>\n
     <\/p>\n
    \n
    <\/a><\/p>\n
    Les classes (class)<\/h1>\n
    Syntaxe<\/p>\n
    …<\/p><\/blockquote>\n
    class ClassePersonnage {\n  var nom = \"Non d\u00e9finie\"\n  var niveau = 0\n  var force = 0.0\n  var positionX = 0.0\n  var positionY = 0.0\n  var vies:Int = 0\n  func description() ->String {\n    return \"Je suis le personnage \\(nom) et j'ai une force de \\(force).\"\n  } \/\/ description()\n  func deplacer(#vitesse:Int, posX:Float, posY:Float) {\n    println(\"\\(nom) se d\u00e9place vers (\\(posX),\\(posY)) \u00e0 la vitesse \\(vitesse).\")\n  } \/\/ deplacer()\n} \/\/ ClassePersonnage\nvar personnage = ClassePersonnage()\npersonnage.nom = \"La terreur des barbares\"\nprintln(personnage.description())\npersonnage.deplacer(vitesse: 99, posX: 100, posY: 200)<\/pre>\n
     <\/p>\n
    struct\/class avec un constructeur<\/h2>\n
    class ClassePersoAvecInit {\n  var nom:String\n  var niveau:Float\n  var force:Float\n  var positionX:Float\n  var positionY:Float\n  var vies:Int \/\/ = 0  \/\/ Va produire une erreur\n  init(unNom:String){\n    nom = unNom; niveau = 0; force = 0; positionX = 0; positionY = 0;\n  } \/\/ init(unNom:String)\n  init(unNom:String, uneForce:Float) {\n    nom = unNom;\n    force = uneForce\n    niveau = 0; positionX = 0; positionY = 0;\n  } \/\/ init(unNom:String, uneForce:Float)\n  func description() ->String {\n    return \"Je suis le personnage \\(nom) et j'ai une force de \\(force).\"\n  } \/\/ description()\n} \/\/ ClassePersoAvecInit\nlet perso_01 = ClassePersoAvecInit(unNom: \"Tintin\")\nlet perso_02 = ClassePersoAvecInit(unNom: \"Milou\", uneForce: 99)<\/pre>\n
     <\/p>\n
    Les extensions de classe<\/h2>\n
    extension ClassePersoAvecInit {\n  func retourAuCamp() {\n    println(\"\\(nom) revient au camp.\")\n  }\n}\nlet perso_03 = ClassePersoAvecInit(unNom: \"Le voyageur\")\nperso_03.retourAuCamp()\n\/\/ ---------------------------------\n\/\/ Avec une classe du langage swift:\nextension String {\n    func servirARien()->String{\n        return \"Quelle perte de temps pour '\\(self)'!\"\n    } \/\/ servirARien()\n}\nlet ouf = \"\"\nouf.servirARien()\n\"allo\".servirARien()\n<\/pre>\n
     <\/p>\n
    H\u00e9ritage<\/h2>\n
    class PersonnageComplexe:ClassePersoAvecInit {\n  func methodeQuiTue() ->String {\n    return \"\\(nom) est prit d'une rage et an\u00e9antit tous ses adversaires... glup!\"\n  }\n}\nlet mechant = PersonnageComplexe(unNom: \"Boris\")\nprintln(mechant.methodeQuiTue())\n<\/pre>\n
     <\/p>\n
    \n
    \u00c9num\u00e9rations – enum<\/h2>\n
    enum TypeDeJoueur  {\n    case Novice\n    case Inter\n    case Expert\n}\nlet joueur01:TypeDeJoueur\njoueur01 = .Novice\nif joueur01 != .Expert {\n    println(\"Le joueur n'est pas un expert\")\n} \/\/ if\nswitch joueur01 {\ncase .Novice: println(\"Le joueur est un novice\"); break\ncase .Inter: break\ncase .Expert:break\n    \/\/ Note, pas besoin de clause 'default:' car tous les choix sont \u00e9puis\u00e9s.\n} \/\/ switch<\/pre>\n
     <\/p>\n
    \n
    Protocole –\u00a0Voir le projet Aquarium<\/a><\/h2>\n
     <\/p>\n
    \n
    Observation des valeurs dans le temps<\/h2>\n
    \/\/ Exemple 1: 10 nombres al\u00e9atoires entre 0..<100\nfor x in 0...10 {\n    arc4random_uniform(100)\n}\n\/\/ Un peu de trigonom\u00e9trie dans le temps...\nfor x in 0...255 {\n    let t = Double(x) * sin(Double(x) * M_PI_4\/4)\n}\nfor i in 0...180\n{\n let x = cos(Double(i) \/ M_PI_4)\n}<\/pre>\n
    \"playground-valeursVSTemps\"
    \n 
    \n    R\u00e9f\u00e9rence Apple<\/a><\/p>\n
    \n
    Document r\u00e9dig\u00e9 par Alain Boudreault – Juillet 2014<\/h6>\n
     
    \n <\/p>\n","protected":false},"excerpt":{"rendered":"
    Note\u00a0– Article en cours de r\u00e9vision – version du 2015.09.30 Contenu Le langage de programmation Swift Le ‘playground’ Concepts et syntaxe Les variables et constantes Traitements sur les cha\u00eenes de caract\u00e8res Interpolation de cha\u00eenes Conversion de types Les tableaux Les dictionnaires Les boucles Les tests (if, switch) Les fonctions Les structures de donn\u00e9es Les classes […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1065","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/ve2cuy.com\/xcode\/wp-json\/wp\/v2\/pages\/1065","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ve2cuy.com\/xcode\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/ve2cuy.com\/xcode\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/ve2cuy.com\/xcode\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ve2cuy.com\/xcode\/wp-json\/wp\/v2\/comments?post=1065"}],"version-history":[{"count":0,"href":"https:\/\/ve2cuy.com\/xcode\/wp-json\/wp\/v2\/pages\/1065\/revisions"}],"wp:attachment":[{"href":"https:\/\/ve2cuy.com\/xcode\/wp-json\/wp\/v2\/media?parent=1065"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}