文章目录
基础数据类型分类
整数类型
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 main
import (
"fmt"
"unsafe"
)
func main() {
var a int8 = 1
var b int16 = 128
var c int32 = 32678
var d int64 = 2147483648
fmt.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 main
import (
"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 main
import "fmt"
func main() {
var a = 9
fmt.Printf("%T", a)
}
输出结果
int
浮点类型
支持32位和64位的浮点数
32位浮点数表示的数值范围是1.4e-45到3.4e38
64位浮点数表示的数值范围是4.9e-324到1.8e308
若是想支持显示几位小数，可以使用以下方式
package main
import "fmt"
func main() {
f := 3.2
//%.2f表示保留两位小数；.0没有小数位；默认是6位小数
fmt.Printf("%.2f", f)
}
浮点数在声明的时候可以只写小数位或者整数位
func main() {
f1 := 3.
f2 := .12
fmt.Printf("%.2f,%.2f", f1, f2)
}
输出：3.00,0.12
通常使用float64位类型，因为float32的累计计算误差容易扩散，并且float32能表示的正整数并不是很大，以下方式执行结果为true
package main
import "fmt"
func testF() {
var f float32 = 1 << 24
fmt.Println(f == f+1)
}
func main() {
testF()
}
输出结果为true
若用float64表示，则结果为false；
package main
import "fmt"
func testF() {
var f float64 = 1 << 24
fmt.Println(f == f+1)
}
func main() {
testF()
}
输出结果为false
很小或很大的数最好用科学计数法书写，通过e或者E来指定指数部分
package main
import "fmt"
func main() {
f1 := 3.23456789e10
f2 := 1e-10
fmt.Printf("%.2f,%.10f", f1, f2)
}
复数类型
在Go语言中complex有两种类型，complex64和complex128。complex64中实部和虚部是32位的，在complex128中实部和虚部是64位的。
package main
import (
"fmt"
"math"
"math/cmplx"
"unsafe"
)
var aa complex64
var bb complex128
func main() {
aa = 5
fmt.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 main
import (
"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 main
import "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 main
import (
"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 main
import (
"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 main
import (
"bytes"
"fmt"
)
func main() {
//字符串拼接1.+
var s = "hello"
var s1 = s + ",你好"
fmt.Printf("%s\n", s1)
//字符串拼接2.bytes.Buffer,性能高，参考java
var sBuilder bytes.Buffer
sBuilder.WriteString(s)
sBuilder.WriteString(",你好")
fmt.Printf("%s", sBuilder.String())
}
字符串获取指定位置字符
指定位置的字符要区分字符串中中是否有中文，若有中文，不能直接通过下标去获取；可以通过显示转换为rune数组，然后通过下标获取
package main
import (
"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 main
import (
"fmt"
)
func main() {
var aInt int = 19
var bFloat float32 = 4.78
var cBool bool = false
var 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 main
import (
"fmt"
"strconv"
)
func main() {
i := 123
//等同于FormatInt(int64(i), 10)
iStr := strconv.Itoa(i)
fmt.Printf("整数转字符串:%T,%v\n", iStr, iStr)
f := 3.1415926
fStr := strconv.FormatFloat(f, 'f',2,64)
fmt.Printf("浮点数转字符串:%T,%v\n", fStr, fStr)
b := true
bStr := strconv.FormatBool(b)
fmt.Printf("布尔数转字符串:%T,%v\n", bStr, bStr)
}
输出结果
整数转字符串:string,123
浮点数转字符串:string,3.14
布尔数转字符串:string,true
字符串类型转其它基础类型
strconv包中函数
package main
import (
"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种，分别是整数类型，浮点类型，复数类型，字节类型，字符串类型，布尔类型
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
