English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
运算符是任何编程语言的基础。因此,在不使用运算符的情况下,Go语言的功能是不完整的。运算符允许我们对操作数执行不同类型的运算。在Go语言中,可以根据操作员的不同功能对其进行分类:
这些用于对Go语言中的操作数执行算术/数学运算:
加法: “ +”运算符将两个操作数相加。例如,x + y。
减法: “-”运算符减去两个操作数。例如,x-y。
乘法: '*' 运算符将两个操作数相乘。例如,x * y。
除法: '/' 运算符将第一个操作数除以第二个。例如,x / y。
求模:当第一个操作数除以第二个操作数时,'%'运算符返回余数。例如,x%y。
注意: -,+,!,&,*,<-和^也称为一元运算符,一元运算符的优先级更高。++和—运算符来自于语句,它们不是表达式,因此不在运算符层次结构中。
package main import "fmt" func main() { p := 34 q := 20 // 加法 result1 := p + q fmt.Printf("计算结果 p + q = %d", result1) // 减法 result2 := p - q fmt.Printf("\n计算结果 p - q = %d", result2) // 乘法 result3 := p * q fmt.Printf("\n计算结果 p * q = %d", result3) // 除法 result4 := p / q fmt.Printf("\n计算结果 p / q = %d", result4) // 求模 result5 := p % q fmt.Printf("\nCalcul du résultat p %% q = %d", result5) }
Sortie :
Calcul du résultat p + q = 54 Calcul du résultat p - q = 14 Calcul du résultat p * q = 680 Calcul du résultat p / q = 1 Calcul du résultat p % q = 14
Les opérateurs de relation sont utilisés pour comparer deux valeurs. Voici comment les examiner :
’==' (égal)L'opérateur vérifie si les deux opérateurs donnés sont égaux. S'ils sont égaux, il renvoie true. Sinon, il renvoie false. Par exemple,5 == 5il renvoie true.
’!=' (différent)L'opérateur vérifie si les deux opérateurs donnés sont égaux. S'ils ne sont pas égaux, il renvoie true. Sinon, il renvoie false. Par exemple,5!= 5il renvoie false.
’>’ (supérieur)L'opérateur vérifie si le premier opérateur est supérieur au second opérateur. Si supérieur, il renvoie true. Sinon, il renvoie false. Par exemple,6> 5il renvoie true.
’<’ (inférieur)L'opérateur vérifie si le premier opérateur est inférieur au second opérateur. Si inférieur, il renvoie true. Sinon, il renvoie false. Par exemple,6 <5il renvoie false.
’> =’ (supérieur ou égal)L'opérateur vérifie si le premier opérateur est supérieur ou égal au second opérateur. Si supérieur ou égal, il renvoie true. Sinon, il renvoie false. Par exemple,5> = 5il renvoie true.
“ <=” (inférieur ou égal)L'opérateur vérifie si le premier opérateur est inférieur ou égal au second opérateur. Si inférieur ou égal, il renvoie true. Sinon, il renvoie false. Par exemple,5 <= 5t aussi renvoie true.
package main import "fmt" func main() { p := 34 q := 20 // ‘==' (égal) result1 := p == q fmt.Println(result1) // ‘!=' (différent) result2 := p != q fmt.Println(result2) // ‘<’ (inférieur) result3 := p < q fmt.Println(result3) // ‘>' (supérieur) result4 := p > q fmt.Println(result4) // ‘>=' (supérieur ou égal) result5 := p >= q fmt.Println(result5) // ‘<=' (inférieur ou égal) result6 := p <= q fmt.Println(result6) }
Sortie :
false true false true true false
Ils sont utilisés pour fusionner deux ou plusieurs conditions/Contrainte ou évaluation supplémentaire des conditions originales considérées.
Logique AND :Lorsque les deux conditions considérées sont satisfaites, l'opérateur "&&" renvoie true. Sinon, il renvoie false. Par exemple, lorsque a et b sont tous deux vrais (c'est-à-dire non nuls), a && b renvoie true.
Logique ou : Lorsque l'une des conditions (ou les deux) est satisfaisante, l'opérateur "||" renvoie true. Sinon, il renvoie false. Par exemple, si l'une de a ou b est vraie (c'est-à-dire non nulle), || b renvoie true. Bien sûr, lorsque a et b sont tous deux vrais, il renvoie true.
Non logique : Si les conditions de considération ne sont pas satisfaites, l'opérateur "!" renvoie true. Sinon, il renvoie false. Par exemple, si a est faux, c'est-à-dire a = 0, alors !a renvoie true.
package main import "fmt" func main() { var p int = 23 var q int = 60 if p != q && p <= q { fmt.Println("True") } if p != q || p <= q { fmt.Println("True") } if !(p == q) { fmt.Println("True") } }
Sortie :
True True True
En langage Go, il y a6Il y a plusieurs opérateurs de travail par bit ou utilisés pour des opérations par bit. Voici les opérateurs de travail par bit :
&(AND par bit): MettreDeux nombres en tant qu'opérateurs, et effectuent une opération et sur chaque bit des deux nombres. Seulement si les deux bits sont1alors le résultat de l'AND est1.
|(OR par bit): MettreDeux nombres en tant qu'opérateurs, et effectuent une opération ou sur chaque bit des deux nombres. Si l'un des deux bits est1le résultat de l'OR est1.
^(XOR par bit): MettreDeux nombres en tant qu'opérateurs, et effectuent un XOR sur chaque bit des deux nombres. Si les deux bits sont différents, le résultat de l'XOR est1.
<<(gauche):Prend deux nombres, déplace la position du premier opérateur à gauche, et le second opérateur détermine le nombre de déplacements.
>>(droite):Prend deux nombres, déplace la position du premier opérateur à droite, et le second opérateur détermine le nombre de déplacements.
&^(AND NOT):L'opérateur (nettoyage par bit) effectue effectivement l'opérateur & (^)。
package main import "fmt" func main() { p := 134 q := 320 // & (AND) result1 := p & q fmt.Printf("Résultat de calcul p & q = %d", result1) // | (OR) result2 := p | q fmt.Printf("\nRésultat de calcul p | q = %d", result2) // ^ (XOR) result3 := p ^ q fmt.Printf("\nRésultat de calcul p ^ q = %d", result3) // << (gauche) result4 := p << 1 fmt.Printf("\nRésultat de calcul p << 1 = %d", result4) // >> (droite) result5 := p >> 1 fmt.Printf("\nRésultat de calcul p >> 1 = %d", result5) // &^ (AND NOT) result6 := p &^ q fmt.Printf("\nRésultat de calcul p &^ q = %d", result6) }
Sortie :
Résultat de calcul p & q = 0 Résultat de calcul p | q = 454 Résultat de calcul p ^ q = 454 Résultat de calcul p << 1 = 268 Résultat de calcul p >> 1 = 67 Résultat de calcul p &^ q = 134
Les opérateurs d'affectation sont utilisés pour affecter des valeurs aux variables. L'opérateur d'affectation de gauche est une variable, tandis que l'opérateur d'affectation de droite est une valeur. La valeur de droite doit avoir le même type de données que la variable de gauche, sinon le compilateur lancera une erreur. Voici quelques exemples d'opérateurs d'affectation de types différents :
“ =”(简单赋值):这是最简单的赋值操作符。该操作符用于将右侧的值分配给左侧的变量。
“ + ‘=’(加法赋值):此操作符是+‘和’='操作符的组合。该操作符首先将左侧变量的当前值添加到右侧的值,然后将结果分配给左侧的变量。
“-‘=’(减法赋值):此操作符是-‘和’='操作符的组合。该操作符首先从右侧的值中减去左侧变量的当前值,然后将结果分配给左侧的变量。
“ * ‘=’(乘法赋值):此操作符是*‘和’='操作符的组合。该操作符首先将左侧变量的当前值乘以右侧值,然后将结果分配给左侧变量。
“ / ‘=’(除法赋值):此操作符是/‘和’='操作符的组合。该操作符首先将左侧变量的当前值除以右侧值,然后将结果分配给左侧变量。
“%=”(模赋值):此操作符是“%”和“ =”操作符的组合。该操作符首先对左侧变量的当前值乘以右侧变量的值,然后将结果赋给左侧变量。
“&=”(按位与赋值):此操作符是'&'和'='操作符的组合。该操作符首先将左侧变量的当前值与右侧变量进行“按位与”运算,然后将结果分配给左侧变量。
“ ^ =”(按位异或):此操作符是'^'和'='操作符的组合。该操作符首先将左侧变量的当前值与右侧变量进行“按位异或”,然后将结果分配给左侧变量。
“ | =”(按位或):此操作符是“ |”和'='操作符的组合。该操作符首先将左边变量的当前值与右边的值“按位或”,然后将结果分配给左边的变量。
package main import "fmt" func main() { var p int = 38 var q int = 70 // “=”(简单赋值) p = q fmt.Println(p) // “+=(加法赋值) p += q fmt.Println(p) //“-=(减法赋值) p-=q fmt.Println(p) // “*=(乘法赋值) p*= q fmt.Println(p) // “/=(除法赋值) p /= q fmt.Println(p) // “%=”(求模赋值) p %= q fmt.Println(p) }
Sortie :
70 140 70 4900 70 0
&:此操作符返回变量的地址。
*:此操作符提供指向变量的指针。
<-:此操作符的名称为接收。它用于从通道接收值。
package main import "fmt" func main() { a := 94 //使用操作符(&)和 //指针间接(*)操作符 b := &a fmt.Println(*b) *b = 67 fmt.Println(a) }
Sortie :
94 67