Go语言的基本数据类型：整型、浮点型、字符串
目录
【整型int】
整型溢出
整型字面值
【浮点型float】
浮点型字面值
复数类型
【字符串string】
Go 字符串类型的内部表示
Go 字符串类型的常见操作
关于整型、浮点型、字符串 的一些其它示例：
字符串和数值类型的转换
【创建自定义数据类型】
【输出方法Print】
【运行测试】
Go语言中的基本数据类型包括下面这些：
基本数据类型
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32,represents a Unicode code point
float32 float64
complex64 complex128
【整型】
分为平台无关整型和平台相关整型这两种，平台无关整型在任何 CPU 架构或任何操作系统下面，长度都是固定不变的。
byte 等同于 uint8；rune 等同于 int32
平台相关整型的长度会根据运行平台的改变而改变。Go语言原生提供了三个平台相关整型，它们是 int、uint 与 uintptr。
在编写有移植性要求的代码时，千万不要强依赖这些类型的长度，可以通过 unsafe 包提供的 SizeOf 函数来获取。
var ao, bo = int(5), uint(6)
var p uintptr = 0x12345678
fmt.Println(unsafe.Sizeof(ao)) // 8
fmt.Println(unsafe.Sizeof(bo)) // 8
fmt.Println(unsafe.Sizeof(p)) // 8整型溢出
如果整型的结果超出了它的边界值，就会发生整型溢出问题。出现溢出情况后，对应的整型变量的值依然会落到它的取值范围内，只是结果值与预期不符。这个问题最容易发生在循环语句的结束条件判断中，因为这也是经常使用整型变量的地方。
var num int8 = 127
num += 1
fmt.Println(num) //期望结果128,实际-128
var num2 uint8 = 1
num2 -= 2
fmt.Println(num2) //期望结果-1,实际255整型字面值
a := 53 // 十进制
b := 0700 // 八进制，以"0"为前缀
c1 := 0xaabbcc // 十六进制，以"0x"为前缀
c2 := 0Xddeeff // 十六进制，以"0X"为前缀
//Go 1.13 版本中，Go 又增加了对二进制字面值的支持和两种八进制字面值的形式
d1 := 0b10000001 // 二进制，以"0b"为前缀
d2 := 0B10000001 // 二进制，以"0B"为前缀
e1 := 0o700 // 八进制，以"0o"为前缀
e2 := 0O700 // 八进制，以"0O"为前缀
//Go 1.13 版本还支持在字面值中增加数字分隔符“_”，分隔符可以用来将数字分组以提高可读性。
a := 5_3_7 // 十进制: 537
b := 0b_1000_0111 // 二进制位表示为10000111
c1 := 0_700 // 八进制: 0700
c2 := 0o_700 // 八进制: 0700
d1 := 0x_5c_6d // 十六进制：0x5c6d
//通过标准库 fmt 包的格式化输出函数，将一个整型变量输出为不同进制的形式
var a int8 = 59
fmt.Printf("%b\n", a) //输出二进制：111011
fmt.Printf("%d\n", a) //输出十进制：59
fmt.Printf("%o\n", a) //输出八进制：73
fmt.Printf("%O\n", a) //输出八进制(带0o前缀)：0o73
fmt.Printf("%x\n", a) //输出十六进制(小写)：3b
fmt.Printf("%X\n", a) //输出十六进制(大写)：3B【浮点型】
Go 语言提供了 float32 与 float64 两种浮点类型，默认值都是0.0，但是它们占用的内容空间大小不一样，并且可表示的浮点数的范围和精度也不一样。一般比较常用的float64是双精度，float32由于精度不足可能会导致输出结果出现异常，比如下面的代码：
var x1 float32 = 16777216.0
var x2 float32 = 16777217.0
fmt.Println("x1==x2? ", x1 == x2) // true浮点型字面值
//用十进制表示的浮点值形式
float1 := 3.1415
float2 := .15 // 整数部分如果为0，整数部分可以省略不写
float3 := 81.80
float4 := 82. // 小数部分如果为0，小数点后的0可以省略不写
//十进制的科学计数法形式（e/E 代表的幂运算的底数为 10）
float5 := 6674.28e-2 // 6674.28 * 10^(-2) = 66.742800
float6 := .12345E+5 // 0.12345 * 10^5 = 12345.000000
//十六进制科学计数法形式（ p/P 代表的幂运算的底数为 2）
float7 := 0x2.p10 // 2.0 * 2^10 = 2048.000000
float8 := 0x1.Fp+0 // 1.9375 * 2^0 = 1.937500
//通过 %f 可以输出浮点数最直观的原值形式
var f9 float64 = 123.45678
fmt.Printf("%f\n", f9) // 123.456780
//将浮点数输出为科学计数法形式
fmt.Printf("%e\n", f9) // 1.234568e+02 //十进制的科学计数法
fmt.Printf("%x\n", f9) // 0x1.edd3be22e5de1p+06 //十六进制的科学计数法Go 语言中没有提供 float 类型。这不像整型那样既提供了 int16、int32 等类型又有 int 类型。也就是说：Go 提供的浮点类型都是平台无关的。
复数类型
复数类型分别是 complex64 和 complex128，complex64 的实部与虚部都是 float32 类型，而 complex128 的实部与虚部都是 float64 类型。如果一个复数没有显示赋予类型，那么它的默认类型为 complex128。下面是表示复数字面值的方法：
//第一种，可以通过复数字面值直接初始化一个复数类型变量
var c = 5 + 6i
var d = 0o123 + .12345E+5i // 83+12345i
//第二种，通过complex 函数创建一个 complex128 类型值
var c = complex(5, 6) // 5 + 6i
var d = complex(0o123, .12345E+5) // 83+12345i
//第三种，通过 real 和 imag 函数来获取一个复数的实部与虚部，返回值为一个浮点类型
var c = complex(5, 6) // 5 + 6i
r := real(c) // 5.000000
i := imag(c) // 6.000000【字符串】
Go语言中的字符串类型的值在它的生命周期内是不可改变的，最大好处就是不用再担心字符串的并发安全问题，这样字符串可以被多个 Goroutine 共享，不用担心并发安全问题。另外也由于字符串的不可变性，针对同一个字符串值无论在程序的几个位置被使用，Go 编译器只需要为它分配一块存储就好了，大大提高了存储利用率。
var s string = "hello"
s[0] = 'k' // 错误：字符串的内容是不可改变的
s = "gopher" //可以重新赋值Go 采用的是 Unicode 字符集，每个字符都是一个 Unicode 字符。打印字符串中的每个字节，以及整个字符串的长度：
var s = "中国人"
fmt.Printf("the length of s = %d\n", len(s)) // 9
for i := 0; i < len(s); i++ {
fmt.Printf("0x%x ", s[i]) // 0xe4 0xb8 0xad 0xe5 0x9b 0xbd 0xe4 0xba 0xba
}
fmt.Printf("\n")通过字符序列的视角来看字符串
var s = "中国人"
fmt.Println("the character count in s is", utf8.RuneCountInString(s)) // 3
for _, c := range s {
fmt.Printf("0x%x ", c) // 0x4e2d 0x56fd 0x4eba
}
fmt.Printf("\n")Go 字符串类型的内部表示
string 类型其实是一个“描述符”，它本身并不真正存储字符串数据，而仅是由一个指向底层存储的指针和字符串的长度字段组成的。获取字符串长度的时间复杂度是O(1)
// $GOROOT/src/reflect/value.go
// StringHeader是一个string的运行时表示
type StringHeader struct {
Data uintptr
Len int
}
因此，直接将 string 类型通过函数 / 方法参数传入也不会带来太多的开销。因为传入的仅仅是一个“描述符”，而不是真正的字符串数据。
Go 字符串类型的常见操作
1、在字符串的实现中，真正存储数据的是底层的数组，因此一般可以使用字符串的下标获取某个字节（而不是字符）
var s = "中国人"
fmt.Printf("0x%x\n", s[0]) // 0xe4：字符“中” utf-8编码的第一个字节2、使用 for 与 for range 迭代字符串，这两种形式的迭代对字符串进行操作得到的结果是不同的。
//字节视角的迭代，使用 for
var s = "中国人"
for i := 0; i < len(s); i++ {
fmt.Printf("index: %d, value: 0x%x\n", i, s[i])
}
//字符串中 Unicode 字符的码点值，使用 for ... range
var s = "中国人"
for i, v := range s {
fmt.Printf("index: %d, value: 0x%x\n", i, v)
}
常⽤字符串函数
1. strings 包：https://golang.org/pkg/strings
2. strconv 包：https://golang.org/pkg/strconv
关于整型、浮点型、字符串 的一些其它示例：
//go01/data_type.go
package main
import "fmt"
func main() {
//1.布尔类型
var b1 bool
b1 = true
fmt.Printf("b1: %T,%t\n", b1, b1)
b2 := false
fmt.Printf("b2: %T,%t\n", b2, b2)
//bool类型占用存储空间是1个字节
fmt.Println("b2 的占用空间 =", unsafe.Sizeof(b2)) //1
//2.整数
var i1 int8
i1 = 100
fmt.Println(i1)
var i2 uint8
i2 = 200
fmt.Println(i2)
var i3 int
i3 = 1000
fmt.Println(i3)
//语法角度：int，int64不认为是同一种类型
//var i4 int64
//i4 = i3 //cannot use i3 (type int) as type int64 in assignment
var i5 uint8
i5 = 100
var i6 byte
i6 = i5
fmt.Println(i5, i6)
var i7 = 100
fmt.Printf("%T,%d\n", i7, i7)
//浮点
var f1 float32
f1 = 3.14
var f2 float64
f2 = 4.67
fmt.Printf("f1: %T,%.2f\n", f1, f1)
fmt.Printf("f2: %T,%.3f\n", f2, f2)
fmt.Println(f1)
var f3 = 2.55
fmt.Printf("f3: %T\n", f3)
//字符串
//1.定义字符串
var s1 string
s1 = "你好"
fmt.Printf("s1: %T,%s\n", s1, s1)
s2 := `Hello World`
fmt.Printf("s2: %T,%s\n", s2, s2)
//2.区别：'A',"A"
v1 := 'A'
v2 := "A"
fmt.Printf("v1: %T,%d\n", v1, v1) //int32
fmt.Printf("v2: %T,%s\n", v2, v2)
v3 := '中'
fmt.Printf("v3: %T,%d,%c,%q\n", v3, v3, v3, v3)
//3.转义字符
fmt.Println("\"HelloWorld\"")
fmt.Println("Hello\nWor\tld")
fmt.Println(`He"lloWor"ld`)
fmt.Println("Hello`Wor`ld")
//字节长度：和编码无关，用 len(str)获取
fmt.Println(len("ab")) //2
fmt.Println(len("你好")) //6
//字符数量：和编码有关，用编码库来计算
fmt.Println(utf8.RuneCountInString("ab")) //2
fmt.Println(utf8.RuneCountInString("你好")) //2
//字符串拼接,用 + 号
sk1 := "你好"
sk2 := "再见"
fmt.Println(sk1 + sk2) //你好再见
//指针对应的是变量在内存中的存储位置,也就是说 指针的值就是变量的内存地址
dat := 10
datP := &dat //data的指针
// datP = datP + 1 //报错:指针不支持运算
datV := *datP //dataP指针对应的值
fmt.Println(datP, datV) //0xc00001e1a0 10
fmt.Printf("%T %T \n", datP, datV) //*int int
//判断数据类型
data := "个人信息"
fmt.Println(getVarType(data)) //string
}
func getVarType(args interface{}) string {
switch args.(type) {
case nil:
return "nil"
case int:
return "int"
case int64:
return "int64"
case float64:
return "float64"
case bool:
return "bool"
case string:
return "string"
case func(int) float64:
return "func(int)"
default:
return "unknown"
}
}
/*字符串分割成数组，以及数组拼接成字符串*/
func stringFn(s string) {
parts := strings.Split(s, ",")
for _, part := range parts {
fmt.Println(part)
}
fmt.Println(strings.Join(parts, "-"))
}
字符串和数值类型的转换
var str string = "true"
var b bool
b, _ = strconv.ParseBool(str)
fmt.Printf("b type %T b=%v\n", b, b) //b type bool b=true
var str2 string = "1234590"
var n1 int64
var n2 int
n1, _ = strconv.ParseInt(str2, 10, 64)
n2 = int(n1)
fmt.Printf("n1 type %T n1=%v\n", n1, n1) //n1 type int64 n1=1234590
fmt.Printf("n2 type %T n2=%v\n", n2, n2) //n2 type int n2=1234590
var str3 string = "123.456"
var f1 float64
f1, _ = strconv.ParseFloat(str3, 64)
fmt.Printf("f1 type %T f1=%v\n", f1, f1) //f1 type float64 f1=123.456
var str4 string = "hello"
var n3 int64 = 11
n3, _ = strconv.ParseInt(str4, 10, 64)
fmt.Printf("n3 type %T n3=%v\n", n3, n3) //n3 type int64 n3=0
【创建自定义数据类型】
//MyInt的数值性质与 int32 完全相同
type MyInt int32
//但仍然是完全不同的两种类型，无法直接让它们相互赋值或放在同一个运算中直接计算
var m int = 5
var n int32 = 6
var a MyInt = m // 错误：在赋值中不能将m（int类型）作为MyInt类型使用
var a MyInt = n // 错误：在赋值中不能将n（int32类型）作为MyInt类型使用
//需要显示的转换类型才可以
var a MyInt = MyInt(m) // ok
var a MyInt = MyInt(n) // ok
//也可以通过类型别名（Type Alias）来自定义数值类型，此时定义的新类型与原类型没有区别
type YourInt = int32
var n int32 = 6
var a YourInt = n // ok
【输出方法Print】
fmt.Print：输出到控制台（仅只是输出）
fmt.Println：输出到控制台并换行
fmt.Printf：仅输出格式化的字符串和字符串变量（整型和整型变量不可以）
fmt.Sprintf：格式化并返回一个字符串，不输出。
//go01/print.go
package main
import (
"fmt"
)
func main() {
fmt.Print("输出到控制台不换行--- ")
fmt.Println("输出到控制台并换行")
fmt.Printf("name=%s,age=%d\n", "Tom", 30)
fmt.Printf("name=%s,age=%d,height=%v\n", "Tom", 30, fmt.Sprintf("%.2f", 180.567))
}
【运行测试】
编写测试程序
1.源码⽂文件以 _test 结尾:xxx_test.go
2.测试⽅方法名以 Test 开头:func TestXXX(t *testing.T) {...}
运行方法： go test -v run_test.go
//go01/run_test.go
package main_test
import "testing"
const (
Monday = 1 + iota
Tuesday
Wednesday
)
func TestPoint(t *testing.T) {
t.Log(Monday, Tuesday, Wednesday)
a := 1
aPtr := &a
t.Log(a, aPtr)
t.Logf("%T %T", a, aPtr)
}
源代码：go-demo-2023: Go语言基本用法和实用笔记 - Gitee.com