Déclarer les constantes et les variables

Les constantes et les variables doivent être déclarées avant d’être utilisées. On déclare les constantes avec le mot-clé let et les variables avec var. Voici un exemple qui montre comment les constantes et les variables peuvent être utilisées pour vérifier le nombre de tentative de connexion d’un utilisateur sur votre application :

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

Ce bout de code peut être lu de la façon suivante : « Déclare une nouvelle constante appelée maximumNumberOfLoginAttempts, et attribue lui la valeur 10. »
« Ensuite, déclare une nouvelle variable appelée currentLoginAttempt, et donne lui la valeur initiale 0. »

Dans cet exemple, le nombre maximum de connexions autorisées est déclaré en tant que constante, parce-que ce nombre ne devra pas être amené à être changé. En revanche le compteur du nombre de tentative de connexion est déclaré en tant que variable, puisque sa valeur sera incrémentée positivement après chaque échec de connexion.

Vous pouvez déclarer plusieurs constantes ou plusieurs variables en même temps sur une seule ligne en les séparant par des virgules :

var x = 0.0, y = 0.0, z = 0.0

Note : Si vous stockez une valeur dans votre code qui ne sera pas ammenée à changer, déclarez là toujours en tant que constante avec le mot-clé let. Utilisez les variables uniquement pour stocker des valeurs qui auront besoin de changer.

Annotation des types

Vous pouvez indiquer le type de votre constante ou votre variable lors vous la déclarez, pour être clair avec les sortes de valeurs que vous souhaitez stocker. Pour indiquer le type d’une constante ou d’une variable, écrivez le type juste après son nom séparé par deux points et d’un espace.

Cet exemple montre une annotation de type pour une variable appelée welcomeMessage pour indiquer qu’il s’agit d’une chaine de caractère (String) :

var welcomeMessage: String

Les deux points dans la déclaration veulent dire : « …du type… », du coup le code ci-dessus peut-être lu comme ceci :

« Déclare une variable appelée welcomeMessage qui est du type String. »

La phrase « du type String«  veut dire « peut stocker une valeur de type chaine de caractères ». C’est le « type de chose » qui peut être stocké. La variable welcomeMessage peut maintenant accueillir n’importe quelle chaine de caractère sans erreur :

welcomeMessage = "Hello"

Note : En réalité il est rare dans la pratique que vous ayiez à indiquer le type d’une variable ou d’une constante. En fournissant une valeur lors de la déclaration de votre constante ou de votre variable, Swift est capable de deviner son type. Les annotations de typages interviennent uniquement dans le cas d’une conversion ou de l’enregistrement d’une donnée ambigüe. Dans l’exemple ci-dessus avec la variable welcomeMessage, aucune valeur initiale n’est fournie, le type de la variable est alors spécifié avec une annotation, mais cette annotation aurait été inutile en fournissant une valeur initiale à la variable.

Nommage des constantes et des variables

Vous pouvez utiliser n’importe quel caractère pour vos noms de variables et de constantes, même les caractères spéciaux et unicode :

let π = 3.14159
let 你好 = "你好世界"
let  = "bisoucoeur"

Les noms des constantes et des variables ne peuvent pas contenir de symboles mathématiques, de flèches, de code Unicode invalide ni de points. Ils ne peuvent pas non plus commencer par un chiffre mais il est possible d’inclure des chiffres dans le nom de variables et des constantes n’importe où ailleurs dans leurs noms.

Une fois que vous avez déclaré une contante ou une variable d’un certain type, vous ne pouvez plus utiliser son nom pour en déclarer une autre ou changer le type de valeur qui y sont stockées. Vous ne pouvez pas non plus changer une constante en variable et une variable en constante.

Note : Si vous avez besoin de donner à une constante ou une variable le même nom en tant que mot-clé Swift réservé, vous pouvez le faire en entourant le mot-clé avec des guillemets inversés (`) quand vous l’utilisez en tant que nom. Néanmoins vous ne devriez utiliser cette solution que dans la mesure où vous n’avez vraiment pas le choix.

Vous pouvez change la valeur d’une variable existante par une autre valeur d’un type compatible. Dans l’exemple ci-dessous, la valeur de friendlyWelcome est passée de "Hello!" à "Bonjour!" :

var friendlyWelcome = "Hello!"
friendlyWelcome = "Bonjour!" // friendlyWelcome vaut maintenant "Bonjour!"

Contrairement aux variables, la valeur d’une constante ne peut pas être modifiée une fois qu’elle a été définie. Si vous tentez de changer la valeur d’une constante vous vous exposez à une erreur au moment de la compilation :

let languageName = "Swift"
languageName = "Swift++"
// Error - languageName cannot be changed

Afficher les constantes et les variables

Vous pouvez afficher la valeur courante d’une constante ou d’une variable avec la fonction println :

println(friendlyWelcome)
// Affichera à l'écran "Bonjour!"

println est une fonction globale qui affiche une valeur, suivie d’un retour à la ligne, à la sortie appropriée. Si vous travaillez depuis Xcode, par exemple, println affichera la valeur demandé dans la console Xcode. Une seconde fonction, print, réalise exactement la même opération mais sans le retour à la ligne après l’affichage de la valeur.

La fonction println affiche n’importe quelle chaine de caractères qu’on lui fournit :

println("Ceci est une chaine de caractères")
// Affiche dans la console Xcode "Ceci est une chaine et caractères"

La fonction println peut afficher des messages plus complexes similaires à la fonction NSLog de Cocoa.

Swift convertit systématiquement les valeurs incluses dans les variables et les constantes en chaine de caractères pour s’afficher dans la console Xcode avec println. Il est possible d’afficher une chaine de caractères avec une variable ou une constante en précédant son nom d’un anti-slash et en l’entourant de parenthèses :

println("La valeur actuelle de friendlyWelcome est \(firendlyWelcome)")
// Affiche "La valeur actuelle de friendlyWelcome est Bonjour!"

Note : Toutes les options que vous pouvez utiliser sont expliquées plus en détails dans la partie Interpolation des chaines de caractères.

The post Les constantes et les variables appeared first on SWIFT Code.

Les commentaires dans Swift sont très similaires aux commentaires en C. Pour les commentaires sur une seule ligne, ils commencent par deux slashs (//) :

// Ceci est un commentaire

Vous pouvez aussi écrire des commentaires plus longs sur plusieurs lignes, qui commencent par un slash suivit d’une astérisque (/) et finissent par une astérisque suivie d’un slash (/) :

/* Ceci est aussi un commentaire,
    mais écrit sur plusieurs lignes */

Contrairement aux commentaires multi-lignes en C, les commentaires multi-lignes de Swift peuvent être imbriqués à l’intérieur d’autres commentaires multi-lignes. Vous devez simplement commencer votre commentaire comme s’il allait s’étendre sur plusieurs lignes et imbriquer chaque commentaires multi-lignes de la même façon :

/* Ceci est le commencement de mon commentaire,
    il s'étend sur plusieurs lignes
/* Je peux imbriquer un nouveau commentaire à l'intérieur,
    qui peut lui-même s'étendre sur plusieurs lignes */
Ensuite je termine mon commentaire principal ici,
    Et je n'oublie pas de le fermer */

Les commentaires multi-lignes imbriqués de la sorte permettent de commenter de large bloc de code rapidement et facilement, même si le code contient déjà d’autres commentaires multi-lignes.

The post Les commentaires appeared first on SWIFT Code.

Les points virgules ne sont pas requis pour les lignes simples qui ne comprennent qu’une seule action mais son indispensable pour séparer plusieurs action que l’on souhaite mettre sur la même ligne.

let chat = "félin"; println(chat)
// affiche "félin"

Par soucis de lisibilité il est plus judicieux d’écrire un code plus aéré en sautant une ligne après chaque action. Ainsi vous évitez de surcharger votre code avec des caractères inutiles et vous vous assurez une lisibilité optimale. C’est également une recommandation à prendre en compte lorsque vous travaillez sur des projets collaboratifs.

The post Les points virgules appeared first on SWIFT Code.

Swift prévoit des entiers avec ou sans signes sous la forme 8, 16, 32 et 64 bits. Ces entiers suivent des conventions de nommage similaires au langage C, un entier sans signe en 8 bits est du type UInt8, et un entier en 32 bits dont le signe est connu est du type Int32. Comme tous les types dans Swift, les types d’entiers commencent par une lettre en majuscule.

Les limites des entiers

Vous pouvez accéder aux valeurs minimales et maximales de chaque type d’entier avec leurs propriétés min et max :

let minValue = UInt8.min //minValue vaut 0 et est du type UInt8
let maxValue = UInt8.max //maxValue vaut 255 et est du type UInt8

Les valeurs de ces propriétés sont taillés en fonction du type du nombre entier (UInt8 dans l’exemple ci-dessus) et peuvent être utilisés dans des expressions à côté de valeurs du même type.

Int

Dans la plupart des cas, vous n’aurez pas besoin de spécifier une taille spécifique pour vos entiers à l’intérieur de votre code. Swift propose un type d’entier additionnel, Int, qui possède la même taille que le système d’exploitation que vous utilisez :

• Sur les plateformes 32 bits, Int possède la même taille que Int32.
• Sur les plateformes 64 bits, Int possède la même taille que Int64.

Si vous n’avez pas besoin, de travailler avec une taille spécifique d’entier, utilisez toujours Int pour les valeurs de vos entiers dans votre code. Cela facilite la cohérence et l’interopérabilité. Même si vous travaillez dans un environnement 32 bits, avec Int vous pouvez stocker une valeur entre -2 147 483 648 et 2 147 483 647, et c’est surement largement assez grand pour la grande majorité des besoins !

UInt

Swift permet aussi d’avoir des entiers sans signe du type UInt, qui possède la même taille que le système d’exploitation que vous utilisez :

• Sur les plateformes 32 bits, UInt possède la même taille que UInt32.
• Sur les plateformes 64 bits, UInt possède la même taille que UInt64.

Note : Utilisez UInt uniquement quand vous avez spécialement besoin d’un entier sans signe avec la taille de votre plateforme (32 ou 64 bits). Si ce n’est pas le cas préférez Int même si vous savez que la valeur ne sera jamais négative.

The post Les entiers appeared first on SWIFT Code.

Les types des nombres à virgules représentent une beaucoup plus large palette de valeurs possible par rapport aux types des entiers, et peuvent stocker des nombres beaucoup plus long mais surtout beaucoup plus petit que ce que peut faire le type Int. Swift propose deux types de nombres à virgules dont le signe est connu :

• Le type Double représente un nombre à virgule en 64 bits. Utilisez-le quand votre nombre à virgule doit être très grand ou particulièrement précis.
• Le type Float représente un nombre à virgule en 32 bits. Utilisez-le quand votre nombre à virgule ne requiert pas la précision d’un nombre en 64 bits.

Note : Le type Double possède une précision pouvant aller jusqu’à 15 décimales alors que le type Float n’accepte que 6 chiffres après la virgule. le type de vos nombres à virgule dépend de vos besoins, de la plateforme sur laquelle vous travaillez et de votre code.

The post Les nombres à virgule flottante appeared first on SWIFT Code.