一、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:%sn", 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 }
到此这篇关于go语言数据类型详细介绍的文章就介绍到这了,更多相关go数据类型内容请搜索<计算机技术网(www.ctvol.com)!!>以前的文章或继续浏览下面的相关文章希望大家以后多多支持<计算机技术网(www.ctvol.com)!!>！
需要了解更多python教程分享Go语言数据类型详细介绍，都可以关注python教程分享栏目—计算机技术网(www.ctvol.com)!
本文来自网络收集，不代表计算机技术网立场，如涉及侵权请联系管理员删除。
ctvol管理联系方式QQ:251552304
本文章地址：https://www.ctvol.com/pythontutorial/1069819.html