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

import Cocoa

/* Mon premier programme Swift */
var myString = "Hello, World!"

print(myString)

Si nous voulons créer un playground iOS, nous devons importer UIKit :

Exemple

import UIKit

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

let message = "Hello, Swift!"  // Instruction de déclaration
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

// Ceci est un commentaire sur une seule ligne
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