Tutoriel Swift pour les débutants

View more categories:

1- Introduction

C'est un guide de Swift pour des débutants. Pour programmer Swift, vous devez installer les outils de programmation XCode. Vous pouvez voir les instructions pour télécharger et installer à:
  • TODO Link!
Il s'agit d'un document d'instruction rapide, si vous commencez simplement par Swift, lisez-le respectivement de haut en bas, ce document vous aidera à avoir une vue d'ensemble avant d'entrer dans d'autres documents plus détaillés.

2- Créer votre premier projet Swift

C'est la première image lorsque vous ouvrez  XCode
Créez un nouveau projet:
Nous avons créé un projet simple (l'application de Console, une application n'a pas de l'interface).
Le nom de votre projet est  SwiftBasics:
Créez un dossier sur Desktop pour stocker votre projet.
Le nom du dossier contenant votre projet est  SwiftTutorials:
Votre projet est créé.
main.swift est un fichier source créé lors de la création d'un projet, vous devez exécuter ce fichier source, il écrira sur l'écran Console des mots "Hello, world".
Cliquez sur "Enable" permet le programme d'exécuter à la mode de programmeur.
Le programme exécute et imprime le message  "Hello, world".

3- Expliquer les caractéristiques de base du Swift

Vous devez avoir un aperçu de base de Swift, c'est très important.

Qu'est ce que Top level?

Une commande ou une expression n'a pas été incluse dans une fonction, un bloc ou une classe signifie qu'elle se trouve dans Top-Level.
Top-Level est l'endroit pour déclarer l'utilisation de la bibliothèque, pour déclarer des variables, des constantes, des fonctions, des classes. Par défaut, les variables et les constantes sont déclarées dans le Top-Level de ce fichier source peuvent être utilisées dans d'autres fichiers source dans le même projet (project).
Vous ne pouvez pas écrire une expression dans Top-Level, une telle expression pour appeler la fonction. Appelez donc la fonction print("Hello") pour imprimer les mots "Hello" dans Top-Level n'est pas valide, sauf si vous le faites dans les fichiers sources nommés main.swift (Ceci est l'exception).

Le point de départ du programme Swift:

Dans un programme Swift, le fichier main.swift est un fichier spécial, car c'est le point de départ pour exécuter le programme. Vous pouvez appeler ou écrire l'expression sur Top-Level dans le fichier source  main.swift, qui est une exception pour ce fichier.
Je crée un nouveau fichier source nommé newfile.swift, vous obtiendrez un message d'erreur lorsque je rédige délibérément une expression au Top-Level.
L'expression doit être placée dans une fonction ou un bloc.

4- Ajouter un nouveau fichier source

Vous devez ajouter votre premier fichier source et l'exécuter.
Sur  XCode, cliquez sur le bouton droit du dossier contennant le fichier source  main.swift, sélectionnez  "New file".
Saisissez le nom du fichier  MyFirstSwift:
Le fichier  MyFirstSwift.swift est créé:
Je modifie le contenu du fichier source qui a été créé et j'ai ajouté une fonction sayHello(), note: plus d'informations sur la fonction seront discutées dans une autre section.
MyFirstSwift.swift
import Foundation

// Le contenu de la salutation.
var message = "Hello every body"

// La fonction sayHello()
func sayHello()  {
    
    // Appelez la fonction print pour imprimer un message affiché sur l'écran Console.
    // Notez que vous ne pouvez pas appeler cette fonction au niveau supérieur.
    print(message)
    
}
Dans Swift, le point de départ pour exécuter l'application est main.swift, afin de tester la fonction sayHello() que vous devez appeler dans main.swift. Éditez le code de main.swift:
main.swift
import Foundation


print("Hello, World!")

// Appelez la fonction sayHello()
// (Définie dans MyFirstSwift.swift
sayHello()
L'exécution du projet.

5- Des types de données dans Swift

Type Typical Bit Width Typical Range
Int8 1byte -127 to 127
UInt8 1byte 0 to 255
Int32 4bytes -2147483648 to 2147483647
UInt32 4bytes 0 to 4294967295
Int64 8bytes -9223372036854775808 to 9223372036854775807
UInt64 8bytes 0 to 18446744073709551615
Float 4bytes 1.2E-38 to 3.4E+38 (~6 digits)
Double 8bytes 2.3E-308 to 1.7E+308 (~15 digits)

6- Des variables et la déclaration de la variable

Une variable est identifiée par un nom, pour une zone de stockage de données que votre programme peut être manipulé. Chaque variable dans Swift a un type spécifique, qui détermine la taille et la disposition de la mémoire de la gamme de valeurs qui peuvent être stockées dans cette mémoire et l'ensemble des opérations qui peuvent être appliquées à la variable.
La variable peut changer de valeur au cours de son existence dans le programme. Les variables ont une valeur fixe appelée constantes. En utilisant le mot-clé let pour déclarer une variable constante.
Dans swift, vous pouvez déclarer une variable dans Top-Level ou une variable locale dans une classe ou une fonction. La variable est déclarée dans Top-Level peut être utilisée dans d'autres fichiers source dans le même projet (project).
Déclarer une variable:
// <Variable name>: Nom de variable
// <Data Type>: Type de données
var <Variable name> : <Data Type> ;

// Déclarez une variable et lui attribuez une valeur.
// <Variable name>: Nom de variable
// <Data Type>: Type de données
// <value>: Valeur
var <Variable name> : <Data Type> = <value>;

// Déclarez une constante
// <Constant name>: Nom de constante.
// <Data Type>: Type de données
// <value>: Valeur
let <Constant name> : <Data Type> = <value>;

// Exemple:
// Déclarez une variable
// Nom de variable : year
// Type de données : Int
// Valeur : 2016
var year: Int = 2016;

// Avec les types de données primitifs (primitive type) (Int, Double, Bool) et String,
// vous pouvez ignorer de le déclarer.
// Swift peut comprendre vos intentions.
..

// Déduit comme String
var languageName = "Swift"     
var version = 1.0  // Double
var introduced = 2014  // Int
var isAwesome = true   // Bool
VariableExample.swift
import Foundation

// Utilisez le mot-clé 'let' pour déclarer une constante.
// Le nom de la constante est COPYRIGHT, le type de données est String.
// Et sa valeur est "o7planning".
// (Ceci est une constante déclarée dans le niveau supérieur
// Il peut être utilisé dans d'autres fichiers sources du projet).
let COPYRIGH: String = "o7planning"

// Utilisez le mot-clé 'var' pour déclarer une variable (variable).
// Nom de la variable: année
// Type de données: Int
// Valeur: 2016
// (Ceci est une variable déclarée dans le niveau supérieur
// Il peut être utilisé dans d'autres fichiers sources du projet).
var year: Int = 2016



func variableExample()  {
    
    // Déclarez un entier (integer) constant.
    // Vous ne pouvez pas affecter de nouvelles valeurs pour les constantes.
    let MAX_SCORE = 100;
    
    // Déclarez un entier (integer) constant.
    var score = 90;
    
    // Déclarez une chaîne (string).
    var studentName = "Tom"
    
    // Imprimez la chaîne sur l'écran Console.
    print("Hi \(studentName)")
    
    print("Your score: \(score)/\(MAX_SCORE)")
    
    print("Assign new value for studentName")
    
    // Attribuez une nouvelle valeur à studentName.
    studentName = "Jerry"
    print("Hi \(studentName)")
    
    
}
Éditez le code du fichier source main.swift:
main.swift
import Foundation

// Appelez la fonction variableExample(),
// est définie dans le fichier VariableExample.swift
variableExample()
L'exécution de l'exemple:

7- Des déclarations de marquage

7.1- La déclaration If-else

if est une commande qui vérifie une certaine condition dans Swift. Par exemple: Si a> b, faites quelque chose ....
Les opérateurs de comparaison communs:
Opérateur Signification Exemple
> Plus grand que 5 > 4 est vrai (true)
< Moins que 4 < 5 est vrai (true)
>= Supérieur ou égal à 4 >= 4 est vrai (true)
<= Inférieur ou égal à 3 <= 4 est vrai (true)
== Égal à 1 == 1 est vrai (true)
!= Pas égal à  1 != 2 est vrai (true)
&& Et  a > 4 && a < 10
|| Ou  a == 1 || a == 4
// condition: La condition.
if ( condition )  {
    // Fait quelque chose ici.
}
Exemple:
// Exemple 1:
if ( 5 < 10 )   {
   print( "Five is now less than ten");
}

// Exemple 2:
if ( true )   {
    print( "Do something here");
}
La structure complète de la déclaration  if - else if - else:
// Notez qu'au plus un bloc de code sera exécuté.
// Le programme vérifie les conditions de haut en bas.
// Quand une condition est vraie, ce bloc sera exécuté.
// Les conditions restantes seront ignorées.
...

// Si la condition1 est vraie, alors ..
if (condition1 )  
{
	 // Faites quelque chose si la condition1 est vraie (true).
}
// Sinon si condition2 est vraie, alors ....
else if(condition2 )  
{
	// Faites quelque chose ici si la condition2 est vrai ( la condition1 est faux).
}
// Sinon, si la conditonN est vraie, alors ...
else if(conditionN )  
{
	 // Faites quelque chose ici si la conditionN est vraie
	 // (Toutes les conditions ci-dessus sont fausses).
}
// Sinon (toutes les conditions ci-dessus sont fausses).
else  {
	 // Faites quelque chose.
}
IfElseExample.swift
import Foundation


func  ifElseExample()  {
    
    // Déclarez un type de variable UInt32 avec une valeur aléatoire.
    // (la fonction arc4random () revoie la valeur aléatoire).
    var randomValue: UInt32 = arc4random()
    
    print("Random value = " + String(randomValue))
    
    // Division 200 et renvoie le reste (remainder).
    // (Renvoie 0 -> 99)
    var age: UInt32 = randomValue % 200;
    
    print("Your age= " + String(age))
    
    // Vérifiez si l'âge <80 puis
    if (age < 80)    {
        print("You are pretty young");
    }
    
    // Sinon, si l'âge se situe entre 80 et 100 ans, alors ...
    else if  age >= 80 && age <= 100     {
        print("You are old");
    }
    
    // Les autres cas.
    else    {
        print("You are verry old");
    }
    
    
}
L'exécution de l'exemple:

7.2- La déclaration Switch-Case

Quelques exemples utilisent la déclaration  switch:
SwitchExample1.swift
import Foundation

func switchExample1()   {
    
    // Đề nghị người dùng chọn một lựa chọn.
    print("Please select one option:")
    
    print("1 - Play a game")
    print("2 - Play music")
    print("3 - Shutdown computer")
    print("---------------------")
    

    var randomValue: UInt32 = arc4random()
    
    // Chia cho 5 và trả về số dư (remainder) (0, 1, 2, 3, 4)
    var myValue:UInt32 = randomValue%5
    
    // Khai báo một biến 'option'.
    // Ép kiểu UInt32 thành kiểu Int.
    // 'option' sẽ có giá trị 1, 2, 3, 4 hoặc 5.
    var option:Int = Int(myValue) + 1
    
    // String(option): Ép kiểu (cast) thành String.
    print("You select: " + String(option))
    
    // Kiểm tra các giá trị của 'option'.
    switch (option)   {
        
    case 1:
        print("You choose to play the game");
    case 2:
        print("You choose to play the music");
    case 3:
        print("You choose to shutdown the computer");
    // Các trường hợp còn lại.
    default:
        print("Nothing to do...");
    }
    
    
}
L'exécution de l'exemple:
Vous pouvez utiliser plusieurs valeurs dans un cas (case):
SwitchExample2.swift
import Foundation


func switchExample2() {
    
    // Déclarez une variable et lui attribuez une valeur de 3.
    var option = 3
    
    print("Option = \(option) ")
    
    // Vérifiez la valeur de 'option'.
    switch (option)    {
        
    case 1:
        print("Case 1")
    
    // Dans le cas où la valeur est 2,3,4,5
    case 2, 3, 4, 5:
        print("Case 2,3,4,5!!!")
   
    // Le cas où la valeur est de 6 -> 10
    case 6...10:
        print("Case 6...10")
    
    // Dans le cas où la valeur est entre 11 -> 20 et impaire.
    case 11...20 where option % 2 == 1:
        print("Case 11...20 and odd")
        
    default:
        print("Nothing to do...")
        
    }
    
    
    
}
L'exécution de l'exemple:

Fallthrought:

Si vous avez travaillé avec d'autres langues de programmation comme Java, C#, vous pouvez trouver la syntaxe pour utiliser switch aucune différence par rapport à Swift. Dans Swift lorsqu'un cas (case) est vrai, le bloc d'instructions de cette affaire sera exécuté et, dans d'autres cas (case), il ne fonctionnera pas.

Avec Java, C# lorsqu'un cas est vrai, le bloc d'instruction de ce cas sera exécuté et, s'il n'y a pas de déclaration de break, le case (ou default) du prochain bloc sera exécuté.

Swift a été  break automatiquement après avoir fini d'exécuter le bloc case.
Swift a ajouté la déclaration  fallthrought (Cette déclaration n'est pas disponible dans  Java, C#), fallthrought a dit au programme à continuer d'exécuter le bloc prochain de la déclaration  case (ou celui du  default).
Voyez une illustration:
SwitchFallthroughExample.swift
import Foundation

func switchFallthroughExample()  {
    
    
    var option = 15
    
    switch (option)   {
        
        
    case 0...10:
        print("Case 0...10")
        // fallthrough: Exécutez le cas suivant.
        fallthrough
        
    case 11...20:
        print("Case 11...20")
        // fallthrough: Exécutez le cas suivant.
        fallthrough
        
    case 21...30:
        print("Case 21...30")
        // fallthrough: Exécutez le cas suivant.
        fallthrough
        
    case 31...40:
        print("Case 31...40")
        
    case 41...50:
        print("Case 41...50")
        
    default:
        print("Default case")
    }
    
}
L'exécution de l'exemple:

8- La boucle dans Swift

La boucle est utilisée pour exécuter de manière répétitive un bloc de déclaration. Cela permet à votre programme d'exécuter à maintes reprises un bloc de déclaration, c'est l'une des tâches de base de la programmation.
Swift prend en charge 4 types de boucles différentes:
Swift fournit 4 types différents de boucles:
  • FOR .. IN
  • FOR
  • WHILE
  • REPEAT WHILE

8.1- La boucle for in

La boucle  for .. in utilise pour l'itérateur sur un ensemble ou un tableau.
Syntaxe:
// <element>: Élément
// <collection>: Collection
for <element> in <collection> {
       // Faites quelque chose ici.
}
L'exemple utilisant la boucle  for .. in pour itérer dans un tableau (la définition du tableau mentionnera dans la section suivante)
ForInExample1.swift
import Foundation


func forInExample1()  {
    
    // Déclarez un type de tableau de String comprenant 5 éléments.
    var languages:[String] = ["Java","C#", "C/C++", "Swift", "Ruby"]
    
    
    for lang in languages  {
        
        print("Language " + lang)
    }
    
}
L'exécution de l'exemple:

8.2- La boucle for

La syntaxe de la boucle FOR:
// initialize variable: Initialisez la valeur.
// condition: Condition.
// updates new value for variable: Mettez à jour de nouvelle valeur de variable.
for (initialize variable ; condition ; updates new value for variable )
{
	// Exécutez le bloc de commande si les conditions sont vraie (true).
}
Exemple:
// Exemple 1:
// Créez une variable x et lui attribuez une valeur de 0.
// La condition de vérification est x < 5
// Si x < 5 est vraie, alors exécutez le bloc de commande.
// Après chaque itération (iteration), la valeur de x est augmentée de 1.
for (int  x = 0;  x < 5 ; x = x + 1)
{
    // Faites quelque chose ici si x < 5 est vraie (true).
}


// Exemple 2:
// Créez une variable x et lui attribuez une valeur de 2
// La condition de vérification est x < 15
// Si x < 15, exécutez le bloc de commande.
// Après chaque itération (iteration), la valeur de x est augmentée de 3.
for (int  x = 2;  x < 15 ; x = x + 3)
{
    // Faites quelque chose ici si x < 15 est vraie (true).
}
ForLoopExample.swift
import Foundation


func forLoopExample()   {
    
    print("For loop example");
    
    // Créez une variable x et lui attribuez une valeur de 2
    // La condition de vérification est x < 15
    // Si x < 15, exécutez le bloc de commande.
    // Après chaque itération (iteration), la valeur de x est augmentée de 3.
    for (var x = 2; x < 15; x = x + 3)    {
        print( );
        print("Value of x = \(x)");
    }
    
}
L'exécution de l'exemple:

8.3- La boucle while

La syntaxe de la boucle WHILE:
// condition: Condition
while (condition)  
{
     // Alors que 'condition' est vraie, exécutez le bloc de commande.
}
Exemple:
// Déclarez une variable x.
int x = 2;

while ( x < 10)
{
    // Faites quelque chose ici si x < 10 est encore vraie.
    ...
    	
    // Mettez à jour de nouvelle valeur de la variable x.
    x = x + 3;
}
WhileLoopExample.swift
import Foundation

func whileLoopExample()   {
    
    print("While loop example");
    
    // Déclarez une variable x et lui attribuez la valeur de 2.
    var x = 2;
    
    // La condition est x < 10
    // Si x < 10 est vraie (true) exécutez le bloc de commande.
    while (x < 10)  {
        
        print("Value of x = \(x)");
        
        x = x + 3;
    }
    
}
L'exécution de l'exemple:

8.4- La boucle repeat-while

La syntaxe de la boucle REPEAT-WHILE
// Les caractéristiques de la boucle 'repeat-while' sont qu'elle exécutera le bloc au moins une fois.
// Une fois le bloc terminé, elle vérifie à nouveau les conditions qu'elle continue à exécuter ou non.
repeat   {

    // Faites quelque chose ici
    // Après cela, continuez à vérifier les conditions si vous continuez à exécuter ce bloc ou non.
} while (condition)
RepeatWhileExample.swift
import Foundation

func repeatWhileExample()    {
    
    print("Repeat-While loop example")
    
    // Khai báo một biến và gán giá trị 2 cho nó.
    var x = 2
    
    // Thực thi khối lệnh ít nhất một lần.
    // Sau mỗi lần thực hiện xong khối lệnh,
    // nó sẽ kiểm tra điều kiện,
    // nếu điều kiện vẫn đúng, khối lệnh sẽ được thực thi tiếp.
    repeat    {
        print("Value of x = \(x)")
        
        x = x + 3;
        
    } while (x < 10)
    
}
L'exécution de l'exemple:

8.5- La demande break dans la boucle

break est une commande qui peut être située dans un bloc de boucle. Cette commande met fin à la boucle inconditionnellement.
LoopBreakExample.swift
import Foundation


func loopBreakExample()    {
    
    print("Break example");
    
    // Déclarez une variable et lui attribuez la valeur de 2.
    var x = 2;
    
    while (x < 15)     {
        
        print("----------------------");
        print("x = \(x)");
        
        // Si x = 5, quittez la boucle.
        if (x == 5)  {
            break;
        }
        // Augmenter la valeur de x par 1.
        x = x + 1;
        print("After +1, x = \(x)");
        
    }
    
}
L'exécution de l'exemple:

8.6- L'instruction continue dans la boucle

continue est une déclaration qui peut être située dans une boucle. Lorsque le programme a pris la déclaration continue, il ignorera les lignes de commande dans le bloc ci-dessous de continue et commencera une nouvelle boucle.
LoopContinueExample.swift
import Foundation

func loopContinueExample()  {
    
    print("Continue example")
    
    // Déclarez une variable et lui attribuez une valeur de 2.
    var x = 2
    
    while (x < 7) {
        
        print("----------------------")
        print("x = \(x)")
        
        // L'opérateur % est utilisé pour calculer le reste
        // Si x est pair, ignorez la ligne de commande ci-dessous de 'continue'
        // et démarrez la prochaine itération (si la conition est toujours vraie).
        if (x % 2 == 0)  {
            // Augmentez la valeur de x de 1
            x = x + 1
            continue
        }
        else {
            // Augmentez la valeur de x de 1
            x = x + 1
        }
        print("After +1, x = \(x)")
        
    }
}
L'exécution de l'exemple:

9- Des tableaux dans Swift

9.1- Le tableau unidimensionnel

Naturellement, le tableau sur Swift est un Struct, il diffère d'un tableau d'autres langues telles que Java, C#, ... Le tableau de Java, C# a un nombre d'éléments fixe et ne peut pas ajouter ou supprimer le nombre d'éléments, alors que le tableau de Swift peut le faire.
Ce sont des illustrations du tableau à une seule dimension avec 5 éléments indexés de 0 à 4.
La syntaxe pour déclarer un tableau unidimensionnel:
// Manière 1:
// Déclarez un tableau avec Int et spécifiez des éléments.
var years: [Int] = [ 2001, 2003, 2005, 1980, 2003 ];

// Ou (Swift est đéuit comme un tableau avec des numéros Int).
var years = [ 2001, 2003, 2005, 1980, 2003 ];



// Manière 2:
// Déclarez un tableau de Float.
// 3 éléments et tous ses trois valeurs sont 0.
var salaries:[Float] = [Float](count: 3,repeatedValue :0 );

// Ou:
var salaries  = [Float](count: 3,repeatedValue :0 );

// Manière 3:
// Déclarez un tableau vide (Aucun élément).
var emptyArray:[Int] = [Int]()
Exemple:
ArrayExample1.swift
import Foundation

func arrayExample1()  {
    
    // Manière 1:
    // Déclarz un tableau de Int, spécifiez les éléments.
    var years: [Int] = [ 2001, 2003, 2005, 1980, 2003 ];
    
    print("--- years --- ");
    
    // count est une propriété (property) de tableau, elle renvoie le nombre des éléments du tableau.
    print("Element count of array years = \(years.count)");
    
    // Utilisez la boucle for pour imprimer des éléments de tableau.
    for (var i = 0; i < years.count; i = i + 1) {
        print("Element at \(i) =  \(years[i])");
    }
    
    print("--- salaries --- ");
    
    // Manière 2:
    // Déclarez un tableau de Float.
    // 3 éléments et tous ses 3 valeurs sont 0.
    var salaries:[Float] = [Float](count: 3,repeatedValue :0 );
    
    // Attribuez la valeur aux éléments.
    salaries[0] = 1000;
    salaries[1] = 1200;
    salaries[2] = 1100;
    
    // Utilisez la boucle for afin d'imprimer des éléments de tableau.
    for (var i = 0; i < salaries.count; i = i + 1) {
        print("Element at \(i) =  \(salaries[i])");
    }
    
    
}
L'exécution de l'exemple:

Le tableau de Swift est une Struct

Dans  Swift, naturellement, un tableau est une  Struct (Structure) donc elle dépend aux propriétés et aux méthodes. Contenant la méthode d'ajouter des éléments au tableau ou supprimer des élément.
// Déclarez un tableau de String, comprend 2 éléments.
var languages = ["Java","C#"]

// Utilisez la méthode append() pour un élément aux extrémités du tableau.
languages.append("Swift")

// Possibilité d'utiliser l'opérateur + = pour ajouter un tableau à la fin.
languages += ["C/C++", "Perl"];
Exemple:
ExpaddingArrayExample.swift
import Foundation


func expaddingArrayExample()  {
    
    // Déclarez un tableau de String, avec 2 éléments.
    var languages = ["Java","C#"]
    
    // Utilisez la méthode append() pour un élément aux extrémités du tableau.
    languages.append("Swift")
    
    // Possibilité d'utiliser l'opérateur + = pour ajouter un tableau à la fin.
    languages += ["C/C++", "Perl"];
    
    // Utilisez la boucle for-in.
    for lang in languages {
        
        print("Language: " + lang)
    }
    
}
L'exécution de l'exemple:

enumerate

La méthode  enumerate() de tableau renvoie l'objet de la structure  EnumerateSequence. Chaque élément de  EnumerateSequence contient es informations d'index et l'élément du tableau.
Voir plus de la Struct à:
L'exemple de tableau:
EnumerateArrayExample.swift
import Foundation
import Cocoa

func enumerateArrayExample()  {
    
    // Déclarez un tableau de String avec 3 éléments.
    var languages :[String] = ["Java", "C#", "Swift"]
    
    
    
    for  (index, element )  in languages.enumerate()  {
        
        print("Element at \(index) = \(element)");
    }
    
}
L'exécution de l'exemple:

View more categories: