[GO专栏-4]Go语言数据类型
Go 语言数据类型包含基础类型和复合类型两大类。
基础类型包括:
-
布尔类型
bool
。 -
数值类型
int
,int8
,int16
,int32
,int64
,float32
,float64
。 -
uint8
,uint16
,uint32
,uint64
。 -
字符串
string
,byte
,rune
。
复合类型包括:
指针
、数组
、切片
、字典
、通道
、结构体
、接口
。
下面用代码加注释的方式说明:
基础类型
声明一个bool类型的变量,只有true和false两个值,初始值为false
var isLogin bool
// 声明一个int类型的变量,初始值为0
//(int8,int16,int32 uint8,uint16....类似,只是有符号和无符号的区别)
// 最常用的就是int,如果需要更大的范围可以用int64或者uint64
var count int
// 声明一个string类型的变量,初始值为""
var s string
//声明一个byte类型的变量
var b byte
//声明一个rune类型的变量
//int32的别名,表示单个Unicode字符
var r rune
复合类型
指针
go的指针和c语言的指针类型,都是表示一个变量的地址,不同的是,go的指针要比c的指针简单的多,老规矩,代码注释,如下:
package main
import "fmt"
func main() {
var count = 100 //定义变量count
var ptr *int //定义一个指针ptr,此指针可以保存int类型变量的地址
ptr = &count //ptr保存的是变量count的地址, & 符号是取变量地址的符号
fmt.Println("count=",count) //打印count的值
fmt.Println("ptr=", *ptr) //打印ptr指向的变量的值,此句打印100
}
运行结果如下:
count= 100
ptr= 100
数组(array)
数组为一组相同数据类型数据的集合,大小固定,不能更改,每个元素称为element
,声明的数组元素默认值都是对应类型的0值。而且数组在Go语言中是一个值类型(value type)
所有值类型变量在赋值和作为参数传递时都会产生一次复制动作,即对原值的拷贝
package main
import "fmt"
func main() {
// 1.声明后赋值 (var <数组名称> [<数组长度>]<数组元素>)
var arr [2]int // 数组元素的默认值都是 0
fmt.Println(arr) // 输出:[0 0]
arr[0] = 1
arr[1] = 2
fmt.Println(arr) // 输出:[1 2]
// 2.声明并赋值 (var <数组名称> = [<数组长度>]<数组元素>{元素1,元素2,...})
var intArr = [2]int{1, 2}
strArr := [3]string{`aa`, `bb`, `cc`}
fmt.Println(intArr) // 输出:[1 2]
fmt.Println(strArr) // 输出:[aa bb cc]
// 3.声明时不设定大小,赋值后语言本身会计算数组大小
// var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{元素1,元素2,...}
var arr1 = [...]int{1, 2}
arr2 := [...]int{1, 2, 3}
fmt.Println(arr1) // 输出:[1 2]
fmt.Println(arr2) // 输出:[1 2 3]
//arr1[2] = 3 // 编译报错,数组大小已设定为2
// 4.声明时不设定大小,赋值时指定索引
// var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{索引1:元素1,索引2:元素2,...}
var arr3 = [...]int{1: 22, 0: 11, 2: 33}
arr4 := [...]string{2: "cc", 1: "bb", 0: "aa"}
fmt.Println(arr3) // 输出:[11 22 33]
fmt.Println(arr4) // 输出:[aa bb cc]
// 遍历数组
for i := 0; i < len(arr4); i++ {
v := arr4[i]
fmt.Printf("i:%d, value:%s\n", i, v)
}
}
切片(slice)
因为数组的长度定义后不可修改,所以需要切片来处理可变长数组数据。切片可以看作是一个可变长的数组,是一个引用类型。它包含三个数据:
-
指向原生数组的指针
-
切片中的元素个数
-
切片已分配的存储空间大小
注:了解c++和java的同学,可以参考vector
和List
,切片就是类似这两个数据结构,直接上代码:
package main
import "fmt"
func main() {
var sl []int // 声明一个切片
sl = append(sl, 1, 2, 3) // 往切片中追加值
fmt.Println(sl) // 输出:[1 2 3]
var arr = [5]int{1, 2, 3, 4, 5} // 初始化一个数组
var sl1 = arr[0:2] // 冒号:左边为起始位(包含起始位数据),右边为结束位(不包含结束位数据);不填则默认为头或尾
var sl2 = arr[3:]
var sl3 = arr[:5]
fmt.Println(sl1) // 输出:[1 2]
fmt.Println(sl2) // 输出:[4 5]
fmt.Println(sl3) // 输出:[1 2 3 4 5]
sl1 = append(sl1, 11, 22) // 追加元素
fmt.Println(sl1) // 输出:[1 2 11 22]
}
使用make
关键字直接创建切片,语法:make([]类型, 大小,预留空间大小)
,make() 函数
用于声明slice切片
、map字典
、channel通道
。如下:
package main
import "fmt"
func main() {
var s1 = make([]int, 5) // 定义元素个数为5的切片
s2 := make([]int, 5, 10) // 定义元素个数5的切片,并预留10个元素的存储空间(预留空间不知道有什么用?)
s3 := []string{`aa`, `bb`, `cc`} // 直接创建并初始化包含3个元素的数组切片
fmt.Println(s1, len(s1)) // 输出:[0 0 0 0 0] 5
fmt.Println(s2, len(s2)) // 输出:[0 0 0 0 0] 5
fmt.Println(s3, len(s3)) // [aa bb cc] 3
s1[1] = 1 // 声明或初始化大小中的数据,可以指定赋值
s1[4] = 4
//s1[5] = 5 // 编译报错,超出定义大小
s1 = append(s1, 5) // 可以追加元素
fmt.Println(s1, len(s1)) // 输出:[0 1 0 0 4 5] 6
s2[1] = 1
s2 = append(s2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
fmt.Println(s2, len(s2)) // 输出:[0 1 0 0 0 1 2 3 4 5 6 7 8 9 10 11] 16
// 遍历切片
for i := 0; i < len(s2); i++ {
v := s2[i]
fmt.Printf("i: %d, value:%d \n", i, v)
}
}
字典/映射(map)
map
是一种键值对的无序集合,与 slice 类
似也是一个引用类型。map
本身其实是个指针,指向内存中的某个空间。
声明方式与数组类似,声明方式:var 变量名
map[key类型
值类型 或直接使用 make 函数
初始化:make(map[key类型]值类型
, 初始空间大小)。
其中key值
可以是任何可以用==判断的值类型,对应的值类型没有要求。 直接上代码,如下:
package main
import (
"fmt"
"unsafe"
)
func main() {
// 声明后赋值
var m map[int]string
fmt.Println(m) // 输出空的map:map[]
//m[1] = `aa` // 向未初始化的map中赋值报错:panic: assignment to entry in nil map
// 声明并初始化,初始化使用{} 或 make 函数(创建类型并分配空间)
var m1 = map[string]int{}
var m2 = make(map[string]int)
m1[`a`] = 11
m2[`b`] = 22
fmt.Println(m1) // 输出:map[a:11]
fmt.Println(m2) // 输出:map[b:22]
// 初始化多个值
var m3 = map[string]string{"a": "aaa", "b": "bbb"}
m3["c"] = "ccc"
fmt.Println(m3) // 输出:map[a:aaa b:bbb c:ccc]
// 删除 map 中的值
delete(m3, "a") // 删除键 a 对应的值
fmt.Println(m3) // 输出:map[b:bbb c:ccc]
// 查找 map 中的元素
v, ok := m3["b"]
if ok {
fmt.Println(ok)
fmt.Println("m3中b的值为:", v) // 输出:m3中b的值为: bbb
}
// 或者
if v, ok := m3["b"]; ok { // 流程处理后面讲
fmt.Println("m3中b的值为:", v) // 输出:m3中b的值为: bbb
}
fmt.Println(m3["c"]) // 直接取值,输出:ccc
// map 中的值可以是任意类型
m4 := make(map[string][5]int)
m4["a"] = [5]int{1, 2, 3, 4, 5}
m4["b"] = [5]int{11, 22, 33}
fmt.Println(m4) // 输出:map[a:[1 2 3 4 5] b:[11 22 33 0 0]]
fmt.Println(unsafe.Sizeof(m4)) // 输出:8,为8个字节,map其实是个指针,指向某个内存空间
}
通道(channel)
说到通道 channel
,则必须先了解下 Go 语言的 goroutine 协程(轻量级线程)
。channel
就是为 goroutine 间通信提供通道
。goroutine
是 Go 语言提供的语言级的协程,是对 CPU 线程
和调度器的一套封装。
channel
也是类型相关的,一个 channel
只能传递一种类型的值。
声明:var 通道名 chan 通道传递值类型 或 make 函数初始化:make(chan 值类型, 初始存储空间大小)
说白了,通道类似消息队列,主要应用在并发编程里面比较多,直接上代码,如下:
package main
import (
"fmt"
"time"
)
func main() {
var ch1 chan int // 声明一个通道
ch1 = make(chan int) // 未初始化的通道不能存储数据,初始化一个通道
ch2 := make(chan string, 2) // 声明并初始化一个带缓冲空间的通道
// 通过匿名函数向通道中写入数据,通过 <- 方式写入
go func() { ch1 <- 1 }()
go func() { ch2 <- `a` }()
v1 := <-ch1 // 从通道中读取数据
v2 := <-ch2
fmt.Println(v1) // 输出:1
fmt.Println(v2) // 输出:a
// 写入,读取通道数据
ch3 := make(chan int, 1) // 初始化一个带缓冲空间的通道
go readFromChannel(ch3)
go writeToChannel(ch3)
// 主线程休眠1秒,让出执行权限给子 Go 程,即通过 go 开启的 goroutine,不然主程序会直接结束
time.Sleep(1 * time.Second)
}
func writeToChannel(ch chan int) {
for i := 1; i < 10; i++ {
fmt.Println("写入:", i)
ch <- i
}
}
func readFromChannel(ch chan int) {
for i := 1; i < 10; i++ {
v := <-ch
fmt.Println("读取:", v)
}
}
运行结果如下:
// ------ 输出:--------
1
a
写入: 1
写入: 2
写入: 3
读取: 1
读取: 2
读取: 3
写入: 4
写入: 5
写入: 6
读取: 4
读取: 5
读取: 6
写入: 7
写入: 8
写入: 9
读取: 7
读取: 8
读取: 9
goroutine
和 channel
的详细用法会有相应的博客专门来讲这一章节,具体可在我的个人主页里面,找一下相关的博客参考。
结构体(struct)
结构体是一种聚合的数据类型,是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员,和java中的class是一个意思:
package main
import "fmt"
// 定义一个结构体 person
type person struct {
name string
age int
}
func main() {
var p person // 声明一个 person 类型变量 p
p.name = "max" // 赋值
p.age = 12
fmt.Println(p) // 输出:{max 12}
p1 := person{name: "mike", age: 10} // 直接初始化一个 person
fmt.Println(p1.name) // 输出:mike
p2 := new(person) // new函数分配一个指针,指向 person 类型数据
p2.name = `张三`
p2.age = 15
fmt.Println(*p2) // 输出:{张三 15}
}
接口(interface)
接口用来定义行为。Go 语言不同于面向对象语言,没有类的概念,也没有传统意义上的继承。Go 语言中的接口,用来定义一个或一组行为,某些对象实现了接口定义的行为,则称这些对象实现了(implement
)该接口,类型即为该接口类型。
定义接口也是使用 type 关键字
,格式为:
// 定义一个接口
type InterfaceName interface {
FuncName1(paramList) returnType
FuncName2(paramList) returnType
...
}
实列:
package main
import (
"fmt"
"strconv"
)
// 定义一个 Person 接口
type Person interface {
Say(s string) string
Walk(s string) string
}
// 定义一个 Man 结构体
type Man struct {
Name string
Age int
}
// Man 实现 Say 方法
func (m Man) Say(s string) string {
return s + ", my name is " + m.Name
}
// Man 实现 Walk 方法,strconv.Itoa() 数字转字符串
func (m Man) Walk(s string) string {
return "Age: " + strconv.Itoa(m.Age) + " and " + s
}
func main() {
var m Man // 声明一个类型为 Man 的变量
m.Name = "Mike" // 赋值
m.Age = 30
fmt.Println(m.Say("hello")) // 输出:hello, my name is Mike
fmt.Println(m.Walk("go work")) // 输出:Age: 30 and go work
jack := Man{Name: "jack", Age: 25} // 初始化一个 Man 类型数据
fmt.Println(jack.Age)
fmt.Println(jack.Say("hi")) // 输出:hi, my name is jack
}
错误(error)
error 类型
本身是 Go 语言内部定义好的一个接口,接口里定义了一个 Error()
打印错误信息的方法,源码如下:
type error interface {
Error() string
}
自定义错误信息:
package main
import (
"errors"
"fmt"
)
func main() {
// 使用 errors 定制错误信息
var e error
e = errors.New("This is a test error")
fmt.Println(e.Error()) // 输出:This is a test error
// 使用 fmt.Errorf() 定制错误信息
err := fmt.Errorf("This is another error")
fmt.Println(err) // 输出:This is another test error
}
💫点击直接资料领取💫
这里有各种学习资料还有有有趣好玩的编程项目,更有难寻的各种资源。