【GO语言基础】基本数据类型

系列文章目录

【Go语言学习】ide安装与配置
【GO语言基础】前言
【GO语言基础】变量常量
【GO语言基础】数据类型

---

---

数据类型

数值型：

整数类型：

注意：u开头为无符号数，在C语言中，例如，有 "unsigned int"（无符号整型）和 "unsigned short"（无符号短整型）等类型，它们都以 "u" 或 "unsigned" 开头。无符号数只能表示正数和零，不能表示负数。

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var New1 int = 1
	var New2 int8 = 1
	var New3 int16 = 1
	var New4 int32 = 1
	var New5 int64 = 1
	//无符号数
	var New6 uint = 1
	var New7 uint8 = 1
	var New8 uint16 = 1
	var New9 uint32 = 1
	var New10 uint64 = 1

	fmt.Println(New1, New2, New3, New4, New5, New6, New7, New8, New9, New10)
	//unsage.Sizeof输出数据类型存储的大小
	fmt.Println(unsafe.Sizeof(New1))
	fmt.Println(unsafe.Sizeof(New2))
	fmt.Println(unsafe.Sizeof(New3))
	fmt.Println(unsafe.Sizeof(New4))
	fmt.Println(unsafe.Sizeof(New5))
	fmt.Println("无符号数：")
	fmt.Println(unsafe.Sizeof(New6))
	fmt.Println(unsafe.Sizeof(New7))
	fmt.Println(unsafe.Sizeof(New8))
	fmt.Println(unsafe.Sizeof(New9))
	fmt.Println(unsafe.Sizeof(New10))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

浮点数类型：

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	//浮点数类型
	var New1 float32 = 3.14
	var New2 float64 = 3.1415926

	fmt.Println(New1, New2)
	//unsage.Sizeof输出数据类型存储的大小
	fmt.Println(unsafe.Sizeof(New1))
	fmt.Println(unsafe.Sizeof(New2))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

字符型-布尔型-字符串

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	// 字符型（byte）
	var b byte = 'a'
	fmt.Printf("Byte: %c\n", b)

	// 布尔型
	var boolVar bool = true
	fmt.Println("Bool:", boolVar)

	// 字符串，技巧使用：反引号括起来的字符串可以原样输出
	var strVar string = "Hello, Go!"
	fmt.Println("String:", strVar)
	
	//unsage.Sizeof输出数据类型存储的大小
	fmt.Println(unsafe.Sizeof(b))
	fmt.Println(unsafe.Sizeof(boolVar))
	fmt.Println(unsafe.Sizeof(strVar))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

零值

在Go中，所有声明的变量都会被赋予一个零值，例如，int类型的零值是0，string类型的零值是空字符串。

package main

import "fmt"

func main() {
	var New1 int
	var New2 string
	fmt.Println(New1)
	fmt.Println(New2)
}
1
2
3
4
5
6
7
8
9
10

转义字符

常用类型转换

自定义类型之间的转换
自定义类型之间的转换取决于它们的底层类型。如果底层类型相同，那么它们可以相互转换。
如float64转换为int

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var a int = 42
	var b float64 = float64(a) // 将整数转换为浮点数
	//输出数据
	fmt.Println(b)
	//输出数据类型
	fmt.Println("b 的类型:", reflect.TypeOf(b))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

数值类型：

• 可以将整数类型转换为浮点数类型，例如int转换为float64。
• 可以将浮点数类型转换为整数类型，但会丢失小数部分，例如float64转换为int。
• 不同大小的整数类型之间可以相互转换，但注意可能会导致溢出或数据丢失。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var x int = 42
	var y float64 = float64(x) // int到float64的显式转换
	fmt.Println(x)
	fmt.Println("y 的类型", reflect.TypeOf(y))
	fmt.Println("")

	//float64转换int后精度丢失
	var f float64 = 58.0022
	var z int = int(f)
	fmt.Println(f)
	fmt.Println("f 的类型(转换前)", reflect.TypeOf(f))
	fmt.Println(z)
	fmt.Println("z 的类型(转换后)", reflect.TypeOf(z))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

字符串类型：

• 可以将字符串转换为字节数组或切片，例如string转换为[]byte。
• 可以将字节数组或切片转换为字符串，例如[]byte转换为string。
• 可以将一些数值类型转换为字符串，例如int转换为string。
• 在字符类型转换中常用strconv包（点我跳转中文网）。
  

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var New1 int = 555

	fmt.Println(New1)
	fmt.Println("New1的数据类型是：", reflect.TypeOf(New1))
	// 将整数转换为字符串
	var New2 string = strconv.Itoa(New1)
	fmt.Println(New2)
	fmt.Println("New2的数据类型是：", reflect.TypeOf(New2))

	// 将浮点数转换字符串
	var New3 float64 = 3.14
	fmt.Println(New3)
	fmt.Println("New3的数据类型是：", reflect.TypeOf(New3))
	var New4 string = strconv.FormatFloat(New3, 'f', -1, 64)
	//第一个参数是要转换的浮点数。
	//第二个参数是格式标记，其中'f'表示使用普通的浮点数格式。
	//第三个参数是精度，-1表示使用尽可能多的精度。
	//第四个参数是浮点数的位数，通常使用64表示float64类型。
	fmt.Println(New4)
	fmt.Println("New4的数据类型是：", reflect.TypeOf(New4))

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

布尔类型：
布尔类型不能直接转换为其他数据类型，也不能从其他类型直接转换为布尔类型，需要使用条件语句来进行转换。

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var b1 bool = true
	var b2 bool = false

	// 不能直接将b1转换为b2或反之，需要使用条件语句或逻辑运算符来转换
	b1 = !b2 // 使用逻辑非来转换
	fmt.Println(b1)
	fmt.Println("b1数据类型是", reflect.TypeOf(b1))
	//布尔转换为字符串\
	var New1 string = strconv.FormatBool(b1)
	fmt.Println(New1)
	fmt.Println("New1数据类型是", reflect.TypeOf(New1))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运算符

package main

import "fmt"

func main() {
	//算术运算符
	var a, b int = 10, 5
	fmt.Println(a + b) // 加法
	fmt.Println(a - b) // 减法
	fmt.Println(a * b) // 乘法
	fmt.Println(a / b) // 除法
	fmt.Println(a % b) // 取余

	//赋值运算符
	var c int
	c = 100
	fmt.Println(c)
	c += 50 // 简写加法赋值：等于c=c+50
	fmt.Println(c)
	c -= 20 // 简写减法赋值：等于c=c-20
	fmt.Println(c)
	c *= 3 // 简写乘法赋值：c=c*20
	fmt.Println(c)
	c /= 10 // 简写除法赋值：c=c/20
	fmt.Println(c)

	//比较运算符
	var d, e int = 50, 75
	fmt.Println(d == e) // 等于，输出 false
	fmt.Println(d != e) // 不等于，输出 true
	fmt.Println(d < e)  // 小于，输出 true
	fmt.Println(d > e)  // 大于，输出 false
	fmt.Println(d <= e) // 小于等于，输出 true
	fmt.Println(d >= e) // 大于等于，输出 false

	//位运算符
	var f, g uint8 = 5, 3
	fmt.Println(f & g)  // 按位与，输出 1
	fmt.Println(f | g)  // 按位或，输出 7
	fmt.Println(f ^ g)  // 按位异或，输出 6
	fmt.Println(f << 2) // 左移，输出 20
	fmt.Println(f >> 2) // 右移，输出 1

	//其他运算符
	var h bool = true
	var i int = 42
	fmt.Println(!h)     // 取反，输出 false
	fmt.Println(+i)     // 取正，输出 42（正数）
	fmt.Println(-i)     // 取负，输出 -42（负数）
	fmt.Println(i << 3) // 无符号左移，输出 168（无符号8位数的正数）
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

非布尔数据类型不能使用取反

---

总结

需要根据数据类型之间的关系选择合适的方法。需要特别注意的是，不支持任意类型的隐式转换，必须使用显式类型转换来完成转换操作，并且在一些情况下可能会引起精度丢失或运行时错误。因此，在进行数据类型转换时，务必小心谨慎。