数据类型
文章发布较早,内容可能过时,阅读注意甄别。
go 语言内置以下这些基础类型:
类型 | 名称 | 长度 | 零值 | 说明 |
---|---|---|---|---|
bool | 布尔类型 | 1 | false | 其值不为真即为假,不可以用数字代表 true 或 false |
byte | 字节型 | 1 | 0 | uint8 别名 |
rune | 字符类型 | 4 | 0 | 专用于存储 unicode 编码,等价于 uint32 |
int,uint | 整型 | 4 或 8 | 0 | 23 位或 64 位 |
int8,uint8 | 整型 | 1 | 0 | -128-127,0-255 |
int16,uint16 | 整型 | 2 | 0 | -32768-32768,0-65535 |
int32,uint32 | 整型 | 4 | 0 | -21 亿-21 亿,0-42 亿 |
int64,uint64 | 整型 | 8 | 0 | |
float32 | 浮点型 | 4 | 0.0 | 小数位精确到 7 位 |
float64 | 浮点型 | 8 | 0.0 | 小数位精确到 15 位 |
complex64 | 复数类型 | 8 | ||
complex128 | 复数类型 | 16 | ||
unitptr | 整型 | 4 或 8 | 足以存储指针的 uint32 或 uint64 整数 | |
string | 字符串 | "" | utf-8 字符串 |
其中零值表示默认值
,常用的已经使用高亮
提示。
# 1,布尔类型。
package main
import "fmt"
func main() {
//1,声明变量,如果没有初始化,默认为false
var a bool
fmt.Println("a =", a)
a = true
fmt.Println("a =", a)
//2,同样可以自动推到类型
var b = false
fmt.Println("b =", b)
//或者另一种写法
c := true
fmt.Println("c =", c)
fmt.Printf("c type is %T", c)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 2,浮点型。
package main
import "fmt"
func main() {
//声明变量
var a float32
a = 3.14
fmt.Println("a =", a)
//自动推导类型,默认类型为float64
b := 3.14
fmt.Printf("b type is %T", b)
//float64存储结果要比float32更精确
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 3,字符类型。
package main
import "fmt"
func main() {
//声明字符类型
var a byte
a = 97
//fmt.Println("a =", a) 常规打印
/*
使用fmt的Printf可以格式化输出
%c表示以字符方式打印
%d以整型方式打印
*/
fmt.Printf("%c, %d\n", a, a) //可以发现第一个a输出为a,第二个a输出为97
//这两者的输出,是与ASCII码表对照的。
var ch byte
ch = 'a' //注意,单引号表示字符,双引号表示字符串
fmt.Printf("%c, %d\n", ch, ch)
//大写转小写,小写转大写,大小写相差32,大的数字是小写。
fmt.Printf("大写:%d, 小写:%d\n", 'A', 'a')
fmt.Printf("大写转小写:%c\n", 'A'+32)
fmt.Printf("小写转大写:%c\n", 'a'-32)
//如果没有换行符,那么不同的行,输出也会变成一行
fmt.Printf("hello a")
fmt.Println("hello b")
//'\'以反斜杠开头的字符是转义字符,'\n'代表换行符
fmt.Printf("hello a%c", '\n')
fmt.Printf("hello b")
}
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
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
# 4,字符串类型。
package main
import "fmt"
func main() {
//声明字符串类型
var str1 string
str1 = "abc"
fmt.Println("str1 =", str1)
//自动推导类型
str2 := "jenkins"
fmt.Printf("str2 的类型是 %T\n", str2)
//内建函数,len(),可以检测字符串的长度,即有多少个字符
fmt.Println("len(str2) =", len(str2))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 5,字符和字符串的区别。
package main
import "fmt"
func main() {
var ch byte
var str string
//字符
// 1,字符用单引号表示。
// 2,字符,往往都只有一个字符,转义字符除外'\n'
ch = 'a'
fmt.Println("ch =", ch)
// 字符串
// 1,字符串用双引号表示。
// 2,字符串有一个或多个字符组成
// 3,字符串都隐藏了一个结束符,'\0',表示空字符
str = "a"
fmt.Println("str =", str)
//如果只想操作某个字符,可用如下方式,0表示第一个
str = "hello go"
fmt.Printf("str[0] = %c, str[1] = %c", str[0], str[1])
}
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 6,复数类型。
package main
import "fmt"
func main() {
//声明一个复数类型的变量
var t complex128
t = 2.1 + 3.14i
fmt.Println("t =", t)
//自动推导类型
t1 := 3.3 + 4.4i
fmt.Printf("t1 的类型是 %T\n", t1)
//通过内建函数,取出实部和虚部
fmt.Println("real(t1) =", real(t1), ",imag(t1) =", imag(t1))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
上次更新: 2024/06/13, 22:13:45
← 基础知识 fmt的格式化输入输出→