Types de données rapides

Lorsque nous programmons dans n'importe quel langage de programmation, nous devons utiliser différents types de données pour stocker différentes informations.

Le type de données d'une variable détermine la manière dont les bits représentant ces valeurs sont stockés dans la mémoire de l'ordinateur. Vous pouvez également spécifier le type de données d'une variable lors de sa déclaration.

Toutes les variables ont un type de données pour déterminer quel type de données peut être stocké.

Types de données intégrés

Swift fournit un ensemble très riche de types de données. Ce qui suit répertorie plusieurs types de données couramment utilisés :

Int

<. 🎜 >D'une manière générale, vous n'avez pas besoin de préciser spécifiquement la longueur d'un entier. Swift fournit un type entier spécial

avec la même longueur que la longueur de mot natif de la plateforme actuelle : Int

Sur les plateformes 32 bits,
et Int ont le même longueur. Int32
Sur les plateformes 64 bits,
et Int ont la même longueur. Int64

À moins que vous n'ayez besoin d'un entier d'une longueur spécifique, l'utilisation de

suffit généralement. Cela améliore la cohérence et la réutilisabilité du code. Même sur les plateformes 32 bits, la plage d'entiers que Int peut stocker est Int~-2,147,483,648, ce qui est suffisamment grand la plupart du temps. 2,147,483,647

UInt

Swift fournit également un type spécial non signé

, dont la longueur est la même que la longueur de mot natif de la plateforme actuelle : UInt

Sur les plateformes 32 bits,
et UInt ont la même longueur. UInt32
Sur les plateformes 64 bits,
et UInt ont la même longueur. UInt64

Remarque :
Essayez de ne pas utiliser
à moins que vous n'ayez vraiment besoin de stocker un entier non signé de la même longueur que la longueur du mot natif de la plateforme actuelle. Sauf que dans ce cas, il vaut mieux utiliser UInt même si la valeur que vous souhaitez stocker est connue pour être non négative. L'utilisation uniforme de Int peut améliorer la réutilisabilité du code, éviter les conversions entre différents types de nombres et correspondre à l'inférence de type des nombres. Veuillez vous référer à la sécurité des types et à l'inférence de type. Int

Nombres à virgule flottante

Les nombres à virgule flottante sont des nombres avec une partie décimale, tels que

, 3.14159 et 0.1. Le type à virgule flottante -273.15

représente une plage plus grande que le type entier et peut stocker des nombres plus grands ou plus petits que le type

. Swift propose deux types de nombres à virgule flottante signés : Int

représente un nombre à virgule flottante de 64 bits. Utilisez ce type lorsque vous devez stocker des nombres à virgule flottante de très grande taille ou de très haute précision. Double
représente un nombre à virgule flottante de 32 bits. Ce type peut être utilisé si les exigences de précision ne sont pas élevées. Float

Remarque :

est très précis et comporte au moins 15 chiffres, tandis que Double comporte au moins 6 chiffres. Le type que vous choisissez dépend de la plage de valeurs que votre code doit gérer. Float

Valeur booléenne

Swift a un type booléen de base appelé Bool. Les valeurs booléennes font référence à des valeurs logiques car elles ne peuvent être que vraies ou fausses. Swift a deux constantes booléennes, vraie et fausse.

Chaîne

Une chaîne est une collection de séquences de caractères, par exemple :

"Hello, World!"

Caractère

Le caractère fait référence à une seule lettre, par exemple :

"C"

Types facultatifs

Utilisez des types facultatifs (facultatifs) pour gérer les situations où des valeurs peuvent être manquantes. Les types facultatifs représentent soit une valeur, soit aucune valeur.

Plage de valeurs

Le tableau suivant montre l'espace de stockage des différents types de variables, ainsi que les valeurs maximales et minimales des types de variables :

类型	大小（字节）	区间值
Int8	1 字节	-127 到 127
UInt8	1 字节	0 到 255
Int32	4 字节	-2147483648 到 2147483647
UInt32	4 字节	0 到 4294967295
Int64	8 字节	-9223372036854775808 到 9223372036854775807
UInt64	8 字节	0 到 18446744073709551615
Float	4 字节	1.2E-38 到 3.4E+38 (~6 digits)
Double	8 字节	2.3E-308 到 1.7E+308 (~15 digits)

Alias de type

Un alias de type définit un autre nom pour le type actuel. Les alias de type sont définis à l'aide du mot-clé typealias. Le format de syntaxe est le suivant :

typealias newname = type

Par exemple, ce qui suit définit l'alias de type de Int comme Feet :

typealias Feet = Int

Maintenant, nous pouvons définir des variables via des alias :

import Cocoa

typealias Feet = Int
var distance: Feet = 100
print(distance)

Nous utilisons l'exécution de terrain de jeu. Le résultat de sortie du programme ci-dessus est :

Sécurité de type

Swift est un langage de type sécurisé.

Étant donné que Swift est de type sécurisé, il effectue des vérifications de type lors de la compilation de votre code et marque les types incompatibles comme des erreurs. Cela vous permet de trouver et de corriger les bogues dès le début du développement.

import Cocoa

var varA = 42
varA = "This is hello"
print(varA)

Le programme ci-dessus signalera une erreur dans Xcode :

error: cannot assign value of type 'String' to type 'Int'
varA = "This is hello"

Cela signifie que la chaîne 'String' ne peut pas être affectée à la variable 'Int'.

Inférence de type

La vérification de type peut vous aider à éviter les erreurs lorsque vous devez gérer des valeurs de types différents. Toutefois, cela ne signifie pas que vous devez spécifier explicitement le type chaque fois que vous déclarez une constante ou une variable.

Si vous ne spécifiez pas explicitement un type, Swift utilise l'inférence de type pour choisir le type approprié.

Par exemple, si vous attribuez une valeur de 42 à une nouvelle constante et n'indiquez pas de type, Swift peut en déduire que le type de constante est Int car la valeur initiale que vous lui attribuez ressemble à un entier :

let meaningOfLife = 42
// meaningOfLife 会被推测为 Int 类型

De même, si vous ne spécifiez pas de type pour un littéral à virgule flottante, Swift en déduira que vous voulez Double :

let pi = 3.14159
// pi 会被推测为 Double 类型

Lors de la déduction du type d'un nombre à virgule flottante, Swift choisira toujours Double au lieu de Float.

Si des nombres entiers et des nombres à virgule flottante apparaissent dans l'expression, ils seront déduits comme étant de type double :

let anotherPi = 3 + 0.14159
// anotherPi 会被推测为 Double 类型

La valeur d'origine 3 n'a pas de déclaration de type explicite et un mot à virgule flottante apparaît dans l'expression est littérale, donc l'expression sera déduite comme étant de type Double.

Instance

import Cocoa

// varA 会被推测为 Int 类型 
var varA = 42
print(varA)

// varB 会被推测为 Double 类型  
var varB = 3.14159
print(varB)

// varC 也会被推测为 Double 类型   
var varC = 3 + 0.14159
print(varC)

exécute le code ci-dessus et le résultat de sortie est :

42
3.14159
3.14159