我的Go+语言初体验——（3）Go+ 语言数据类型

最新推荐文章于 2024-07-25 15:06:16 发布

youcans_

最新推荐文章于 2024-07-25 15:06:16 发布

阅读量969

点赞数 1

分类专栏：科创训练项目文章标签：开发语言 golang visual studio code 数据类型教程

本文链接：https://blog.csdn.net/youcans/article/details/121619284

版权

科创训练项目专栏收录该内容

27 篇文章 149 订阅

订阅专栏

我的Go+语言初体验——（3）Go+ 语言数据类型

“我的Go+语言初体验” | 征文活动进行中…

Go+ 语言刚刚发布，网络上还很难找到各种的支持文档和编程指南，使初学者很难深入地进行学习。
本文结合官方文档与 Go 语言的技术资料，介绍 Go+ 数据类型与基本运算符。全文内容已在 Go+ 环境下进行了测试。

1. Go+ 基本数据类型

数据类型是程序设计中重要的基本概念。在程序设计语言中，采用数据类型来描述程序中的数据结构、数据范围和数据在内存中的存储分配。

Go+ 对于数据类型有严格的定义，相同类型的值才能进行比较，兼容类型的值才能进行运算。

如果值的类型是接口（interface），必须实现相同的接口。
如果一个值是常量，那么另一个值必须与该常量的类型兼容。

1.1 布尔类型

布尔型的值只能是常量 true 或者 false。未初始化的布尔变量的初值为 false。

布尔型无法参与数值运算，也无法与其他类型进行转换。

【例程 1】

var v1 bool = true

1.2 数字类型

Go+ 语言支持整型和浮点型数字，数字类型包括：整型 int 和浮点型 float32、float64。

Go+ 语言引入了有理数类型，用后缀 “r” 表示有理数，可以支持大整数运算，包括：bigint、bigrat、bigfloat。

例如： (1r << 200) 表示 bigint ，其值等于 2 的 65 次幂；4/5r 表示有理常数 4/5。

// 有符号整数
int8 (-128 ~ 127)
int16 (-32768 ~ 32767)
int32 (-2,147,483,648 ~ 2,147,483,647)
int64 (-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807)
int (32位操作系统上 32 位，64位操作系统 64 位)

// 无符号整数
uint8 (0 ~ 255)
uint16 (0 ~ 65,535)
uint32 (0 ~ 4,294,967,295)
uint64 (0 ~ 18,446,744,073,709,551,615)
uint (32位操作系统上 32 位，64位操作系统 64 位)

// 浮点型
float32 (+/- 1e-45 ~ +/- 3.4*1e38)
float64 (+/- 5*1e-324 ~ +/- 107*1e308）

// 复数，用 "re+im I" 表示
complex64 (32 位实数和虚数)
complex128 (64 位实数和虚数)

// 有理数，用后缀 "r" 表示
bigint  // 有理数整数
bigrat  //有理数分数
bigfloat  //有理数浮点数

Go+ 语言使用 var 关键字进行变量声明。

【例程 2】

package main
import "fmt"

func main() {
	// 变量声明和初始化
	var v1 int = -1                 //声明一个整型变量 v1
	var v2 uint = 10                //声明一个无符号整型变量 v2
	var v3 float64 = 3.14           //声明一个浮点型变量 v3
	var v4 complex64 = -1.0 + 3.14i //声明一个复数变量 v4
	var v5 bigint = 1r << 65        // 声明一个有理数变量 v5
	var v6 bigrat = 4/5r            // 声明一个有理数变量 v6

	// 输出
	fmt.Println("整型变量 v1: ", v1)
	fmt.Println("无符号整型变量 v2: ", v2)
	fmt.Println("浮点型变量 v3: ", v3)
	fmt.Println("复数变量 v4: ", v4)
	fmt.Println("有理数变量 v5: ", v5)
	fmt.Println("有理数变量 v6: ", v6)
}

程序运行结果：

整型变量 v1: -1
无符号整型变量 v2: 10
浮点型变量 v3: 3.14
复数变量 v4: (-1+3.14i)
有理数变量 v5: 36893488147419103232
有理数变量 v6: 4/5

1.3 字符类型

Go+ 语言的字符类型包括： byte 类型（uint8 类型）和 rune 类型（int32 类型）。

uint8 类型（ byte 类型）用 “\x” + 2位16进制数表示，表示 ASCII 码字符；rune 类型用"\u" + 4位16进制数表示，表示 UTF-8 码字符，可以处理中文、日文或复合字符。

【例程 3】

package main
import "fmt"

func main() {
	// 变量声明和初始化
	var ch1 byte = '\x4C'   // "\x" + 2位16进制数表示
	var ch2 uint = 36       // 等价于 ASCII 数字
	var ch3 rune = '\u004C' // "\u" + 4位16进制数表示
	var ch4 int32 = '\u03B3'
	var ch5 int = '\U00101024'

	// 输出
	fmt.Printf("%d - %d\n", ch1, ch2)           // integer
	fmt.Printf("%c - %c\n", ch1, ch2)           // character
	fmt.Printf("%d - %d - %d\n", ch3, ch4, ch5) // integer
	fmt.Printf("%c - %c - %c\n", ch3, ch4, ch5) // character
	fmt.Printf("%X - %X - %X\n", ch3, ch4, ch5) // UTF-8 bytes
	fmt.Printf("%U - %U - %U", ch3, ch4, ch5)   // UTF-8 code point
}

程序运行结果：

76 - 36
L - $
76 - 947 - 1052708
L - γ - 􁀤
4C - 3B3 - 101024
U+004C - U+03B3 - U+101024

1.4 字符串类型

字符串是一串固定长度的字符连接而成的字符序列。

字符串的值是用双引号中 ” ” 包括的内容，多行字符串使用反括号 ``表示。

【例程 4】

package main
import "fmt"

func main() {
	// 变量声明和初始化
	var s1 string = "hello Go+!"
	var s2 string = "你好"
	var s3 string = `
Line 1
Line 2
Line 3`

	// 输出
	fmt.Printf("%s\n", s1)
	fmt.Printf("%s\n", s2)
	fmt.Printf("%s\n", s3)
}

程序运行结果：

hello Go+!
你好

Line 1
Line 2
Line 3

2. Go+ 扩展数据类型

2.1 指针类型

Go+ 语言的指针类型和 C/C++的指针类型用法相同，使用 “&(普通变量)” 对普通变量取内存地址后，得到指针变量，其类型为 *T，即 T 的指针类型。

针对 C/C++ 在指针运算和内存释放上的问题，Go+ 语言对指针增加了一些限制：

不同类型的指针不能互相转换，例如 int, int32 与 int64 类型的指针不能互相转换
任何普通指针类型 *T和 uintptr 之间不能互相转换
指针变量不能进行运算，例如不能对指针进行 ++, – 操作

【例程 5】

package main
import "fmt"

func main() {
	// 定义指针变量
	vint := 1    // 定义普通变量
	ptr := &vint // 定义指针变量
	fmt.Println("普通变量 vint：", vint)
	fmt.Println("普通变量 *ptr：", *ptr)
	fmt.Println("指针变量 &vint：", &vint)
	fmt.Println("指针变量 ptr：", ptr)

	vstr := "hello Go+"
	vbool := false
	vrune := 'y'
	vfloat := 3.14
	fmt.Printf("vstr 的指针类型：%T\n", &vstr)
	fmt.Printf("vint 指针类型是：%T\n", &vint)
	fmt.Printf("vbool 指针类型是：%T\n", &vbool)
	fmt.Printf("vrune 指针类型是：%T\n", &vrune)
	fmt.Printf("vfloat 指针类型是：%T\n", &vfloat)

	// 空指针
	var p *string
	fmt.Println(p)
	fmt.Printf("p的值是: %v\n", p)
}

程序运行结果：

普通变量 vint： 1
普通变量 *ptr： 1
指针变量 &vint： 0xc00000a088
指针变量 ptr： 0xc00000a088
vstr 的指针类型：*string
vint 指针类型是：*int
vbool 指针类型是：*bool
vrune 指针类型是：*int32
vfloat 指针类型是：*float64
<nil>
p的值是: <nil>

2.2 数组类型

数组是一系列同一类型数据的集合。数组也是一种数据类型，在 Go+ 语言中数组是值类型。

在 Go+ 语言中，数组类型由元素类型和数组长度两部分组成，数组长度在定义后不可更改。

数组类型定义的基本语法如下：

var 数组名 [数组大小]值的数据类型

【例程 6】

package main
import "fmt"

func main() {
	// 数组声明
	var arrayBytes [10]byte                 // 声明长度为5的数组，每个元素为一个字节；
	var arrayPointer [2]*int                // 指针数组
	var array2Dimensional [2][3]int         // 二维数组
	var array3Dimensional [2][3][4]int      // 三维数组，等同于[2]([3]([4]int))
	var arrayString [5]string               // 字符串数组
	var arrayDynamic = [...]int{1, 2, 3, 4} // 动态数组声明时需要赋值

	fmt.Println(arrayBytes)        // [0 0 0 0 0 0 0 0 0 0]
	fmt.Println(arrayPointer)      // [<nil> <nil>]
	fmt.Println(array2Dimensional) // [[0 0 0] [0 0 0]]
	fmt.Println(array3Dimensional) // [[[0 0 0 0] [0 0 0 0] [0 0 0 0]] [[0 0 0 0] [0 0 0 0] [0 0 0 0]]]
	fmt.Println(arrayString)       // [    ]
	fmt.Println(arrayDynamic)      // [1 2 3 4]
}

程序运行结果：

[0 0 0 0 0 0 0 0 0 0]
[<nil> <nil>]
[[0 0 0] [0 0 0]]
[[[0 0 0 0] [0 0 0 0] [0 0 0 0]] [[0 0 0 0] [0 0 0 0] [0 0 0 0]]]
[ ]
[1 2 3 4]

2.3 切片类型

切片是 Go+ 中的数据类型，切片是基于数组类型的抽象，其长度可以改变，也称为可变数组。

切片类型定义的基本语法如下：

var 类型名[]值的数据类型

切片的原型为：

type Slice struct {
base *elemType // 指向0th元素的指针
len int // 切片中元素的数量
cap int // 切片可以容纳元素的数量
}

【例程 7】

func main() {
	// 切片类型
	var slice []int        // 定义 int 类型切片
	slice = make([]int, 5) // 初始化切片，切片长度为5
	slice[0] = 9           // 向切片元素赋值

	var slice2 = []int{1, 2, 3, 4, 5} // 定义 int 类型切片并赋值

	var v [10]int             // 定义int类型长度为 10 的数组
	var slice3 []int = v[2:5] // 将数组 v 中的 2:5 元素赋值给切片

	array := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	slice4 := array[1:5]  //[]int{1,2,3,4}
	slice5 := slice4[4:7] //[]int{6,7,8}

	fmt.Println(slice)       // [9 0 0 0 0]
	fmt.Println(slice2)      // [1 2 3 4 5]
	fmt.Println(slice3)      // [0 0 0]
	fmt.Printf("slice4:%v,len:%d,cap:%d\n", slice4, len(slice4), cap(slice4)) // slice4:[2 3 4 5],len:4,cap:9
	fmt.Printf("slice5:%v,len:%d,cap:%d\n", slice5, len(slice5), cap(slice5)) // slice5:[6 7 8],len:3,cap:5
}

程序运行结果：

[9 0 0 0 0]
[1 2 3 4 5]
[0 0 0]
slice4:[2 3 4 5],len:4,cap:9
slice5:[6 7 8],len:3,cap:5

2.4 字典类型（map）

字典类型是由若干个 key:value 键值对组合形成的数据类型，key 和 value 可以有各自的数据类型。

字典类型的变量要经过初始化后才能赋值。

字典类型使用 map 关键字来声明，字典类型定义的基本语法如下：

var 类型名 map[key的数据类型]value的数据类型

【例程 8】

package main
import "fmt"

func main() {
	// 字典类型
	var scores1 map[string]int = map[string]int{"student1": 90, "student2": 80}

	scores2 := map[string]int{"student1": 90, "student2": 80}

	scores3 := make(map[string]int)
	scores3["student1"] = 80
	scores3["student2"] = 85

	var scores4 map[string]int     // 声明字典类型 scores
	scores4 = make(map[string]int) // 初始化字典
	scores4["student1"] = 90

	fmt.Println(scores1)  // map[student1:90 student2:80]
	fmt.Println(scores2)  // map[student1:90 student2:80]
	fmt.Println(scores3)  // map[student1:90 student2:80]
	fmt.Println(scores4)  // map[student1:90]
}

程序运行结果：

map[student1:90 student2:80]
map[student1:90 student2:80]
map[student1:90 student2:80]
map[student1:90]

2.5 结构体类型（struct）

与 C/C++ 语言类似，在 Go+ 语言中可以声明新的结构体类型，作为其它类型的属性或字段的容器。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。结构体类型是由一些列属性组成的复合数据类型，每个属性都具有名称、类型和值，结构体将属性组合在一起进行由程序进行处理。

结构体定义使用 type 和 struct 关键字来声明，需要指定其包含的属性（名和类型）。结构体类型定义的基本语法如下：

type 类型名 struct {

字段1 类型1

字段2 类型2

… }

其中 “类型名” 标识自定义结构体的名称，“字段1…” 表示结构体中的字段名，“类型1…” 表示结构体中的各个字段的类型。同一个包内的类型名不能重复，一个结构体中的字段名不能重复。

在定义结构体时可以为结构体指定结构体名（命名结构体），用于后续声明结构体变量使用。

【例程 9】

package main
import "fmt"
type Book struct {
	title  string
	author string
	press  string
	price  float64
}

func main() {
	var book1 Book                // 初始化一个 Boook 实例, book1 是一本具体的书(Object)
	fmt.Println("book1: ", book1) // {title: author: press: price}

	book1 = Book{"Go+语言", "author", "GoPress", 80.0}
	fmt.Println("book1: ", book1) // {Go+语言 author GoPress 80}

	var book2 Book = Book{
		title:  "C语言程序设计",
		author: "谭浩强",
		press:  "高等教育出版社",
		price:  50.0, // 最后一个逗号","不能省略
	}
	fmt.Println("book2: ", book2) // {C语言程序设计 谭浩强 高等教育出版社 50}

	fmt.Println("book3: ", Book{title: "Go+ Programming Language", press: "IT Press"})
	// {Go+ Programming Language  IT Press 0}, 缺少的字段为 0 或 空
}

程序运行结果：

book1: { 0}
book1: {Go+语言 author GoPress 80}
book2: {C语言程序设计谭浩强高等教育出版社 50}
book3: {Go+ Programming Language IT Press 0}

2.6 接口类型（interface）

接口类型是 Go语言的一种数据类型。接口类型是其它类型行为的概括与抽象，它把所有的具有共性的方法定义在一起，任何其它类型只要实现了这些方法就是实现了这个接口。

接口是用来定义行为的类型。这些被定义的行为不由接口直接实现，而是由用户定义的类型实现，一个实现了这些方法的具体类型是这个接口类型的实例。

接口类型使用 type 和 interface 关键字来声明。接口类型定义的基本语法如下：

/* 定义接口 */
type interface_name interface {
method_name1 [return_type]
...
method_namen [return_type]
}
/* 定义结构体 */
type struct_name struct {
/* variables */
}
/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
/* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* 方法实现*/
}

2.7 nil 类型

任何类型的变量在初始化前都对应一个初值：布尔类型的初值为 false，整型的初值为 0，字符串类型的初值为""，而指针、数组、切片、字典、结构体和接口类型的初值都是 nil。

3. 总结

本文结合官方文档与 Go 语言的技术资料，介绍 Go+ 数据类型与基本运算符。

本文的大部分内容参考 Go 语言教程进行整理。全文内容和例程都已在 Go+ 环境下进行调试和运行测试。

【本节完】

原创作品，转载必须标注原文链接：(https://blog.csdn.net/youcans/article/details/121619284)

Crated：2021-11-29

欢迎关注『我的Go+语言初体验』系列，持续更新中…

我的Go+语言初体验——（1）超详细安装教程
 我的Go+语言初体验——（2） IDE 详细安装教程
 我的Go+语言初体验——（3）Go+ 数据类型

“我的Go+语言初体验” | 征文活动进行中…

youcans_

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
我的Go+语言初体验——（3）Go+ 语言数据类型

Go+ 语言刚刚发布，网络上还很难找到各种的支持文档和编程指南，使初学者很难深入地进行学习本文结合官方文档与 Go 语言的技术资料，介绍 Go+ 数据类型与基本运算符。全文内容和例程都已在 Go+ 环境下进行调试和运行测试。
复制链接

扫一扫