2

Commencer avec Swift : Les tableaux

Bonjour à tous ! Aujourd’hui on va parler d’un type de variable dont on a pas parlé jusqu’a présent : les array (tableaux). Ils permettent de structurer des données et d’y accéder rapidement, nous allons voir comment s’en servir dans notre code !

Les tableaux

Tout d’abord, sachez qu’on les appelle des tableaux mais ils sont en réalité plus comme des listes ordonnées permettant de stocker plusieurs données dans un ordre précis. Ils contiennent plusieurs valeurs pour une seule variable chacune étant identifiable par son ordre dans la liste. Par exemple on pourrait imaginer déclarer une variable Liste qui contiendrai :

  1. Premier item
  2. Deuxième item
  3. Troisième item

On pourrait connaitre chacune des valeurs en donnant leur numéro : Liste->1 = Premier Item. En bien les tableaux fonctionnent exactement de la même façon. Il y a tout de même quelques contraintes supplémentaires inhérentes au swift.

Chaque valeur du tableau doit être du même type. Par exemple, on ne peut pas stocker des valeurs Int et des valeurs String dans un même Array (va falloir commencer à s’y faire). Par contre, contrairement à certains autres langages de programmation (comme le C), il n’est pas nécessaire de déclarer la taille d’un tableau. En swift ils s’adaptent automatiquement au nombre de valeurs présentes.
On les déclare avec des crochets [ ] que l’on peut écrire sur un mac avec les touches ⇧ + ⌥ et les parenthèses (maj. + alt + parenthèse gauche ou droite). Entre ces crochets on inscrit toutes les valeurs séparées par des virgules “,“.

1
2
let salutations = ["Salut", "Bonjour", "Hello"]
print(salutations[1])    // Bonjour

On peut ensuite accéder aux valeurs en inscrivant leur adresse (appelé index) entre les crochets suivant le nom de la variable. Vous aurez remarqué que notre exemple affiche “Bonjour” alors que nous lui avions demandé le premier élément de la liste et qu’il s’avère être le deuxième. C’est tout à fait normal, en Swift (et à peu près dans tous les langages) les compteurs des tableaux commencent à l’index 0 qui correspond au premier élément, 1 qui correspond au deuxième, etc…

Ca peut sembler stupide si vous n’avez jamais programmé mais vous vous habituerez vite. On peut tester les valeurs des tableaux dans des conditions comme avec des variables standard :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let entree = "Salut"
let salutations = ["Salut", "Comment ça va ?", "Au revoir"]

if entree == salutations[0] {
   // Bonjour !
}
else if entree == salutations[1] {
   // Bien et vous ?
}
else if entree == salutations[2] {
   // A plus tard !
}
else {
   // Requête inconnue
}

Remarque : l’opérateur == retourne true uniquement si les variables comparées sont exactement identiques. Ce qui signifie pour une variable de type String que les majuscules sont prises en compte dans la comparaison.

Les dictionnaires

Les dictionnaires sont un type de tableau particulier. Leurs index ne sont pas des nombres mais peuvent être n’importe quoi d’autre (on les appelle des clés). On peut utiliser n’importe quel type de variable à la place, mais par conséquent l’ordre du dictionnaire n’est pas forcément conservé.

1
2
let dict = ["nom": "Dupont", "prenom": "Pierre"]
print(dict["prenom"])

Ici, on utilise des String comme index du dictionnaire, et on accède à chaque valeur de la même façon qu’avec un tableau. La valeur retournée ici est bien “Pierre” mais elle apparaît en tant que valeur optionnelle.

Elle apparait ainsi car avant la compilation, c’est a dire dans le code, Xcode n’est pas capable de savoir si telle ou telle entrée existe dans le dictionnaire. Oui ici il pourrait car le tableau est déclaré juste au dessus et n’est pas modifiable (let) mais sur une vraie application, le tableau sera crée en fonction de données dynamiques, par exemple récupérées sur internet. Dans ce cas, il sera nécessaire de tester si l’entrée existe avant de pouvoir l’utiliser.

1
2
3
4
5
6
7
8
9
let dict = ["nom": "Dupont", "prenom": "Pierre"]

if let nom = dict["nom"] {
    // Ici la constante nom est utilisable, elle existe
    // Ce code ne s'exécutera que si l'association est possible
    print(nom)
}

// Ici la variable nom n'existe plus, l'utiliser retournera une erreur

Ici on teste si la déclaration d’une variable nom est possible avec une des valeurs du dictionnaire comme valeur. Si l’association échoue alors le dictionnaire ne contient pas de valeur pour l’index “nom”, on passera directement au code après la condition.

Les types des collections

On peut déclarer une collection (un tableau ou un dictionnaire) vide simplement avec des crochets et deux points dans le cas d’un dictionnaire ( [:] ). Mais cela va vite nous poser un problème, si on déclare une collection vide il faut définir le type de variable qu’elle contiendra ou bien Xcode nous donnera l’erreur Empty collection literal requires an explicit type. On doit donc déclarer le type des variables que l’on va utiliser (les variables) de cette façon :

1
2
var tableau: [String] = []
var dict: [String:Int] = [:]

Dans cet exemple, le tableau ne pourra contenir que des valeurs de type String et le dictionnaire des index de type String et des valeurs de type Int.

Travailler avec les tableaux

Les tableaux (comme tous les types de variable) contiennent des fonctions ou des sous-variables intégrées permettant d’agir dessus. On les appelle des instances de méthodes (Apple Developer). Elles sont accessibles en accolant un point (.) à la suite de la variable de type tableau. on peut ainsi savoir combien il y a d’entrées à un tableau ou un dictionnaire en faisant appel à la sous-variable .count qui nous retournera une valeur de type Int

1
2
3
4
5
6
let salutations = ["Salut", "Comment ça va ?", "Au revoir"]

let longueurTableau = salutations.count

print("Longueur du tableau : " + String(longueurTableau))
// On converti la valeur de type Int en String pour pouvoir l'utiliser

Il existe une multitude de variables et de méthodes (de fonctions) pour travailler sur les tableaux ou les dictionnaires, on ne les verra bien sur pas toutes aujourd’hui, je vous en donne une autre indispensable : .append qui permet d’ajouter une entrée à un tableau. C’est une fonction qui s’utilise de cette façon : .append( nouvelElement ). Pour ajouter une entrée à un dictionnaire, il suffit de faire appel à son index et d’y associer une valeur comme une déclaration de variable classique. Attention à bien respecter les types de variables attendus, et n’oubliez pas que vous ne pouvez pas modifier de constantes.

1
2
3
4
5
6
7
8
9
10
11
var tableau: [String] = ["Salut", "Comment ça va ?", "Au revoir"]
var dict = ["nom": "Dupont", "prenom": "Pierre"]

tableau.append("Hello")    // On ajoute "Hello" à la fin du tableau
dict["age"] = "24"         // On ajoute ["age":"24"] au dictionnaire

print(tableau)
// ["Salut", "Comment ça va ?", "Au revoir", "Hello"]

print(dict)
// ["age": "24", "nom": "Dupont", "prenom": "Pierre"]

.append va ajouter la valeur à la fin du tableau (liste ordonnée) alors que le dictionnaire va s’ajouter automatique là où Xcode le place.

On peut supprimer une valeur d’un tableau très simplement en utilisant la fonction .remove(at: index). Il suffira de remplacer “index” par l’index de la valeur que l’on souhaite supprimer (rappelez-vous, ca commence à 0).

1
2
3
4
5
6
7
// [...] suite du dernier exemple
// tableau = ["Salut", "Comment ça va ?", "Au revoir", "Hello"]

tableau.remove(at: 1)

print(tableau)
// ["Salut", "Au revoir", "Hello"]

Pour supprimer une valeur d’un dictionnaire, il y a quelques étapes en plus car on doit supprimer sa clé en plus. On doit donc récupérer une variable de type “index de dictionnaire” via la méthode .index(forKey: key) en remplaçant “key” par la clé à supprimer dans le dictionnaire.

1
2
3
4
// [...] suite du dernier exemple
// dict = ["age": "24", "nom": "Dupont", "prenom": "Pierre"]

let removeIndex = dict.index(forKey: "nom")

La valeur retournée est également optionnelle, on doit donc la tester avant de pouvoir l’utiliser. Il suffira ensuite d’appeler la méthode .remove(at: index) en remplaçant “index” par l’index calculé.

1
2
3
4
5
6
7
8
// dict = ["age": "24", "nom": "Dupont", "prenom": "Pierre"]

if let removeIndex = dict.index(forKey: "nom") {
    dict.remove(at:removeIndex)
}

print(dict)
// ["age": "24", "prenom": "Pierre"]

 

Vous êtes toujours là ? Eh oui on commence les difficultés ici, je ne m’attarde pas trop sur les variables optionnelles, les tests de déclaration ou les instances de méthode car ce sont des sujets bien plus vastes et nous aurons tout le temps et le loisir d’y revenir !

Suite du tutoriel Commencer avec swift

Les boucles

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *