Syntaxe de base Swift
Dans le chapitre précédent, nous avons déjà vu comment créer le programme "Hello, World!" en Swift. Maintenant, passons-le en revue.
Si vous créez un playground OS X, vous devez importer Cocoa :
Exemple
/* Mon premier programme Swift */
var myString = "Hello, World!"
print(myString)
Si nous voulons créer un playground iOS, nous devons importer UIKit :
Exemple
var myString = "Hello, World!"
print(myString)
Exécutez le programme ci-dessus, et le résultat de sortie est :
Hello, World!
Le code ci-dessus est la structure de base d'un programme Swift. Ensuite, nous expliquerons les composants de la structure en détail.
Importation Swift
Nous pouvons utiliser l'instructionimportpour importer n'importe quel framework Objective-C (ou bibliothèque C) dans un programme Swift. Par exempleimport cocoaL'instruction importe la bibliothèque Cocoa et les API, et nous pouvons les utiliser dans des programmes Swift.
Cocoa lui-même est écrit en Objective-C, et Objective-C est un surensemble strict de C, donc dans les applications Swift, nous pouvons facilement intégrer du code en langage C, et même du code C++.
Jetons Swift
Un programme Swift est composé de divers jetons. Les jetons peuvent être des mots, des identifiants, des constantes, des chaînes de caractères ou des symboles. Par exemple, le programme Swift suivant se compose de trois jetons :
print("test!")
L'instruction ci-dessus se compose de 3 symboles : le motprint, le symbole( ), et la chaîne"test"。
print ( "test!" )
Instructions et expressions
Le code en Swift se compose d'instructions et d'expressions.
Les instructions effectuent des actions spécifiques, tandis que les expressions évaluent et renvoient des valeurs.
Exemple
print(message) // Instruction d'expression
// Exemple d'expression
let sum = 5 + 3 // 5 + 3 est une expression, renvoie 8
let isGreater = sum > 5 // sum > 5 est une expression, renvoie true
Commentaires
Swift prend en charge les commentaires sur une seule ligne et les commentaires multilignes. Les commentaires servent à expliquer la fonctionnalité et la logique du code.
Les commentaires Swift sont très similaires à ceux du langage C. Les commentaires sur une seule ligne commencent par deux barres obliques :
// This is a line comment
Les commentaires multilignes commencent par /* et se terminent par */ :
/* This is also a comment, but it spans multiple lines */
Contrairement aux commentaires multilignes du langage C, les commentaires multilignes de Swift peuvent être imbriqués à l'intérieur d'autres commentaires multilignes. La façon de l'écrire consiste à insérer un autre commentaire multiligne dans un bloc de commentaires multilignes. Lorsque le deuxième bloc de commentaires se ferme, le premier bloc de commentaires continue toujours :
/* This is the beginning of the first multi-line comment /* This is the nested second multi-line comment */ This is the end of the first multi-line comment */
L'imbrication de commentaires multilignes vous permet d'annoter des blocs de code plus rapidement et plus facilement, même si le bloc de code contient déjà des commentaires.
Exemple
let age = 25
/*
Ceci est un commentaire sur plusieurs lignes
Peut s'étendre sur plusieurs lignes
Utilisé pour expliquer en détail la fonctionnalité du code
*/
let name = "Zhang San"
// Les commentaires peuvent aussi être imbriqués
/*
Commentaire externe
/* Commentaire interne */
Toujours le commentaire externe
*/
Point-virgule
Contrairement à d'autres langages, Swift n'exige pas de point-virgule à la fin de chaque instruction.;Mais lorsque vous écrivez plusieurs instructions sur la même ligne, vous devez les séparer par des points-virgules :
// 一般情况下不需要分号 let x = 10 let y = 20 // 在同一行写多个语句时需要分号 let a = 1; let b = 2; let c = 3 // 在某些复杂表达式中可以提高可读性 let result = calculate(); process(result)
Identificateurs
Les identifiants sont des noms donnés aux variables, constantes, méthodes, fonctions, énumérations, structures, classes, protocoles, etc.
Les lettres qui composent un identifiant doivent suivre certaines règles. Les règles de nommage des identifiants en Swift sont les suivantes :
- Sensible à la casse : Myname et myname sont deux identifiants différents ;
- Le premier caractère d'un identifiant peut être un tiret bas_ou une lettre, mais ne peut pas être un chiffre ;
- Les autres caractères de l'identifiant peuvent être des tirets bas_, des lettres ou des chiffres.
Par exemple : userName, User_Name, _sys_val, height, etc. sont des identifiants valides, tandis que 2mail, room#, et class sont des identifiants non valides.
Conventions de nommage :
- Utilisez camelCase.
- Les noms de variables et de fonctions commencent par une lettre minuscule.
- Les noms de types commencent par une lettre majuscule.
- Les constantes peuvent être entièrement en majuscules (séparées par des traits de soulignement).
// 好的命名示例 let userAge = 25 let maxRetryCount = 3 let isUserLoggedIn = true let serverURL = "https://api.example.com" // 避免的命名示例 let a = 25 // 不清楚含义 let temp = 3 // 缩写不明确 let flag = true // 不具体 let url1 = "..." // 数字后缀不好
Nommage des booléens :
// 使用疑问词开头 let isEmpty = true let isVisible = false let hasChildren = true let canEdit = false let shouldRefresh = true let willAppear = false
Remarque :Les lettres en Swift utilisent l'encodage Unicode. Unicode est appelé le système d'encodage unifié. Il inclut les encodages de caractères asiatiques, tels que le chinois, le japonais, le coréen, et même les emojis que nous utilisons dans les outils de messagerie.
Si vous tenez absolument à utiliser un mot-clé comme identifiant, vous pouvez ajouter des accents graves autour du mot-clé`, par exemple :
let `class` = "Example"
Constantes et variables
les mots-clés let et var
Constantes (let) :
// 声明常量
let maximumNumberOfLoginAttempts = 10
let welcomeMessage = "欢迎使用Swift"
// 常量一旦赋值就不能更改
// maximumNumberOfLoginAttempts = 5 // 错误!不能修改常量
// 延迟初始化常量
let username: String
if userIsLoggedIn {
username = "用户A"
} else {
username = "访客"
}
// username 只能赋值一次
Variables (var) :
// 声明变量 var currentLoginAttempt = 0 var friendlyWelcome = "Hello!" // 变量可以修改 currentLoginAttempt = 1 friendlyWelcome = "Bonjour!" // 变量可以多次赋值 var temperature = 25.0 temperature = 30.0 temperature = 22.5
Mots-clés
Les mots-clés sont des séquences de caractères réservées similaires aux identifiants. À moins d'être entourés d'accents graves`, ils ne peuvent pas être utilisés comme identifiants. Les mots-clés sont des identifiants réservés prédéfinis qui ont une signification particulière pour le compilateur.
Il existe 4 types courants de mots-clés.
Mots-clés liés aux déclarations
| classe | deinit | enum | extension |
| func | import | init | internal |
| let | operator | private | protocol |
| public | static | struct | subscript |
| typealias | var |
Mots-clés liés aux instructions
| break | case | continue | default |
| do | else | fallthrough | for |
| if | in | return | switch |
| où | while |
Mots-clés d’expression et de type
| as | dynamicType | false | est |
| nil | self | Self | super |
| vrai | _COLUMN_ | _FILE_ | _FUNCTION_ |
| _LINE_ |
Mots-clés utilisés dans des contextes spécifiques
| associativity | convenience | dynamic | didSet |
| final | get | infix | inout |
| lazy | left | mutating | none |
| nonmutating | optional | override | postfix |
| precedence | préfixe | Protocol | required |
| right | set | Type | unowned |
| faible | willSet |
Espaces blancs Swift
Swift n'est pas comme C/C++ ou Java, qui ignorent complètement les espaces blancs. Swift a certaines exigences concernant l'utilisation des espaces blancs, mais ce n'est pas aussi strict que les exigences d'indentation de Python.
En Swift, les opérateurs ne peuvent pas suivre directement une variable ou une constante. Par exemple, le code suivant provoquera une erreur :
let a= 1 + 2
Le message d'erreur est :
error: prefix/postfix '=' is reserved
Cela signifie à peu près que l'utilisation du signe égal directement avant ou après est réservée.
Le code suivant provoquera toujours une erreur (continuez à faire attention aux espaces blancs) :
let a = 1+ 2
Le message d'erreur est :
error: consecutive statements on a line must be separated by ';'
C'est parce que Swift considère que l'instruction s'est terminée à `1+`, et `2` est l'instruction suivante.
Ce n'est qu'en l'écrivant de cette façon qu'il n'y aura pas d'erreur :
let a = 1 + 2; // 编码规范推荐使用这种写法 let b = 3+4 // 这样也是OK的
Littéraux Swift
Le littéral, comme on l'appelle, désigne une valeur telle qu'un nombre, une chaîne ou un booléen spécifique, qui peut indiquer directement son propre type et être assignée à une variable. Par exemple :
42 // 整型字面量 3.14159 // 浮点型字面量 "Hello, world!" // 字符串型字面量 true // 布尔型字面量
Affichage de sortie
Swift utilise la fonction print pour afficher la sortie :
print("Example") // 输出 Example
La fonction print est une fonction globale, et sa signature de fonction complète est :
public func print(items: Any..., separator: String = default, terminator: String = default)
Si nous voulons qu'elle affiche sans saut de ligne, il suffit de définir le dernier paramètre sur une chaîne vide :
for x in 0...10{
print("\(x) ", terminator: "")
}
print()
Le résultat de sortie est:
0 1 2 3 4 5 6 7 8 9 10
Si vous avez besoin de recevoir une saisie utilisateur, vous pouvez utiliserreadLine():
let theInput = readLine()Autres extensions