基础数据类型分类

整数类型

go语言提供了无符号和有符号的整数类型

有符号整数

有符号就是整数有正负之分

类型	字节数	数值范围
int8	1	-128～127
int16	2	-2^15 ～2^15-1(-32678-32677)
int32	4	-2^31 ～2^31-1(-2147483648-2147483647)
int64	8	-2^63 ～2^63-1

package mainimport ("fmt""unsafe"
)func main() {var a int8 = 1var b int16 = 128var c int32 = 32678var d int64 = 2147483648fmt.Printf("a=%v,类型%T,a占字节%d\n", a, a, unsafe.Sizeof(a))fmt.Printf("b=%v,类型%T,b占字节%d\n", b, b, unsafe.Sizeof(b))fmt.Printf("c=%v,类型%T,c占字节%d\n", c, c, unsafe.Sizeof(c))fmt.Printf("d=%v,类型%T,d占字节%d\n", d, d, unsafe.Sizeof(d))
}输出结果：
a=1,类型int8,a占字节1
b=128,类型int16,b占字节2
c=32678,类型int32,c占字节4
d=2147483648,类型int64,d占字节8

fmt.Printf中%d格式表示输出数字，%v表述输出变量的原始值， %T格式表示输出变量的数据类型，更多fmt.Printf输出写法可以参考go官方文档【https://pkg.go.dev/fmt】

我们在定义一个整型值时，要估摸这个整型值的范围，再来确定使用哪个int的类型。因为int类型赋值不当就会出现如下错误

package mainimport ("fmt""unsafe"
)func main() {var a int8 = 128
}输出结果：
constant 128 overflows int8

无符号整数

无符号整数类型就是没有负数之说只有整正数（没有符号位）
无符号整数范围：0-2^n-1

类型	字节数	数值范围
int8	1	0～255
int16	2	0～2^16-1
int32	4	0～2^32-1
int64	8	0～2^64-1

无符号整数类型在有符号整数类型int的前面多了一个u，这就是表示无符号的意思，值得注意的是，其占用储存空间的字节大小没有变化，但表数范围变了，没有负数了，最大值更大了，这就是无符号整型特点。若实际应用场景某变量中无负数，比如年龄或者身高，可以使用uint来表示

默认整数类型

若直接使用int或者uint，它们占用字节大小是由计算机系统的位数来决定的

类型	是否有符号	字节数	数值范围
int	是	系统32位占4节，系统64位占8节	-231-1～231-1或者-263-1～263-1
uint	无	系统32位占4节，系统64位占8节	0～232-1或者0～264-1

若不指定数据类型，直接赋值给一个变量，默认类型是int；所以我们在写代码时要有意识的确定具体的数据类型，否则它有可能只需要占用1个字节，但由于编写不规范，导致变量占用4或者8字节，浪费内存空间

package mainimport "fmt"func main() {var a = 9fmt.Printf("%T", a)
}
输出结果
int

浮点类型

支持32位和64位的浮点数
32位浮点数表示的数值范围是1.4e-45到3.4e38
64位浮点数表示的数值范围是4.9e-324到1.8e308

若是想支持显示几位小数，可以使用以下方式

package mainimport "fmt"func main() {f := 3.2//%.2f表示保留两位小数；.0没有小数位；默认是6位小数fmt.Printf("%.2f", f)
}

浮点数在声明的时候可以只写小数位或者整数位

func main() {f1 := 3.f2 := .12fmt.Printf("%.2f,%.2f", f1, f2)
}输出：3.00,0.12

通常使用float64位类型，因为float32的累计计算误差容易扩散，并且float32能表示的正整数并不是很大，以下方式执行结果为true

package main
import "fmt"func testF() {var f float32 = 1 << 24fmt.Println(f == f+1)
}
func main() {testF()
}输出结果为true

若用float64表示，则结果为false；

package main
import "fmt"func testF() {var f float64 = 1 << 24fmt.Println(f == f+1)
}
func main() {testF()
}输出结果为false

很小或很大的数最好用科学计数法书写，通过e或者E来指定指数部分

package mainimport "fmt"func main() {f1 := 3.23456789e10f2 := 1e-10fmt.Printf("%.2f,%.10f", f1, f2)
}

复数类型

在Go语言中complex有两种类型，complex64和complex128。complex64中实部和虚部是32位的，在complex128中实部和虚部是64位的。

package mainimport ("fmt""math""math/cmplx""unsafe"
)var aa complex64
var bb complex128func main() {aa = 5fmt.Printf("%d,%v\n", unsafe.Sizeof(aa), aa)fmt.Printf("%d,%v\n", unsafe.Sizeof(bb), bb)//欧拉公式fmt.Println(cmplx.Exp(1i*math.Pi) + 1)
}

布尔类型

go语言中表达布尔类型使用bool，布尔型的值只可以是常量 true 或者 false
布尔类型占一个字节
布尔类型适于逻辑运算，一般用于程序流程控制。

package mainimport ("fmt""unsafe"
)func main() {flag := 1 == 2//打印结果fmt.Printf("%v\n", flag)//输出占用的字节fmt.Println(unsafe.Sizeof(flag))}输出：
false
1

字符类型

字符表示使用byte或者rune，byte相当于unit8别名；rune相当于int32别名；

package mainimport "fmt"func main() {var ch byte = 'a' //byte相当于uint8，一个字符，1个字节，8位var cha rune = 'a'     //rune 相当于int32别名%v打印出a的ascii的id，%c打印出字符，%T打出对应动态类型fmt.Printf("%T,%v,%c\n", ch, ch, ch)fmt.Printf("%T,%v,%c\n", cha, cha, cha)
}输出：
uint8,97,a
int32,97,a

字符串

字符串类型用 string 来定义。
字符串定义后就不能改变了（单指字符串，变量的值可以变）
字符串可以拼接
当一个字符串里面有转义的时候最好用 `` （Esc下面的按键）括起来（当然转义字符也可以）

golang语言中string是不可变，简单的赋值操作其实内部新建了一个新的对象，新对象的指针指向了新的值
至于为什么这么做，类比与Java的String设计原理
这种设计有几个原因：

1. 效率：字符串不可变性使得字符串的拼接、截取、替换等操作更加高效。因为无需每次操作都重新分配内存，而是可以共享底层的内存空间。
2. 并发安全：字符串的不可变性使得多个string操作可以同时读取同一个字符串，而无需加锁或同步机制。
3. 可靠性：字符串的不可变性可以避免由于修改字符串内容而导致的意外变化，确保了字符串的一致性

介绍几种字符串的常见操作

replace字符串

package mainimport ("fmt""strings"
)func main() {sOld := "hello,码神之路java教程"subString := "java"repString := "go"replace := strings.Replace(sOld, subString, repString, len(subString))fmt.Printf("%s\n", replace)
}
输出结果：
hello,码神之路go教程

获取字符串长度

在utf8编码方式中，1个英文或者符号占用1个字节，中文占用3个字节。len()获取占用的字节长度

package mainimport ("fmt""unicode/utf8"
)var name string
func main()  {name = "hello,你好"//字节长度fmt.Printf("字节长度->%d\n", len(name))//字符个数fmt.Printf("字符个数->%d\n", utf8.RuneCountInString(name))
}输出：
字节长度->12
字符个数->8

字符串的拼接

通过+号直接拼接，不过效率不高；通过bytes.Buffer进行拼接，性能高，参考Java中string和stringBuidler的区分去理解

package mainimport ("bytes""fmt"
)func main()  {//字符串拼接1.+var s = "hello"var s1 = s + ",你好"fmt.Printf("%s\n", s1)//字符串拼接2.bytes.Buffer,性能高，参考javavar sBuilder bytes.BuffersBuilder.WriteString(s)sBuilder.WriteString(",你好")fmt.Printf("%s", sBuilder.String())
}

字符串获取指定位置字符

指定位置的字符要区分字符串中中是否有中文，若有中文，不能直接通过下标去获取；可以通过显示转换为rune数组，然后通过下标获取

package mainimport ("fmt"
)func main()  {//默认使用ascii字符集，128个字符，包含英文，数字，标点符号sF := "hello"//中文默认会使用unicode编码，一个中文占用3个字节sFR := "你好"//英文获取第一个特定字符直接获取第一个字符即可fmt.Printf("%c\n", sF[0])//中文获取第一个特定字符只能转成rune字符数组，然后取第一个fmt.Printf("%s\n", string([]rune(sFR)[0]))
}输出：
h
你

更多string操作

参考：https://pkg.go.dev/strings
参考：https://pkg.go.dev/unicode/utf8
参考：https://pkg.go.dev/strconv

数据类型之间的转换

其它基本类型转字符串类型

fmt包中的Sprintf

“%参数”， 要转换的变量（注意：原先的变量值不变，只是将面值赋给一个string类型的变量
更多操作参考go官方文档：https://pkg.go.dev/fmt

package mainimport ("fmt"
)func main() {var aInt int = 19var bFloat float32 = 4.78var cBool bool = falsevar dByte byte = 'a'var aStr string = fmt.Sprintf("%d",aInt)fmt.Printf("aStr对应的类型是：%T ，s1 = %q \n",aStr, aStr)var bStr string = fmt.Sprintf("%f",bFloat)fmt.Printf("bStr对应的类型是：%T ，s2 = %q \n",bStr, bStr)var cStr string = fmt.Sprintf("%t",cBool)fmt.Printf("cStr对应的类型是：%T ，s3 = %q \n",cStr, cStr)var dStr string = fmt.Sprintf("%c",dByte)fmt.Printf("dStr对应的类型是：%T ，s4 = %q \n",dStr, dStr)
}输出结果：
aStr对应的类型是：string ，s1 = "19" 
bStr对应的类型是：string ，s2 = "4.780000" 
cStr对应的类型是：string ，s3 = "false" 
dStr对应的类型是：string ，s4 = "a" 

strconv包中函数

更多操作参考go官方文档：https://pkg.go.dev/strconv

package mainimport ("fmt""strconv"
)func main() {i := 123//等同于FormatInt(int64(i), 10)iStr := strconv.Itoa(i)fmt.Printf("整数转字符串:%T,%v\n", iStr, iStr)f := 3.1415926fStr := strconv.FormatFloat(f, 'f',2,64)fmt.Printf("浮点数转字符串:%T,%v\n", fStr, fStr)b := truebStr := strconv.FormatBool(b)fmt.Printf("布尔数转字符串:%T,%v\n", bStr, bStr)
}输出结果
整数转字符串:string,123
浮点数转字符串:string,3.14
布尔数转字符串:string,true

字符串类型转其它基础类型

strconv包中函数

package mainimport ("fmt""strconv"
)func main() {i := "123"//等同于FormatInt(int64(i), 10)iInt, _ := strconv.Atoi(i)fmt.Printf("字符串转整型:%T,%v\n", iInt, iInt)f := "3.1415926"fFloat, _ := strconv.ParseFloat(f, 64)fmt.Printf("字符串转浮点数:%T,%v\n", fFloat, fFloat)b := "true"bBool, _ := strconv.ParseBool(b)fmt.Printf("字符串转布尔数:%T,%v\n", bBool, bBool)}

总结

基本数据类型包含6种，分别是整数类型，浮点类型，复数类型，字节类型，字符串类型，布尔类型