Variables, constantes et littéraux en Swift

Dans cet article, vous découvrirez les variables, les constantes, les littéraux et leurs exemples dans la programmation Swift.

Qu'est-ce qu'une variable ?

Dans la programmation, les variables sont utilisées pour stocker des données en mémoire et peuvent être utilisées dans tout le programme. Mais chaque variable doit avoir un nom unique, appeléidentifier（标识符）。可以将变量看作保存信息的容器，并且以后可以更改这些信息。

从技术上讲，您可以将变量视为用于在其中存储书包的一些书，以后也可以将这些书替换为其他书籍。

如何在Swift中声明变量？

在Swift中，我们使用var关键字声明变量。

var siteName: String
print(siteName)

我们已经声明了一个名为 siteName 的String变量，这意味着它只能保存字符串值。访问Swift字符串可以了解有关字符串的更多信息。

如果您尝试在Playground中运行以上代码，则会给我们带来编译时错误（在初始化之前使用变量），因为它没有存储/包含任何值。

如何在Swift中为变量赋值？

您可以使用赋值运算符（=）在变量中赋值。

Exemple1：声明并将值分配给变量

var siteName: String
siteName = "Apple.com"
print(siteName)

ou

您还可以将该值内联赋值为：

var siteName: String = "Apple.com"
print(siteName)

Lors de l'exécution de ce programme, la sortie est :

Apple.com

变量 siteName，现在包含值“ Apple.com”。

由于Swift是一种类型推断语言，因此它可以自动推断（知道）“ Apple.com”是一个字符串，并声明siteName为String类型。因此，您甚至可以将(:String)声明中的类型删除为：

Exemple2：在Swift中类型推断的变量

var siteName = "Apple.com"
print(siteName)

Lors de l'exécution de ce programme, la sortie est :

Apple.com

由于siteName是一个变量，因此您还可以通过简单地使用赋值运算符来更改其值，而无需使用var关键字，例如：

Exemple3：更改变量的值

var siteName = "Apple.com"　
//　为siteName分配一个新值
siteName = "w"3codebox.com"
print(siteName)

Lors de l'exécution de ce programme, la sortie est :

oldtoolbag.com

什么是常量？

常量是变量的一种特殊类型，其值不能更改。将常量视为保存以后无法更改的信息的容器。

从技术上讲，您可以将常量视为用于存储某些书籍的书包，而将这些书放入书包后就无法替换。

如何在Swift中声明常量？

在Swift中，我们使用 let 关键字来声明变量。

let siteName: String
print(siteName)

我们已经声明了一个名为 siteName 的常量字符串。

如果您尝试运行以上代码，则会给我们带来编译时错误（初始化之前使用常量），因为它不包含/保留任何值。

如何在Swift中为常量分配值？

您可以使用赋值运算符（=）在与变量相同的常量中赋值。

Exemple4：声明一个值并将其分配给一个常量

let siteName: String
siteName = "Apple.com"
print(siteName)

ou

ou

let siteName:String = "Apple.com"

Lors de l'exécution de ce programme, la sortie est :

Apple.com

Maintenant, la constante siteName contient/qui contient la valeur "Apple.com".

Comme pour les variables, vous pouvez supprimer le type (:String) de la déclaration, comme suit :

Exemple5: Constantes avec inférence de type en Swift

let siteName = "Apple.com"
print(siteName)

Lors de l'exécution de ce programme, la sortie est :

Apple.com

Mais contrairement aux variables, vous ne pouvez pas changer la valeur d'une constante. Donc, vous ne pouvez pas faire cela :

Exemple6: Changer la valeur d'une constante (interdit)

let siteName = "Apple.com"
siteName = "w"3codebox.com"　//erreur de temps de compilation
print(siteName)

La ligne ci-dessus nous donne un message d'erreur car, comme nous l'avons dit, une fois les données stockées, la valeur de la constante ne peut pas être modifiée. C'est la principale différence entre une variable et une constante.

Qu'est-ce qu'un littéral ?

Les littéraux sont des valeurs qui apparaissent directement dans le code source. Ils peuvent être des nombres, des caractères ou des chaînes de caractères, par exemple : "Hello, World",12,23.0, "C" est un exemple simple de littéral. Les littéraux sont souvent utilisés pour initialiser des variables ou des constantes (affecter une valeur à celles-ci).

Par exemple :

let siteName = "Apple.com"

Dans l'expression ci-dessus, siteName est une variable et "Apple.com" est un littéral.

Types de littéraux en Swift

Littéraux numériques

Il représente une valeur décimale, binaire, octale ou hexadécimale. Il existe quatre types.

• Littéral binaire

• représente une valeur binaire.

• Commence par 0b.

• Littéral octal

• représente une valeur octale.

• Commence par 0o.

• Littéral hexadécimal

• représente une valeur hexadécimale.

• Commence par 0x.

• Littéral décimal

• représente une valeur décimale.

• Commencez par zéro. Tout ce que vous déclarez en tant que littéral numérique est de type décimal.

Exemple7Comment utiliser les littéraux numériques en Swift ?

let binaryNumber = 0b11111111
print(binaryNumber)
print(1231)

Lors de l'exécution de ce programme, la sortie est :

255
1231

Dans le programme ci-dessus, il y a deux littéraux numériques 0b11111111（littéral binaire）et1231（littéral décimal）。11111111 la valeur décimale est 255par conséquent, l'expression print(binaryNumber) affiche à l'écran 255

De même, print(1231) Afficher la valeur décimale dans la console 255

Chaînes de caractères et littéraux de caractères

Les littéraux de chaîne sont une séquence de caractères entourés de guillemets doubles, et les littéraux de caractères sont un seul caractère entouré de guillemets doubles.

Exemple8Comment utiliser les chaînes de caractères et les littéraux de caractères en Swift ?

let someCharacter:Character = "C"
let someString:String = "Swift is awesome"

Dans le programme ci-dessus "C" est un littéral de caractère, "Swift is awesome" est un littéral de chaîne de caractères.

Littéral de nombre en virgule flottante

Utilisé pour initialiser des variables de type float et double. Il peut y avoir deux types :

Décimal :

Il peut avoir une exponentielle optionnelle représentée par une majuscule ou une minuscule e. Pour un nombre décimal avec une exponentielle exp, la base est multipliée par 10 ^exp:

Exemple9：Comment utiliser les littéraux décimaux en Swift ?

let someFloat =　12.23
let someAnotherFloat =　3.14e2　
print(someFloat)
print(someAnotherFloat)

Lors de l'exécution de ce programme, la sortie est :

12.23
314.0

Dans le programme ci-dessus12.23,3.14e2est un littéral de nombre en virgule flottante.3.14e2 Réprésenté en exposant, équivaut à3.14 * 10 ²

Hexadécimal :

Un nombre en virgule flottante hexadécimal doit avoir une exponentielle représentée par une majuscule ou une minuscule p. Pour un nombre hexadécimal avec une exponentielle exp, la base est multipliée par2 ^exp:

Exemple10：Comment utiliser les littéraux hexadécimaux en Swift ?

let someFloat = 0xFp10　
let someAnotherFloat = 0xFp-12
print(someFloat)
print(someAnotherFloat)

Lors de l'exécution de ce programme, la sortie est :

15360.0
0.003662109375

Dans le programme ci-dessus 0xFp10，0xFp-12 est un littéral de nombre en virgule flottante. 0xFp10Réprésenté en exposant, équivaut à15 * 210（F est représenté comme décimal15）。Par conséquent, print(someFloat) affiche15360.0。

De même, 0xFp-12 Équivaut à 15 * 2-12. Par conséquent, print(someAnotherFloat) affiche 0.00 sur l'écran3662109375

Littéral booléen

Swift a deux valeurs littérales booléennes. Ce sont true et false.。

Exemple11：Comment utiliser les littéraux booléens en Swift ?

let result:Bool = false

Dans le programme ci-dessus, false est une constante booléenne qui est assignée à la constante result.

Règles et meilleures pratiques des variables et des constantes

1. Choisissez un nom significatif. Par exemple,var name Que var n Plus significatif

2. Déclarez des variables ou des constantes en utilisant la notation camelCase. La notation camelCase commence par une lettre minuscule. Par exemple :

   var studentName
   let studentAge
   let address

3. Vous pouvez également définir des variables et des constantes sans les marquer. Ne pas utiliser de marqueurs de nom signifie que vous ne les utiliserez pas dans votre programme. Dans de nombreux cas, vous souhaitez créer une variable non utilisée. Dans ce cas, vous pouvez utiliser le symbole de remplacement _.

   var _ = "Apple.com"　//La chaîne a été initialisée, mais elle n'est pas stockée dans une variable
   let _ = "Apple.com"

   　 　 　 　 　 　 Même cela est valide

   _ = "Apple.com"

4. Utilisez des constantes si vous devez définir une valeur une seule fois et ne pas la modifier à nouveau dans le programme. Cependant, utilisez des variables si vous devez modifier cette valeur à l'avenir.

5. Les noms de constantes et de variables ne peuvent pas contenir de caractères d'espace, de symboles mathématiques, de flèches, de points Unicode privés (ou invalides) ou de caractères de lignes et de cadres. Ils ne peuvent pas non plus commencer par un chiffre, bien que les chiffres puissent se trouver ailleurs dans le nom.

   var　12　= "Apple.com"　//donne une erreur de compilation : attendu un schéma
   var @hello = "Hello"　//donne une erreur de compilation : attendu un schéma