Fil d'Ariane
Mis à jour le vendredi 27 janvier 2017
  • 15 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Ce cours existe en eBook.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Rattrapons le temps perdu !

Connectez-vous ou inscrivez-vous pour bénéficier de toutes les fonctionnalités de ce cours !

Il existe quelques petites astuces ou notions supplémentaires dont j’aurais pu vous faire part dans la première partie. Néanmoins, elles étaient liées à la programmation orientée objet. Pour ne pas vous embêter de suite avec cette notion, j’ai volontairement omis ces astuces et notions. Sauf que maintenant, vous savez ce qu’est la POO ! Il est temps pour nous de rattraper ce temps perdu, et je vais vous présenter quelques astuces et notions en complément de la première partie.

Les variables

Ce que je ne vous ai pas dit jusqu’à présent, c’est que chaque variable en Swift représente en fait un objet. On ne le déclare pas comme je vous l’ai appris dans les chapitres de cette partie, mais pourtant une variable est bel et bien un objet.

Quel objet représente une variable alors ?

L’objet sera le type de votre variable. Une variable peut être du type de l’objet que vous avez vous-mêmes créé, mais aussi tout simplement de typeString,Int,Float,Bool, etc. Eh bien, sachez que ces types sont des objets eux aussi. De ce fait, dès lors que vous déclarez ces variables, vous avez des objets.

String

Les quelques astuces intéressantes pour unString sont :

  • Concaténer grâce à une nouvelle méthode. La concaténation se fera à la fin de la chaîne concaténée (et non pas à la fin de la chaîne à concaténer donc).

  • Connaître le nombre de caractères d’une chaîne de caractères.

Pour cela, il suffit de se servir de la méthodeappend()‌et d’utiliser l’attribut character.count

var str: String = "ABC"

// On concatène "DE" à "ABC"
str.append("DE")

// On obtient donc "ABCDE"
print(str)

// Affichera le nombre de caractères que comporte "ABCDE"
print(str.characters.count)

 

Les tableaux et dictionnaires

Pour les tableaux et les dictionnaires, de nombreuses méthodes sont intéressantes !

  • Une méthodecount() qui permettra de vous dire directement le nombre d’éléments de votre tableau ou dictionnaire.

  • Une méthodeappend() qui comme pour leString vous permettra d’ajouter un nouvel élément à la fin de votre tableau à la condition que cet élément respecte le type de ce dernier.

  • L’attributfirst ou l’attributlast qui vous donneront la valeur du premier élément de votre tableau ou la valeur du dernier élément de votre tableau. Ne marche pas pour un dictionnaire.

  • Une méthodeisEmpty() qui vous retournera un booléen si votre tableau ou dictionnaire est vide.

  • Une méthodeinsert() pour insérer un nouvel élément dans votre tableau ou dictionnaire. Il faudra préciser en paramètre le nouvel élément et l’index où placer ce nouvel élément.

  • Une méthoderemoveAll() pour supprimer tous les éléments de votre tableau ou dictionnaire. Vous vous retrouverez alors avec un tableau ou un dictionnaire vide, sans éléments.

  • Une méthoderemoveAtIndex() pour supprimer l’élément de votre tableau à l’index donné en paramètre.

  • Une méthoderemoveLast() qui supprime le dernier élément de votre tableau.

  • Une méthodereverse() qui donnera un tableau avec l’ordre de vos éléments changés. Le premier élément deviendra le dernier et le dernier deviendra le premier élément.

Voici un exemple d’utilisation :

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

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.reverse() // [7, 6, 5, 4, 3, 2, 1]

Les optionnelles

Il s’agit là d’une notion supplémentaire que j’aurais pu elle aussi vous présenter dans la première partie. Seulement, pour vous l'expliquer de façon simple, la notion de POO m’était utile. Il s’agit des variables optionnelles.

Une variable est dite optionnelle si lors de l’affectation on peut se retrouver avec deux cas :

  • Une valeur peut être affectée.

  • Une valeur ne peut pas être affectée.

Pour mieux vous expliquer ce concept, j’ai choisi ici de vous présenter ce qu'on appelle un initialiseur, à savoir iciInt(). Cet initialiseur vous permettra de convertir, si c’est possible seulement, une chaîne de caractères en un entier. Je m’explique : « 123 » peut se convertir en l’entier 123. La chaîne « Bonjour ! » elle, ne peut pas se convertir en entier, logique non ? Seulement, lorsque l’on exécute cet initialiseur sur unString , Swift ne sait pas forcément la valeur de la variable. C’est pourquoi on se retrouve avec les deux cas que j’ai présentés ci-dessus : si c’est « 123 » alors on peut affecter une valeur, si c’est « Bonjour ! » alors on ne pourra rien affecter. 

Voici un exemple d’utilisation de cette méthode :

let nombreString: String = "123"
let nombreInt = Int(nombreString)

Dans cet exemple, l'initialiseur Int() fonctionnera car la chaîne « 123 » peut retourner l’entier 123.  Seulement, elle aurait très bien pu échouer si à la place de « 123 » on avait écrit « Bonjour ! ». De ce fait, on dit que l'initialiseur Int() retourne unInt mais optionnel (car on n'est pas sûr). UnInt optionnel s’écrit en SwiftInt?, grâce au point d'interrogation. 

Quelle valeur contient notre variable nombreInt si la méthode échoue et que l’on n'a pas pu attribuer d’Int ?

Quand la méthode échoue, la variable aura pour valeurnil, c’est-à-dire une valeur nulle : la variable ne contient rien. Grâce à cenil, on peut donc tester si la méthode a échoué ou non. On utilisera les conditions de cette façon :

let nombreString: String = "123"
let nombreInt = Int(nombreString)

if nombreInt != nil {
    print("nombreInt contient une valeur")
} else {
    print("nombreInt ne contient pas de valeur")
}

Si la variablenombreInt est différent denil, alors c’est qu’on a pu attribuer une valeur à notre variable. Sinon, la méthode a échoué et la variable ne contient rien (doncnil).

Vous pouvez tester et voir le contenu de la variable quand on remplit la condition et quand on ne la remplit pas :

let nombreString: String = "123"
let nombreInt = Int(nombreString)

if nombreInt != nil {
    print(nombreInt)
} else {
    print(nombreInt)
}

Si vous mettez « abc » comme valeur ànombreString, alors la console vous afficheranil. Sinon, la console va vous afficher votre nombre, mais pas que. En effet, la console vous affiche pour l’exemple ci-dessus :Optional(123).

C’est tout à fait normal, je vous ai dit que quand on n'est pas sûr, ce n’est pas unInt qui est retourné mais unInt?, c’est-à-dire unInt optionnel. 

Oui mais bon, grâce à la condition, je sais que j’ai obligatoirement unInt. Comment afficher ceInt et pas unInt? ?

Eh bien, quand on est absolument sûr que la variable que nous utilisons est bien ce à quoi on s’attendait, il suffit d’ajouter un point d’exclamation à la fin du nom de votre variable. 

let nombreString: String = "123"
let nombreInt = Int(nombreString)

if nombreInt != nil {
    print(nombreInt!)
} else {
    print(nombreInt)
}

Une dernière chose, on peut éviter les conditions en assignant une valeur par défaut dans le cas où l'on aura pas pu affecter un nombre. Voici comment procéder :

let nombreString: String = "abc"
let nombreInt = Int(nombreString)

print(nombreInt ?? 1)

On utilise aussi les liaisons optionnelles pour savoir si une optionnelle contient oui ou non une valeur.  Les liaisons optionnelles s'utilisent avec les conditionsif  et la boucle while. Grâce à une liaison optionnelle, on peut alors extraire la valeur sûre en variable ou constante et cette fois-ci en une seule action.

Par exemple, avec une conditionif :

if let nomConstanteAExtraire = variableOuConstanteOptionnelle {
    
}

if var nomVariableAExtraire = variableOuConstanteOptionnelle {
    
}

// Exemple
let nombreString = "123"
if let nombreInt = Int(nombreString) {
    print("On a accès aux deux variables : \(nombreString), \(nombreInt)")
} else {
    print("On a accès qu'à la variable : \(nombreString)")
}

Si la condition marche, alors une nouvelle variable ou constante est alors créé et vous y avez accès par la suite. Si la condition n'est pas vérifiée, alors cette constante ou variable n'existera tout simplement pas. 

Vous pouvez à présent gérer de nouveaux types : en effet, maintenant, rien ne vous empêche de déclarer vous-mêmes vos variables optionnelles. 

var nombre: Int?

var str: String?

Lors des prochaines affectations, vous ne serez donc pas sûrs des valeurs que contiendrontnombre oustr, si c’est vraiment unInt ou unString ou non.

Déclarées comme ceci, vos variables prennent directement la valeurnil. Vous pouvez néanmoins vous-mêmes assigner la valeurnil  à vos variables optionnelles.

var nombre: Int? = nil

var str: String? = "Coucou"

Pour résumer :

  • ‌Les types connus jusqu'à présent commeInt,String,Bool sont en fait des objets.

  • De ce fait, plusieurs méthodes sont déjà présentes.

  • Une optionnelle est une variable ou constante qui peut contenir soit une valeur, soitnil.

Exemple de certificat de réussite
Exemple de certificat de réussite