必看的题目:https://blog.csdn.net/weiyuefei/article/details/77963810
1、关于值传递、引用传递与指针传递
false : bool, 0: integer 0.0: float "": string nil : pointer, function, interface, slice, channel, map
对于复合类型, go语言会自动递归地将每一个元素初始化为其类型对应的零值。比如:数组, 结构体。
nil 是专门为go语言的指针类型和引用类型准备的,go语言的数组和结构体可是值类型, 切片、字典或通道为引用类型。所以如果数组作为函数参数时,因为是值类型, 所以要复制 。
nil 可以用作 interface、function、pointer、map、slice 和 channel 的“空值”
在go语言中没有引用传递,只有值传递。
例1:值传递
func main() { a := []string{"a", "b"} test(a) fmt.Println(a) } func test(b []string) { b = []string{"cc", "cc"} }
打印出来后值为:[a b],表明在传递时是复制了一份单独的数组结构。
指针传递也是值传递。
例2:指针传递,也是值传递
func main() { a := &[]string{"a", "b"} test(a) fmt.Println(*a) } func test(b *[]string) { b = nil }
打印出来后为:[a b]。传递指针时,能修改指针所指向的值,并不能修改指针本身的值。
传引用
var a Object modify(a) // 修改a的值 print(a)
如果函数modify
修改a
的值, 然后print
打印出来的也是修改后的值,那么就可以认为modify是通过引用的方式使用了参数a。而如上例子证明了指明传递是值传递。
例3:引用传递
func main() { a := new(int) fmt.Println(a) func() { a = nil }() fmt.Println(a) }
打印结果为:
0xc042008220
<nil>
关于指针传递与引用传递参考:https://studygolang.com/articles/4810
2、关于go中的map
go语言中的map不是协程安全的,如果要多个协程对同 一个map进行写操作,则会出错:
fatal error: concurrent map writes
举例:
func main() { Map := make(map[int]int) for i := 0; i < 100000; i++ { go writeMap(Map, i, i) go readMap(Map, i) } } func readMap(Map map[int]int, key int) int { return Map[key] } func writeMap(Map map[int]int, key int, value int) { Map[key] = value }
因为map为引用类型,所以即使函数传值调用,参数副本依然指向映射m, 所以N个goroutine并发写同一个映射m,共享资源会遭到破坏。
解决办法就是加锁,或者channel排队串行化。
例2:
type S struct { I int } func main() { m := map[string]S{ "a": S{1}, } m["a"].I = 5 // cannot assign to struct field m["a"].I in map }
对于一个struct值的map,你无法更新单个的struct值。因为只有变量才可以赋值,变量的定义里包括了array和slice的下标表达式,但是不包括map的下标表达式。
go中的map输出是无序的,如下:
m := make(map[int]int) m[0] = 0 m[1] = 1 m[2] = 2 m[3] = 3 m[4] = 4 for k,v := range m{ fmt.Printf("map[%d = %d\n",k,v) }
(4)map中的元素不是变量,因此不能寻址!!
参考:https://blog.csdn.net/erlib/article/details/50963152
3、关于初始化make与new
1、make用于内建类型(map、slice 和channel)的内存分配。new用于各种类型的内存分配。
2、new(T)分配了零值填充的T类型的内存空间,并且返回其地址,即一个*T类型的值。用Go的术语说,它返回了一个指针,指向新分配的类型T的零值。有一点非常重要:new返回指针。
3、make只能创建slice、map和channel,并且返回一个有初始值(非零)的T类型(引用类型),而不是*T。本质来讲,导致这三个内建类型有所不同的原因是:引用在使用前必须被初始化。例如,一个slice,是一个包含指向数据(内部array)的指针、长度和容量的三项描述符;在这些项目被初始化之前,slice为nil。对于slice、map和channel来说,make初始化了内部的数据结构,填充适当的值。make返回初始化后的(非零)值。
例1:
type X struct { a int } type T struct { i int; f float64; next *T x X y *X }
则:
(1)new(T) 结果:&{0 0 <nil> {0} <nil>}
(2)mySlice1 := make([]T, 1) 结果:[{0 0 <nil> {0} <nil>}]
(3)mySlice1 := make([]T, 2,5) 结果:[{0 0 <nil> {0} <nil>} {0 0 <nil> {0} <nil>}]
(4)mySlice1 := make([]*T, 2,5) 结果: [<nil> <nil>]
(5)t := new(*T) 则*t为nil
(6)t := new([]T) 结果:&[]
(7)t := new([]*T) 结果为:&[]
make在初始化一个切片时,如:
a := make([]int, 5, 10) // 注意这样是初始化了一个切片类型
则第一个参数为len,第二个为cap。长度是指已经被赋过值的最大下标+1,可通过内置函数len()获得。容量是指切片目前可容纳的最多元素个数,可通过内置函数cap()获得
4、数组Array与切片Slice
数组举例如下:
var arr [5]int var arr [5]int{1,2,3,4,5} var arr [...]int{1,2,3,4,5}
数组只是连续的内存块,如果你去阅读 Go 运行时的源码(src/runtime/malloc.go),你会发现创建一个数组本质上就是分配了一块指定大小的内存。数组元素总是会初始化为指定类型的 零值
切片举例如下:
var foo []int
切片的数据结构包括 3 个部分 - 指向数组的指针、切片的长度和切片的容量:
type slice struct { array unsafe.Pointer len int cap int }
当创建一个新的切片时,Go 运行时会在内存里创建这样一个包含 3 块区域的对象,并且会把数组指针初始化为 nil
,len
和 cap
初始化为 0。
可以用 make
来初始化一个指定大小的切片:
foo = make([]int, 5)
这段代码会创建一个切片,包含了一个 5 个元素的数组,每个元素的初值为 0,len
和 cap
的初值则为 5。
Cap 是指切片大小可以达到的上限,以便为未来可能的增长留出空间。可以用 make([]int, len, cap)
语法来指定容量。
关于切片与数组需要注意:
(1)如果你要更改切片中某些元素的值,实际上是在改变切片指向的数组元素的值。
举例:
func main() { foo := make([]int, 5) foo[3] = 42 foo[4] = 100 fmt.Println(foo) bar := foo[1:4] bar[1] = 99 fmt.Println(foo) fmt.Println(bar) }
打印结果如下:
[0 0 0 42 100]
[0 0 99 42 100]
[0 99 42]
(2)切片函数append 注意是追加
例2:
func main() { s := make([]int, 3) s = append(s, 1, 2, 3) fmt.Println(s) }
结果如下:[0 0 0 1 2 3]
(3) 数组扩容
当切片的容量不够用时,会开辟一个新的数组,然后将原来数组中的值复制到新数组中,这样就改变了切片指向的底层数组:
a := make([]int, 16) b1 := a[1:8] // 在a[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]上进行切片操作 a = append(a, 1) // 追加元素导致底层的数组变为了新的,而旧的仍然为16个0 a[2] = 42 fmt.Println(a) // [0 0 42 0 0 0 0 0 0 0 0 0 0 0 0 0 1] b2 := a[1:8] // 在新的上进行切片操作,此时的a为[0 0 42 0 0 0 0 0 0 0 0 0 0 0 0 0 1] fmt.Println(b1) // [0 0 0 0 0 0 0] fmt.Println(b2) // [0 42 0 0 0 0 0]
由于切片由于底层是指向数组,所以无法知道这个切片到底耗费了多少内存。
5、for range
转载地址: https://www.cnblogs.com/hetonghai/p/6718250.html
go只提供了一种循环方式,即for循环,在使用时可以像c那样使用,也可以通过for range方式遍历容器类型如数组、切片和映射。但是在使用for range时,如果使用不当,就会出现一些问题,导致程序运行行为不如预期。比如,下面的示例程序将遍历一个切片,并将切片的值当成映射的键和值存入,切片类型是一个int型,映射的类型是键为int型,值为*int,即值是一个地址。
package main import "fmt" func main() { slice := []int{0, 1, 2, 3} myMap := make(map[int]*int) for index, value := range slice { myMap[index] = &value } fmt.Println("=====new map=====") prtMap(myMap) } func prtMap(myMap map[int]*int) { for key, value := range myMap { fmt.Printf("map[%v]=%v\n", key, *value) } }
运行程序输出如下:
=====new
map
=====
map
[3]=3
map
[0]=3
map
[1]=3
map
[2]=3
=====new
map
=====
map
[0]=0
map
[1]=1
map
[2]=2
map
[3]=3
但是由输出可以知道,映射的值都相同且都是3。其实可以猜测映射的值都是同一个地址,遍历到切片的最后一个元素3时,将3写入了该地址,所以导致映射所有值都相同。其实真实原因也是如此,因为for range创建了每个元素的副本,而不是直接返回每个元素的引用,如果使用该值变量的地址作为指向每个元素的指针,就会导致错误,在迭代时,返回的变量是一个迭代过程中根据切片依次赋值的新变量,所以值的地址总是相同的,导致结果不如预期。
package main import "fmt" func main() { slice := []int{0, 1, 2, 3} myMap := make(map[int]*int) for index, value := range slice { num := value myMap[index] = &num } fmt.Println("=====new map=====") prtMap(myMap) } func prtMap(myMap map[int]*int) { for key, value := range myMap { fmt.Printf("map[%v]=%v\n", key, *value) } }
运行程序输出如下:
=====new
map
=====
map
[2]=2
map
[3]=3
map
[0]=0
map
[1]=1
type Job struct { dsp_id string out chan Job } func main() { jobs := []Job{} num := 2 for i:= 0;i<num;i++{ job := Job{ dsp_id:"i" } jobs = append(jobs,job) } jobChannel := make(chan Job,num) for _,j := range jobs{ j.out = jobChannel } for _,j := range jobs{ fmt.Println(j) // 打印结果没有out值 } }
输出结果为:
{i <nil>}
{i <nil>}
6、defer、return和返回值之间的执行顺序
func main() { fmt.Println("return:", a()) // 打印结果为 return: 0 fmt.Println("return:", b()) // 打印结果为 return: 2 fmt.Println("c return:", *(c())) // 打印结果为 c return: 2 } func a() int { var i int defer func() { i++ fmt.Println("defer2:", i) // 打印结果为 defer: 2 }() defer func() { i++ fmt.Println("defer1:", i) // 打印结果为 defer: 1 }() // 函数的返回值没有被提前声明,其值来自于其他变量的赋值, // 而defer中修改的也是其他变量,而非返回值本身,因此函数 // 退出时返回值并没有被改变。 return i } func b() (i int) { defer func() { i++ fmt.Println("defer2:", i) // 打印结果为 defer: 2 }() defer func() { i++ fmt.Println("defer1:", i) // 打印结果为 defer: 1 }() // 函数的返回值被提前声明,也就意味着defer中是可以调用到真实 // 返回值的,因此defer在return赋值返回值 i 之后,再一次地修改 // 了 i 的值,最终函数退出后的返回值才会是defer修改过的值。 return i // 或者直接 return 效果相同 } func c() *int { var i int defer func() { i++ fmt.Println("c defer2:", i) // 打印结果为 c defer: 2 }() defer func() { i++ fmt.Println("c defer1:", i) // 打印结果为 c defer: 1 }() // 虽然 c()*int 的返回值没有被提前声明,但是由于 c()*int 的 // 返回值是指针变量,那么在return将变量 i 的地址赋给返回值后, // defer再次修改了 i 在内存中的实际值,因此函数退出时返回值 // 虽然依旧是原来的指针地址,但是其指向的内存实际值已经被成功修改了。 return &i }
需要掌握2个要点:
- 多个defer的执行顺序为“后进先出”;
- defer、return、返回值三者的执行逻辑应该是:return最先执行,return负责将结果写入返回值中;接着defer开始执行一些收尾工作;最后函数携带当前返回值退出。
7、一定要理解go的接口与实现类
type People interface { Speak(string) string } type Stduent struct{} func (stu *Stduent) Speak(think string) (talk string) { if think == "bitch" { talk = "You are a good boy" } else { talk = "hi" } return } func main() { var peo People = &Stduent{} // 注意这里必须Student的对象的指针类型 think := "bitch" fmt.Println(peo.Speak(think)) }
8、比较结构体类型
// 进行结构体比较时候,只有相同类型的结构体才可以比较, // 结构体是否相同不但与属性类型个数有关,还与属性顺序相关 func main() { sn1 := struct { age int name string }{age: 11, name: "qq"} sn2 := struct { age int name string }{age: 11, name: "qq"} if sn1 == sn2 { fmt.Println("sn1 == sn2") // 打印 } sm1 := struct { age int m map[string]string }{age: 11, m: map[string]string{"a": "1"}} sm2 := struct { age int m map[string]string }{age: 11, m: map[string]string{"a": "1"}} // 报错,结构体中有不可比较的类型,如引用类型map与slice //if sm1 == sm2 { // fmt.Println("sm1 == sm2") //} if reflect.DeepEqual(sm1, sm2) { fmt.Println("sm1 == sm2") // 打印 } else { fmt.Println("sm1 != sm2") } }
9、go字符串的遍历输出
https://blog.csdn.net/benben_2015/article/details/78904860