Parce-que Swift est un langage au type sécurisé, il vérifie tous les types lorsqu’il compile votre code et vous indique les problèmes de types comme étant des erreurs. Cela vous permet de corriger le problème rapidement et le plus tôt possible dans votre processus de développement.

La vérification des types vous aide à éviter les erreurs lorsque vous travaillez sur différents types de valeurs. Cependant, cela ne veut pas dire que vous devez forcement spécifier le type de chaque constante et de chaque variable que vous déclarez. Si vous ne spécifiez pas le type de vos valeurs, Swift est capable de déduire le type approprié. La déduction des types permet au compileur de deviner le type d’une expression particulière automatiquement lorsqu’il compile votre code, simplement en examinant les valeurs que vous avez fourni.

À cause de la déduction des types, Swift requiert beaucoup moins de déclarations de type que des langages comme le C ou l’Objective-C. Les constants et les variables sont toujours explicitement typées, et il n’est plus nécessaire de passer trop de temps là dessus maintenant.

La déduction des types est particulièrement utile lorsque vous déclarez une constante ou une variable avec une valeur initiale. Cela fonctionne aussi en assignant une valeur factice au moment de la déclaration. Par exemple si votre variable est prédestinée à être et rester un entier (Int), vous pouvez la déclarer avec un entier factice pour que le compileur déduise simplement son type tout au long de son existence.

var variableTest = 42 // Le compileur déduit que variableTest est un Int

De même, si vous ne spécifiez pas le type d’une constante mais que vous lui donnez une valeur avec une virgule, Swift comprendra qu’il s’agit d’un Double :

let pi = 3.14159 // pi est une constante de type Double

Swift choisi toujours le type Double pour les nombres à virgule flottante dont le type n’est pas spécifié (plutôt que Float) pour permettre des extensions plus larges.

Si vous combinez une valeur factive comprenant un entier et un nombre à virgule, le type de l’expression sera déduit comme étant un Double en fonction du contexte :

let autrePi = 3 + 0.141559 // autrePi est un Double

La valeur 3 n’a pas de type explicite et comme elle est additionnée avec une valeur comprenant un chiffre à virgule, autrePi est automatiquement défini comme un Double après avoir obtenu le résultat de l’addition.

The post Sécurité et déduction des types appeared first on SWIFT Code.

Les entiers littéraux peuvent être écrits de différentes manières :

• Un nombre décimal, sans aucun préfixe
• Un nombre binaire, avec un préfixe 0b
• Un nombre octal, avec un préfixe 0o
• Un nombre hexadécimal, avec un préfixe 0x

Tous ces entiers littéraux correspondent à la valeur décimale de 17 :

let decimalEntier = 17
let binaireEntier = 0b10001 // 17 en binaire
let octalEntier = 0o21 // 17 en octal
let hexadecimalEntier = 0x11 // 17 en hexadécimal

Les nombres à virgule littéraux peuvent être décimaux (sans préfixe), ou hexadécimaux (avec le préfixe 0x). Ils doivent juste toujours avoir un nombre décimal (ou hexadécimal) de chaque côté de la virgule. Ils peuvent aussi avoir un exposant optionnel, indiqué avec un e majuscule ou minuscule pour les nombres décimaux et un p majuscule ou minuscule pour les nombres hexadécimaux.

Pour les nombres décimaux avec un exposant, la base du nombre est multipliée par 10ᵉˣᵖ :

• 1.25e2 signifie 1.25 x 10² ou 125.0
• 1.25e-2 signifie 1.25 x 10⁻² ou 0.0125

Pour les nombres hexadécimaux avec un exposant, la base du nombre est multipliée par 2ᵉˣᵖ :

• 0xFp2 signifie 15 x 2² ou 60.0
• 0xFp-2 signifie 15 x 2⁻² ou 3.752

Tous les nombres à virgule ci-dessous ont une valeur décimale de 12.1875 :

let decimalDouble = 12.1875
let exposantDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

Les nombres littéraux peuvent contenir un formatage supplémentaire afin de les rendre plus lisibles. Entiers comme nombres à virgule, peuvent être rembourrés avec des zéros supplémentaires et des underscores pour aider à la lecture. En aucun cas, le formatage n’affecte la valeur du nombre littéral :

let decimalDouble = 000123.456
let unMillion = 1_000_000
let plusdunMillion = 1_000_000.000_000_1

N’oubliez pas cette astuce, elle peut s’avérer très pratique lorsque vous serez amené à manipuler des nombres très très grands. Bien sur la technique des puissances et des exposants est une bonne manière de réduire le nombre de caractères de votre code et d’utiliser la puissance des machines qui exécuteront votre code, mais au moins vous êtes au courant !

The post Les nombres littéraux appeared first on SWIFT Code.

Utilisez un autre type d’entier uniquement quand vous en avez expressément besoin pour réaliser une tâche particulière. Parce-qu’il s’agit d’un typage imposé par une source extérieure ou un autre langage, pour la performance, l’utilisation de la mémoire ou d’autres optimisations nécessaires. Utiliser les types explicites dans ces situations évite d’voir des types de valeurs accidentelles qui ne pourront pas fonctionner avec le reste de votre code.

Conversions d’entiers

Le nombre total de chiffres qui peuvent être stocké dans un entier constant ou variable est différent en fonction du type numérique. Une constante ou un variable du type Int8 peut stocker des nombres entre -128 et 127 alors qu’une constante ou une variable du type UInt8 pourra stocker des nombres entre 0 et 255. Un nombre qui ne sera pas amené à rentrer dans cette fourchette autorisé par le typage numérique des valeurs provoquera une erreur lors de la compilation :

let nonNegatif: UInt = -1 
// UInt8 ne peut pas stocker de nombre négatif
let tropGros: Int8 = Int8.max + 1 
// UInt8 ne peut pas stocker de nombre plus grand que sa valeur maximale

Parce-que chaque type numérique peut stocker une quantité différente de valeurs, vous devrez parfois optez pour une conversion du type numérique au cas par cas. Cette approche vous aidera à convertir de façon claire et explicite vos valeurs et ainsi éviter certaines erreurs dans votre code.

Pour convertir un type spécifique de nombre vers un autre, vous devez initialiser un nouveau nombre du type désiré avec la valeur existante. Dans l’exemple suivant, la constante deuxMille est du type UInt16 et l’autre constante un est du type Uint8. Elles ne peuvent pas être additionnée ensemble directement parce-qu’elle ne possèdent pas le même type numérique. Du coup, cet exemple appelle Uint16(un) pour créer un nouveau entier du type UInt16 initialisé avec la valeur de un et utilisant sa valeur à la place de l’original :

let deuxMille: UInt16 = 2_000
let un: UInt8 = 1
let deuxMilleUn = deuxMille + UInt16(un)

Comme les deux côtés de l’addiction sont maintenant du type UInt16, l’opération est permise. Le résultat en sortie de la constante deuxMilleUn est du type UInt16 parce-qu’elle est le résultat d’une addition entre deux valeurs de type UInt16.

Dans Swift, Type(valeurInitiale) est le format par défaut pour initialiser une valeur et la passer dans un autre type. Derrière le rideau, UInt16 possède un convertisseur qui accepte les valeurs du type UInt8, et ce convertisseur est utilisé pour créer une nouvelle valeur en UInt16 depuis un typage UInt8 existant. Vous ne pouvez pas passer n’importe quel type ici, uniquement les types qui sont prévus pour être convertis avec UInt16. Il est possible de passer outre cette limitation en utilisant ou en développant des extensions.

The post Conversions de types de nombres appeared first on SWIFT Code.