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

系列文章目录

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

---

---

数据类型

数值型：

整数类型：

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

类型	取值范围	大小（字节）
int	根据平台变化	32或64
int8	-128到127	1
int16	-32768到32767	2
int32	-2147483648到2147483647	4
int64	-9223372036854775808到9223372036854775807	8
uint	根据平台变化	32或64
uint8	0到255	1
uint16	0到65535	2
uint32	0到4294967295	4
uint64	0到18446744073709551615	8

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))
}

浮点数类型：

类型	取值范围	大小（字节）
float32	±1.18e-38 to ±3.4e38	4
float64	±2.23e-308 to ±1.8e308	8

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))
}

字符型-布尔型-字符串

类型	取值范围	大小（字节）
字符（byte）	uint8 类型，代表一个ASCII字符	1字节
布尔型（bool）	true 或 false	1字节（通常）
字符串（string）	由多个字符组成的序列，以空字符（‘\0’）结尾	变长，取决于字符串的长度

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))
}

零值

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

package main

import "fmt"

func main() {
	var New1 int
	var New2 string
	fmt.Println(New1)
	fmt.Println(New2)
}

转义字符

转义字符	描述
\n	换行符，表示一个新的行开始。
\r	回车符，表示回到当前行的开头。
\t	制表符，表示一个制表位（Tab）。
\"	双引号，用于表示包含在字符串中的双引号。
\'	单引号，用于表示包含在字符串中的单引号。
\\	反斜杠，用于表示包含在字符串中的反斜杠本身。
\0	空字符，表示一个空字符。
\xHH	十六进制转义字符，用于表示一个两位十六进制数表示的字节。例如，\x0A表示换行符（ASCII码为10）。
\uHHHH	Unicode转义字符，用于表示一个四位十六进制数表示的Unicode字符。例如，\u0020表示空格字符（Unicode码为U+0020）。
\UHHHHHHHH	大写Unicode转义字符，用于表示一个八位十六进制数表示的Unicode字符。例如，\U00000020表示空格字符（Unicode码为U+0020）。

常用类型转换

自定义类型之间的转换
自定义类型之间的转换取决于它们的底层类型。如果底层类型相同，那么它们可以相互转换。
如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))
}

数值类型：

• 可以将整数类型转换为浮点数类型，例如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))
}

字符串类型：

• 可以将字符串转换为字节数组或切片，例如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))

}

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

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))
}

运算符

运算符	描述
+	加法
-	减法
*	乘法
/	除法
%	取余
++	自增（前置）
–	自减（前置）
+++	自增（后置）
–	自减（后置）
&	取地址运算符
&^	按位取反运算符
^	按位异或运算符
|	按位或运算符
&<<	左移位运算符
&>>	右移位运算符
==	等于运算符
!=	不等于运算符
>	大于运算符
<	小于运算符
>=	大于等于运算符
<=	小于等于运算符
&&	逻辑与运算符
||	逻辑或运算符
!	逻辑非运算符
<<	低位位移运算符
>>	高位位移运算符
+=	加等于运算符
-=	减等于运算符
*=	乘等于运算符
/=	除等于运算符
%=	取模等于运算符
&=	按位与等于运算符
^=	按位异或等于运算符
|=	按位或等于运算符
&=<<	低位左移位等于运算符
&=>>	低位右移位等于运算符

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位数的正数）
}

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

---

总结

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