3 基本数据类型

基本数据类型包括：整型、浮点型、布尔型、字符串。

除以上基本类型之外，还有 数组、切片、结构体、函数、map、通道 等。

3.1 整型

3.1.1 整型

整型分为：int8、int16、int32、int64 ，以及对应的无符号整型：uint8、uint16、uint32、uint64

其中 unit8 对应其他语言中的 byte 类型；int16 对应 C 语言中的 short 类型；int64 对应 C 语言中的 long 类型。

各数据类型及对应的取值关系如下：

特殊整型：

注意: 获取对象的长度时，内建的 len() 函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以直接使用 int 来表示 。

3.1.2 八进制和十六进制

package mainimport ("fmt"
)func main() {// 声明十进制数.var a = 10// %d 为十进制数的占位符，表示输出十进制数——10fmt.Printf("%d \n", a)// %b 为二进制数的占位符，输出二进制数——1010fmt.Printf("%b \n", a)// %o 为八进制数的占位符，输出八进制数——12fmt.Printf("%o \n", a)// %x 为十六进制数的占位符，输出十六进制数——afmt.Printf("%x \n", a)// %T 表示获取某个变量的类型_intfmt.Printf("%T \n", a)// 声明八进制数，以 0 开头b := 077// 63fmt.Printf("%d \n", b)//111111fmt.Printf("%b \n", b)// 77fmt.Printf("%o \n", b)// 3ffmt.Printf("%x \n", b)// intfmt.Printf("%T \n", b)// 声明 16 进制数，以 0x开头c := 0xff// 255fmt.Printf("%d \n", c)// 11111111fmt.Printf("%b \n", c)// 377fmt.Printf("%o \n", c)// fffmt.Printf("%x \n", c)// intfmt.Printf("%T \n", c)// 显示声明为 int8 类型，否则，默认 int 类型d := int8(9)// 9fmt.Printf("%d \n", d)// 1001fmt.Printf("%b \n", d)// 11fmt.Printf("%o \n", d)// 9fmt.Printf("%x \n", d)// int8fmt.Printf("%T \n", d)// %v 表示获取某个变量的值——int8,9fmt.Printf("d 的类型为：%T，值为: %v", d, d)
}

3.2 浮点型

go 语言支持两种浮点型数，float32 和 float64.

这两种浮点型数据格式遵循 IEEE 754 标准， float32 的浮点数的最大范围约为 3.4e38 ，可以使用常量定义：math.MaxFloat32。float64 的浮点数的最大范围约为 1.8e308, 可以使用常量定义 math.MaxFloat64

package mainimport ("fmt""math"
)func main() {// %f 为浮点数的占位符，fmt.Printf("%f \n", math.MaxFloat32)fmt.Printf("%f \n", math.MaxFloat64)var a = 1.2345// 默认 floa64fmt.Printf("%T \n", a)var b = float32(1.2345)// 显示声明为 float32fmt.Printf("%T \n", b)
}

3.3 复数

• 复数实际上是有两个实数（浮点数）的组合，一个表示实部（real），一个表示虚部（imag）。
• 虚部需要添加 i 作为后缀。
• real(复数)可以获取实部 ，imag(复数) 可以获取虚部
• 有 complex64 和 complex128 两种类型，complex64 的实部和虚部为 32 位，complex128 的实部和虚部为 64 位。

package mainimport "fmt"func main() {// 1、声明一个复数var v1 complex64// 虚部数据需要后缀 iv1 = 3.2 + 12ifmt.Println("v1=", v1)// 2、自动推导类型的复数v2 := 3.3 + 2.0ifmt.Printf("v2的类型为：%T \n", v2)fmt.Println("v2的值为：", v2)// 3、获取复数的实部和虚部: real(复数)，imag(复数)fmt.Println("v2的实部为：", real(v2), "v2的虚部为：", imag(v2))
}

运行结果：

cnpeng$ go run Day1.go 
v1= (3.2+12i)
v2的类型为：complex128 
v2的值为： (3.3+2i)
v2的实部为： 3.3 v2的虚部为： 2

3.4 布尔类型

3.4.1 布尔类型

go 语言中以 bool 声明布尔类型数据。布尔类型仅有 true 和 false 两种值。

注意：

• 布尔类型变量的默认值为 false
• go 语言中不允许将整型强制转换为布尔类型
• 布尔型数据无法参与数值运算，与无法与其他类型进行转换。

3.4.2 补充：格式化输出的总结

fmt 包的 Printf() 格式化输出可以使用下面的格式化符号：

格式含义%%% 字面量%b二进制整数值(基数为2)，或者是(高级的)用科学计数法表示的指数为2的浮点数%c字符型。可以把输入的数字按照 ASCII 码转换为对应的字符。%d十进制数值(基数为10)%e以科学计数法 e 表示的浮点数或者复数值%E以科学计数法 E 表示的浮点数或者复数值%f以标准计数法表示的浮点数或者复数值%g以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出%G以 %E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出%o以八进制表示的数字%p以十六进制表示的值的地址，前缀为 0x, 字母使用小小的 a-f 表示%s字符串%t以 true 或者 false 输出布尔值%T获取数据类型。%U用 Unicode 表示法表示的整型码点。默认值为四个数字字符%v使用默认格式输出的内置或自定义类型的值。或者时使用期望类型的 String() 方式输出的自定义值。%#v如果输出的字符串，该字符串会被双引号包裹起来%x以十六进制表示的整型值, a-f 使用小写%X以十六进制表示的整型值， A-F 使用大写

package mainimport ("fmt"
)func main() {var str = "abc"// "abc" fmt.Printf("%#v \n", str)
}

3.4 字符串

go 语言中的字符串以原生数据类型出现，使用字符串就想使用其他原生数据类型（int、bool、float32、float64 等）一样。

go 语言中字符串的内部实现使用了 UTF-8 编码。字符串的值使用双引号 " " 包裹（ go 语言中，只有使用单引号 ' ' 包裹的是字符）。

3.4.1 字符串转义符

转义符含义\r回车符（返回行首）\n换行符\t制表符\'单引号\"双引号\\反斜杠

1字节=8Bit ，即1字节表示八个二进制位，也就是 八个 01——01010101
一个 UTF-8 编码的汉字通常占用三个字节，偏僻字可能会占四个字节。

package mainimport ("fmt"
)func main() {// 打印 windows 下的一个文件目录，需要使用转义字符// 输出结果："D:\Go\src\code.github.cnoeng\stu"fmt.Printf("\"D:\\Go\\src\\code.github.cnoeng\\stu\"")
}

3.4.2 多行字符串（原样字符串）

go 语言中要定义一个多行字符串时，使用 反引号 (即键盘左上角数字一左侧的那个按键) 包裹。也叫原样字符串，输入啥样，输出就啥样。

package mainimport ("fmt"
)func main() {s := `床前明月光，疑是地上霜。举头望明月，低头思故乡。`fmt.Printf("%s \n", s)
}

package mainimport ("fmt"
)func main() {s := `D:\Go\src\code.github.cnoeng\stu`// D:\Go\src\code.github.cnoeng\stu fmt.Printf("%s \n", s)
}

3.4.3 字符串的常用操作

方法含义len(str)获取字符串的长度+ 或 fmt.Sprintf()拼接字符串strings.Split分割strings.contains判断是否包含strings.HasPrefix、strings.HasSuffix前缀、后缀的判断strings.Index()、strings.LastIndex()子串出现的位置strings.Join(a[]string,sep string)join 操作 （拼接）

字符串是由 byte 字节组成，所以字符串的长度就是 byte 字节的长度。

package mainimport ("fmt""strings"
)func main() {s := `张三`// 6 fmt.Println(len(s))// 字符串拼接s1 := "李四"// fmt.Printf 只能输出到终端// 张三李四fmt.Printf("%s \n", s+s1)// 张三李四fmt.Printf("%s%s \n", s, s1)// fmt.Sprintf 可以将拼接后的值返回给变量s2 := fmt.Sprintf("%s%s \n", s, s1)// 张三李四fmt.Printf("%s \n", s2)// 字符串分割s3 := "/Users/cnpeng/CnPeng/04_Demos/12_Go"splitS := strings.Split(s3, "/")// [ Users cnpeng CnPeng 04_Demos 12_Go]fmt.Printf("%s \n", splitS)// 是否包含——truefmt.Println(strings.Contains(s2, "张三"))// 前缀和后缀——truefmt.Println(strings.HasPrefix(s2, "张"))// truefmt.Println(strings.HasSuffix(s2, "四"))// 子串位置——0fmt.Println(strings.Index(s2, "张"))// 9fmt.Println(strings.LastIndex(s2, "四"))// Join 拼接——+Users+cnpeng+CnPeng+04_Demos+12_Gofmt.Println(strings.Join(splitS, "+"))
}

3.4.4 byte 和 rune 类型

组成每个字符串的元素叫做字符。可以通过遍历或者单个获取字符串元素获得字符。字符使用单引号包裹，如：

var a := '中'
var b := 'x'

go 语言中的字符有如下两种：

• uint8 类型，或者叫 byte 类型，代表了 ASCII 码的一个字符。
• rune 类型，代表一个 UTF-8 字符。一个 rune 字符由一个或多个 byte 组成。

当需要处理中文、日文或其他复合字符时，需要使用 rune 类型。rune 类型实际是一个 int32

package mainimport ("fmt"
)func main() {s := "中国"// 普通遍历方式得到的是 byte ，最终输出结果为：228——ä184——¸173——­229——å155——›189——½for i := 0; i < len(s); i++ {fmt.Printf("%v——%c", s[i], s[i])}fmt.Println()// range 遍历得到的数 rune ，最终结果为：20013——中22269——国for _, c := range s {fmt.Printf("%v——%c", c, c)}fmt.Println()
}

因为 UTF-8 编码下一个中文汉字由 3-4 个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面第一个遍历中的结果。

3.4.5 修改字符串

字符串是不能直接修改的。

字符串底层是一个 byte 数组，所以可以和 []byte 类型相互转换。

修改字符串时，需要先将其转换成 []rune 或 []byte, 修改完成后再转换为 string。无论哪种转换都会重新分配内存，并复制字节数组。

package mainimport ("fmt"
)func main() {s1 := "big"byteS1 := []byte(s1)byteS1[0] = 'p'// pigfmt.Println(string(byteS1))s2 := "白萝卜"runeS2 := []rune(s2)runeS2[0] = '红'//红萝卜fmt.Println(string(runeS2))
}

3.5 类型转换和类型别名

3.5.1 类型转换

Go 语言中不允许隐式转换，所有类型转换必须显示声明，而且转换只能发生在两种相互兼容的类型之间。

package mainfunc main() {var a byte = 97//显示类型转换var b int = int(a)//隐式类型转换，报错// var c int = a//类型不兼容，int 不能转为 bool//var d bool = bool(b)fmt.Println(d)
}

3.5.2 类型别名

• 为现有的类型定义别名，方便调用。关键字 type

( 在 Swift 中也有这种类型别名，特别是对函数类型定义别名很有用)

package mainimport "fmt"func main() {//1、为 int64 起一个类型别名为，biginttype bigint int64var x bigint = 100//2、同时定义多个类型别名type (myint intmystr string)var y myint = 11var z mystr = "12"fmt.Println(x, y, z)fmt.Printf("x,y,z 的类型分别为：%T , %T , %T \n ", x, y, z)
}

运行结果：

cnpeng$ go run Day1.go 
100 11 12
x,y,z 的类型分别为：main.bigint , main.myint , main.mystr 

3.6 strconv 包

Go 语言中 strconv 包实现了基本数据类型和其字符串表示的相互转换。主要有以下常用函数： Atoi()、Itoa()、parse 系列、format 系列、append 系列。

更多函数请查看官方文档。

3.6.1 string与int类型转换

这一组函数是我们平时编程中用的最多的。

3.6.1.1 Atoi()

Atoi() 函数用于将字符串类型的整数转换为int类型，函数签名如下。

func Atoi(s string) (i int, err error)

如果传入的字符串参数无法转换为int类型，就会返回错误。

s1 := "100"
i1, err := strconv.Atoi(s1)
if err != nil {fmt.Println("can't convert to int")
} else {fmt.Printf("type:%T value:%#v\n", i1, i1) //type:int value:100
}

3.6.1.2 Itoa()

Itoa() 函数用于将 int 类型数据转换为对应的字符串表示，具体的函数签名如下。

func Itoa(i int) string

示例代码如下：

i2 := 200
s2 := strconv.Itoa(i2)
fmt.Printf("type:%T value:%#v\n", s2, s2) //type:string value:"200"

3.6.1.3 a的典故

这是 C 语言遗留下的典故。C 语言中没有 string 类型而是用字符数组(array)表示字符串，所以 Itoa 对很多 C 系的程序员很好理解。

3.6.2 Parse系列函数

Parse 类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

3.6.2.1 ParseBool()

func ParseBool(str string) (value bool, err error)

返回字符串表示的 bool 值。

• 当 str 为：1，t，T，TRUE，true，True 中的一种时为真值
• 当 str 为：0，f，F，FALSE，false，False 中的一种时为假值
• 其他输入内容一律返回 false

fmt.Println(strconv.ParseBool("t"))
fmt.Println(strconv.ParseBool("TRUE"))
fmt.Println(strconv.ParseBool("true"))
fmt.Println(strconv.ParseBool("True"))
fmt.Println(strconv.ParseBool("0"))
fmt.Println(strconv.ParseBool("f"))

3.6.2.2 ParseInt()

func ParseInt(s string, base int, bitSize int) (i int64, err error)

返回字符串表示的整数值，接受正负号。

• base 指定进制（2到36），如果 base 为0，则会从字符串前置判断；0x 是16进制，0 是 8 进制，否则是 10 进制；

• bitSize 指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64；

• 返回的 err 是 *NumErr 类型的，如果语法有误，err.Error = ErrSyntax；如果结果超出类型范围 err.Error = ErrRange。

3.6.2.3 ParseUnit()

func ParseUint(s string, base int, bitSize int) (n uint64, err error)

ParseUint 类似 ParseInt 但不接受正负号，用于无符号整型。

3.6.2.4 ParseFloat()

func ParseFloat(s string, bitSize int) (f float64, err error)

解析一个表示浮点数的字符串并返回其值。

如果 s 合乎语法规则，函数会返回最为接近 s 表示值的一个浮点数（使用 IEEE754 规范舍入）。

• bitSize 指定了期望的接收类型，32 是 float32（返回值可以不改变精确值的赋值给float32），64 是 float64；
• 返回值 err 是 *NumErr 类型的，语法有误的，err.Error=ErrSyntax；结果超出表示范围的，返回值 f 为 ±Inf，err.Error= ErrRange。

3.6.2.5 代码示例

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-2", 10, 64)
u, err := strconv.ParseUint("2", 10, 64)

这些函数都有两个返回值，第一个返回值是转换后的值，第二个返回值为转化失败的错误信息。

3.6.3 Format系列函数

Format 系列函数实现了将给定类型数据格式化为 string 类型数据的功能。

3.6.3.1 FormatBool()

func FormatBool(b bool) string

根据 b 的值返回 "true" 或 "false"。

3.6.3.2 FormatInt()

func FormatInt(i int64, base int) string

返回 i 的 base 进制的字符串表示。base 必须在2到36之间，当 base 大于 10 时，结果中会使用小写字母 a 到 z 表示大于 10 的数字。

3.6.3.3 FormatUint()

func FormatUint(i uint64, base int) string

是 FormatInt 的无符号整数版本。

3.6.3.4 FormatFloat()

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

函数将浮点数表示为字符串并返回。

• bitSize 表示 f 的来源类型（32：float32、64：float64），会据此进行舍入。
• fmt 表示格式：f（-ddd.dddd）、b（-ddddp±ddd，指数为二进制）、e（-d.dddde±dd，十进制指数）、E（-d.ddddE±dd，十进制指数）、g（指数很大时用e格式，否则f格式）、G（指数很大时用E格式，否则f格式）。
• prec 控制精度（排除指数部分）：对 f、e、E，它表示小数点后的数字个数；对 g、G，它控制总的数字个数。如果 prec 为 -1，则代表使用最少数量的、但又必需的数字来表示 f 。

3.6.3.5 代码示例

s1 := strconv.FormatBool(true)
s2 := strconv.FormatFloat(3.1415, 'E', -1, 64)
s3 := strconv.FormatInt(-2, 16)
s4 := strconv.FormatUint(2, 16)

3.6.4 其他

3.6.4.1 isPrint()

func IsPrint(r rune) bool

返回一个字符是否是可打印的，和 unicode.IsPrint 一样，r 必须是：字母（广义）、数字、标点、符号、ASCII空格。

3.6.4.2 CanBackquote()

func CanBackquote(s string) bool

返回字符串 s 是否可以不被修改的表示为一个单行的、没有空格 和 tab之外控制字符的反引号字符串。

3.6.4.3 其他

除上文列出的函数外，strconv 包中还有 Append系列、Quote系列等函数。具体用法可查看官方文档。

更多函数请查看官方文档。