基本数据类型
Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。
整形
获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。
打印时可以用%d打印
八进制/十六进制
八进制以0开头，使用%o打印
十六进制以0x开头，使用%x打印
浮点型
Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。
可使用%f打印,%.2f表示只打印2位小数
布尔值
布尔型数据只有true（真）和false（假）两个值。
字符串
Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容。多个byte集合，理解为一个字符序列，用双引号来表示！
例子：s1 := "ares"
单引号与双引号区别
v1 := 'A'
v2 := "A"
fmt.Printf("类型:%T,内容:%v\n",v1,v1) //类型:int32,内容:65
fmt.Printf("类型:%T,内容:%v\n",v2,v2) //类型:string,内容:A
字符串转义符
| 转义符 | 含义 |
|---|---|
| \r | 回车 |
| \n | 换行符 |
| \t | 制表符 |
| \' | 单引号 |
| \" | 双引号 |
| \ | 反斜杠 |
fmt.Println("\"Hello World!\"") //"Hello World!"
fmt.Println("\"Hello \t World!\"") //"Hello World!"
多行字符串
Go语言中要定义一个多行字符串时，就必须使用反引号字符"`"
字符串常用操作

代码示例：
package main import (
"fmt"
"strings"
) //字符串操作
func main() {
s1 := "ares"
fmt.Println(len(s1)) //4
//字符串拼接
s2 := "GO"
fmt.Println(s1 + s2) //aresGO
s3 := fmt.Sprintf("%s----%s", s1, s2)
fmt.Println(s3) //ares----GO
//分割
ret := strings.Split(s1, "r")
fmt.Println(ret) //[a es]
//判断是否包含
ret2 := strings.Contains(s1, "a")
ret3 := strings.Contains(s1, "a1")
fmt.Println(ret2, ret3) //true false
//判断前缀和后缀
ret4 := strings.HasPrefix(s1, "ar") //是不是以ar做前缀
ret5 := strings.HasSuffix(s1, "es1") //是不是以es1做后缀
fmt.Println(ret4, ret5) //true false
//判断子串出现的位置
s4 := "applepen"
fmt.Println(strings.Index(s4, "p")) //
fmt.Println(strings.LastIndex(s4, "p")) //5
//join
a1 := []string{"Python", "PHP", "JS", "Ruby", "Golang"}
fmt.Println(a1) //[Python PHP JS Ruby Golang]
fmt.Println(strings.Join(a1, "-")) //Python-PHP-JS-Ruby-Golang
}
byte和rune类型
组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来，如：var a := '中'
Go 语言的字符有以下两种： 1. uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。 2. rune类型，代表一个 UTF-8字符。rune类型实际是一个int32。
字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。
修改字符串
要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。
类型转换
Go语言中只有强制类型转换，没有隐式类型转换。 基本语法：T(表达式)
T表示要转换的类型，兼容类型才可以转换！
//变量需要手工转型
var w1 int8
w1 =
var w2 int16
w2 = int16(w1) //先将w1转为int16类型再赋值给w2
fmt.Printf("w1类型：%T,w1数值：%v，w2类型：%T,w2数值：%v\n", w1,w1,w2,w2) //w1类型：int8,w1数值：10，w2类型：int16,w2数值：10
f1 := 3.14
var f2 int
f2 = int(f1)
fmt.Printf("f1类型：%T,f1数值：%v，f2类型：%T,f2数值：%v\n", f1,f1,f2,f2) //f1类型：float64,f1数值：3.14，f2类型：int,f2数值：3
//常量在有需要的时候自动转
sum := f1 +
fmt.Printf("%T,%v",sum,sum) //float64,13.14
代码示例：
package main //字符
import "fmt" func main() {
s1 := "Golang"
c1 := 'G' //ASCII下占一个字节
fmt.Println(s1, c1) //Golang 71
s2 := "中国"
c2 := '中' //UTF8下中文字符占3字节
fmt.Println(s2, c2) //中国 20013
s3 := "hello青年路"
fmt.Println(len(s3)) //14 //遍历字符串
for i := ; i < len(s3); i++ {
fmt.Printf("%c\n", s3[i])
}
fmt.Println()
// for range 循环，是按照rune类型去遍历
for _, v := range s3 {
fmt.Printf("%c\n", v)
}
//打印索引
for k, v := range s3 {
fmt.Printf("%d%c\n", k, v)
}
//强制类型转换
s5 := "big"
//将字符串强制转换成字节数组类型
byterArray := []byte(s5)
fmt.Println(byterArray) //[98 105 103]
//修改字符串
byterArray[] = 'p'
fmt.Println(byterArray) //[112 105 103]
//将字节数组强制转换成字符串类型
s5 = string(byterArray)
fmt.Println(s5) //pig
//修改字符串
s6 := "菜鸟"
arr6 := []rune(s6)
arr6[] = '大'
fmt.Println(string(arr6)) //大鸟
//字符串反转
a1 := "hello"
arr := []byte(a1) // [h e l l o]
a2 := "" //定义空的字符串
for i := len(arr) - ; i >= ; i-- {
//i 是 4 3 2 1 0
// arr[i] o l l e h (字符)
a2 = a2 + string(arr[i])
}
fmt.Println(a2) //olleh
//反转2
length := len(arr)
for i := ; i < length/; i++ {
arr[i], arr[length--i] = arr[length--i], arr[i]
}
fmt.Println(string(arr)) //olleh
}