一. 命名規則
-
go 語言中的函數名、變量名、常量名、類型名、語句標號和包名等所有的命名，都遵循一個簡單的命名規則
-
必須以一個字母或下劃線_開頭，後面可以跟任意數量的字母、數字或下劃線
-
go 語言中大小寫字母認爲是不同的
-
go 語言中有 25 個關鍵字，不能用於自定義名字
| break | default | func | interface | select |
|---|---|---|---|---|
| case | defter | go | map | struct |
| chan | else | goto | package | switch |
| const | fallthrough | if | range | type |
| continue | for | import | retrun | var |
還有 30 多個預定義的名字，用於內建的常量、類型和函數
1.內建常量
true false iota nil
2.內建類型
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
3.內建函數
make len cap new append copy close delete
complex real imag
panic recover
二、變量
1. 變量聲明
語法格式: var 變量名 變量類型
package main
import "fmt"
func main() {
/*
變量不引用會報錯
*/
// 1. 直接聲明
var v1 int
var v2 int
// 2. 一次聲明多個變量
var v3, v4 int
var (
v5 int
v6 int
)
fmt.Println(v1, v2, v3, v4, v5, v6)
}
2.初始化變量
package main
import "fmt"
func main() {
// 1. 直接初始化
var v1 int = 1
// 2. 自動推導初始化
var v2 = 2
// 3. 聲明並初始化
v3 := 3
fmt.Println(v1, v2, v3)
}
3.變量賦值
package main
import "fmt"
func main() {
// 1. 直接賦值
var v1 int
v1 = 1
// 2. :=
v2 := 2
// 3. 多重賦值
var v3, v4 int
fmt.Println(v1, v2, v3, v4)
}
4.匿名變量
_ 單下滑線表示匿名變量，爲了防止變量爲被引用報錯
package main
import "fmt"
func test() (int, int) {
return 1,2
}
func main() {
// _單下滑線表示匿名變量，了不報錯
v1, _ := test()
fmt.Println(v1)
}
三. 常量與枚舉
1.const 關鍵字 定義常量
package main
import "fmt"
// 聲明在函數外部
const filename = "123.txt"
const (
username = "admin"
password = "admin"
)
func main() {
// 聲明在函數的內部
const filename = "456.txt"
fmt.Println(filename)
}
2.iota 常量生成器和枚舉類型
package main
import "fmt"
// 枚舉
func enums001() {
const (
v1 = 0
v2 = 1
v3 = 2
)
fmt.Println(v1, v2, v3)
// 輸出結果 0 1 2
}
// 可省略的枚舉
func enums002() {
const (
v1 = 0
v2
v3 = 1
v4
)
fmt.Println(v1, v2, v3, v4)
// 輸出結果 0 0 1 1
}
// 定義自增的枚舉類型
// iota默認值爲0
// 往下依次自增
func enums003() {
const (
v1 = iota
v2
v3
v4
)
fmt.Println(v1, v2, v3, v4)
// 輸出結果 0 1 2 3
}
// 計算枚舉
func enums004() {
// b等於1左移
// 1<<(10 * 0) 1 << 0 相當於 1*2^0
const (
b = 1 << (10*iota)
kb
mb
gb
tb
pb
)
fmt.Println(b, kb, mb, gb, tb, pb)
// 輸出結果
}
func main() {
//enums001()
//enums002()
//enums003()
enums004()
}
四. 基本數據類型
int8 是有符號類型，uint8 是無符號類型
go 語言中不同類型的數據不能相加，會編譯錯誤
| 類型 | 名稱 | 長度 | 零值 | 說明 |
|---|---|---|---|---|
| bool | 布爾類型 | 1 | false | 值爲 true 或 false, 不可以用數字代表 |
| byte | 字節型 | 1 | 0 | uint8 |
| rune | 字符類型 | 4 | 0 | 專用於存儲 unicode 編碼，等價於 uint32 |
| int, uint | 整型 | 4 或 8 | 0 | 32 位或 64 位 |
| int8, uint8 | 整型 | 1 | 0 | -128~127, 0~255 |
| int16, uint16 | 整型 | 2 | 0 | -32768~32767, 0~65535 |
| int32, uint32 | 整型 | 4 | 0 | -21 億~21 億, 0~42 億 |
| int64, uint64 | 整型 | 8 | 0 | |
| float32 | 浮點型 | 4 | 0.0 | 小數位精確到 7 位 |
| float64 | 浮點數 | 8 | 0.0 | 小數位精確到 15 位 |
| complex64 | 複數類型 | 8 | ||
| complex128 | 複數類型 | 16 | ||
| uintptr | 整型 | 4 或 8 | 足以存儲指針的 uint32 或 uint64 整數 | |
| string | 字符串 | "" | utf-8 字符串 |
1.整形
package main
import (
"fmt"
"reflect"
)
func main() {
var v1 int
v1 = 123
v2 := 42
fmt.Println(reflect.TypeOf(v1))
fmt.Println(reflect.TypeOf(v2))
}
2.浮點型
package main
import (
"fmt"
"reflect"
)
func main() {
var f1 float32
f1 = 12.5
f2 := 13.66
fmt.Println(reflect.TypeOf(f1))
fmt.Println(reflect.TypeOf(f2))
}
3.布爾型
package main
import (
"fmt"
"reflect"
)
func main() {
// 只有true和false兩個值
var b1 bool
b1 = false
fmt.Println(b1)
// 可以使用 == 或 != 得到布爾值
b2 := (1!=2)
fmt.Println(reflect.TypeOf(b2))
// 使用 ! 對布爾類型進行取反
b3 := !b2
fmt.Println(b3)
}
4.byte字符型
package main
import (
"fmt"
"reflect"
)
func main() {
// 單引號賦值byte
var ch byte
ch = 'a'
fmt.Println(ch)
// 格式化輸出
fmt.Printf("ch = %c\n", ch)
// uint8
fmt.Println(reflect.TypeOf(ch))
}
5.字符串
package main
import "fmt"
func main() {
// 字符串使用雙引號賦值
var s1 string
s1 = "abc"
fmt.Println(s1)
// 取字符串中第一個字符
ch := s1[0]
fmt.Println(ch)
// 反引號用來創建原生的字符串字面量(原格式輸出)
s2 := `hello
xxxxx
world
`
fmt.Println(s2)
}
五.fmt 包的使用
格式化參數列表
| 格式 | 含義 |
|---|---|
| %% | 一個%字面量 |
| %b | 一個二進制整數值(基數爲 2)，或者是一個(高級的)用科學計數法表示的指數爲 2 的浮點數 |
| %c | 字符型。可以把輸入的數字按照 ASCII 碼相應轉換爲對應的字符 |
| %d | 一個十進制數值(基數爲 10) |
| %e | 以科學記數法 e 表示的浮點數或者複數值 |
| %E | 以科學記數法 E 表示的浮點數或者複數值 |
| %f | 以標準記數法表示的浮點數或者複數值 |
| %g | 以%e 或者%f 表示的浮點數或者複數，任何一個都以最爲緊湊的方式輸出 |
| %G | 以%E 或者%f 表示的浮點數或者複數，任何一個都以最爲緊湊的方式輸出 |
| %o | 一個以八進制表示的數字(基數爲 8) |
| %p | 以十六進制(基數爲 16)表示的一個值的地址，前綴爲 0x, 字母使用小寫的 a-f 表示 |
| %q | 使用 Go 語法以及必須時使用轉義，以雙引號括起來的字符串或者字節切片[]byte，或者是以單引號括起來的數字 |
| %s | 字符串。輸出字符串中的字符直至字符串中的空字符（字符串以'\0'結尾，這個'\0'即空字符） |
| %t | 以 true 或者 false 輸出的布爾值 |
| %T | 使用 Go 語法輸出的值的類型 |
| %U | 一個用 Unicode 表示法表示的整型碼點，默認值爲 4 個數字字符 |
| %v | 使用默認格式輸出的內置或者自定義類型的值，或者是使用其類型的 String()方式輸出的自定義值，如果該方法存在的話 |
| %x | 以十六進制表示的整型值(基數爲十六)，數字 a-f 使用小寫表示 |
| %X | 以十六進制表示的整型值(基數爲十六)，數字 A-F 使用小寫表示 |
六. 類型別名
使用 type 關鍵字自定義類型
package main
import (
"fmt"
"reflect"
)
// type 自定義類型名 原類型
type myint int
func main() {
var v1 myint
v1 = 10
fmt.Println(reflect.TypeOf(v1))
}
// 輸出結果: main.myint
七. 類型轉換
go 語言不允許隱式轉換
package main
import (
"fmt"
"reflect"
)
func main() {
var a byte
a = 97
var b int
b = int(a)
// 輸出變量類型
fmt.Println(reflect.TypeOf(b))
}
八. 運算符
1.算數運算符
| 符號 | 說明 |
|---|---|
| + | 相加 |
| - | 相減 |
| * | 相乘 |
| / | 相除 |
| % | 求餘 |
| ++ | 自增 |
| -- | 自減 |
2.關係運算符
| 符號 | 說明 |
|---|---|
| == | 等於 |
| != | 不等於 |
| > | 大於 |
| < | 小於 |
| >= | 大於等於 |
| <= | 小於等於 |
3.邏輯運算符
| 符號 | 說明 |
|---|---|
| && | 與 |
| || | 或 |
| ! | 非 |
4.賦值運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| = | 簡單的賦值運算符，將一個表達式的值賦給一個左值 | 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 等於 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 |
5.位運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 按位與運算符"&"是雙目運算符。 其功能是參與運算的兩數各對應的二進位相與。 | (A & B) 結果爲 12, 二進制爲 0000 1100 |
| | | 按位或運算符"|"是雙目運算符。 其功能是參與運算的兩數各對應的二進位相或 | (A | B) 結果爲 61, 二進制爲 0011 1101 |
| ^ | 按位異或運算符"^"是雙目運算符。 其功能是參與運算的兩數各對應的二進位相異或，當兩對應的二進位相異時，結果爲 1。 | (A ^ B) 結果爲 49, 二進制爲 0011 0001 |
| << | 左移運算符"<<"是雙目運算符。左移 n 位就是乘以 2 的 n 次方。 其功能把"<<"左邊的運算數的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補 0。 | A << 2 結果爲 240 ，二進制爲 1111 0000 |
| >> | 右移運算符">>"是雙目運算符。右移 n 位就是除以 2 的 n 次方。 其功能是把">>"左邊的運算數的各二進位全部右移若干位，">>"右邊的數指定移動的位數。 |
6.其他運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 返回變量存儲地址 | &a; 將給出變量的實際地址。 |
| * | 指針變量。 | *a; 是一個指針變量 |
package main
import "fmt"
func main() {
var a int = 4
var b int32
var c float32
var ptr *int
/* 運算實例 */
fmt.Printf("a 變量類型爲 = %T\n", a );
fmt.Printf("b 變量類型爲 = %T\n", b );
fmt.Printf("c 變量類型爲 = %T\n", c );
/* & 和 * 運算符實例 */
ptr = &a /* 'ptr' 包含了 'a' 變量的地址 */
fmt.Printf("a 的值爲 %d\n", a);
fmt.Printf("*ptr 爲 %d\n", *ptr);
}
7.運算符優先級
有些運算符擁有較高的優先級，二元運算符的運算方向均是從左至右。下表列出了所有運算符以及它們的優先級，由上至下代表優先級由高到低：
| 優先級 | 運算符 |
|---|---|
| 5 | * / % << >> & &^ |
| 4 | + - \ ^ |
| 3 | == != < <= > >= |
| 2 | && |
| 1 | || |