1.main包的特殊性
传统语言中对主入口的要求是main函数，如c++/java等，只必要包管这点即可，但是在go中还必要包管main包的唯一性。
如下，在一个main包界说如下函数
package main
import "fmt"
func func1(){
fmt.Println("test func1")
}
然后在另一个main包的main函数中如下调用
package main
import "fmt"
func main(){
//实验1-实验调用同目次下另一个main包中的函数
//func1()
}
go build test_main1.cpp报错如下：
common_point\test_main1.go:63:2: undefined: func1
可以看到，两个main包现实上是相互不可见的，对于自己来说都是唯一的。必要提下的是，现实项目中，可以同一目次下包罗多个
main包，go build/run xxx指明对应main包文件编译运行即可，如果必要多个main包内容相互引用，可如下使用go build test_maijn1.cpp，test_mian2.cp。如许处理处罚的目的在于使项目布局都清晰，同时兼容一个项目存在多个入口的环境。
2.
通常在for循环中，使用break可以跳出循环，但是留意在go语言中，for select配适时，break并不能跳出循环。
如下代码：
func testSelectFor(chExit chan bool){
for {
select {
case v, ok := <-chExit:
if !ok {
fmt.Println("close channel 1", v)
break
}
fmt.Println("ch1 val =", v)
}
}
fmt.Println("exit testSelectFor")
}
如下调用：
//实验2 select for 跳出循环
c := make(chan bool)
go testSelectFor(c)
c <- true
c <- false
close(c)
time.Sleep(time.Duration(2) * time.Second)
运行效果如下，可以看到break无法跳出循环：
...
close channel 1 false
close channel 1 false
close channel 1 false
close channel 1 false
...
为了管理这个题目，必要设置标签，break 标签或goto 便签即可跳出循环，如下两种方法均可。
func testSelectFor2(chExit chan bool){
EXIT:
for {
select {
case v, ok := <-chExit:
if !ok {
fmt.Println("close channel 2", v)
break EXIT//goto EXIT2
}
fmt.Println("ch2 val =", v)
}
}
//EXIT2:
fmt.Println("exit testSelectFor2")
}
同样调用，输出效果如下：
ch2 val = true
ch2 val = false
close channel 2 false
exit testSelectFor2
3.怎样在切片中查找
go中使用sort.searchXXX方法在排序好的切片中查找指定的方法，但是其返回效果很奇怪，返回是对应的查找元素不存在时待插入的位置下标(元素插入在返回下标前)。如下调用：
//实验3 search查找返回值
s := []string{"ab", "ac", "ac", "bb", "bb", "ee"}
fmt.Println("s=", s)
fmt.Println(sort.SearchStrings(s, "aa"))
fmt.Println(sort.SearchStrings(s, "ac"))
fmt.Println(sort.SearchStrings(s, "ad"))
fmt.Println(sort.SearchStrings(s, "ff"))
返回效果如下：
s= [ab ac ac bb bb ee]
0
1
3
6
可以看到，单独根据返回值没法判断对应元素是否存在，封装如下函数：
func IsExist(s []string, t string) (int, bool) {
iIndex := sort.SearchStrings(s, t)
bExist := iIndex!=len(s) && s[iIndex]==t
return iIndex, bExist
}
这里用返回的下标取值再和原来值对比下，即可判断对应元素是否存在。
fmt.Println(IsExist(s, "aa"))
fmt.Println(IsExist(s, "ac"))
fmt.Println(IsExist(s, "ad"))
fmt.Println(IsExist(s, "ff"))
/*out
0 false
1 true
3 false
6 false*/
4.怎样初始化带嵌套布局的布局体
go的哲学是组合优于继续，使用struct嵌套即可完成组合，内嵌的布局体属性就像外层布局的属性即可，可以直接调用；但是留意初始化外层布局体时必须指定内嵌布局体名称的布局体初始化，如下看到s1方式报错，s2方式精确。
type stPeople struct {
Gender bool
Name string
}
type stStudent struct {
stPeople
Class int
}
//实验4 嵌套布局的初始化表达式
//var s1 = stStudent{false, "JimWen", 3}
var s2 = stStudent{stPeople{false, "JimWen"}, 3}
fmt.Println(s2.Gender, s2.Name, s2.Class)
5.切片和数组
go中没有特殊复杂的数据布局，焦点就是数组(array)和map，切片(slice)是基于数组的。许多人轻易肴杂array和slice的关系，这里侧重说下两者的接洽和区别以及应用场合。
先看二者的初始化方法,如下：
//slice和数组初始化方法
var a0 [5]int
a1 := [5]int{}
a2 := [5]int{1,2,3}
a3 := [...]int{1,2,3}
a4 := [5]int{1,2,3,4,5}
fmt.Println(a0, a1, a2, a3, a4)
var s0 []int
s1 := a4[0:3]
s2 := []int{1,2,3}
s3 := make([]int, 2, 3)
fmt.Println(s0==nil, s1, s2, s3)
输出如下
[0 0 0 0 0] [0 0 0 0 0] [1 2 3 0 0] [1 2 3] [1 2 3 4 5]
true [1 2 3] [1 2 3] [0 0]
可以看到，array可以如下初始化：
1.单独声明长度，会主动添补0值，如 var a0 [5]int
2.也可以初始化时赋值，末了没有填满的添补0值，如a2 := [5]int{1,2,3}
3.如果不指定长度还可以主动盘算，如a3 := [...]int{1,2,3}
而slice不关联数组是即为nil(如var s0 []int)，称为nil切片。slice要想不为空，必须和数组关联，有如下几种方法：
1.引用已有数组，如s1 := a4[0:3]
2.初始化表达式赋值，会默认天生底层数组，然后引用它，如s2 := []int{1,2,3}
3.使用make天生底层数组，数组添补0值，然后引用它，如s3 := make([]int, 2, 3)
除了引用数组的环境，slice和array初始化很轻易区别，array必须指定长度(具体数字或...)，而slice不指定长度。
前面说了slice必须关联数组，现实上看下二者的内存布局就都明确了，如下：
array在内存中是连续的块，而slice底层也是数组，只不外加了一个头，分别包罗数组起始地点、slice长度、slice容量，数组起始地点和slice长度决定了slice引用的数组范围，slice容量决定了append操纵时是否开发新的底层数组。
如下操纵：
//slice以数组为基准
v0 := [4]int{-10, 20, 30, 40}
s := v0[1:3]
fmt.Println(v0, s, &v0[1], &s[0])
//s[3] = 10 panic
s = append(s, 80)
fmt.Println(v0, s, &v0[1], &s[0])
s = append(s, 90)
fmt.Println(v0, s, &v0[1], &s[0])
效果：
[-10 20 30 40] [20 30] 0xc04200a488 0xc04200a488
[-10 20 30 80] [20 30 80] 0xc04200a488 0xc04200a488
[-10 20 30 80] [20 30 80 90] 0xc04200a488 0xc042008330
一开始s指向v0的第一个元素，包罗两个元素，slice长度为2，slice容量剩余数组元素长度3。打印效果可以看到，此时s-0和v0-1是同一个元素，即slice是指向已有array的。
然后append一个80，此时可以看到底层数组也发生了改变，这是由于slice的容量为3，当前数组还够用，以是直接用了当前数组，此时s-0和v0-1是同一个元素，即slice照旧指向已有array的。
然后再append一个90，此时可以看到此时s-0和v0-1不再是同一个元素，即slice指向了新的底层数组，由于原有数组已经不敷用了，以是新天生数组。
肯定要留意此处的逻辑，否则很轻易不鉴戒修改了底层数组或想修改底层数组而天生了新数组。
那么为什么要同时又数组和切片呢，在我看来，数组是为了提供一种底层C数组的本领，而切片相称于一种容器迭代器，可以很方便的实现动态语言的易操纵特性，同时联合二者可以实现高性能和易用性兼得。
明确了这些，看下如下题目，如下给函数changeValue1转达一个数组，修改数组元素值，然后打印，发现并没有变革。现实上go中变量赋值都是拷贝，要想实现改变可以使用数组指针changeValue2或切片changeValue3，们依然是拷贝，只不外拷贝的是地点，但是指向的依然是底层数组，以是可以或许乐成改变数组元素值，如许就包管了go中逻辑的同等性。
//数组
func changeValue1(v [5]int) {
v[0] = 100
}
//数组指针
func changeValue2(v *[5]int) {
(*v)[0] = 100
}
//切片
func changeValue3(v []int) {
v[0] = 100
}
// 转达数组参数
v1 := [5]int{-10, 20, 30, 40, 50}
changeValue1(v1)
v2 := [5]int{-10, 20, 30, 40, 50}
changeValue2(&v2)
v3 := [5]int{-10, 20, 30, 40, 50}
changeValue3(v3[0:])
fmt.Println(v1, v2, v3)
//输出
[-10 20 30 40 50] [100 20 30 40 50] [100 20 30 40 50]
同样必要留意的是for range遍历切片的时间，返回的是拷贝，要想改变对应的元素值必须使用索引来改变原来的值，如下：
//for range 对数组/切片为拷贝
v4 := [5]int{-10, 20, 30, 40, 50}
for _,v := range v4{
v = v*2 //不会改变原来值
}
for k,v := range v4{
fmt.Println(k,v)
}
for k,v := range v4{
v4[k] = v*2 //改变原来值
}
for k,v := range v4{
fmt.Println(k,v)
}
5.map布局查找是否存在键值
在其他语言中，键值不存在直策应用会报非常，但是在go语言中会返回一个0值，因此可以如下两种方法判断键值是否存在：
package main
import "fmt"
func main(){
m := map[int]string{1:"aaa", 2:"bbb", 3:"ccc", 4:"ddd", 5:"eee"}
fmt.Println(m)
v0, exist0 := m[5]
if exist0{
fmt.Println("exist key 5", v0)
} else{
fmt.Println("not exist key 5")
}
v1 := m[5]
if v1!=""{
fmt.Println("exist key 5", v0)
} else{
fmt.Println("not exist key 5")
}
}
保举几门算法的课程，一个好的开发职员算法是必修课程！
1：BAT大牛亲授 个性化保举算法实战
http://www.97yrbl.com/forum.php?mod=viewthread&tid=106&fromuid=1
(出处: 猿人部落 http://www.97yrbl.com)
2：算法大神带你玩转数据布局 从入门到醒目
http://www.97yrbl.com/forum.php?mod=viewthread&tid=104&fromuid=1
(出处: 猿人部落 http://www.97yrbl.com)
3：玩转算法口试 从真题到头脑全面提拔算法头脑
http://www.97yrbl.com/forum.php?mod=viewthread&tid=16&fromuid=1
(出处: 猿人部落 http://www.97yrbl.com )
演示代码下载链接
http://www.97yrbl.com
原创，转载请注明来自www.97yrbl.com
有疑问加站长微信联系（非本文作者）
