系列文章目录
【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位数的正数）
}
非布尔数据类型不能使用取反
总结
需要根据数据类型之间的关系选择合适的方法。需要特别注意的是，不支持任意类型的隐式转换，必须使用显式类型转换来完成转换操作，并且在一些情况下可能会引起精度丢失或运行时错误。因此，在进行数据类型转换时，务必小心谨慎。
