Go语言基本数据类型

1、转义字符

常用的转义字符有如下:

1) \t : 表示一个制表符，通常使用它可以排版。

2) \n：换行符

3) \：一个\

4) "：一个”

**5)**\r：一个回车

2、数据类型概述

在 Go 编程语言中，数据类型用于声明函数和变量。

数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。

3、整型

用于存放整数值的，比如 0, 1、2、3、4、5 等等

无符号类型可以存放的正数范围比有符号整型中的范围大一倍

image-20230120205149218

image-20230120205158647

image-20230120205207117

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var i int = 255
	fmt.Printf("i的类型是%T,占用字节数为%d", i, unsafe.Sizeof(i))
}


//输出的结果
i的类型是int,占用字节数为8

4、字符型

字符串中的每一个元素叫做“字符”，在遍历或者单个获取字符串元素时可以获得字符。

Go语言的字符有以下两种：

1）一种是 uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。

2）另一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型等价于 int32 类型。

byte 类型是 uint8 的别名，对于只占用 1 个字节的传统 ASCII 编码的字符来说，完全没有问题，例如 var ch byte = ‘A’，字符使用单引号括起来。

Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。

查看字符码值转换地址：

http://www.mytju.com/classcode/tools/encode_utf8.asp

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
package main

import "fmt"

//演示golang中字符类型的使用
func main() {
	var c1 byte = 'a'
	var c2 byte = '0' //字符的0
	var c3 rune = '测'

	fmt.Printf("c3的数据格式是%T\n", c3)
	//如果我们希望输出对应的字符，需要使用格式化输出%c,会直接输出数字对应的unicode字符
	fmt.Printf("c1=%c,c2=%c,c3=%c\n", c1, c2, c3)
	//直接输出的话就会显示unicode码
	fmt.Println(c1, c2, c3)

	//字符类型是可以进行计算的，相当于一个整数，运算时是按照码值来进行运算
	var n1 = 10 + '测' //10 + 27979 = 27989
	fmt.Println(n1)
	fmt.Printf("n1=%c", n1)
}



//输出结果
c3的数据格式是int32
c1=a,c2=0,c3=测
97 48 27979
27989
n1=浕

备注：字符类型使用细节

**1)**字符型存储到计算机中，需要将字符对应的码值（整数）找出来存储：

字符—>对应码值>二进制–>存储

读取：二进制—-> 码值 —-> 字符 –> 读取

**2)**字符和码值的对应关系是通过字符编码表决定的(是规定好)

3) Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了

**4)**字符常量是用单引号(‘’)括起来的单个字符。例如：

1
2
3
var c1 byte = 'a'	
var c2 int =  '中'	
var c3 byte = '9'

**5)**Go 中允许使用转义字符 ‘\’来将其后的字符转变为特殊字符型常量。例如：var c3 char = ‘\n’

英文字母-1 个字节 汉字-3 个字节

**7)**在 Go 中，字符的本质是一个整数，直接输出时，是该字符对应的 UTF-8 编码的码值。

**8)**可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的 unicode 字符

**9)**字符类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码.

5、布尔类型

一个布尔类型的值只有两种：true 或 false（不写话默认为false）。if 和 for 语句的条件部分都是布尔类型的值，并且==和<等比较操作也会产生布尔型的值。

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
package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var a bool = false
	var b bool = true
	fmt.Println(a, b)
	//注意事项
	//bool类型占用的存储空间是1个字节

	fmt.Printf("a的占用字节数%d,a的类型是%T\n", unsafe.Sizeof(a), a)

	var d = 1
	var e = 2
	if d > e {
		fmt.Println("true")
	} else {
		fmt.Println("false")
	}
}



//输出的结果
false true
a的占用字节数1,a的类型是bool
false

6、字符串类型

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。

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"

func main() {
	var str1 string = "hello man"
	fmt.Println(str1)
	//在go中字符串是不可变得，字符串一旦赋值了，就不能再次更改了
	//str[0] = 'a' 这里就不能取修改str得内容，即go中得字符串是不能改变的

	//双隐号，会识别转义字符
	//反引号，以字符串原生形式输出，包括换行和特殊字符，也就是所见即所得
	str2 := `cesj\n\r`
	fmt.Println(str2)

	//字符串进行拼接
	str2 += "拼接上"
	fmt.Println(str2)

	//当一个拼接很长时，注意需要将 + 留在上一行
	str3 := "adsa" + "adas" +
		"asdadawds"
	fmt.Println(str3)

}


//输出结果
hello man
cesj\n\r
cesj\n\r拼接上
adsaadasasdadawds

6、基本数据类型默认值

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

import "fmt"

func main() {
	var a int
	var b float32
	var c float64
	var d bool

	var e string

	//这里的%v是按照变量的值输出
	fmt.Printf("a=%v,b=%v,c=%v.d=%v,e=%v", a, b, c, d, e)

}


//输出的结果
a=0,b=0,c=0.d=false,e=

7、基本数据类型相互转换

在程序开发中，我们经常将基本数据类型转成 string,或者将 string 转成基本数据类型。

7.1 基本数据类型转string

fmt.Sprintf(“%参数”, 表达式)

注意：参数需要和表达式的数据类型相匹配

fmt.Sprintf().. 会返回转换后的字符串

%d表示是整数

%f表示的是浮点数

%t表示的是布尔类型

%c表示的byte类型

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"

func main() {
	var num1 int = 1
	var num2 float64 = 8.7
	var b bool = true
	var cha byte = 'a'
	var str string

	//使用fmt.Sprintf方法转成字符串,%d表示是整数，%v/%q表示原值输出
	str = fmt.Sprintf("%d", num1)
	fmt.Printf("str的数据类型是%T str=%q\n", str, str)

	//使用fmt.Sprintf方法转成字符串，%f表示的是浮点数
	str = fmt.Sprintf("%f", num2)
	fmt.Printf("str的数据类型是%T, str=%q\n", str, str)

	//%t表示的是布尔类型
	str = fmt.Sprintf("%t", b)
	fmt.Printf("str的数据类型是%T str=%q\n", str, str)

	//%c表示的byte类型
	str = fmt.Sprintf("%c", cha)
	fmt.Printf("str的数据类型是%T str=%q", str, str)
}


//输出的结果
str的数据类型是string str="1"
str的数据类型是string, str="8.700000"
str的数据类型是string str="true"
str的数据类型是string str="a"

7.2 string转基本数据类型

使用strconv包

在标准官方库文档有：

https://studygolang.com/static/pkgdoc/pkg/strconv.htm

image-20230120230455470

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
52
53
54
55
56
57
58
// 注意：
// 将string转成基本数据类型时，要确保数据类型能够转换成有效的数据
// 否则将会转换成默认的数值，float-->0，bool-->false
package main

import (
	"fmt"
	"strconv"
)

func main() {
	var str string = "true"
	var b bool
	//b,_ = strconv,ParseBool(str)
	//说明
	//1、strconv.ParseBool(str)函数会返回两个值（value bool,err error）
	//2、只想要获取到value bool,不想获取到err，所以用_进行忽略
	b, _ = strconv.ParseBool(str)
	fmt.Printf("b type %T\nb=%v\n", b, b)

	var str1 string = "12"
	var n1 int64
	var n2 int
	n1, _ = strconv.ParseInt(str1, 10, 64)
	// strconv.ParseInt(str1,10,64)解释
	//参数10表示数字的字符串进制
	//参数64表示返回的bit大小，如int8,int16,int32等
	fmt.Printf("n1 type %T\nn1=%v\n", n1, n1)
	//将n1的赋值给n2,且类型为int
	n2 = int(n1)
	fmt.Printf("n2 type %T\nn2=%v\n", n2, n2)

	var str2 = "12.6"
	var f1 float64
	f1, _ = strconv.ParseFloat(str2, 64)
	fmt.Printf("f1 type %T\nf1=%v\n", f1, f1)

	//演示错误的转换，转换的参数格式要正确
	var str3 = "hello"
	var n3 int64
	n3, _ = strconv.ParseInt(str3, 10, 64)
	fmt.Printf("n3 type %T\nn3=%v\n", n3, n3)

}



//输出的结果
b type bool
b=true
n1 type int64
n1=12
n2 type int
n2=12
f1 type float64
f1=12.6
n3 type int64
n3=0

8、指针

Go语言中的函数传参都是值拷贝，当我们想要修改某个变量的时候，我们可以创建一个指向该变量地址的指针变量。传递数据使用指针，而无须拷贝数据。类型指针不能进行偏移和运算。Go语言中的指针操作非常简单，只需要记住两个符号：&（取地址）和*（根据地址取值）。

一个指针变量可以指向任何一个值的内存地址，它所指向的值的内存地址在 32 和 64 位机器上分别占用 4 和8 个字节，占用字节的大小与所指向的值的大小无关。当一个指针被定义后没有分配到任何变量时，它的默认值为 nil。指针变量通常缩写为 ptr。

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用在变量名前面添加&操作符（前缀）来获取变量的内存地址（取地址操作），格式如下：

1
2
3
//变量 i的地址使用变量 ptr 进行接收，ptr 的类型为*int，称做 int 的指针类型，*代表指针。
var i int = 10
var ptr  \*int = &i
1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
	var num int = 1
	var str string = "home"
	fmt.Printf("num:%p.str:%p", &num, &str) //使用%v的结果也是一样的
}


//输出的结果
num:0xc0000180a8.str:0xc00005e260

使用 fmt.Printf 的动词%p打印 num和 str 变量的内存地址，指针的值是带有0x十六进制前缀的一组数据。

现在我们已经了解了什么是内存地址和如何去访问它。接下来我们将具体介绍指针。

一个指针变量指向了一个值的内存地址。

在使用指针前你需要声明指针。指针声明格式如下

1
2
3
4
5
var 变量名 *var-type

// var-type 为指针类型， * 号用于指定变量是作为一个指针。以下是有效的指针声明：
var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

8.1 指针使用流程：

1、定义指针变量。

2、为指针变量赋值。

3、访问指针变量中指向地址的值。

在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。

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
package main

import "fmt"

func main() {
	var i int = 10
	//i变量的地址&i
	fmt.Printf("i的地址=%v", &i)

	//下面的var str *int = &i
	//1、ptr是一个指针变量
	//2、ptr的类型是*int
	//3、ptr本身的值&i
	var ptr *int = &i
	//输出ptr的值
	fmt.Printf("ptr=%v\n", ptr)
	//输出ptr地址
	fmt.Printf("ptr地址=%v\n", &ptr)
	//输出ptr指向的值
	fmt.Printf("ptr指向的值=%v\n", *ptr)

}


//输出的结果
i的地址=0xc0000180a8ptr=0xc0000180a8
ptr地址=0xc00000a030
ptr指向的值=10

8.2 总结：

\1) 基本数据类型，变量存的就是值，也叫值类型

\2) 获取变量的地址，用&，比如： var num int, 获取 num 的地址：&num

\3) 指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值比如：var ptr *int = &num

4)获取指针类型所指向的值，使用：*，比如：var ptr int, 使用ptr 获取 ptr 指向的值

go
go

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！