Swift : aide-mémoire

Commmentaires

// Ceci est un commentaire sur une ligne
// Ceci est autre commentaire sur une ligne
// Ceci est un troisième commentaire sur une ligne

/* Ceci est un bloc de commentaire
sur plusieurs lignes */

Types de données

TypeUsageExemple
StringTexteNom de l’utilisateur, titre de l’écran, message d’alerte
IntNombresAge de l’utilisateur, score dans le jeu, nombre de notifications
FloatNombre sur 32 bits6 chiffres après la virgule (poids de l’utilisateur, température)
DoubleNombre sur 64 bits15 chiffres après la virgule (3.14159265359)
BoolVRAI ou FAUXRésultat d’une question/expression (Fait-il beau ? )
Types de données basiques

Constantes et Variables

Constante – let

Une constante est immuable (immutable), sa valeur ne peut pas changer après qu’elle ait été initialisée

// Vous pouvez spécifier le type de données lors de la déclaration d'une constante
// ou laisser Swift gérer l'inférence de type
let variableName: VariableType = variableValue
let variableName = variableValue

// Déclaration de plusieurs constantes
let countryString: String = “Brazil” 
let postalCode = 59000
let decimalValue = 10.0
let isSelected = true

Variable – var

Une variable est muable (mutable), sa valeur peut so its value can change when needed

// Vous pouvez spécifier le type de données lors de la déclaration d'une variable
// ou laisser Swift gérer l'inférence de type
var variableName: VariableType = variableValue
var variableName = variableValue

// Déclaration de plusieurs variables
var countryString: String = “Brazil” 
var postalCode = 59000
var decimalValue = 10.5
var isSelected = true

Operateurs

Arithmétique basique

var myScore = 10 
myScore = myScore + 3 
myScore = myScore - 5 
myScore = myScore * 2 
myScore = myScore / 2

// Une autre manière d'écrire le code ci-dessus grâce à l'assignation composée (compound assignment)
myScore += 3 
myScore -= 5
myScore *= 2 
myScore /= 2

Priorité des opérateurs

  1. ( )
  2. * /
  3. + –
var x = 2
var y = 3
var z = 5
print(x + y * z) // 17
print((x + y) * z) // 25 

Structures conditionnelles

Opérateurs conditionnels

OperatorDescription
==Le deux éléments ou valeurs sont égaux
!=Le deux éléments ou valeurs ne sont pas égaux
>La première valeur est strictement supérieure à la seconde valeur
>=La première valeur est supérieure ou égale à la seconde valeur
<La première valeur est strictement inférieure à la seconde valeur
<=La première valeur est inférieure ou égale à la seconde valeur
&&Opératuer AND : Toutes les conditions doivent être VRAIES
||Opérateur OR : Au moins une des conditions est VRAIE

if – else

Exécution de codes différents selon une condition

if myCondition {
// Bloc de code exécuté si myCondition est vraie
}

// Exemple de vérification de la température
var temperature = 100

if temperature >= 100 {
  print("It’s boiling") 
} else {
  print("It’s not boiling")
}

if – else if

if myCondition {
  // Bloc de code exécuté si myCondition est vraie
} else if anotherCondition {
  // Bloc de code exécuté si anotherCondition est vraie
}

// Exemple de vérification de la température
var temperature = 100

if temperature >= 65 && temperature <= 75 {
  print("It’s boiling")
} else if temperature < 65 {
  print("It’s cold”)
}

if – else if – else

Note : « else if » est optionnel, on peut utiliser « if else » sans utiliser « else if »

if myCondition {
  // Block executed if myCondition is true
} else if anotherCondition {
  // Block executed if anotherCondition is true
} else {
  // Block executed if any conditions before is true
}

var temperature = 100
if temperature >= 65 && temperature <= 75 {
  print(“It’s boiling")
} else if temperature < 65 {
  print(“It’s cold”) 
} else {
  print(“It’s too hot”)
}

switch

switch value {
  case a:
    // Bloc de code exécuté si "value" vaut a
  case b:
    // Bloc de code exécuté si "value" vaut b
  case c:
    // Bloc de code exécuté si "value" vaut c
  default:
    // Bloc de code exécuté si "value" vaut une autre valeur
}

// Exemple 1

let initials: String = "DA"
switch initials {
  case "DS":
    print("Dan Santos")
  case "GD":
    print("Guile Dread")
  case "MN":
    print("Mark Niels")
  default:
    print("None of the above")
}

// Exemple 2 avec des intervalles (Range)

0…99   // de 0 à 99 (inclus) 
0..<99 // de 0 à 99 (exclus)

switch distance { 
  case 0…9:
    print("Your destination is close.") 
  case 10..<99:
    print("Your destination is a medium distance from here.") 
  default:
    print("Are you sure you want to travel this far?")
}

Strings

// Les chaînes de caractères se trouvent toujours entre des guillemets ""
let greeting = "Hello"
let greeting = "Hello"
var otherGreeting = "Salutations"
var otherGreeting = “Salutations"

// On peut aussi utiliser du texte sur plusieurs lignes à l'aide de 3 guillements """
let joke = """
Q: Why did the chicken cross the road? A: To get to the other side!
"""

Caractère d’échappement

// La chaîne de caractères affiche les guillemets " grâce au backslash \
let greeting = "It is traditional in programming to print \"Hello World!\""
EscapeDescription
\ »Conserve les guillemets dans le texte
\\Conserve backslash dans le texte
\tInsert une tabulation
\rInsert un retour charriot

Concaténation

let firstName = "John"
let lastName = "Doe"
let greetings = "Hello " + firstName + lastName // Hello John Doe

Interpolation

let firstName = "John"
let lastName = "Doe"
let greetings = "Hello \(firstName) \(lastName)" // Hello John Doe

Fonctions

Fonction simple

func myFunctionName() {
  // Bloc de code exécuté lorsque la fonction est appelée
}
func greetingUser() { 
  print ("Hello James")
}
// Appel de la fonction
greetingUser() //Hello James

Fonctions avec paramètres

func myFunctionName(param1: MyFirstParamType, param2: MySecondParamType) {
  // Bloc de code exécuté lorsque la fonction est appelée
}

func greetingUser(name: String) { 
  print ("Hello \(name)")
}
// Appel de la fonction
greetingUser(name: "James") //Hello James

Fonction avec paramètres et valeur de retour

func myFunctionName(param: MyFirstParamType) -> ReturnValueType { 
  // Bloc de code exécuté lorsque la fonction est appelée
}

func greetingUser(name: String) -> String { 
  return String("Hello \(name)")
}

// Appel de la fonction
let message = greetingUser(name: "James") 
print(message) //Hello James

Collections

Array (Tableau)

var tracks: Array<String> = ["Interlagos", "Velocitta", "Auto Club Speedway"]
var tracks: [String] = ["Interlagos", "Velocitta", "Auto Club Speedway"] 
var tracks = ["Interlagos", "Velocitta", "Auto Club Speedway"]
// Toutes les lignes de code ci-dessus sont équivalentes

// Décalaration d'un collection ordonnée
var visitedContries: Array<String> = ["Brazil", "USA", "Sweden", "Colombia"]

// Accéder à un élément du tableau grâce à son index
print(visitedContries[0]) "Brazil"

// Ajout d'un élément au tableau
visitedContries.append("Italy")

// Ajout d'éléments d'un tableau dans le contenu d'un autre
visitedContries += ["Brazil", "USA", "Sweden", "Colombia"]

// Insertion d'un élément à une position précise
visitedContries.insert("Indonesia", at: 5)

// Connaître le nombre d'élémrnt d'un tableau
visitedContries.count //10

Set (Ensemble)

// Déclaration d'une collection d'élément non-ordonnés
var cakeIngredients: Set = ["Eggs", "Butter", "Flour", "Milk"]

// Affichage du contenu
print(cakeIngredients) //"Milk", "Butter", "Flour", "Eggs"

// Insertion d'un nouvel élément dans la collection
cakeIngredients.insert("Milk")

// Affichage du contenu
print(cakeIngredients) //"Milk", "Butter", "Flour", "Eggs"

// … plus d'infos dans la documentation officielle

Dictionnary (Dictionnaire)

var airports: Dictionary = ["CGH":"São Paulo", "CWB":"Curitiba"]
var airports: [String:String] = ["CGH":"São Paulo", "CWB":"Curitiba"] var airports = ["CGH":"São Paulo", "CWB":"Curitiba"]
// Each above line are doing the same thing

// Declaring an unordered collection
var countryCode: [String:Int] = ["BR":55, "US":1, "IT":39, "IN":62]

// Accessing an element using its key
countryCode["IT"] //39

// Adding / removing an element to the collection
countryCode["UK"] = 44
countryCode["UK"] = nil

// Printing the collection
print(countryCode) ["IT": 39, "BR": 55, "US": 1, “IN": 62]

Boucles

for

// Création d'une boucle basée sur une condition
for yourCurrentElementName in yourElementsToLoop {
  // Block of code to be repeated
}

// Exemple 1
let userNames = ["Dan", "Guile", "Mark"] 
for i in 0…2 {
  print("Hello \(userNames[i])") 
}
//Hello Dan
//Hello Guile
//Hello Mark

// On peut utiliser directement le tableau
for userName in userNames {
  print("Hello \(userName)") 
}
//Hello Dan
//Hello Guile
//Hello Mark

// Exemple 2 avec un ditionnaire
let countries = ["IT": "Italy", "FR": "France"] 
for country in countries {
  print("\(country.key): \(country.value)") 
}
//IT: Italy
//FR: France

// On peut aussi directement extraire les pairs clé-valeur
for (key, value) in countries {
  print("\(key): \(countryvalue)") 
}
//IT: Italy
//FR: France

while

while conditionEndingTheLoop {
  // Block of code to be repeated
}

// Exemple 1
var count: Int = 0
while count < 5 {
  print("count = \(count)")
  count += 1
}

// Exemple 2
let userNames = ["Dan", "Guile", "Mark"] 
for i in 0…2 {
  print("Hello \(userNames[i])") 
}
//Hello Dan
//Hello Guile
//Hello Mark

// On peut utiliser directement le tableau
for userName in userNames {
  print("Hello \(userName)") 
}
//Hello Dan
//Hello Guile
//Hello Mark

Structure

// Déclaration du modèle
struct Person {
  // Déclaration des variables et constantes de du modèle
  var myVariable: Int
  let myConstant: String
  // … on peut ajouter autant de variables et constantes que l'on souhaite

  // Déclaration des fonctions du modèle
  func myStructureFunction() { 
    // …
  }
  // … on peut ajouter autant de fonctions que l'on souhaite
}

// Exemple
struct Person {
  var name: String
  var talkText: String

  func talk() {
    print(talkText)
  } 
}
var eu: Person = Person(name: "Dan", name: "Hello") 
eu.talk() //Hello

// Variables avec valeur par défaut
struct Person {
  var name: String = "Dan"
  var talkText: String

  func talk() {
    print(talkText)
  } 
}
var eu: Person = Person(talkText: "Hello")
eu.talk() //Hello

// Mise à jour des valeurs des variables
struct Person {
  var talkText: String
  func talk() {
    print(talkText)
    } 
}
var eu: Person = Person(talkText: "Hello") 
eu.talkText = "Bonjour"
eu.talk() //Bonjour

Enumération

// Déclaration d'un énumération
enum MyEnumName {
  case myFirstCaseName
  case mySecondCaseName
  // …
}

// Exemple
enum Country {
  case singapore
  case malasia
  case phillipines
}

// Accès à un cas de l'enum
let universityCountry = Country.singapore 
// Affichage de la valeur de l'enum
print(universityCountry) //singapore

Utilisation avec switch

enum Move {
 case up, down, right, left
}

let characterNextMove: Move = .right 

switch characterNextMove {
  case .up:
    print("Hero will jump")
  case .down:
    print("Hero will crouch")
  case .right:
    print("Hero will walk")
  case .left:
    print("Hero will block")
} //Hero will walk

Protocole CaseIterable

enum Move: CaseIterable {
  case up, down, right, left
}

let allCases = Move.allCases

print(allCases) //[Move.up, Move.down, Move.right, Move.left]

Fonction d’Enum

enum Move {
  case up, down, right, left

  func isHorizontal() -> Bool {
    return self == .left || self == .right
  } 
}

// Appel de la fonction
let isHorizontal = Move.up.isHorizontal() 
print(isHorizontal) //false

Optional

// Déclaration d'un optional string
var surname: String? = "John"
// Optional biding
if let sName = surname {
print("The user surname is \(sName)")
}
// Force unwrapping
print("Surname is \(surname!)")