基础数据类型：
- 整型：byte、int、int8、int16、int32、int64、unit、uint16、uint3、uint64等
- 浮点型：float32、float64
- 复数类型：complex64、complex128
- 布尔类型：bool
- 字符串：string
- 字符类型：rune
- 错误类型：error
复合数据类型：
- 指针（pointer）
- 数组（array）
- 切片（slice）
- 字典（map）
- 通道（channel）
- 结构体（struct）
- 接口（interface）
基本数据类型
整型
有符号：int8 int16 int32 int64
无符号：unit8 uint16 uint32 uint64
unit8是byte。
int16对应c语言中的short型 ，int64对应c语言中的long型。
int：自动匹配os，os是32位就是int32，os是64位就是int64。
len()：获取对象的长度，返回int
package main
import "fmt"
func main() {
//十进制
var a int = 10
fmt.Printf("%d \n", a) //10
fmt.Printf("%b \n", a) //1010 占位符%b表示二进制
//八进制
var b int= 077
fmt.Printf("%d \n", b) //63
fmt.Printf("%o \n", b) //77
//十六进制
var c int= 0xff
fmt.Printf("%x \n", c) //ff
fmt.Printf("%X \n", c) //FF
//变量的内存地址
fmt.Printf("%p \n", &a) //0xc000014080
}
math.Nan()，跟谁（包括自己）都不相等
浮点型
遵循IEEE 754标准
float32 :最大范围为3.4e38，用常量math.MaxFloat32
float64:最大范围为1.8e308，用常量math.MaxFloat64
float32的有效bit位只有23个，其它的bit位用于指数和符号；当大于23bit能表达的范围时，float32表示将会出现误差。
package main
import (
"fmt"
"math"
)
func main() {
var a float32 = 2.34
fmt.Printf("%f \n", a) //2.340000
fmt.Printf("%f \n", math.Pi) //3.141593
fmt.Printf("%0.2f \n", math.Pi) //3.14
}
复数类型
complex64 : 实部和虚部分别是32位
complex128 : 实部和虚部分别是64位
package main
import "fmt"
func main() {
var c1 complex64
c1 = 1 + 2i
fmt.Println(c1) //(1+2i)
var c2 complex128
c2 = 3 + 4i
fmt.Println(c2) //(3+4i)
}
布尔类型
bool：只有true和false
注意：
（1）默认值是false；
（2）不允许将整型强制转为布尔型；
（3）不参与数值运算，不与其它类型进行转换；
package main
import "fmt"
func main() {
var b bool
b = 1 //编译报错
b = bool(1) //编译报错
var bb bool
fmt.Println(bb)
bb = true
fmt.Println(bb)
bb = (1 == 0) //编译正确
fmt.Println(bb)
}
字符串
内部实现使用UTF-8编码，用双引号（""）
var s1 string = "hello"
s2 := "你好"
转移字符(\)
\r \n \t ' " \
var s string = "str = \"c:\\users\\temp\""
fmt.Println(s) //str = "c:\users\temp"
多行字符串，用反引号(``)
反引号间换行认为字符串中的换行；但是反引号间所有的转义字符均无效，文本按照原样输出
var multiStr = `这是
多
"不需要转移"
行
`
常用方法
求长度：len(str)
拼接字符串：+或者fmt.Sprintf
分割：string.Split
判断是否包含：strings.Contains
前缀/后缀判断：strings.HasPrefix,strings.HasSuffix
字串出现的位置：strings.Index(),strings.LastIndex
合并操作：strings.Join(a[] string, sep string)
package main
import "fmt"
import "strings"
func main() {
s1 := "Hello "
//求长度
fmt.Println(len(s1)) //6
//连接
s2 := "Go"
// s3 := s1 + s2
s3 := fmt.Sprintf("%s----%s", s1, s2)
fmt.Println(s3) //Hello ----Go
//分割
s4 := strings.Split("Hello Ha Hwx", "H")
fmt.Println(s4) //[ ello a wx]
s5 := "Hello haha"
//是否包含
fmt.Println(strings.Contains(s5, "Ha")) //false
//判断前缀
fmt.Println(strings.HasPrefix(s5, "He")) //true
//判断后缀
fmt.Println(strings.HasSuffix(s5, "ha")) //true
//字串出现位置
s6 := "Hello Apple App"
fmt.Println(strings.Index(s6, "App")) //6
fmt.Println(strings.LastIndex(s6, "App")) //12
//合并
s7 := []string{"a", "b", "c", "d"}
fmt.Println(strings.Join(s7, "-")) //a-b-c-d
}
字符类型：byte和rune类型
字符有两种：
（1）uint8类型，或者叫byte型，代表了ASCII码的一个字符；
（2）rune类型，代表一个UTF-8字符；
当需要出来中文、日文或其它复合字符时，需要用到rune类型。rune类型实际是一个int32，通过reflect.Type可看到。
在类型推导时候，默认是rune类型。byte类型需要强制转换。
package main
import "fmt"
func main() {
s1 := "Golang"
c1 := 'G' //1个字节（8位）
fmt.Println(s1, c1) //Golang 71
fmt.Printf("%c", c1) //Golang G
s2 := "中国"
c2 := '中' //UTF-8编码下一个中文是3个字节
fmt.Println(s2, c2) //中国 20013
s3 := "hello冬雪"
fmt.Println(len(s3)) //11
//遍历字符串
for i := 0; i < len(s3); i++{
fmt.Printf("%c\n", s3[i]) //都成乱码了
}
//for range循环，按照rune类型去遍历
for k,v := range s3{
fmt.Printf("%d - %c\n", k, v)
}
// 0 - h
// 1 - e
// 2 - l
// 3 - l
// 4 - o
// 5 - 冬
// 8 - 雪
}
修改字符串
字符串是值类型，赋值之后不可修改
要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会从新分配内存，并复制字节数组。
s1 := "small"
byteS1 := []byte(s1)
byteS1[0] = 'a'
fmt.Println(s1,string(byteS1)) //small amall
s2 := "冬雪"
runeS2 := []rune(s2)
runeS2[1] = '冬'
fmt.Println(s2,string(runeS2)) //冬雪 冬冬
类型转换
只有强制类型转换，没有隐式转换。
T(表达式)
T是要转换的类型。
表达式包括变量、复杂算子和函数返回值等。
s1 := "small"
byteS1 := []byte(s1)
byteS1[0] = 'a'
fmt.Println(s1,string(byteS1)) //small amall
//强制类型转换
s1 = string(byteS1)
fmt.Println(s1) //amall
