我的Go+语言初体验——Go+ 语言数据类型
Posted Python小白进阶
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了我的Go+语言初体验——Go+ 语言数据类型相关的知识,希望对你有一定的参考价值。
我的Go+语言初体验——(3)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 = [...]int1, 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 = []int1, 2, 3, 4, 5 // 定义 int 类型切片并赋值
var v [10]int // 定义int类型长度为 10 的数组
var slice3 []int = v[2:5] // 将数组 v 中的 2:5 元素赋值给切片
array := []int1, 2, 3, 4, 5, 6, 7, 8, 9, 10
slice4 := array[1:5] //[]int1,2,3,4
slice5 := slice4[4:7] //[]int6,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: ", Booktitle: "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)
Copyright 2021 youcans, XUPT
Crated:2021-11-29
欢迎关注『我的Go+语言初体验』系列,持续更新中…
我的Go+语言初体验——(1)超详细安装教程
我的Go+语言初体验——(2) IDE 详细安装教程
我的Go+语言初体验——(3)Go+ 数据类型
以上是关于我的Go+语言初体验——Go+ 语言数据类型的主要内容,如果未能解决你的问题,请参考以下文章