文章目录
- 基础数据类型分类
- 整数类型
- 有符号整数
- 无符号整数
- 默认整数类型
- 浮点类型
- 复数类型
- 布尔类型
- 字符类型
- 字符串
- replace字符串
- 获取字符串长度
- 字符串的拼接
- 字符串获取指定位置字符
- 更多string操作
- 数据类型之间的转换
- 其它基本类型转字符串类型
- fmt包中的Sprintf
- strconv包中函数
- 字符串类型转其它基础类型
- strconv包中函数
- 总结
基础数据类型分类
整数类型
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设计原理
这种设计有几个原因：
- 效率：字符串不可变性使得字符串的拼接、截取、替换等操作更加高效。因为无需每次操作都重新分配内存，而是可以共享底层的内存空间。
- 并发安全：字符串的不可变性使得多个string操作可以同时读取同一个字符串，而无需加锁或同步机制。
- 可靠性：字符串的不可变性可以避免由于修改字符串内容而导致的意外变化，确保了字符串的一致性
介绍几种字符串的常见操作
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种，分别是整数类型，浮点类型，复数类型，字节类型，字符串类型，布尔类型
