[Swift] base du language

mercredi 18 mai 2016
Variables

variable non typé = Type implicite

var nb =2;

variable typé = Type explicite

var nb:Int =2;

Si implicite, lorsqu’on affecte une valeur, le type de variable est gardé en mémoire. Par la suite, il sera impossible d’affecter un autre type à cette même variable. Dans le cas contraire, on obtiendra une erreur de type Cannot convert value of type « xxx » to specified type « xxx »
Différents type: Int,Float,String,Bool
Ces types sont des objets et possèdent des méthodes.

String.appendContentsOf("") // pour concaténer deux chaînes
String.characters.count // nombre de caractère de la chaîne

AnyObject

permet de typé une variable de manière explicite sans vraiment savoir quel type se sera ou que le type changera par après.

var variable18:AnyObject = "Test"
variable18 = 123.12

Le compilateur ne fera pas d’erreur que si on avait définit un type String au départ car une fois qu’une variable est explicite on ne sait plus changer son type!

Constante

Voici comment on déclare une constante comme son nom l’indique ne peut changer de valeur.

let PI=3,1415

La convention veut que les constantes soient en majuscule.

Les instructions

Une instruction en Swift, n’a pas besoin de ; en fin d’instruction sur une ligne !
Par contre si vous souhaitez mettre plusieurs instructions sur une seul ligne, vous devez séparer les instructions par un ;

Un tuple

Un tuple est un type de variable ou constante qui peut contenir plusieurs valeurs. Il est définit par des parenthèses

var tuple = (404,"Not Found")
let code = erreur404Http.0
let desc = erreur404Http.1

Dans ce cas-ci, le tuple est de type (Int,String)

Voici comment assigner un tuple et récupérer une des valeurs

let erreur404Http = (code:404,message:"Not Found")
let code = erreur404Http.code

Opérateur de concaténation

L’opérateur de concaténation pour les String est le + uniquement si les éléments sont de même type!

let hello = "Hello,"
let world = "World!"
let helloworld = hello+world
ou
print(hello+world)

Si des variables implicite

let nombre1 = 1
let nombre = "Le nombre vaut \(nombre1)"
ou
print("Le nombre vaut "+"\(nombre1)")

Convertir un type de variable en string

let nombre = 1
let text = "Mon nombre choisi est le :"+String(nombre)
Condition

if … else … => pas besoin de mettre des parenthèses.

if … else if … else …

switch case … case … default … => obligé de mettre un default sinon erreur!
Il est possible de faire un swicth sans default si dans le switch on a une énumération car on rentrera jamais dans le default si on a défini tous les case possible de l’enum! Dans le switch, on peut définir un range de valeur via l’opérateur …
Il est aussi possible de mettre plusieurs valeurs ou range dans un case en les séparant par une virgule.

0...9 => range de 0 à 9
0..<10 => range de 0à 9 aussi.

if/else en une ligne:

average = note <10 ? false : true
Boucle
while nblignes <10 {
  nblignes++
}

repeat{

}while nblignes <10

do{

}while nblignes <10

// dans ce cas-ci les instructions dans les {} seront exécuter la première fois même si on ne respecte pas la condition du while.

for nb in 1...10{
  // incrémente de 1 automatiquement par défaut
}

// Va boucler sur chaque caractère du string salut
for i in "Salut"{
  print(i)
}

var courses = [0:"Pain",1:"Confiture",2:"Chips"]
for (key,value) in courses{
  print("Article num:\(key):\(value)")
}

for var nb=0;nb<=1000;nb+2 {
}

On remarque que les parenthèses disparaissent souvent en swift pour alléger le code.

Tableaux
let tab = ["orange,"rouge","bleu","vert"]
var tab2 = [Int]=[] //explicite
for var nb in 1...10{
  tab.append(nb*10)
}

Assignation d’un tableau et parcours de celui-ci

var prenoms = ["Camille","michaël"]
prenoms = prenoms + ["Jean"]

Insert d’un élément dans le tableau

Dictionnaries
var dictionnary = [String:Int] //Déclaration explicite
let personne  = ["Nom":"Thiébault","Prénom":"Michaël"] // déclaration implicite
for(key,value) in personne{
  print(key+" - "+value)
}

parcourir un dictionnaire

Fonction
func test(param1:Type,param2:Type) -> Type_retour{

}
Block

Sont des fonctions sans nom mais peuvent être manipulé comme des variables. Voir le sujet ici

{(param1:Type,param2:Type) -> Type_retour in

}
ou 
maFonction { (nb1: Int, nb2: Int) -> Bool in
    return nb1 > nb2
}
Les classes

En swift pour créer un fichier classe:

  • Créé un fichier .swift et on utilise class comme attribut. Ce fichier contiendra le contenu de la classe avec ces attributs et fonctions
  • Ensuite, dans un autre fichier .swift, on fait juste un appel de cette classe sans devoir faire un import du fichier swift, ils sont automatiquement chargé!

On peut faire un let d’une instance de classe car même si on change les valeurs des attributs de cette classe, l’objet restera le même (sa référence).

Lorsqu’une méthode possède plusieurs paramètres, lors de son appel, il faudra indiquer uniquement la valeur de ce premier paramètre sans devoir spécifier son nom. Et tout comme en Objective-C pour les paramètres suivants, il faudra spécifier le nom des paramètres juste avant leur valeur.
Il existe la surcharge de méthode en swift.
Le constructeur en Swift est init() et il n’a pas d’attribut func avant !

Structure

Les structures sont exactement comme des classes mais il ne bénéficie pas de l’héritage et sont des types par valeur et non par référence comme les classes. Donc si on appelle et créé deux structures, qu’on assigne l’une à l’autre et qu’on modifie l’une, l’autre n’est pas modifié si ce sont des structures. Mais si ce sont des classes (par références), elles sont modifiés toutes les deux et donc identiques. On ne peut pas assigner des valeurs par défaut aux attributs dans une structure.

Héritage

L’attribut super permet d’accéder aux attributes ou méthodes de la classe parente. En swift, l’héritage multiple n’existe pas, il y a qu’une seule classe parent.

Polymorphisme

Le polymorphisme permet de surcharger une fonction d’une autre classe via l’attribut override

override func test(){
  super.test()
  print("Happy birthday")
}
Protocole

Protocole = Interface = modèle de la classe

Un protocole sert à définir un plan minimal que doit suivre une classe.
Le protocole n’implémente pas les méthodes, on écrit juste les méthodes sans décrire ce qu’elles vont réellement faire. Tout seul, le protocole ne sert à rien, il faut définir une classe qui va implémenter les méthodes du protocole.

protocol ProtocolAnimal{
  func cri()
  func seDeplacer()
}

Toute classe qui implémente un protocole doit suivre scrupuleusement la signature du protocole. Et une classe peut implémenter plusieurs protocoles.

class Animal : ProtocolAnimal1,ProtocolAnimal2{
}

Si notre classe hérite aussi d’une classe parent, alors après les : on met d’abord la classe à hériter ensuite les protocoles !

Enumération
enum language{
  case Swift (String,String)
  case Java (String)
  case Php (String)
  case C (String)
}
var langeUtilise = language.Swift("Le language Swift","Le language que vous apprenez")

Une énumération permet de préciser une liste de cas possible pour traiter une valeur
Les énumérations permettent de s’assurer que les valeurs passées dans enum soit bien défini si ce n’est pas le cas, on sera avertit par Xcode. Très utile d’utiliser une énumération pour préciser les valeurs possibles et uniquement celles-ci et pas d’autre possible.

Optionnelle

Il peut arriver en Swift d’obtenir une valeur dans une variable de type optionnelle c’est-à-dire que Swift ne sait pas si la valeur peut être affectée ou non. On a cela lorsqu’on souhaite faire un cast d’un String en Int par exemple. Si on est sur on peut mettre un ! après le nom de la variable et le optionnelle disparaît. Il est aussi possible de définir le type qu’il sera en ajoutant as Type. Les conversions (cast) de variables rendent leur valeur optionnel. A l’inverse pour rendre une variable optionnelle, il suffit de mettre un ? à côté. Une variable optionnelle pourra être nil ce qui n’est pas possible pour une variable typé Int, Double, String, etc…

var courses = [0:"Pain",1:"Confiture",2:"Chips"]
var premierArticle = courses[0] as String
Extension

Une extension en Swift va vous permettre d’augmenter la capacité de vos types, c’est-à-dire pouvoir ajouter de nouveaux attributs ou méthodes à une classe par exemple déjà existante. Très utile si on veut ajouter des informations sur une classe qui nous appartient pas !
Une extension pet s’appliquer aussi à des protocoles !

extension NomduTypeAEtendre: Protocole1{
}

On peut aussi faire une extension sur des types définit par framework iOS

extension Int{
  var carre : Int { return self*self}
  var fois10 : Int { return self*10}
}

extension Int{
  var m : Int { return self}
  var mm : Int{ return self * 1000}
  var cm : Int{ return self * 100}
  var dm : Int{ return self * 10} 
}
print("2m vaut \(2.cm) cm")
PlayGround

Ajouter un fichier playground dans votre projet permet de tester à la volée le code que vous produisez, c’est-à-dire d’afficher la valeur de chaque variable instruction par instruction sans devoir compiler votre code.

Be Sociable, Share!

Tags: Swift