Pergi Bahasa Operator
Operator digunakan untuk melakukan operasi matematika atau logis dalam aplikasi yang berjalan.
Pergi operator dibangun ke dalam bahasa:
- operator aritmatika
- Operator relasional
- Operator logis
- bitwise Operator
- Operator penugasan
- operator lain
Mari kita lihat masing-masing secara rinci operator diperkenalkan.
operator aritmatika
Daftar tabel berikut semua bahasa Pergi operator aritmatika. Asumsikan bahwa A adalah 10, B adalah 20.
operator | deskripsi | contoh |
---|---|---|
+ | menambahkan | A + B keluaran 30 |
- | pengurangan | A - B keluaran -10 |
* | dikalikan | A * B 200 keluaran |
/ | terbagi | B / A keluaran 2 |
% | sisa | B% A keluaran 0 |
++ | kenaikan | Sebuah keluaran ++ 11 |
- | pengurangan | Output A-- 9 |
Contoh berikut menunjukkan penggunaan berbagai operator aritmatika:
package main import "fmt" func main() { var a int = 21 var b int = 10 var c int c = a + b fmt.Printf("第一行 - c 的值为 %d\n", c ) c = a - b fmt.Printf("第二行 - c 的值为 %d\n", c ) c = a * b fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a / b fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a % b fmt.Printf("第五行 - c 的值为 %d\n", c ) a++ fmt.Printf("第六行 - c 的值为 %d\n", a ) a-- fmt.Printf("第七行 - c 的值为 %d\n", a ) }
Contoh hasil operasi di atas:
第一行 - c 的值为 31 第二行 - c 的值为 11 第三行 - c 的值为 210 第四行 - c 的值为 2 第五行 - c 的值为 1 第六行 - c 的值为 22 第七行 - c 的值为 21
Operator relasional
Tabel berikut mencantumkan semua operator relasional bahasa Go. Asumsikan bahwa A adalah 10, B adalah 20.
operator | deskripsi | contoh |
---|---|---|
== | Memeriksa dua nilai yang sama, hasil yang sama Benar jika sebaliknya False. | (A == B) adalah False |
! = | Periksa apakah dua nilai yang tidak sama, tidak kembali sama Benar jika sebaliknya False. | (A! = B) Benar |
> | Memeriksa nilai kiri lebih besar dari nilai sisi kanan, kembali Benar jika False. | (A> B) adalah False |
< | Memeriksa nilai kiri adalah kurang dari nilai sisi kanan, kembali Benar jika False. | (A <B) Benar |
> = | Periksa apakah nilai lebih besar dari atau sama dengan kiri dengan nilai yang tepat, ia mengembalikan Benar jika dinyatakan palsu. | (A> = B) adalah False |
<= | Periksa apakah nilai kurang dari atau sama dengan kiri dengan nilai yang tepat, ia mengembalikan Benar jika dinyatakan palsu. | (A <= B) Benar |
Contoh berikut menunjukkan penggunaan operator relasional:
package main import "fmt" func main() { var a int = 21 var b int = 10 if( a == b ) { fmt.Printf("第一行 - a 等于 b\n" ) } else { fmt.Printf("第一行 - a 不等于 b\n" ) } if ( a < b ) { fmt.Printf("第二行 - a 小于 b\n" ) } else { fmt.Printf("第二行 - a 不小于 b\n" ) } if ( a > b ) { fmt.Printf("第三行 - a 大于 b\n" ) } else { fmt.Printf("第三行 - a 不大于 b\n" ) } /* Lets change value of a and b */ a = 5 b = 20 if ( a <= b ) { fmt.Printf("第四行 - a 小于等于 b\n" ) } if ( b >= a ) { fmt.Printf("第五行 - b 大于等于 b\n" ) } }
Contoh hasil operasi di atas:
第一行 - a 不等于 b 第二行 - a 不小于 b 第三行 - a 大于 b 第四行 - a 小于等于 b 第五行 - b 大于等于 b
Operator logis
Daftar tabel berikut semua bahasa Pergi operator logika. Asumsikan bahwa A adalah Benar, B adalah False.
operator | deskripsi | contoh |
---|---|---|
&& | Logis operator AND. Jika kedua sisi operan yang Benar, kondisi ini True, jika False. | (A && B) adalah False |
|| | Logis ATAU operator. Jika operan di kedua sisi ada Benar, kondisi ini True, jika False. | (A || B) Benar |
! | Logis TIDAK operator. Jika kondisi ini True, maka logis TIDAK kondisi False, jika tidak benar. | ! (A && B) Benar |
Contoh berikut menunjukkan penggunaan operator logika:
package main import "fmt" func main() { var a bool = true var b bool = false if ( a && b ) { fmt.Printf("第一行 - 条件为 true\n" ) } if ( a || b ) { fmt.Printf("第二行 - 条件为 true\n" ) } /* 修改 a 和 b 的值 */ a = false b = true if ( a && b ) { fmt.Printf("第三行 - 条件为 true\n" ) } else { fmt.Printf("第三行 - 条件为 false\n" ) } if ( !(a && b) ) { fmt.Printf("第四行 - 条件为 true\n" ) } }
Contoh hasil operasi di atas:
第二行 - 条件为 true 第三行 - 条件为 false 第四行 - 条件为 true
bitwise Operator
operator bitwise pada bilangan bulat dalam bit memori beroperasi.
Tabel berikut berisi daftar operator bitwise &, |, dan ^ dihitung:
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 |
Asumsikan bahwa A = 60; B = 13; bilangan biner untuk:
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
komputasi bit simbol bahasa dukungan C ditunjukkan pada tabel berikut. Asumsikan bahwa A adalah 60, B adalah 13:
operator | deskripsi | contoh |
---|---|---|
& | Bitwise DAN operator "&" adalah operator biner. Fungsinya adalah dua angka biner yang sesuai dengan setiap fase operasi dan partisipasi. | (A & B) hasilnya adalah 12, biner adalah 0000 1100 |
| | Bitwise operator OR "|" adalah operator biner. Fungsinya adalah untuk berpartisipasi dalam operasi dua nomor masing-masing sesuai fase biner atau | (A | B) hasilnya adalah 61, biner adalah 00111101 |
^ | Bitwise eksklusif OR operator "^" adalah operator biner. Fungsinya adalah untuk berpartisipasi dalam operasi dua nomor masing-masing sesuai XOR biner ketika dua sesuai bit biner yang berbeda dan hasilnya adalah 1. | (A ^ B) hasil untuk 49 binari untuk 00110001 |
<< | Pergeseran kiri operator "<<" adalah operator biner. N-bit pergeseran kiri dikalikan dengan 2 ^ n. Fungsinya untuk setiap biner "<<" kiri operan kiri semua sejumlah bit yang ditentukan dengan jumlah "<<" kanan bergerak desimal, membuang 0s tinggi dan lebih rendah. | A << 2 hasil untuk 240 biner adalah 11110000 |
>> | pergeseran Operator kanan ">>" adalah operator biner. Benar dengan n bit dibagi 2 ^ n. Fungsinya untuk berbagai biner ">>" operan kiri Beberapa baiklah, ">>" di sebelah kanan jumlah bit yang ditentukan. | Sebuah >> 2 hasil untuk 15 0000 1111 sistem biner |
Contoh berikut menunjukkan penggunaan operator logika:
package main import "fmt" func main() { var a uint = 60 /* 60 = 0011 1100 */ var b uint = 13 /* 13 = 0000 1101 */ var c uint = 0 c = a & b /* 12 = 0000 1100 */ fmt.Printf("第一行 - c 的值为 %d\n", c ) c = a | b /* 61 = 0011 1101 */ fmt.Printf("第二行 - c 的值为 %d\n", c ) c = a ^ b /* 49 = 0011 0001 */ fmt.Printf("第三行 - c 的值为 %d\n", c ) c = a << 2 /* 240 = 1111 0000 */ fmt.Printf("第四行 - c 的值为 %d\n", c ) c = a >> 2 /* 15 = 0000 1111 */ fmt.Printf("第五行 - c 的值为 %d\n", c ) }
Contoh hasil operasi di atas:
第一行 - c 的值为 12 第二行 - c 的值为 61 第三行 - c 的值为 49 第四行 - c 的值为 240 第五行 - c 的值为 15
Operator penugasan
Tabel berikut mencantumkan semua operator penugasan bahasa Go.
operator | deskripsi | contoh |
---|---|---|
= | operator penugasan sederhana memberikan ekspresi nilai lvalue | C = A + B A + B akan ditugaskan untuk hasil ekspresi C |
+ = | Ditambahkan bersama-sama sebelum penugasan | C + = A sama dengan C = C + A |
- = | Setelah pengurangan tugas | C - = A sama dengan C = C - A |
* = | Kemudian mengalikan tugas | C * = A sama dengan C = C * A |
/ = | Divisi setelah tugas | C / = A sama dengan C = C / A |
% = | Sisanya setelah tugas | C% = A sama dengan C = C% A |
<< = | Kiri setelah tugas | C << = 2 sama dengan C = C << 2 |
>> = | Tepat setelah tugas | C >> = 2 sama dengan C = C >> 2 |
& = | Bitwise AND tugas setelah | C & = 2 sama dengan C = C & 2 |
^ = | Setelah menekan sedikit XOR tugas | C ^ = 2 sama dengan C = C ^ 2 |
| = | Setelah posisi atau tugas menekan | C | = 2 adalah sama dengan C = C | 2 |
Contoh berikut menunjukkan penggunaan operator penugasan:
package main import "fmt" func main() { var a int = 21 var c int c = a fmt.Printf("第 1 行 - = 运算符实例,c 值为 = %d\n", c ) c += a fmt.Printf("第 2 行 - += 运算符实例,c 值为 = %d\n", c ) c -= a fmt.Printf("第 3 行 - -= 运算符实例,c 值为 = %d\n", c ) c *= a fmt.Printf("第 4 行 - *= 运算符实例,c 值为 = %d\n", c ) c /= a fmt.Printf("第 5 行 - /= 运算符实例,c 值为 = %d\n", c ) c = 200; c <<= 2 fmt.Printf("第 6行 - <<= 运算符实例,c 值为 = %d\n", c ) c >>= 2 fmt.Printf("第 7 行 - >>= 运算符实例,c 值为 = %d\n", c ) c &= 2 fmt.Printf("第 8 行 - &= 运算符实例,c 值为 = %d\n", c ) c ^= 2 fmt.Printf("第 9 行 - ^= 运算符实例,c 值为 = %d\n", c ) c |= 2 fmt.Printf("第 10 行 - |= 运算符实例,c 值为 = %d\n", c ) }
Contoh hasil operasi di atas:
第 1 行 - = 运算符实例,c 值为 = 21 第 2 行 - += 运算符实例,c 值为 = 42 第 3 行 - -= 运算符实例,c 值为 = 21 第 4 行 - *= 运算符实例,c 值为 = 441 第 5 行 - /= 运算符实例,c 值为 = 21 第 6行 - <<= 运算符实例,c 值为 = 800 第 7 行 - >>= 运算符实例,c 值为 = 200 第 8 行 - &= 运算符实例,c 值为 = 0 第 9 行 - ^= 运算符实例,c 值为 = 2 第 10 行 - |= 运算符实例,c 值为 = 2
operator lain
Tabel berikut berisi daftar operator lain Pergi bahasa.
operator | deskripsi | contoh |
---|---|---|
& | Kembali alamat memori variabel | & A; akan memberikan alamat sebenarnya dari variabel. |
* | variabel pointer. | * A; adalah variabel pointer |
Contoh berikut menunjukkan penggunaan operator lain:
package main import "fmt" func main() { var a int = 4 var b int32 var c float32 var ptr *int /* 运算符实例 */ fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a ); fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b ); fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c ); /* & 和 * 运算符实例 */ ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */ fmt.Printf("a 的值为 %d\n", a); fmt.Printf("*ptr 为 %d\n", *ptr); }
Contoh hasil operasi di atas:
第 1 行 - a 变量类型为 = int 第 2 行 - b 变量类型为 = int32 第 3 行 - c 变量类型为 = float32 a 的值为 4 *ptr 为 4
Precedence Operator
Beberapa operator memiliki prioritas yang lebih tinggi, operator biner adalah arah operasional dari kiri ke kanan. Tabel berikut mencantumkan semua operator dan prioritas mereka, perwakilan dari atas ke bawah dalam prioritas menurun:
prioritas | operator |
---|---|
7 | ^! |
6 | * /% ^ & << >> & |
5 | + - | ^ |
4 | ==! = << => => |
3 | <- |
2 | && |
1 | || |
Tentu saja, Anda dapat menggunakan tanda kurung untuk sementara meningkatkan prioritas keseluruhan operasi dari sebuah ekspresi.
Contoh hasil operasi di atas:
package main import "fmt" func main() { var a int = 20 var b int = 10 var c int = 15 var d int = 5 var e int; e = (a + b) * c / d; // ( 30 * 15 ) / 5 fmt.Printf("(a + b) * c / d 的值为 : %d\n", e ); e = ((a + b) * c) / d; // (30 * 15 ) / 5 fmt.Printf("((a + b) * c) / d 的值为 : %d\n" , e ); e = (a + b) * (c / d); // (30) * (15/5) fmt.Printf("(a + b) * (c / d) 的值为 : %d\n", e ); e = a + (b * c) / d; // 20 + (150/5) fmt.Printf("a + (b * c) / d 的值为 : %d\n" , e ); }
Contoh hasil operasi di atas:
(a + b) * c / d 的值为 : 90 ((a + b) * c) / d 的值为 : 90 (a + b) * (c / d) 的值为 : 90 a + (b * c) / d 的值为 : 50