Go言語の基本文法
記事ディレクトリ
1. 注意事項
- コードを書くとき、これは長い間起こります。書いたばかりのコードは、ロジックが非常に明確であるように感じます。どうして私はそんなにうまくできるのでしょうか? しばらくしてこのコードを見ると、「このコードは一体誰が書いたのか」という疑問が生まれます。ですので、自分でコードを理解できなかったり、自分が書いたコードを他の人に見せたい場合には、この際に説明する必要があります。
注: これは人間が読むために書かれたものであり、マシンはこのステートメント行を実行しないことを理解していただけます。
- コメントの主な機能はコードの可読性を高めることであり、プログラムのすべての機能に関与するわけではありません。Go 言語のコメントは主に 2 つのカテゴリに分類されます。
1. 一行コメント
package main
// 双斜杠表示单行注释，程序不会执行这行语句，这是写给自己或他人看的
import "fmt"
func main() {
fmt.Printf("helloword!")
}
2. 複数行のコメント
package main
/*
杠星 星杠表示多行注释，在二者之间的范围内可以换行写多行注释
*/
import "fmt"
/*
这是一个main函数，这是go语言启动的入口
*/
func main() {
// fmt.Printfln:打印一行内容，然后执行完成后进行换行
fmt.Printfln("hello,word!")
}
メモを書く良い習慣を身につけると、自分自身が読むのにも、他の人が読むにも便利です。
2. 変数
- 数学では、変数は固定値を持たない変数の数値を表します。たとえば、x=1、x=2、
- 文字通りの理解: 変数は変化する量です。
- たとえば、name という変数を設定します。これは Go 言語では次のように表されます。この値には、Zhang San、Li Si、Wang Wu、またはあなたの名前を指定できます。ここで、この名前は変数、つまり変更できる量です。
// 这里的等于是赋值，就是把等号右边的值，赋值给左边变量的意思
var name string = "guan"
名前に加えて、var と string は何のためにあるのかなど、ここでは他のことも書きました。次に、go 言語の変数の定義と、go 言語のいくつかのデータ型 (上記の名前 name など、文字列型です。数字を表現する必要がある場合があるため、デジタル型などもあります。これについては後ほどさらに理解します) を理解してもらいましょう。
1. 変数の定義
- Go 言語は静的に型付けされた言語です。つまり、すべての型を明確に定義する必要があります。ここでは他の型に関係なく、まず文字列を理解し、それを使用して文字の半分を表します。
- Go 言語では、通常、キーワードを使用するのに十分な変数を宣言します
var。
var name type
- 最初の var は変数を宣言するためのキーワードで、固定の書き方です 変数を宣言するには var が必要です。
- 2 番目の名前は変数の名前で、後で使用するために必要に応じて名前を付けることができます。
- 2 番目の型は、変数の型を表すために使用されます。
栗を取ります：
// 定义一个字符串变量，name
var name string
// 定义一个数字类型变量 age
var age int
以前に Java、C、または他のプログラミング言語を学んだことがある場合は、そのような操作を初めて見ると不快に感じるでしょう。Go 言語は多くのプログラミング言語とは異なります。変数を宣言するときに、変数名の後に変数の型を置きます。これは、C 言語のようなあいまいな宣言形式 (例: int *a, b; ここで、a のみがポインターで、b はそうではありません) を避けるためです。これら 2 つの変数をポインター変数にしたい場合は、それらを別々に記述する必要があります。ただし、Go では、両方を次の型であると簡単に宣言できます。
var a,b *int
変数の命名規則は、ラクダの命名方法に従います。つまり、最初の単語は小文字で、新しい単語の最初の文字は大文字になります (例: helloWord と guanGuan)。。
変数定義の標準形式は次のとおりです。
var 变量名 变量类型
変数宣言はキーワード var で始まり、その後に変数の型が続きます。行末にセミコロンは必要ありません。
変数をバッチで定義することがありますが、毎回個別に定義するのが面倒な場合は、Go 言語ではキー var と括弧を使用して変数定義をひとまとめにするバッチ定義変数がサポートされています。
var (
name string
age int
addr string
)
フォームの宣言ステートメントは、変数の型を明示的に指定する必要がある場合、または後で変数が再割り当てされるため初期値が重要でない場合によく使用されます。変数が宣言されるとき、値が明示的に割り当てられていない場合、システムは自動的にその型のゼロ値を割り当てます。
- 整数変数と浮動小数点変数のデフォルト値は 0 と 0.0 です。
- 文字列変数のデフォルト値は空の文字列です。
- ブール変数のデフォルト値は false です。
- スライス、関数、およびポインター変数のデフォルトは null
fmt.Printf(name, age, addr)
2. 変数の初期化
変数初期化の標準形式
var 变量名 类型 = 值（表达式）
たとえば、グアンに関する情報を定義したい場合は、次のように表現できます。
var name string = "guan"
var age int = 18
fmt.Printf("name:%s,age:%d", name, age)
ここでの名前と年齢は変数名で、名前の型は string 、年齢の型は int です。それらの値はそれぞれguanと18です
短い変数の宣言と初期化
name := "guanGuan"
age :=18
fmt.Printf("name:%s,age:%d", name, age)
これは Go 言語で記述された導出ステートメントであり、コンパイラは右辺値の型に基づいて、対応する左辺値の型を自動的に推測します。一部の型を自動的に推定できますが、使用方法も制限されています。
- 変数を明示的に初期化しながら定義します。
- データ型は指定できません。
- 関数内でのみ使用できます。どこでも定義できるわけではない
短い変数宣言は、その簡潔さと柔軟性により、ほとんどのローカル変数の宣言と初期化に広く使用されています。
注: 代入には = の代わりに := が使用されるため、導出ステートメントに記述される lvalue 変数は未定義の変数である必要があります。定義するとコンパイルエラーとなります。
// 定义变量 name
var name string
// 定义变量 name，并赋值为"guanGuan"
name := "guanGuan"
コンパイルではエラーが報告され、その情報は次のとおりです。:= の左側に新しい変数がありませんは、「:=」の左側に新しい変数が表示されないことを意味します。これは、「:=」の左側の変数が宣言されていることを意味します。
3. 変数（メモリアドレス）を理解する
var num int
num = 1000
fmt.Printf("num的值：%d,内存地址:%p\n", num, &num)
num = 2000
fmt.Printf("num的值：%d,内存地址:%p\n", num, &num)
4. 変数交換
package main
import "fmt"
func main() {
/*
在编程中，最简单的算法就是变量的交换，但是一般常见的方式就是定义中间变量
var a int = 100
var b int = 2oo
var t int
t = a
a = b
a = t
fmt.Println(a,b)
*/
var a int = 100
var b int = 200
fmt.Printf("交换前的变量a=%d,b=%d\n", a, b)
// 在Go语言中，可以直接用这样的方式实现值得交换，无需中间变量
b, a = a, b
fmt.Printf("交换后的变量a=%d,b=%d", a, b)
}
出力
5. 匿名変数
匿名変数はアンダースコア "" によって特徴付けられ、" " 自体は空の識別子として知られる特別な識別子です。他の識別子と同様に変数の宣言または割り当てに使用できます (任意の型を割り当てることができます)。但任何赋给这个标识符的值都将被抛弃そのため、これらの値を後続のコードで使用したり、この識別子を変数として使用して割り当てたり、他の変数を操作したりすることはできません。匿名変数を使用する場合、アンダースコアを使用して変数宣言を置き換えるだけで済みます。
例えば：
package main
import "fmt"
/*
定义一个test函数，它会返回两个int类型的值，每次调用将会返叵 100 和 200 两个数值、这里我们先不只管 函数的定义，后面会讲解。89我们用这个函数来理解这个匿名变量。
*/
func test()(int, int) {
return 100, 200
}
func main(){
a,_:= test()
_, b := test()
fmt.Println(a, b) //输出的结果100,200
// 在第一行代码巾，我们只需要获取第一个返叵值，所以第二个返回值定义为匿名交量
// 在第二行代码巾，我们只需要获取第二个返叵值，所以第一个返回值定义为匿名变量
}
- コンパイル中に、名前のない変数、型、またはメソッドが検出される場合があります。これは必須ではありませんが、これを行うとコードの柔軟性が大幅に向上する場合があり、これらの変数は総称して匿名変数と呼ばれます。
- 匿名変数はメモリ空間を占有せず、メモリを割り当てません。無名変数と無名変数の間では、多重宣言により使用できなくなることはありません。
6. 変数のスコープ
変数 (定数、型、または関数) には、プログラム内でスコープと呼ばれる特定のスコープがあります。
Go 言語では各変数がコンパイル時に使用されているかどうかがチェックされるため、変数のスコープを理解することは Go 言語を学習する上で非常に重要であり、未使用の変数が出現するとコンパイル エラーが報告されます。変数のスコープを解決できない場合、不明なコンパイル エラーが発生する可能性があります。
ローカル変数
関数本体内で宣言された変数をローカル変数といい、その有効範囲は関数本体内のみであり、関数のパラメータや戻り値変数もすべてローカル変数となります。
package main
import "fmt"
// 全局变量
var name string = "guanGuan"
func main() {
//局部变量
var age int = 18
var name string = "Guan"
fmt.Println(name, age)
}
func test() {
fmt.Println(name)
}
グローバル変数
関数の外で宣言された変数はグローバル変数と呼ばれます。グローバル変数は 1 つのソース ファイルで定義するだけでよく、すべてのソース ファイルで使用できます。もちろん、このグローバル変数が含まれていないソース ファイルでは、このグローバル変数を使用する前に、「import」キーを使用してグローバル変数が配置されているソース ファイルをインポートする必要があります。
グローバル変数の宣言は var キーワードで始める必要があり、外部パッケージで使用する場合はグローバル変数の最初の文字を大文字にする必要があります。
//声明全局变量
var c int
func main(){
//声明局部变量
var a,b int
初始化参数
a = 3
b = 4
c = a + b
fmt.printf("a = %d,b = %d,c = %d\n",a,b,c) //a = 3, b = 4, c = 7
}
Go 言語プログラムでは、グローバル変数とローカル変数の名前を同じにすることができますが、関数本体内のローカル変数が優先されます。
package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main(){
//声明局部变量
var a int = 3
fmt.Printf("a = %d\n", a) // a = 3
}
3. 定数
1. 定数の定義：const
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
- 定数のデータ型は、ブール値、数値 (整数、浮動小数点、複素数)、文字のみです。
const identifier [type] = value
コンパイラは変数の値から変数の型を推測できるため、型指定子 [type] を省略できます。
- 明示的な型定義: const b string = "abc"
- 暗黙的な型定義: const b = "abc"
同じ型の複数の宣言は次のように省略できます。
const c_name1, c_name2 = value1, value2
次の例は、定数の使用を示しています。
package main
func main() {
// 常量不能被修改的量，否则会报错
const URL string = "www.baidu.com"
URL = "www.guan.com"
}
出力
package main
import "fmt"
func main() {
const URL1 string = "www.baidu.com" // 显式定义
const URL2 = "www.guan.com" // 隐式定义
const a,b,c = 3.14,"guanGuan",true //同时定义多个常量
fmt.Println(URL1)
fmt.Println(URL2)
fmt.Println(a,b,c)
}
出力
2.iota (特別な定数)
-
特殊な定数である iota は、コンパイラによって変更できる定数と考えることができます。iota は Go 言語を常に認識するツールです
-
const キーワードが出現すると (const 内の最初の行の前)、iota は 0 にリセットされ、const の定数宣言の新しい行ごとに iota が 1 回カウントされます (iota は const ステートメント ブロック内の行インデックスとして理解できます)。
iota は列挙値として使用できます。
const (
a = iota
b = iota
c= iota
)
最初の iota は 0 に等しく、iota が新しい行で使用されるたびに、その値は自動的に 1 ずつ増加します。そのため、a=0、b=1、c=2 は次のように省略できます。
package main
import "fmt"
func main() {
const (
// 一组常量中，如果某个常量没有初始值，默认和上一行一致
a = iota //iota=0
b //iota=1
c //iota=2
d = "hello,guan" // hello,guan iota=3
e // hello,guan iota=4
f = 100 // 100 iota=5
g // 100 iota=6
h = iota //iota=7
i //iota=8
)
const (
j = iota // iota=0
k = iota // iota=1
)
fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}
4. 基本的なデータ型
Go 言語は静的型付けプログラミング言語であり、Go プログラミング言語では関数や変数の宣言にデータ型を使用します。データ型の登場は、データを必要なメモリサイズの異なるデータに分割することであり、大きなデータを必要とするプログラミングの場合、メモリを最大限に活用できる大きなメモリを申請する必要があります。コンパイラがコンパイルについて話し合うとき、コンパイラはこの値に割り当てるメモリの量と、割り当てられたメモリが何を表すかを知るために、各値の型を知る必要があります。
1. ブール型
ブール値は定数 true または false のみです。シンプルな栗を例に挙げます。
package main
import "fmt"
func main() {
// var 变量名 数据类型
// bool： true false
var isFlag bool
var b1 bool = true
var b2 bool = false
fmt.Println(isFlag) //如果不进行初始赋值，则默认值为false
fmt.Printf("%T,%t\n", b1, b1)
fmt.Printf("%T,%t\n", b2, b2)
}
2. 数値
整数型 int と浮動小数点型 loat32、foat64、Go 言語では整数と浮動小数点数、複素数をサポートしており、ビットの演算は補数符号を採用しています。
Go には、アーキテクチャベースの型もあります。例: uint unsigned、int signed
| シリアルナンバー | 種類と説明 |
|---|---|
| 1 | uint8符号なし 8 ビット整数 (0 ～ 255) |
| 2 | uint16符号なし 16 ビット整数 (0 ～ 65535) |
| 3 | uint32符号なし32ビット型(0～4294967295) |
| 4 | uint64符号なし 64 ビット整数 (0 ～ 18446744073709551615) |
| 5 | int8符号付き 8 ビット整数 (-128 ～ 127) |
| 6 | int16符号付き 16 ビット整数 (-32768 ～ 32767) |
| 7 | int32符号付き 32 ビット整数 (-2147483648 ～ 2147483647) |
| 8 | int64符号付き 64 ビット整数 (-9223372036854775808 ～ 9223372036854775807) |
package main
import "fmt"
func main() {
// 定义一个整型
// byte uint8
// rune int32
// int int64
var age int = -100
var i1 int8
var i2 uint8
i1 = 66
i2 = 188
fmt.Printf("%T,%d\n",age,age)
fmt.Println(i1)
fmt.Println(i2)
}
浮動小数点
| シリアルナンバー | 種類と説明 |
|---|---|
| 1 | float32 IEEE-754 32 ビット浮動小数点数 |
| 2 | float64 IEEE-754 64 ビット浮動小数点数 |
| 3 | complex64 32 ビットの実数および虚数 |
| 4 | complex128 64 ビットの頭と虚数 |
package main
import "fmt"
func main() {
var f1 float32
f1 = 3.14
var f2 float64
f2 = 5.12
// %f 默认保留小数点后6位，.2f%就是保留2位，.3f%就是保留3位
fmt.Printf("%T,%.3f\n", f1, f1)
fmt.Printf("%T,%f\n", f2, f2)
}
出力
1. マシン内の浮動小数点数の格納形式の簡単な説明、浮動小数点 = 符号ビット + 指数ビット + 仮数ビット
2. 仮数部が失われ、精度が損なわれる可能性があります。-123.0000901
package main
import "fmt"
func main() {
// float64 尽量使用 float64 来定义浮点类型的小数
var num1 float32 = -123.1234567
var num2 float64 = -123.1234567
fmt.Println("num1=", num1, "num2=", num2)
}
- 説明: float64 の精度は float32 の精度よりも正確です。
- 説明: 高精度で数値を保存したい場合は、float64 を選択する必要があります。
3. 浮動小数点型の記憶は、符号ビット + 指数ビット + 仮数ビットの 2 つの部分に分かれており、記憶処理中に精度が失われます。
4. golang の浮動小数点型はデフォルトで float64 型になります
5. 通常は、float32 よりも精度が高い float64 を使用する必要があります。
その他の数値型を以下に示します。
| シリアルナンバー | 種類と説明 |
|---|---|
| 1 | uint8 のようなバイト |
| 2 | int32に似たルーン |
| 3 | uint 32 または 64 ビット |
| 4 | int は uint と同じサイズです |
| 5 | uintptr 符号なし整数、ポインタを格納するために使用されます |
3.文字列型
import "fmt"
func main() {
var str string
str = "helloWorld!"
fmt.Printf("%T,%s\n", str, str)
//单引号 字符 ，整型-ASCII字符码
x1 := 'A'
x2 := "A"
x3 := '关'
// 拓展
// 编码表 ASCII 字符码
// 所有的中国字的编码表：GBK
// 全世界的编码表：Unicode 编码表
fmt.Printf("%T,%d\n", x1, x1)
fmt.Printf("%T,%s\n", x2, x2)
fmt.Printf("%T,%s\n", x3, x3)
}
package main
import "fmt"
func main() {
var str1, str2, str3 string
str1 = "hello"
str2 = "guan"
str3 = ","
// 字符串的连接 用 + 号
fmt.Println(str1 + str3 + str2)
// 转义字符 \
fmt.Println("hello\\guan")
fmt.Println("hello\"guan")
fmt.Println("hello\nguan") // \n 换行
fmt.Println("hello\tguan") // \t 制表符
}
出力
4. データ型変換
必要かつ実行可能な場合、あるタイプの値を別のタイプの値に変換できます。Go 言語には暗黙的な型変換がないため、すべての型変換を明示的に宣言する必要があります。
valueofTypeA = typeA (valueofTypeB)
型 A の値 = 型 A (型 B の値)
func main() {
a := 5.0 // float64
b := 8 // int
//需求：将int类型的 b 转化为 float64 类型
c := float64(b)
d := int(a)
// 整型不能转换为bool类型
//e := bool(b)
//fmt.Printf("%T,%f\n", e, e)
fmt.Printf("%T,%f\n", c, c)
fmt.Printf("%T,%d\n", d, d)
}
出力
型変換は、値の範囲が小さい型から値の範囲が大きい型への変換 (int16 から int32 への変換) など、定義が正しい場合にのみ成功します。値の範囲が大きい型から小さい値の型への変換 (int32 から int16 への変換、または float32 から int への変換) では、精度の低下 (切り捨て) が発生します。
5. オペレーター
1. 算術演算子
次の表は、Go 言語のすべての算術演算子のリストです。A の値が 1、B の値が 2 であると仮定します。
| オペレーター | 説明 | 例 |
|---|---|---|
| + | 合計する | A+B出力結果3 |
| - | 減算 | AB出力結果 -1 |
| * | 乗算された | A*B出力結果2 |
| / | 分割する | A/Bスティール結果0 |
| % | 余剰 | A % B 負け山結果 1 |
| ++ | 自己増加 | A++出力結果2 |
| – | デクリメント | A – 出力結果 1 |
package main
import "fmt"
func main() {
var a int = 1
var b int = 2
// + - * / % ++ --
fmt.Println(a + b)
fmt.Println(a - b)
fmt.Println(a * b)
fmt.Println(a / b)
fmt.Println(a % b)
a++
fmt.Println(a)
a--
fmt.Println(a)
}
出力
2. 関係演算子
次の表は、Go 言語のすべての関係演算子のリストです。A の値が 1、B の値が 2 であると仮定します。
| オペレーター | 説明 | 例 |
|---|---|---|
| == | 2 つの値が等しいかどうかを確認し、等しい場合は True、そうでない場合は False を返します。 | (A == B) は偽です |
| != | 2 つの値が等しいかどうかを確認し、等しくない場合は True を返し、そうでない場合は False を返します | (A!=B) は True |
| > | 左側の値が右側の値より大きいかどうかを確認し、大きい場合は True を返し、そうでない場合は False を返します。 | (A > B) は偽です |
| < | 左側の値が右側の値より小さいかどうかを確認し、小さい場合は True を返し、そうでない場合は False を返します。 | (A < B) は真です |
| >= | 左側の値が右側の値以上であるかどうかを確認し、大きい場合は True を返し、そうでない場合は False を返します。 | (A > B) は偽です |
| <= | 左側の値が右側の値より小さいかどうかを確認し、小さい場合は True を返し、そうでない場合は False を返します。 | (A<=B) は True |
package main
import "fmt"
func main() {
var a int = 1
var b int = 2
// ==等于 =赋值
// 关系运算符 返回结果都是 bool值
fmt.Println(a == b)
fmt.Println(a != b)
fmt.Println(a > b)
fmt.Println(a < b)
fmt.Println(a >= b)
fmt.Println(a <= b)
}
出力結果
3. 論理演算子
次の表は、Go 言語のすべての論理演算子のリストです。A の値が True、B の値が False であるとします。
| オペレーター | 説明 | 例 |
|---|---|---|
| && | 論理 AND 演算子。条件 両方のオペランドが True の場合は True、それ以外の場合は False | (A && B) 1 つの誤り |
| || | 論理和演算子。両方のオペランドが True の場合、条件は True であり、それ以外の場合は False です。 | (A || B) は True |
| ！ | 論理否定演算子。論理 NOT 条件は、条件が True の場合は False、それ以外の場合は True です。 | !(A && B) One True |
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
// 逻辑与 && 要左右两边的表达式同时为真，才执行，结果才为真，否则为假
// 关系运算符 返回结果都是 bool值
fmt.Println(a && b)
// 逻辑或 || 只要其中有一个为真，则为真，全为假则为假
fmt.Println(a || b)
// !为逻辑非，即取反，结果相反
// a = true
// b = false
fmt.Println(!a)
fmt.Println(!b)
}
出力結果
4. ビット演算子
Go 言語でサポートされているビット演算子を次の表に示します。A を 60、B を 13 とします。
| オペレーター | 説明 | 例 |
|---|---|---|
| & | ビット単位の AND 演算子「&」は二項演算子です。両方が 1 の場合、結果は 1 になり、それ以外の場合は 0 になります。 | (A & B) 結果は 12 です。これは 2 進数で 0000 1100 です。 |
| | | ビット単位の OR 演算子「|」は二重月演算子です。両方が 0 の場合、結果は 0、それ以外の場合は 1 | （A|B）结果为 61，二进制为 0011 1101 |
| ^ | 按位异或运算符"^"是双目运算符。不同则为1，机同为0 | (A^B)结果为49，二进制为 0011 0001 |
| &^ | 位清空,a&^b，对于b上的每个数值，如果为0,则取a对应位上的数值,如果为1,则取0 | (A &^ B) 结果为 48，二进制为 0011 0000 |
| << | 左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。其功能把”<<“左边的运算数的各二进位全部左移若干位,由”<<"右边的数指定移动的位数,高位丢弃,低位补0 | A<<2 结果为 240，二进制为 1111 0000 |
| >> | 右移认算符">>“是双目运算符。右移n位就是除以2的n次方。其功能是把”>>“左边的运算数的各二进制文全部右移若干位，”>>"右边的数指定移动的位数 | A >> 2 结果为 15，二进制为0000 1111 |
package main
import "fmt"
func main() {
// 二进制 0 1 逢二进一
// 位运算：二进制上的 0 false 、 1 true
// 逻辑运算符： && 只要有一个为假，则为假、 || 只要有一个为真，则为真
// a 60 0011 1100
// b 13 0000 1101
// --------------------------
// & 0000 1100 同时满足
// | 0011 1101 一个满足就行
// ^ 0011 0001 不同为1，相同为0
// << 2
// >> 2
var a uint = 60
var b uint = 13
// 位运算
var c uint = 0
c = a & b //位运算
fmt.Printf("%d,二进制%b", c, c) // 0000 1100
fmt.Println()
c = a | b //位运算
fmt.Printf("%d,二进制%b", c, c) // 0011 1101
fmt.Println()
c = a ^ b //位运算
fmt.Printf("%d,二进制%b", c, c) // 0011 0001
fmt.Println()
// 60 0011 1100
c = a << 2
fmt.Printf("%d,二进制%b", c, c) //
fmt.Println()
a = 60
c = a >> 2
fmt.Printf("%d,二进制%b", c, c) //
}
输出
5.赋值运算符
下表列出了所有Go语言的赋值认算符。
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符,将一个表达式的值赋给一个左值 | C=A+B将 A+B表达式结果赋值给C |
| += | 相加后赋值 | B+=A等于B=B+A |
| -= | 相减后再赋值 | B-=A 等于 B=B-A |
| *= | 相乘后再赋值 | C*=A等于C=C*A |
| /= | 相除后由赋值 | C/=A等于C= C/A |
| %= | 求余后再赋值 | C%=A 等于 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 |
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)
}
输出
6.其他运算符
下表列出了Go语言的其他运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a；将给出变量的实际地址 |
| * | ポインタ変数 | *a; はポインタ変数です |
package main
import "fmt"
func main() {
var a int = 6
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 的值为 = %p\n", ptr)
fmt.Printf("ptr 的值为 = %d\n", *ptr)
}
出力
6. キーボード入出力
package main
import "fmt"
func main() {
var name string
var phoneNumber string
// 定义了两个变量，想用键盘来输入这两个变量
//fmt.Println() //打印并换行
//fmt.Printf() //格式化输出
//fmt.Print() //打印输出
fmt.Println("请输入姓名和手机号码：")
// 变量去地址 &变量
// 指针、地址来修改和操作变量
// Scanln 阻塞等待从键盘输入
fmt.Scanln(&name, &phoneNumber)
fmt.Println("name:", name)
fmt.Println("phoneNumber:", phoneNumber)
// fmt.Scanln() //接收输入并换行
// fmt.Scanf() // 接收输入，格式化输入
// fmt.Scan() // 接收输入
}
出力
