Go 基本类型

整形

标准整形

　　 标准整形是按长度进行分类的，其中uint8为byte型，int16为C语言中的short型，int64为C语言中的long类型。

类型	描述
uint8	无符号 8位整型 (0 到 255)
uint16	无符号 16位整型 (0 到 65535)
uint32	无符号 32位整型 (0 到 4294967295)
uint64	无符号 64位整型 (0 到 18446744073709551615)
int8	有符号 8位整型 (-128 到 127)
int16	有符号 16位整型 (-32768 到 32767)
int32	有符号 32位整型 (-2147483648 到 2147483647)
int64	有符号 64位整型 (-9223372036854775808 到 9223372036854775807)

动态整形

类型	描述
uint	32位操作系统上就是uint32，64位操作系统上就是uint64
int	32位操作系统上就是int32，64位操作系统上就是int64
uintptr	无符号整型，用于存放一个指针

　　 动态整形的意思即是再不同的平台上，有不同的差异。

　　 注意事项：len()函数可以根据不同平台动态获取动态整形的长度。但是在涉及到二进制传输、读写文件的结构描述时，不要使用int和uint

进制写法

　　 在Go1.13版本后，可以根据字面量来书写不同的进制。

　　 你甚至可以使用_来做分割，如v:=123_456表示v的值为123456。

　　 需要注意的一点是，Go语言中目前不支持二进制的字面量写法。

　　 借助fmt函数将一个整数用于不同的进制显示。

package main

import "fmt"

func main() {
	// 十进制定义
	var a int = 10
	fmt.Printf("%d 
", a) // 显示十进制
	fmt.Printf("%b 
", a) // 显示二进制
	fmt.Printf("%o 
", a) // 显示八进制
	fmt.Printf("%0x 
", a) // 显示十六进制

	// 八进制定义
	var b int = 077
	fmt.Printf("%d 
", b) // 显示十进制

	// 十六进制定义
	var c int = 0xff
	fmt.Printf("%d 
", c) // 显示十进制

}

浮点型

　　 Go语言中有两种浮点型，float32与float64。

　　 float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。

　　 在打印浮点数时，使用fmt配合%f。

package main

import "fmt"

func main() {
	// float32
	var a float32 = 9.999
	// float64
	var b float64 = 8.888

	fmt.Println(a)

	fmt.Printf("类型：%T-数值：%f 
", a, a)
	fmt.Printf("类型：%T-数值：%f 
", b, b)

	// 9.999
	// 类型：float32-数值：9.999000
	// 类型：float64-数值：8.888000
}

复数

　　 复数用的比较少。有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

布尔类型

　　 Go语言中的bool类型有true和false。

　　 值得一提的是在Go语言中布尔值有以下的特性：

　　 1.布尔类型的变量默认值都是false

　　 2.Go语言中布尔值与整形没有任何关系

　　 3.布尔值无法参与运算，也不能进行转换

字符串

　　 Go语言中的字符串是双引号进行声明，而多行的原生字符串可以使用``来进行声明。

　　 至于单引号，则用来表示单个字符。

　　 另外，Go语言中的字符串都是使用UTF-8编码格式。

基本定义

　　 以下示例中定义了一个字符串。

package main

import "fmt"

func main() {
	var str string = "HELLO,WORLD!"
	fmt.Printf("类型：%T 
值: %v 
", str, str)
	// 类型：string
	// 值: HELLO,WORLD!
}

　　

转义符

　　 可以使用反斜杠来进行特殊字符的转义。

转义符	含义
	回车符（返回行首）
	换行符（直接跳到下一行的同列位置）
	制表符
\	单引号
"	双引号
\	反斜杠

原始字符

　　 使用``来定义多行，并且它还具有原始字符串的功能，即特殊字符在原始字符串中没有意义。

package main

import "fmt"

func main() {
	str := `
		望庐山瀑布
			李白
		日照香炉生紫烟，
		遥看瀑布挂前川。
		飞流直下三千尺，
		疑似银河落九天。
	`
	fmt.Println(str)
}

常用方法

　　 以下是一些字符串的常用方法。注意，需要导入strings包。

方法	描述
len()	求长度，byte长度
+	字符串拼接
fmt.Sprint()	字符串拼接
strings.Contains()	判断是否包含子串
strings.HasPrefix()	是否是以特定前缀开始
strings.HasSuffx()	是否是以特定后缀结束
strings.Index()	子串出现位置，从左至右检索
strings.LastIndex()	子串出现位置，从右至左检索
strings.Split()	字符串按照指定字符分割，返回数组
strings.Join(str,sep string)	数组拼接成字符串

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "this is string"
	fmt.Println(len(str)) // 14
	fmt.Println(str + "拼接后的内容")            // 返回新字符串 this is string拼接后的内容
	fmt.Println(fmt.Sprint(str, "拼接后的内容")) // 返回新字符串 this is string拼接后的内容
	fmt.Println(strings.Contains(str, "this")) // true
	fmt.Println(strings.HasPrefix(str, "this")) // true
	fmt.Println(strings.HasSuffix(str, "string")) // true
	fmt.Println(strings.Index(str,"is")) // 2
	fmt.Println(strings.LastIndex(str,"str")) // 8
	newStr := strings.Split(str,` `) 
	fmt.Println(newStr) // [this is string]
	fmt.Println(strings.Join(newStr,` `)) // this is string
}

byte

　　 当单个字符为英文时，是一个byte类型。一个byte标识八位二进制数。

　　 值得注意的是，byte等同于uint8

package main

import (
	"fmt"
)

func main() {
	str := "this is string"
	fmt.Printf("类型:%T 
值:%v ", str[0], str[0])
	// 类型:uint8 
	// 值:116 
}

rune

　　 当单个字符为中文，或者其他文字如韩文时，该字符为rune类型。

　　 rune等同于uint32。

　　 如下示例，如果按照普通的len()进行遍历，则会遍历出byte类型，而一个中文字符通常是3个byte，所以需要用rune来进行显示。否则就会出现第一次遍历出的结果。

package main

import (
	"fmt"
)

func main() {
	str := "这是字符串"
	for i := 0; i < len(str); i++ { //byte
		fmt.Printf("%v(%c) ", str[i], str[i])
	}

	for _, r := range str { // rune
		fmt.Printf("%v(%c)", r, r)
	}
	// 232(è) 191(¿) 153(™) 230(æ) 152(˜) 175(¯) 229(å) 173(­) 151(—) 231(ç) 172(¬) 166(¦) 228(ä) 184(¸) 178(²)
	// 36825(这)26159(是)23383(字)31526(符)20018(串)
	
	fmt.Print(len(str))
	// 15 按照byte进行遍历
}

字符转换

　　 将一个字符串修改为byte类型，将一个字符串修改为rune类型：

　　 注意：不管是byte还是rune类型，其实都是由数组构成

package main

import (
	"fmt"
)

func main() {
	strChinese := "这是字符串"
	strEngilsh := "this is string"

	byteStr := []byte(strEngilsh)
	runeStr := []rune(strChinese)

	fmt.Println(byteStr) // [116 104 105 115 32 105 115 32 115 116 114 105 110 103]
	fmt.Println(runeStr) // [36825 26159 23383 31526 20018]
}

字符修改

　　 要修改字符串，必须要将其转换为byte类型或rune类型。

　　 并且在修改时用``单引号进行包裹，改完后再将他们转换为字符串。

　　 如下示例：

package main

import (
	"fmt"
)

func main() {
	strChinese := "这是字符串"
	runeStr := []rune(strChinese)
	runeStr[0] = '它' // 注意，用单引号进行包裹
	newString := string(runeStr)
	fmt.Println(newString) // 它是字符串
}

类型转换

　　 Go语言中类型转换用的比较少，它要原本两个不同类型支持互转才行，如浮点型转整型等。

　　 如下示例，将整形转换为浮点数：

package main

import (
	"fmt"
)

func main() {
	var (
		intNum   int16
		floatNum float64
	)
	intNum = 10
	floatNum = float64(intNum)
	fmt.Printf("类型：%T 
值:%v", floatNum, floatNum)
	// 类型：float64 
	// 值:10
}