Opérateurs Swift
Un opérateur est un symbole qui indique au compilateur d'effectuer une opération mathématique ou logique.
Swift fournit les opérateurs suivants :
- Opérateurs arithmétiques
- Opérateurs de comparaison
- Opérateurs logiques
- Opérateurs bit à bit
- Opérateurs d'affectation
- Opérateurs d'intervalle
- Autres opérateurs
Dans ce chapitre, nous présenterons en détail les opérateurs arithmétiques, les opérateurs relationnels, les opérateurs logiques, les opérateurs bit à bit, les opérateurs d'affectation et d'autres opérateurs.
Opérateurs arithmétiques
Le tableau suivant liste les opérateurs arithmétiques pris en charge par le langage Swift, où la variable A vaut 10 et la variable B vaut 20 :
| Operator | Description | Exemple |
|---|---|---|
| + | Plus | Le résultat de A + B est 30 |
| − | Moins | Le résultat de A − B est -10 |
| * | Multiplication | Le résultat de A * B est 200 |
| / | Division | Le résultat de B / A est 2 |
| % | Reste | Le résultat de B % A est 0 |
Remarque :Dans Swift 3, cela a été supprimé.++、--。
Exemple
Voici un exemple simple d’opérations arithmétiques :
import Cocoa
var A = 10
var B = 20
print("A + B 结果为：\(A + B)")
print("A - B 结果为：\(A - B)")
print("A * B 结果为：\(A * B)")
print("B / A 结果为：\(B / A)")
A += 1 // 类似 A++
print("A += 1 后 A 的值为 \(A)")
B -= 1 // 类似 B--
print("B -= 1 后 B 的值为 \(B)")
La sortie du programme ci-dessus est :
A + B 结果为：30 A - B 结果为：-10 A * B 结果为：200 B / A 结果为：2 A += 1 后 A 的值为 11 B -= 1 后 B 的值为 19
Opérateurs de comparaison
Le tableau suivant répertorie les opérateurs de comparaison pris en charge par le langage Swift, où la variable A vaut 10 et la variable B vaut 20 :
| Operator | Description | Exemple |
|---|---|---|
| == | Égal à | (A == B) est faux. |
| != | Différent de | (A != B) est vraie. |
| > | Supérieur à | (A > B) est faux. |
| < | Inférieur à | (A < B) est vraie. |
| >= | Supérieur ou égal à | (A >= B) est faux. |
| <= | Inférieur ou égal à | (A <= B) est vraie. |
Exemple
Voici un exemple simple d’opérations de comparaison :
import Cocoa
var A = 10
var B = 20
print("A == B 结果为：\(A == B)")
print("A != B 结果为：\(A != B)")
print("A > B 结果为：\(A > B)")
print("A < B 结果为：\(A < B)")
print("A >= B 结果为：\(A >= B)")
print("A <= B 结果为：\(A <= B)")
La sortie du programme ci-dessus est :
A == B 结果为：false A != B 结果为：true A > B 结果为：false A < B 结果为：true A >= B 结果为：false A <= B 结果为：true
Opérateurs logiques
Le tableau suivant répertorie les opérateurs logiques pris en charge par le langage Swift, où la variable A vaut true et la variable B vaut false :
| Operator | Description | Exemple |
|---|---|---|
| && | ET logique. Si les deux côtés de l’opérateur sont TRUE, alors le résultat est TRUE. | (A && B) est faux. |
| || | OU logique. Si au moins un côté de l’opérateur est TRUE, alors le résultat est TRUE. | (A || B) est vrai. |
| ! | NON logique. Inverse la valeur booléenne, transformant vrai en faux et faux en vrai. | !(A && B) est vrai. |
Voici un exemple simple d’opérations logiques :
import Cocoa
var A = true
var B = false
print("A && B 结果为：\(A && B)")
print("A || B 结果为：\(A || B)")
print("!A 结果为：\(!A)")
print("!B 结果为：\(!B)")
La sortie du programme ci-dessus est :
A && B 结果为：false A || B 结果为：true !A 结果为：false !B 结果为：true
Opérateurs bit à bit
Les opérateurs bit à bit sont utilisés pour effectuer des opérations sur les bits binaires. ~, &, | et ^ sont respectivement les opérations NON, ET, OU et XOR, comme le montrent les exemples du tableau suivant :
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Si A = 60 ; et B = 13 ; les représentations binaires des deux variables sont :
A = 0011 1100 B = 0000 1101
Effectuer des opérations bit à bit :
| Operator | Description | Schéma | Exemple |
|---|---|---|---|
| & | ET bit à bit. L'opérateur ET bit à bit agit sur deux nombres et renvoie un nouveau nombre, où chaque bit vaut 1 uniquement si les bits correspondants des deux nombres d'entrée valent 1. |  |
Le résultat de (A & B) est 12, en binaire : 0000 1100 |
| | | OU bit à bit. L'opérateur OU bit à bit | compare deux nombres et renvoie un nouveau nombre, où chaque bit est mis à 1 si les bits correspondants des deux nombres d'entrée ne sont pas tous les deux à 0 (c'est-à-dire si l'un vaut 1, ou si les deux valent 1). |  |
Le résultat de (A | B) est 61, en binaire : 0011 1101 |
| ^ | OU exclusif bit à bit. L'opérateur OU exclusif bit à bit ^ compare deux nombres et renvoie un nombre, où chaque bit est mis à 1 si les bits correspondants des deux nombres d'entrée sont différents, et mis à 0 s'ils sont identiques. |  |
Le résultat de (A ^ B) est 49, en binaire : 0011 0001 |
| ~ | L'opérateur NON bit à bit ~ inverse chaque bit d'un opérande. |  |
Le résultat de (~A ) est -61, en binaire : 1100 0011 sous forme de complément à deux. |
| << | Décalage à gauche bit à bit. L'opérateur de décalage à gauche (<<) décale tous les bits de l'opérande vers la gauche du nombre de positions indiqué. |
Le diagramme suivant montre le résultat de 11111111 << 1 (11111111 décalé d'un bit vers la gauche). Les chiffres bleus indiquent les bits décalés, les chiffres gris indiquent les bits supprimés, et les positions vides sont remplies par des 0 orange. 
| Le résultat de A << 2 est 240, en binaire : 1111 0000 |
| >> | Décalage à droite bit à bit. L'opérateur de décalage à droite (>>) décale tous les bits de l'opérande vers la droite du nombre de positions indiqué. |
Le diagramme suivant montre le résultat de 11111111 >> 1 (11111111 décalé vers la droite d'un bit). Les chiffres bleus indiquent les bits décalés, les chiffres gris indiquent les bits supprimés, et les positions vides sont remplies de 0 orange. 
| Le résultat de A >> 2 est 15, en binaire 0000 1111 |
Voici un exemple simple d'opérations bit à bit :
import Cocoa
var A = 60 // 二进制为 0011 1100
var B = 13 // 二进制为 0000 1101
print("A&B 结果为：\(A&B)")
print("A|B 结果为：\(A|B)")
print("A^B 结果为：\(A^B)")
print("~A 结果为：\(~A)")
La sortie du programme ci-dessus est :
A&B 结果为：12 A|B 结果为：61 A^B 结果为：49 ~A 结果为：-61
Opérateurs d'affectation
Le tableau suivant répertorie les opérations d'affectation de base du langage Swift :
| Operator | Description | Exemple |
|---|---|---|
| = | Opération d'affectation simple, affecte l'opérande droit à l'opérande gauche. | C = A + B affecte le résultat de A + B à C |
| += | Addition et affectation, additionne les opérandes gauche et droit et affecte le résultat à l'opérande gauche. | C += A équivaut à C = C + A |
| -= | Soustraction et affectation, soustrait l'opérande droit de l'opérande gauche et affecte le résultat à l'opérande gauche. | C -= A est équivalent à C = C - A |
| *= | Multiplication et affectation, multiplie les opérandes gauche et droit et affecte le résultat à l'opérande gauche. | C *= A est équivalent à C = C * A |
| /= | Division et affectation, divise l'opérande gauche par l'opérande droit et affecte le résultat à l'opérande gauche. | C /= A est équivalent à C = C / A |
| %= | Modulo et affectation, prend le reste des opérandes gauche et droit et affecte le résultat à l'opérande gauche. | C %= A est équivalent à C = C % A |
| <<= | Décalage à gauche bit à bit et affectation | C <<= 2 est équivalent à C = C << 2 |
| >>= | Décalage à droite bit à bit et affectation | C >>= 2 est équivalent à C = C >> 2 |
| &= | ET bit à bit et affectation | C &= 2 est équivalent à C = C & 2 |
| ^= | OU exclusif bit à bit et affectation | C ^= 2 est équivalent à C = C ^ 2 |
| |= | OU bit à bit et affectation | C |= 2 est équivalent à C = C | 2 |
Voici un exemple simple d'opérations d'affectation :
import Cocoa
var A = 10
var B = 20
var C = 100
C = A + B
print("C 结果为：\(C)")
C += A
print("C 结果为：\(C)")
C -= A
print("C 结果为：\(C)")
C *= A
print("C 结果为：\(C)")
C /= A
print("C 结果为：\(C)")
//以下测试已注释，可去掉注释测试每个实例
/*
C %= A
print("C 结果为：\(C)")
C <<= A
print("C 结果为：\(C)")
C >>= A
print("C 结果为：\(C)")
C &= A
print("C 结果为：\(C)")
C ^= A
print("C 结果为：\(C)")
C |= A
print("C 结果为：\(C)")
*/
La sortie du programme ci-dessus est :
C 结果为：30 C 结果为：40 C 结果为：30 C 结果为：300 C 结果为：30
Opérateurs de plage
Swift fournit deux opérateurs de plage.
| Operator | Description | Exemple |
|---|---|---|
| Opérateur de plage fermée | L'opérateur de plage fermée (a...b) définit une plage qui inclut toutes les valeurs de a à b (y compris a et b), et b doit être supérieur ou égal à a. L'opérateur de plage fermée est très utile pour parcourir toutes les valeurs d'une plage, comme dans une boucle for-in : | La plage 1...5 a les valeurs 1, 2, 3, 4 et 5 |
| Opérateur de plage semi-ouverte | L'opérateur de plage semi-ouverte (a..<b) définit une plage de a à b mais n'inclut pas b. Il est appelé semi-ouvert parce qu'il inclut la première valeur mais pas la dernière valeur. | La plage 1..<5 a les valeurs 1, 2, 3 et 4 |
Voici un exemple simple d'opérations sur les plages :
import Cocoa
print("闭区间运算符:")
for index in 1...5 {
print("\(index) * 5 = \(index * 5)")
}
print("半开区间运算符:")
for index in 1..<5 {
print("\(index) * 5 = \(index * 5)")
}
La sortie du programme ci-dessus est :
闭区间运算符: 1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25 半开区间运算符: 1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20
Autres opérateurs
Swift fournit d'autres types d'opérateurs, tels que les opérateurs unaires, binaires et ternaires.
- Un opérateur unaire opère sur un seul opérande (tel que
-a). Les opérateurs unaires se divisent en opérateurs préfixes et postfixes. Un opérateur préfixe doit immédiatement précéder son opérande (par ex.!b), les opérateurs postfixes doivent immédiatement suivre l'opérande (par ex., c!).Remarques :En Java/C, il n'existe pas de syntaxe comme c!. En Swift, elle est utilisée pour obtenir une valeur à partir d'un type Optional. - Les opérateurs binaires opèrent sur deux opérandes (par ex.
2 + 3), et sont infixes car ils apparaissent entre les deux opérandes. - Les opérateurs ternaires opèrent sur trois opérandes. Comme en C, Swift n'a qu'un seul opérateur ternaire, qui est l'opérateur conditionnel ternaire (
a ? b : c）。
| Operator | Description | Exemple |
|---|---|---|
| Moins unaire | Ajoutez un signe - en préfixe devant le nombre | -3 ou -4 |
| Plus unaire | Ajoutez un signe + en préfixe devant le nombre | +6 donne 6 |
| Opérateur ternaire | condition ? X : Y | Siconditionest vraie, la valeur est X, sinon Y |
Voici des exemples simples d'opérations unaires, binaires et ternaires :
import Cocoa
var A = 1
var B = 2
var C = true
var D = false
print("-A 的值为：\(-A)")
print("A + B 的值为：\(A + B)")
print("三元运算：\(C ? A : B )")
print("三元运算：\(D ? A : B )")
La sortie du programme ci-dessus est :
-A 的值为：-1 A + B 的值为：3 三元运算：1 三元运算：2
Précédence des opérateurs
Une expression peut contenir plusieurs objets de données de types différents reliés par différents opérateurs. Comme une expression peut comporter plusieurs opérations, différents ordres d'évaluation peuvent produire des résultats différents, voire des erreurs d'opération. Par conséquent, lorsqu'une expression contient plusieurs opérations, elle doit être combinée dans un certain ordre afin de garantir la rationalité de l'opération ainsi que l'exactitude et l'unicité du résultat.
La priorité diminue du haut vers le bas ; le haut a la priorité la plus élevée, et l'opérateur virgule a la priorité la plus faible.
À priorité égale, les opérations sont effectuées selon l'associativité. La plupart des opérations sont évaluées de gauche à droite, et seuls trois niveaux de priorité sont associatifs de droite à gauche : les opérateurs unaires, les opérateurs conditionnels et les opérateurs d'affectation.
Règles de priorité de base à retenir :
- Les pointeurs ont la priorité la plus élevée, et les opérations unaires ont la priorité sur les opérations binaires. Par exemple, les signes plus et moins.
- Multiplication, division (modulo) avant addition et soustraction.
- Les opérations arithmétiques d'abord, puis les opérations de décalage, et enfin les opérations bit à bit. Veuillez noter : 1 << 3 + 2 & 7 est équivalent à (1 << (3 + 2))&7
- Les opérations logiques sont évaluées en dernier.
Priorité des opérateurs Swift (de la plus élevée à la plus faible) :
| Operator | Exemple |
|---|---|
| Opérateurs bit à bit | >> &<< &>> >> |
| Opérateurs de multiplication | &* % & * / |
| Opérateurs d'addition | | &+ &- + - ^ |
| Opérateurs d'intervalle | ..< ... |
| Opérateurs de conversion de type | est comme |
| Opérateur de coalescence nil | ?? |
| Opérateurs de comparaison | != > < >= <= === == |
| Opérateur ET logique | && |
| Opérateur OU logique | || |
| Flèche ondulée | ~> |
| Opérateur ternaire | ?: |
| Fonction fléchée | ( ) |
| Opérateur d'affectation | |= %= /= &<<= &>>= &= *= >>= <<= ^= += -= |
Voici un exemple simple de priorité des opérateurs :
import Cocoa
var A = 0
A = 2 + 3 * 4 % 5
print("A 的值为：\(A)")
La sortie du programme ci-dessus est :
A 的值为：4
Analyse de l'exemple :
Selon la priorité des opérateurs, les opérations du programme ci-dessus peuvent être analysées en les étapes suivantes. L'expression est équivalente à :
2 + ((3 * 4) % 5)
Étape 1 : (3 * 4) = 12, donc l'expression est équivalente à :
2 + (12 % 5)
Étape 2 : 12 % 5 = 2, donc l'expression est équivalente à :
2 + 2
À ce stade, il est facile de voir que le résultat du calcul est 4.
Autres extensions