Découverte de Swift (1)

Je commence ma découverte de Swift. Au programme, du classique avec les bases du langage : constantes, variables, chaînes de caractères, collections, boucles et conditions.

Pour ma découverte de Swift, j'aurais pu débuter avec une sorte de Développez votre application en 100 leçons, un tutoriel ou un livre proposant de découvrir progressivement les éléments du langage à travers des exercices pratiques et des exemples concrets. Mais ce n'est pas ainsi que je fonctionne. Là où certains trouvent cela rébarbatif, j'ai toujours aimé découvrir la théorie avant la pratique. Je ne sais pas si c'est la méthode la plus efficace pour apprendre, mais c'est celle avec laquelle je me sens le plus à l'aise.

C'est pour cette raison que j'ai choisi de commencer mon apprentissage de Swift avec le livre de référence officiel d'Apple qui décrit le langage : The Swift Programming Language, dans sa version 5.3 (la version la plus récente à ce jour du langage)

The Swift Programming Language - Swift 5.3 Edition

J'en ai lu un bon quart jusque là, et j'aime plutôt ce que j'ai eu l'occasion de découvrir. La syntaxe est claire, plutôt concise, et globalement élégante à quelques exceptions près. Le langage semble bien pensé, en tout cas pour ce que j'ai pu en voir.

C'est le jour et la nuit par rapport à ce que j'ai l'habitude de pratiquer au boulot, c'est-à-dire un étrange mélange d'un langage propriétaire qui ressemble à du COBOL amélioré et d'une couche orientée objet ajoutée par dessus pour faire moderne.

Avec Swift, j'ai le plaisir de découvrir un langage qui propose des concepts modernes et intelligents.

Constantes et variables

Du côté des constantes et des variables, c'est classique mais efficace. J'aime la sécurité apportée par le typage fort, tout en profitant de la souplesse et de la simplicité du typage implicite lors de la première affectation.

let maxAttempts:Int = 3
// Une constante de valeur 3 et de type explicite Int
var numAttempts: Int = 0
// Une variable de valeur 0 et de type explicite Int
let userName = "scott"
// Une constante de valeur "scott" et de type implicite String (déduit de sa valeur)
var password: String
// Une variable sans type explicite ni valeur
password = "tiger"
// La variable obtient à la fois une valeur "tiger" et un type implicite String (déduit de sa valeur)

Chaînes de caractères

Là aussi, on est sur du classique, avec des caractères de type Character et des chaînes de caractères de type String, le tout supportant Unicode.

Il y a des fonctions assez classiques pour savoir si une chaîne de caractères est vide, pour savoir combien de caractères elle contient, pour récupérer le énième caractère, pour extraire une partie de la chaîne, etc.

On peut aussi, évidemment, intégrer des éléments variables dans une chaîne de caractères, que ce soit une variable ou le résultat d'une opération plus complexe, voire une fonction.

let string1 = "hello"
let string2 = " there"
var welcome = string1 + string2
// welcome now equals "hello there"

for character in "Dog!🐶" {
    print(character)
}
// D
// o
// g
// !
// 🐶

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
// message is "3 times 2.5 is 7.5"

Opérateurs

Pour les opérateurs, on retrouve du très classique, notamment pour ceux qui connaissent le C++ : opérateurs d'affection, arithmétiques, comparaison, logiques, le fameux opérateur conditionnel ternaire (question ? yes : no) permettant d'abréger une condition if ... else.

J'ai par contre découvert des opérateurs que je ne connaissais pas, comme ceux pour manipuler des ranges, particulièrement utiles pour parcourir des tableaux ou des séquences.

// Closed Range Operator
for index in 1...5 {
    print("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

// Half-Open Range Operator
for index in 1..<5 {
    print("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20

Boucles et conditions

Concernant les boucles et les conditions, on est là encore sur du classique, je n'ai pas été perdu avec mes souvenirs de C++ datant de mes études. On trouve dans if ... else, des for ... in, des while, et des repeat ... while

Swift apporte tout de même quelques subtilités qui m'ont bien plu, notamment pour les switch où il n'est plus nécessaire d'ajouter systématiquement un break à la fin de chaque case pour éviter de déclencher par erreur le case suivant, comme c'était le cas en C++ ...

Collections

Swift propose 3 types standards de collection : – Array : liste ordonnée de valeurs (pas forcément uniques) – Set : liste non ordonnée de valeurs uniques – Dictionnary : liste non ordonnée de paires clé-valeur

On trouve ensuite des fonctions pour manipuler ces collections, certaines communes aux 3 collections proposées, d'autres spécifiques aux fonctionnalités de chaque collection.

Par exemple pour les sets, il existe des fonctions pour réaliser l'intersection, l'union, la soustraction ou la différence symétrique entre deux sets, ou pour savoir si un set est un subset ou un superset d'un autre set.

A suivre ...

Vous l'aurez compris : pour l'instant, on est plutôt sur du classique. Rien ne m'a vraiment surpris, j'ai retrouvé des concepts et une syntaxe que j'avais déjà rencontrés entre C++ ou en Java. J'ai tout de même apprécié certaines notions ou des choix forts faits par Swift par rapport à des langages plus anciens comme C++ ou Java.

Par contre, les chapitres suivants abordent des notions plus nouvelles pour moi, ou en tout cas abordées d'une façon que je ne soupçonnais pas. Mais ce sera pour le prochain billet, ou les prochains billets selon que je sois plus ou moins bavard. Je vous parlerai de fonctions, de tuples, d'optionals, et de closures.

#swift

Zéro Tech, le blog Tech de Zéro Janvier@zerojanvier@mamot.fr