在Go語言中常用的基本數據類型有如下幾種：
- 整型
- 浮點型
- 布爾類型
- 複數
- 字符串
整型
- 有符號
- int8
- int16
- int32
- int64
- 無符號
- uint8
- uint16
- uint32
- uint64
- 特殊整型
- uint，32位操作系統就是uint32，64位操作系統就是uint64
- int，32位操作系統就是int32，64位操作系統就是int64
- uintptr，無符號整型，用於存放指針
注意：在使用
int和uint類型時，不能假定它是32位或64位的整型，而是考慮int和uint可能在不同平臺上的差異。
進制
// 程序入口
func main() {
// age = "17"
// fmt.Println("Hello World")
// fmt.Print("isOK")
// fmt.Printf("Age: %s", age)\n
var a1 = 10
fmt.Printf("十進制：%d\n", a1)
fmt.Printf("二進制：%b\n", a1)
fmt.Printf("八進制：%o\n", a1)
fmt.Printf("十六進制：%x\n", a1)
// 直接定義八進制
a2 := 077
fmt.Printf("直接聲明八進制：%d\n", a2)
// 直接定義十六進制
a3 := 0x12321
fmt.Printf("直接聲明十六進制：%d\n", a3)
}浮點型
Go語言支持兩種浮點型：
- float32，使用常量math.MaxFloat32來定義；
- float64，使用常量math.MaxFloat64來定義；
打印浮點數，可以用fmt包配合%f ，如下：
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
}布爾類型
Go語言中以bool類型進行聲明布爾型數據，布爾型數據只有true（真）和false（假）兩個值。
注意：
- 布爾類型變量的默認值爲
false。 - Go 語言中不允許將整型強制轉換爲布爾型.
- 布爾型無法參與數值運算，也無法與其他類型進行轉換。
複數
複數有實部和虛部，complex64的實部和虛部爲32位，complex128的實部和虛部爲64位。如下：
func main(){
var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)
}子符串
Go語言中的字符串以原生數據類型出現，使用字符串就像使用其他原生數據類型（int、bool、float32、float64 等）一樣。 Go 語言裏的字符串的內部實現使用UTF-8編碼。 字符串的值爲雙引號(")中的內容，可以在Go語言的源碼中直接添加非ASCII碼字符，例如：
s1 := "Joker"
s2 := "HelloWorld"如果是多行字符串，則是用反引號，它裏面的內容會原樣輸出，比如：
s1 := `
你好，
歡迎光臨。
`字符
組成每個字符串的元素叫做字符 ，字符 用'' 括起來，如下：
s1 := 'H'
s2 := '你'Go語言中的字符有兩種：
- uint8類型，或者叫byte型，代表
ASCII碼的一個符號； - rune類型，代表一個
UTF-8符號；
當需要處理中文、日文或者其他複合字符時，則需要用到rune類型。rune類型實際是一個int32。
Go 使用了特殊的 rune 類型來處理 Unicode，讓基於 Unicode 的文本處理更爲方便，也可以使用 byte 型進行默認字符串處理，性能和擴展性都有照顧。
package main
import "fmt"
func main() {
s1 := "Hello World，你好啊！"
// fmt.Printf(s1)
// 遍歷字符串,Byte類型
for i := 0; i < len(s1); i++ {
fmt.Printf("%v(%c)", s1[i], s1[i])
}
fmt.Println()
// 遍歷字符串，rune類型
for _, r := range s1 {
fmt.Printf("%v(%c)", r, r)
}
}其輸出結果如下：
72(H)101(e)108(l)108(l)111(o)32( )87(W)111(o)114(r)108(l)100(d)239(ï)188(¼)140()228(ä)189(½)160( )229(å)165(¥)189(½)229(å)149(
)138()239(ï)188(¼)129()
===============================================
72(H)101(e)108(l)108(l)111(o)32( )87(W)111(o)114(r)108(l)100(d)65292(，)20320(你)22909(好)21834(啊)65281(！)從上可以看到，第一種遍歷方法是按字節進行遍歷的，而對於非英文字母或者數字來說，其佔用的並非一個字節，比如中文在UTF-8 編碼中就佔用3個字節，這時候如果我們按着字節來遍歷就會得到第一種結果，這種結果並不是我們想要的。我們就需要採用第二用遍歷方式，rune類型用來 表示UTF-8 字符，一個rune字符由一個或者多個字節組成。
字符串轉義
特殊字符串需要保持其原生的意義，就需要對其進行轉義，常用的如下表：
| 轉義符 | 含義 |
|---|---|
| \r | 回車 |
| \n | 換行 |
| \t | 製表 |
| \' | 單引號 |
| \\ | 反斜槓 |
| \" | 雙引號 |
比如：
package main
import "fmt"
func main() {
s1 := "\"Hello World\""
fmt.Printf(s1)
}字符串的常用操作
| 方法 | 作用 |
|---|---|
| len(s) | 求長度（是字節的長度） |
| +或者fmt.Sprintf | 字符串拼接 |
| strings.Split | 字符串切割 |
| strings.contains | 判斷字符串中是否包含 |
| strings.HasPrefix,strings.HasSuffix | 判斷字符串的前綴/後綴（布爾類型） |
| strings.Index(),strings.LastIndex() | 輸出子串出現的位置（索引） |
| strings.Join(a[]string, sep string) | join操作 |
例子：
package main
import "fmt"
import "strings"
func main() {
s := "Hello World 你好啊！"
// 求長度
fmt.Println(len(s))
// 字符串拼接
s1 := "Joker"
s2 := "你好"
fmt.Println(s1 + s2)
s12 := fmt.Sprintf("%s%s", s1, s2)
fmt.Println(s12)
// 字符串切割
sSplit := strings.Split(s, " ")
fmt.Println(sSplit)
// 判斷字符串是否包含
fmt.Println(strings.Contains(s, "H"))
fmt.Println(strings.Contains(s, "L"))
// 判斷字符串的前綴
fmt.Println(strings.HasPrefix(s, "H"))
// 判斷字符串的後綴
fmt.Println(strings.HasSuffix(s, "啊"))
// 判斷字串出現的位置
fmt.Println(strings.Index(s, "H"))
// 判斷子串最後出現的位置
fmt.Println(strings.LastIndex(s, "o"))
// join操作
fmt.Println(strings.Join(sSplit, "-"))
}字符串的修改
要修改字符串，需要先將其轉換成[]rune或[]byte，完成後再轉換爲string。無論哪種轉換，都會重新分配內存，並複製字節數組。
package main
import "fmt"
func main() {
s1 := "hello"
// 1、強制轉換
byteS1 := []byte(s1)
// 2、進行修改
byteS1[0] = 'H'
// 3、強制轉換成字符串並打印
fmt.Println(string(byteS1))
s2 := "我愛你中國"
// 1、強制轉換
runeS2 := []rune(s2)
// 2、修改
runeS2[3] = '祖'
// 3、強制轉換成字符串並打印
fmt.Println(string(runeS2))
}類型轉換
Go語言中只有強制類型轉換，沒有隱式類型轉換。該語法只能在兩個類型之間支持相互轉換的時候使用。
強制類型轉換的基本語法如下：
T(表達式)其中，T表示要轉換的類型。表達式包括變量、複雜算子和函數返回值等.