Opérateurs Swift

Un opérateur est un symbole qui indique au compilateur d'effectuer une opération mathématique ou logique.

Swift propose les opérateurs suivants :

• Opérateurs arithmétiques

• Opérateurs de comparaison

• Opérateurs logiques

• Opérateurs au niveau du bit

• Opérateurs d'affectation

• Opérateurs d'intervalle

• Autres opérateurs

Dans ce chapitre, nous présenterons les opérateurs arithmétiques, les opérateurs relationnels et les opérations logiques en détail les opérateurs, les opérateurs au niveau du bit, les opérateurs d'affectation et d'autres opérateurs .

---

Opérateurs arithmétiques

Le tableau suivant répertorie les opérateurs arithmétiques pris en charge par le langage Swift, où la variable A vaut 10 et la variable B vaut 20 :

运算符	描述	实例
+	加号	A + B 结果为 30
−	减号	A − B 结果为 -10
*	乘号	A * B 结果为 200
/	除号	B / A 结果为 2
%	求余	B % A 结果为 0
++	自增	A++ 结果为 11
--	自减	A-- 结果为 9

Exemple

Ce qui suit est un exemple simple d'opération arithmétique :

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++
print("A++ 后 A 的值为 \(A)")
B--
print("B-- 后 B 的值为 \(B)")

Le résultat de l'exécution du programme ci-dessus est :

A + B 结果为：30
A - B 结果为：-10
A * B 结果为：200
B / A 结果为：2
A++ 后 A 的值为 11
B-- 后 B 的值为 19

---

Opérateur de comparaison

Le tableau suivant Les opérateurs de comparaison pris en charge par le langage Swift sont répertoriés, où la variable A est 10 et la variable B est 20 :

运算符	描述	实例
==	等于	(A == B) 为 false。
!=	不等于	(A != B) 为 true。
>	大于	(A > B) 为 false。
<	小于	(A < B) 为 true。
>=	大于等于	(A >= B) 为 false。
<=	小于等于	(A <= B) 为 true。

Exemple

Ce qui suit est un exemple simple de comparaison opération :

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)")

Le résultat de l'exécution 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ù variable A est vrai et la variable B est fausse：

运算符	描述	实例
&&	逻辑与。如果运算符两侧都为 TRUE 则为 TRUE。	(A && B) 为 false。
||	逻辑或。 如果运算符两侧至少有一个为 TRUE 则为 TRUE。	(A || B) 为 true。
!	逻辑非。布尔值取反，使得true变false，false变true。	!(A && B) 为 true。

Ce qui suit est un exemple simple d'opération logique :

import Cocoa

var A = true
var B = false

print("A && B 结果为：\(A && B)")
print("A || B 结果为：\(A || B)")
print("!A 结果为：\(!A)")
print("!B 结果为：\(!B)")

Le résultat de l'exécution du programme ci-dessus est :

A && B 结果为：false
A || B 结果为：true
!A 结果为：false
!B 结果为：true

---

Les opérateurs au niveau du bit

Les opérateurs au niveau du bit sont utilisé pour effectuer des opérations binaires Les opérations au niveau du bit, ~,&,|,^ sont respectivement des opérations de négation, ET au niveau du bit, ET au niveau du bit, ET au niveau du bit et XOR, comme indiqué dans le 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 vous précisez A = 60; et B = 13;, le binaire correspondant aux deux variables est :

A = 0011 1100

B = 0000 1101

Effectuer des opérations sur les bits :

opérateur	Description	Illustration	Exemple
&	ET au niveau du bit. L'opérateur AND au niveau du bit opère sur deux nombres et renvoie un nouveau nombre. Chaque bit de ce nombre est 1 uniquement si le même bit des deux nombres d'entrée est 1.		(A & B) Le résultat est 12, le binaire est 0000 1100
|	OU au niveau du bit . Opérateur OR au niveau du bit | Compare deux nombres, puis renvoie un nouveau nombre. La condition pour définir chaque bit de ce nombre sur 1 est que le même bit des deux nombres d'entrée n'est pas 0 (c'est-à-dire que l'un ou l'autre vaut 1, ou les deux). sont 1 1).		(A | B) Le résultat est 61, le binaire est 0011 1101
^	exclusif au niveau du bit Ou. L'opérateur XOR au niveau du bit ^ compare deux nombres, puis renvoie un nombre. La condition pour que chaque bit de ce nombre soit défini sur 1 est que le même bit des deux nombres d'entrée est différent. est mis à 0.		(A ^ B) Le résultat est 49, le binaire est 0011 0001
~	bit à bit Le l'opérateur de négation ~ annule chaque bit d'un opérande.		(~A ) Le résultat est -61, le binaire est 1100 0011 sous la forme du complément à 2.
<<	Décalage vers la gauche au niveau du bit. L'opérateur de décalage vers la gauche (<<) décale tous les bits de l'opérande vers la gauche du nombre de bits spécifié.	La figure suivante montre le résultat de 11111111 << 1 (11111111 décalé d'un bit vers la gauche). Les nombres bleus représentent les bits décalés, les gris représentent les bits rejetés et les bits vides sont remplis de 0 orange.	Un << 2 résultats en 240, le binaire est 1111 0000
>>	Déplacement au niveau du bit droite. L'opérateur de décalage vers la droite (<<) déplace tous les bits de l'opérande du nombre de bits spécifié.	La figure suivante montre le résultat de 11111111 >> 1 (11111111 décalé d'une position vers la droite). Les nombres bleus représentent les bits décalés, les gris représentent les bits rejetés et les bits vides sont remplis de 0 orange.	A >> 2 Le résultat est 15, soit 0000 en binaire 1111

Ce qui suit est un exemple simple d'opération sur les bits :

Le résultat de l'exécution du programme ci-dessus est :

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)")

---

Opération d'affectation

Le tableau suivant répertorie les opérations d'affectation de base du langage Swift :

Opérateur	Description	Exemple

运算符	描述	实例
=	简单的赋值运算，指定右边操作数赋值给左边的操作数。	C = A + B 将 A + B 的运算结果赋值给 C
+=	相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数。	C += A 相当于 C = C + A
-=	相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数。	C -= A 相当于 C = C - A
*=	相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数。	C *= A 相当于 C = C * A
/=	相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数。	C /= A 相当于 C = C / A
%=	求余后再赋值，将左右两边的操作数求余后再赋值给左边的操作数。	C %= A is equivalent to C = C % A
<<=	按位左移后再赋值	C <<= 2 相当于 C = C << 2
>>=	按位右移后再赋值	C >>= 2 相当于 C = C >> 2
&=	按位与运算后赋值	C &= 2 相当于 C = C & 2
^=	按位异或运算符后再赋值	C ^= 2 相当于 C = C ^ 2
|=	按位或运算后再赋值	C |= 2 相当于 C = C | 2

=

Une opération d'affectation simple, attribuant l'opérande de droite à l'opérande de gauche.

C = A + B Attribuez le résultat de l'opération de A + B à C

---

+=

et ajoutez-le à gauche et à droite. les opérandes sont ajoutés puis attribués à l’opérande de gauche.

运算符	描述	实例
闭区间运算符	闭区间运算符（a...b）定义一个包含从a到b(包括a和b)的所有值的区间，b必须大于等于a。 ‌ 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在for-in循环中：	1...5 区间值为 1, 2, 3, 4 和 5
半开区间运算符	半开区间（a..<b）定义一个从a到b但不包括b的区间。 之所以称为半开区间，是因为该区间包含第一个值而不包括最后的值。	1..< 5 区间值为 1, 2, 3, 和 4

<🎜>C += A est équivalent à C = C + A<🎜><🎜><🎜>-=<🎜><🎜> avant de soustraire et d'affecter, les opérandes gauche et droit sont ajoutés ensemble Après soustraction, attribuez la valeur à l'opérande de gauche. <🎜><🎜>C -= A est équivalent à C = C - A<🎜><🎜><🎜>*=<🎜><🎜>Multipliez puis attribuez, ajoutez les opérandes gauche et droit Après en multipliant, attribuez la valeur à l’opérande de gauche. <🎜><🎜>C *= A est équivalent à C = C * A<🎜><🎜><🎜>/=<🎜><🎜>Divisez puis attribuez, comparez les opérandes gauche et droit Après division, attribuez la valeur à l’opérande de gauche. <🎜><🎜>C /= A est équivalent à C = C / A<🎜><🎜><🎜>%=<🎜><🎜>Après avoir trouvé le reste puis attribué la valeur, calculez le opérandes gauche et droit Le reste est ensuite affecté à l'opérande de gauche. <🎜><🎜>C %= A est équivalent à C = C % A<🎜><🎜><🎜><<=<🎜><🎜>Décaler vers la gauche au niveau du bit, puis attribuer une valeur<🎜 ><🎜>C <<= 2 est équivalent à C = C << 2<🎜><🎜><🎜>>>=<🎜><🎜> après avoir décalé vers la droite Affectation< 🎜><🎜>C >>= 2 est équivalent à C = C >> 2<🎜><🎜><🎜>&=<🎜><🎜>Affectation après opération ET au niveau du bit <🎜 ><🎜>C &= 2 est équivalent à C = C & 2<🎜><🎜><🎜>^=<🎜><🎜>opérateur XOR au niveau du bit puis affectation<🎜>< 🎜>C ^ = 2 est équivalent à C = C ^ 2<🎜><🎜><🎜>|=<🎜><🎜>opération OU au niveau du bit puis affectation<🎜><🎜>C |= 2 Équivalent à C = C | 2<🎜><🎜><🎜><🎜><🎜>Ce qui suit est un exemple simple d'opération d'affectation : <🎜>

A&B 结果为：12
A|B 结果为：61
A^B 结果为：49
~A 结果为：-61

<🎜>Le résultat de l'exécution du programme ci-dessus est : <🎜>

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)")
*/

<🎜 > <🎜>Opérateurs d'intervalle<🎜><🎜>Swift propose deux opérateurs d'intervalle. <🎜><🎜>Opérateur d'intervalle fermé<🎜><🎜>L'opérateur d'intervalle fermé (a...b) définit une plage de a à b (y compris a et b) Pour toutes les valeurs intervalles, b doit être supérieur ou égal à a. ‌ L'opérateur de plage fermée est très utile lors de l'itération sur toutes les valeurs d'une plage, comme dans une boucle for-in : <🎜><🎜>1...5 Les valeurs de la plage sont 1, 2, 3 , 4 et 5< 🎜><🎜><🎜>Opérateur d'intervalle semi-ouvert<🎜><🎜>Intervalle semi-ouvert (a..<b) définit un intervalle de a à b mais n'incluant pas b . On l'appelle un intervalle semi-ouvert car l'intervalle inclut la première valeur mais pas la dernière valeur. <🎜><🎜>1..< 5 valeurs d'intervalle sont 1, 2, 3 et 4<🎜><🎜><🎜><🎜>

Ce qui suit est un exemple simple d'opération d'intervalle :

C 结果为：30
C 结果为：40
C 结果为：30
C 结果为：300
C 结果为：30

Le résultat de l'exécution du programme ci-dessus est :

import Cocoa

print("闭区间运算符:")
for index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}

print("半开区间运算符:")
for index in 1..<5 {
    print("\(index) * 5 = \(index * 5)")
}

Autres opérateurs

Swift fournit d'autres types d'opérateurs , Tels que les opérateurs unaires, binaires et ternaires.

• L'opérateur unaire opère sur un seul opérande (tel que -a). Les opérateurs unaires sont divisés en pré-opérateurs et post-opérateurs. Les pré-opérateurs doivent être immédiatement avant l'objet d'opération (comme !b), et les post-opérateurs doivent être immédiatement après l'objet d'opération (comme i++).

• Les opérateurs binaires opèrent sur deux opérandes (comme 2 + 3) et sont centrés car ils apparaissent entre les deux opérandes.

• L'opérateur ternaire exploite trois opérandes. Comme le langage C, Swift n'a qu'un seul opérateur ternaire, qui est l'opérateur ternaire (a ? b : c).

Opérateur	Description	<🎜>

运算符	描述	实例
一元减	数字前添加 - 号前缀	-3 或 -4
一元加	数字钱添加 + 号前缀	+6 结果为 6
三元运算符	条件 ? X : Y	如果添加为 true ，值为 X ，否则为 Y

Voici des exemples simples d'opérations unaires, binaires et ternaires :

闭区间运算符:
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

Le résultat de l'exécution du programme ci-dessus est :

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 )")

---

Priorité des opérateurs

Une expression peut contenir plusieurs objets de données de différents types de données connectés par différents opérateurs ; puisque l'expression comporte plusieurs opérations, différents ordres d'opération peuvent produire des résultats différents ou même des erreurs d'opération incorrectes, car lorsqu'une expression contient plusieurs opérations, elles doivent être combinées dans un certain ordre pour garantir la rationalité des opérations ainsi que l'exactitude et l'unicité des résultats.

Les priorités diminuent de haut en bas, celle du haut ayant la priorité la plus élevée et l'opérateur virgule ayant la priorité la plus basse.

Au sein d'une même priorité, le calcul est basé sur l'ordre de combinaison. La plupart des opérations sont calculées de gauche à droite et seuls trois niveaux de priorité sont combinés de droite à gauche : les opérateurs unaires, les opérateurs conditionnels et les opérateurs d'affectation.

Les priorités fondamentales doivent être rappelées :

• Les pointeurs sont optimaux et les opérations monoculaires sont meilleures que les opérations binoculaires. Tels que les signes plus et moins.

• Multipliez et divisez d'abord (modulo), puis additionnez et soustrayez.

• Opérations arithmétiques d'abord, puis opérations de décalage et enfin opérations sur bits. Veuillez prêter une attention particulière à : 1 << 3 + 2 & 7 est équivalent à (1 << (3 + 2))&7

• Le calcul final du logique opération

th><. /tr>< tr>< td > Virgule

Type d'opérateur	Opérateur	Combinaison direction
Opération d'expression	() [] expr++ expr--	De gauche à droite	Opérateurs unaires	运算符类型 运算符 结合方向 表达式运算 () [] . expr++ expr-- 左到右 一元运算符 * & + - ! ~ ++expr --expr * / % + - >> << < > <= >= == != 右到左 位运算符 & ^ | && || 左到右 三元运算符 ?: 右到左 赋值运算符 = += -= *= /= %= >>= <<= &= ^= |= 右到左 逗号 , 左到右 * & + - ! ~ ++expr --expr * / % + - >> << <<= >= == !=	De droite à gauche
Opérateurs au niveau du bit	& ^ | && ||<🎜>	De gauche à droite
Opérateur ternaire	? :	De droite à gauche
Opérateur d'affectation	= += -= *= /= %= >>= <<= &= ^= |=	De droite à gauche
,	De gauche à droite

<🎜>Ce qui suit est un exemple simple de priorité des opérateurs : < 🎜>

-A 的值为：-1
A + B 的值为：3
三元运算：1
三元运算：2

<🎜>Le résultat de l'exécution du programme ci-dessus est : <🎜>

import Cocoa

var A = 0

A = 2 + 3 * 4 % 5
print("A 的值为：\(A)")

<🎜><🎜>Exemple d'analyse : <🎜><🎜><🎜>Selon la priorité de l'opérateur, le fonctionnement du programme ci-dessus peut être analysé dans les étapes suivantes, l'expression est équivalente à : <🎜>

A 的值为：4

<🎜> La première étape est le calcul : (3*4) = 12, donc l'expression est équivalente à : <🎜><🎜><🎜><🎜>

2 + ((3 * 4) % 5)

<🎜>La deuxième étape consiste à calculer 12 % 5 = 2, donc l'expression est équivalente à : <🎜>

2 + (12 % 5)

<🎜>À ce stade, on peut facilement voir que le résultat calculé est 4. <🎜><🎜>