Go语言有丰富的数据类型，出了基本的整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。

整型

整型分为两类：无符号、有符号；

其中uint就是byte型，int16就是C语言中short型，int64就是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	无符号整型，用于存放一个指针

注意：在使用int和uint类型时，不能假定它是32位或者64位，而要考虑int和uint可能在不同平台上的差异。尤其是跨平台应用需注意。

注意事项：为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和uint。

八进制& 十六进制

Go语言中无法直接定义二进制数，关于八进制和十六进制数的示例如下：

package main

import "fmt"

// 整型
func main() {
	var i1 = 101 //类型推导,十进制数
	fmt.Printf("%d\n", i1)
	fmt.Printf("%b\n", i1)  //把十进制数转换成二进制
	fmt.Printf("%o\n", i1)  //把十进制数转换成八进制
	fmt.Printf("%ox\n", i1) //把十进制数转换成十六进制

	//八进制
	i2 := 077 //短变量声明
	fmt.Printf("%d\n", i2)

	//十六进制数
	i3 := 0x1234567abc
	fmt.Printf("%d\n", i3)

	//查看变量类型
	fmt.Printf("%T\n", i3)

	//声明int8类型的变量
	i4 := int8(9) //明确指定int8类型，否则为int类型
	fmt.Printf("%T\n", i4)
}

浮点型

Go语言支持两种浮点型数：float32和float64。打印浮点数时，可以使用fmt包配合%f，代码如下：

package main

import (
	"fmt"
	"math"
)

func main() {
	f1 := 3.14159
	fmt.Printf("%T\n", f1) //默认Go语言中的小数都是float64
	f2 := float32(3.14159) //显示声明float32
	fmt.Printf("%T\n", f2) //此处f1的值不能赋值给f2，类型不同
	fmt.Printf("%f\n", math.Pi)
	fmt.Printf("%.2f\n", math.Pi)
}

输出：

D:\Go\src\github.com\hooo818\studygo\day01\05float>.\05float.exe
3.141593
3.14

复数

complex64和complex128

复数有实部和虚部，complex64的实部和虚部都是32位，complex128的实部和虚部都是64位。

var c1 complex64
c1= 1+ 2i
var c2 complex128
c2= 3+ 4i
fmt.printf("%T\n", c1)
fmt.Printf("%T\n", c2)

布尔值

Go语言中以bool类型进行声明布尔类型数据，布尔类型数据只有true（真）和false（假）两个值。

import "fmt"

func main() {
	//布尔类型
	b1 := true
	var b2 bool
	fmt.Printf("%T\n", b1)
	fmt.Printf("%T value：%v\n", b2, b2)
}

输出结果：

bool
bool value：false //默认值是false

注意：

1. 布尔类型变量的默认值为false；
2. Go语言中不允许将整型强制转换为布尔型；
3. 布尔型无法参与数值运算，也无法与其他类型进行转换。

字符串

Go语言中字符串以原生数据类型出现，使字符串就像使用它的原生数据类型int\bool\float32\float64等一样。Go语言里面的字符串的内部实现使用utf-8编码。字符串的值为双引号("...")中的内容。可以在Go语言的源码中直接添加非ASCII码，例如：

s1:= "Hello"
s2:= "你好"

注意：Go语言中字符串必须使用双引号（""）包裹，Go语言中单引号（''）包裹的字符是字符（单独的字母、汉字、符号表示一个字符）

s:= "Hello Go 语言" //字符串
c1:= 'h' //字符
c2:= 'l' //字符
c3:= '洪' //字符，一个utf8汉字占3个字节

字符串转义符

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

例如：

package main

import "fmt"

//字符串

func main() {
	//\本来是具有特殊含义的,此时需要转义
	path := "\"D:\\Go\\src\\github.com\\hooo818\\studygo\\day01\\08string\""
	fmt.Println(path)

	s := "I'm  OK"
	fmt.Println(s)

	//多行字符串
	s2 := `
		床前明月光
		疑是地上霜
	`
	fmt.Println(s2)
}

输出结果为：

"D:\Go\src\github.com\hooo818\studygo\day01\08string"
I'm  OK

                床前明月光
                疑是地上霜

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符（Esc键下方那个键）；反引号间换行将被作为字符串中的换行，但是所有的转义字符无效，文本将会被原样输出。

字符串常用操作

方法	                                     介绍
len(str)	                              求长度
+或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"
	"strings"
)

//字符串

func main() {
	//\本来是具有特殊含义的,此时需要转义
	path := "\"D:\\Go\\src\\github.com\\hooo818\\studygo\\day01\\08string\""
	fmt.Println(path)

	s := "I'm  OK"
	fmt.Println(s)

	//多行字符串
	s2 := `
		床前明月光
		疑是地上霜
	`
	fmt.Println(s2)

	//字符串相关操作
	fmt.Println(len(s)) //字符串长度

	name := "理想"
	world := "帅"

	ss := name + world //使用 "+"" 拼接字符串
	fmt.Println(ss)

	ss1 := fmt.Sprintf("%s%s", name, world) //使用fmt.Sprintf()拼接字符串，拼接后返回一个字符串
	fmt.Println(ss1)

	fmt.Printf("%s%s\n", name, world) //仅仅是打印在一起

	//分割
	ret := strings.Split(path, "\\")
	fmt.Println(ret) //["D: Go src github.com hooo818 studygo day01 08string"]

	//判断是否包含
	fmt.Println(strings.Contains(ss1, "理想")) //true

	//前缀、后缀判断
	fmt.Println(strings.HasPrefix(ss1, "理想")) //true
	fmt.Println(strings.HasSuffix(ss1, "帅"))  //true

	//判断字串出现的位置
	ss2 := "abcdefb"
	fmt.Println(strings.Index(ss2, "c"))  //2
	fmt.Println(strings.Index(ss2, "bc")) //1
	fmt.Println(strings.LastIndex(ss2, "b")) //6

	//拼接
	fmt.Println(strings.Join(ret, "+")) //"D:+Go+src+github.com+hooo818+studygo+day01+08string"
}

fmt占位符

package main

import "fmt"

//fmt 占位符
func main() {
	var n = 100
	fmt.Printf("%T\n", n) //查看类型
	fmt.Printf("%v\n", n) //查看变量的值
	fmt.Printf("%d\n", n) //十进制
	fmt.Printf("%b\n", n) //二进制
	fmt.Printf("%o\n", n) //八进制
	fmt.Printf("%x\n", n) //十六进制

	var s = "Let us Go"
	fmt.Printf("%s\n", s) //字符串
    fmt.Printf("%#v\n", s)//会给字符串加上引号
}