You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
package main
import (
"fmt"
)
func main() {
pase_student()
}
type student struct {
Name string
Age int
}
func pase_student() {
m := make(map[string]*student)
stus := []student{
{Name: "zhou", Age: 24},
{Name: "li", Age: 23},
{Name: "wang", Age: 22},
}
for i, stu := range stus {
m[stu.Name] = &stu; // 应该改为m[stu.Name] = &stus[i]
}
for _, va := range m {
fmt.Printf("%p \n", va)
}
}
field1, offset := nextField(str, 0)
field2, offset := nextField(str, offset) // redeclares offset
a, a := 1, 2 // illegal: double declaration of a or no new variable if a was declared elsewhere
package main
import (
"time"
"math/rand"
"sync"
"log"
"strconv"
)
func main() {
rand.Seed(time.Now().UnixNano())
log.SetFlags(0)
// ...
const MaxRandomNumber = 100000
const NumReceivers = 10
const NumSenders = 1000
wgReceivers := sync.WaitGroup{}
wgReceivers.Add(NumReceivers)
// ...
dataCh := make(chan int, 100)
stopCh := make(chan struct{})
// stopCh is an additional signal channel.
// Its sender is the moderator goroutine shown below.
// Its reveivers are all senders and receivers of dataCh.
toStop := make(chan string, 1)
// 设为缓冲1是为了防止moderator还未准备好就停止了
// the channel toStop is used to notify the moderator
// to close the additional signal channel (stopCh).
// Its senders are any senders and receivers of dataCh.
// Its reveiver is the moderator goroutine shown below.
var stoppedBy string
// moderator
go func() {
stoppedBy = <- toStop // part of the trick used to notify the moderator
// to close the additional signal channel.
close(stopCh)
}()
// senders
for i := 0; i < NumSenders; i++ {
go func(id string) {
for {
value := rand.Intn(MaxRandomNumber)
if value == 0 {
// here, a trick is used to notify the moderator
// to close the additional signal channel.
select {
case toStop <- "sender#" + id:
default:
}
return
}
// the first select here is to try to exit the
// goroutine as early as possible.
select {
case <- stopCh:
return
default:
}
// 为什么要在前面在加一个select stopCh呢? 因为若是到了这一步由于select的随机性（此时stopCh和dataCh都处于活跃状态select是随机选取的），有可能会继续发送，而没有选择stopCh
select {
case <- stopCh:
return
case dataCh <- value:
}
}
}(strconv.Itoa(i))
}
// receivers
for i := 0; i < NumReceivers; i++ {
go func(id string) {
defer wgReceivers.Done()
for {
// same as senders, the first select here is to
// try to exit the goroutine as early as possible.
select {
case <- stopCh:
return
default:
}
select {
case <- stopCh:
return
case value := <-dataCh:
if value == MaxRandomNumber-1 {
// the same trick is used to notify the moderator
// to close the additional signal channel.
select {
case toStop <- "receiver#" + id:
default:
}
return
}
log.Println(value)
}
}
}(strconv.Itoa(i))
}
// ...
wgReceivers.Wait()
log.Println("stopped by", stoppedBy)
}
package main
func main() {
for i:=0;i<10 ;i++ {
loop:
println(i)
}
goto loop
}
注意 defintion 和 type alias 的区别 defintion 是定义了一个新的类型，alias 仅仅是个别名
package main
import "fmt"
func main() {
type MyInt1 int
type MyInt2 = int
var i int =9
var i1 MyInt1 = i // 错误 MyInt1是个新类型
var i2 MyInt2 = i // yes 是个别名
fmt.Println(i1,i2)
}
new allocate the memory and return the pointer 分配内存并且赋予零值
make allocate the memory and initialize the memory cause slice, map and channel must be initialized before use
new 的作用是 初始化 一个指向类型的指针 (T)， make 的作用是为 slice, map 或者 channel 初始化，并且返回引用 T
make(T, args)函数的目的与 new(T)不同。它仅仅用于创建 Slice, Map 和 Channel，并且返回类型是 T（不是 T）的一个初始化的（不是零值）的实例。 这中差别的出现是由于这三种类型实质上是对在使用前必须进行初始化的数据结构的引用。 例如, Slice 是一个 具有三项内容的描述符，包括 指向数据（在一个数组内部）的指针，长度以及容量。在这三项内容被初始化之前，Slice 的值为 nil。对于 Slice，Map 和 Channel， make（）函数初始化了其内部的数据结构，并且准备了将要使用的值。
var x float64 = 3.4
v := reflect.ValueOf(x)
v.SetFloat(7.1) // Error: will panic.
yes
var x float64 = 3.4
p := reflect.ValueOf(&x) // Note: take the address of x.
fmt.Println("type of p:", p.Type())
fmt.Println("settability of p:", p.CanSet())
func readSlice() {
reader := bufio.NewReader(strings.NewReader("http://studygolang.com.\nIt is the home of gophers"))
line, _ := reader.ReadSlice('\n')
fmt.Println("the line is ", string(line))
n, _ := reader.ReadSlice('\n')
fmt.Println(string(n), string(line))
}
func ReadSliceSize() {
reader := bufio.NewReaderSize(strings.NewReader("http://studygolang.com.\nIt is the home of gophers"), 10)
line, _ := reader.ReadSlice('\n')
fmt.Println("the line is ", string(line))
n, _ := reader.ReadSlice('\n')
fmt.Println(string(n), string(line))
}
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
也就是说转化为[]byte以后 只有Data的地址，Len和Cap的值被转化为了字节
string 和 []byte 无copy转换
// reflect.SliceHeader and reflect.StringHeader
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
type StringHeader struct {
Data uintptr
Len int
}
/*
struct string{
uint8 *str;
int len;
}
struct []uint8{
uint8 *array;
int len;
int cap;
}
uintptr是golang的内置类型，是能存储指针的整型，uintptr的底层类型是int，它和unsafe.Pointer可相互转换。
但是转换后的string与[]byte共享底层空间，如果修改了[]byte那么string的值也会改变，就违背了string应该是只读的规范了，可能会造成难以预期的影响。
*/
func str2byte(s string) []byte {
x := (*[2]uintptr)unsafe.Pointer(&s)
h := [3]uintptr{x[0],x[1],x[1]}
return *(*[]byte)(unsafe.Pointer(&h))
}
func byte2str(b []byte) string{
return *(*string)(unsafe.Pointer(&b))
}
golang json问题
json tag json:"name,omitempty,type" json: "name,[option]"
int 为0时，若tag 为omitempty, int会不被序列化出来， omitempty，tag里面加上omitempy，可以在序列化的时候忽略0值或者空值
解决办法是使用 指针
type Test struct {
String *string `json:"string,omitempty"`
Integer *int `json:"integer,omitempty"`
}
int8 byte uint8 json序列化的时候 会被当做字符串处理
type CA struct {
List []uint8
}
func main() {
ca := CA{[]uint8{1,2,3,4,5,6,7,8,9,0}}
r, _ := json.Marshal(ca)
fmt.Println(string(r)) //{"List":"AQIDBAUGBwgJAA=="}
}
当我们想给某操作加缓冲区时就可以使用bytes.Buffer
只有make的map才可以赋值， new的是不行的, var声明的也不行
package main
import "fmt"
type Param map[string]int
type Show struct {
Param
}
func main() {
s := new(Show)
fmt.Println("dj ", s.Param)
s.Param["dengjie"] = 123
}
// 报错
可被json处理都是对外的字段
type People struct {
name string `json:"name"`
}
func main() {
js := `{
"name":"11"
}`
var p People
err := json.Unmarshal([]byte(js), &p)
if err != nil {
fmt.Println("err: ", err)
return
}
fmt.Println("people: ", p)
}
// {} 因为name是小写开头未暴露
type People struct {
Name string
}
func (p *People) String() string {
return fmt.Sprintf("print: %v", p)
}
func main() {
p := &People{}
p.String()
}
send on closed channel
func main() {
ch := make(chan int, 1000)
go func() {
for i := 0; i < 10; i++ {
ch <- i
}
}()
go func() {
for {
a, ok := <-ch
if !ok {
fmt.Println("close")
return
}
fmt.Println("a: ", a)
}
}()
close(ch)
fmt.Println("ok")
time.Sleep(time.Second * 100)
}
类型断言
type student struct {
Name string
}
func zhoujielun(v interface{}) {
switch msg := v.(type) {
case *student, student:
msg.Name
}
}
// 错误 因为 v.(type)返回的是v的类型，是interface{}， 不能操作，v.(student).Name才可以
type ExecuterList struct {
sync.Map
length int
}
func (e ExecuterList) Get(key string) IExecuter {
value, ok := e.Load(key)
if !ok {
return nil
}
if value == nil {
return nil
}
res, _ := value.(IExecuter)
return res
}
使用 go tool vet ，出现“Get passes lock by value: ExecuterList contains sync.Map contains sync.Mutex”， 解决方案有两种：
golang的接口实现定义是结构化的定义，即实现了接口定义的方法那就是实现了该接口，但有的时候我们不希望其他人无意间实现了我们的接口怎么办？ 如下手动。。。
这个位置我觉得可以学习一下pony语言增加结构型接口和命名接口 参见, 就是即有像go的interface又有rust的traits。
golang 的所有的都是 copy 赋值，=，传参，channel 发送等等都是。
:= 这种声明方式若是已经定义了，则不会新建
stus 是个 map, stu 并不会每次新生成一个, 其实循环时每次都是相同的 stu, 而且 golang 每次都是 copy 语义，你再看一眼会发现，给 map 赋值的是指针，那就意味着无论你如何改变 map 都会是相同的值。:= 多次声明不会重新定义新的变量， 可见规范
见下:
golang 的字符串是不可变的，要想使用可变字符串可以使用 bytes，或者[]rune 数组, string 类型不可变，他的 slice 也不可变
我们可以从关闭的 channel 中读取数据但是为空，就是说若是在 select 语句 case 中从关闭的 channel 是可以的。 参见
在使用 Go channel 的时候，一个适用的原则是不要从接收端关闭 channel，也不要关闭有多个并发发送者的 channel。 优雅关闭 go channel(http://www.tapirgames.com/blog/golang-channel-closing)
channel 的使用，当 channel 是非缓冲的时候他就是阻塞读与写的， 所以使用 channel 的时候要小心同步阻塞，导致死锁 game over
所以要小心不要出现只有读或者只有写的 channel 若是出现的话，分布在不同 goroutine 中时就会导致 golang 死锁，主在等子完成可是子阻塞在了 channel 读或者写上了。
golang make 返回的是值类型，用 slice, map, channel, 并且会给 map 和 slice 预分配空间
golang slice 语法可以对值也可以对引用
golang 切片的用法是 [start:end] 但不包括 end
new 返回的是指针类型
golang 也存在 js 中的那个经典问题就是
第一个打印的 i 都是 10， 因为他们打印的都是同一个变量 i。
golang 中 return defer 返回值的顺序
先来假设出结论，帮助大家理解原因：
多个 defer 的执行顺序为“后进先出”；
defer、return、返回值三者的执行逻辑应该是：return 最先执行，return 负责将结果写入返回值中；接着 defer 开始执行一些收尾工作；最后函数携带当前返回值退出。
如何解释两种结果的不同：
上面两段代码的返回结果之所以不同，其实从上面第 2 条结论很好理解。
a()int 函数的返回值没有被提前声名，其值来自于其他变量的赋值，而 defer 中修改的也是其他变量，而非返回值本身，因此函数退出时返回值并没有被改变。
b()(i int) 函数的返回值被提前声名，也就意味着 defer 中是可以调用到真实返回值的，因此 defer 在 return 赋值返回值 i 之后，再一次地修改了 i 的值，最终函数退出后的返回值才会是 defer 修改过的值。
defer 是在函数结束前执行的，当返回值的临时变量赋给外部时才算调用结束吧！a = fn(2) 当把值给了 a 才算结束
在函数有多个返回值时，只要有一个返回值有指定命名，其他的也必须有命名
append 只能作用在 slice 上而不能是指针
参见签名
错误的栗子
进行结构体比较时候，只有相同类型的结构体才可以比较，结构体是否相同不但与属性类型个数有关，还与属性顺序相关。并且结构体可比较的前提是结构的属性都可比较。map 和 slice 还有 function 不可比较
就是说属性名字不同，类型不同或者顺序不同都是不能比较的
此处 sn1 可以和 sn2 使用==比较但是如下
sn3 就不能比较了
还有上例中，含有不可比较的 map,slice，func 等，所以 sm1 和 sm2 是不可比较的但是我们可以使用 deepEqual 来进行比较
:= 赋值模式的限制
定义变量同时显式初始化不能提供数据类型只能在函数内部使用
nil 可以用作 interface、function、pointer、map、slice 和 channel 的“空值”, 是不可以作为其他类型的空值的，比如 String, string 的空值是“”
itoa
golang const 常量可以使用 itoa 赋值， 甚至是自定义类型
参见
若是自定义类型类似于枚举，当我们传递字面量（如：2，3）时也是可以被识别为枚举值的。
goto 不能跳转到其他函数或者内层代码, 只能在本函数以及相同的 scope 内
下面的就是错的
注意 defintion 和 type alias 的区别 defintion 是定义了一个新的类型，alias 仅仅是个别名
1. 我们在返回值中定义的命名返回值，可以直接在函数中使用不用再重新定义 2. 内部 scope 中新定义的内部变量是会覆盖掉外部的变量
改为
panic 仅有最后一个可以被 revover 捕获,panic 中可以传任何值，不仅仅可以传 string
不管运行顺序如何，当参数为函数的时候，要先计算参数的值
map 引用不存在的 key，不报错
map 使用 range 遍历顺序问题，并不是录入的顺序，而是随机顺序
append 函数返回更新后的 slice（长度和容量可能会变），必须重新用 slice 的变量接收，不然无法编译通过
golang channel 和一个 goroutine 组合起来就是一个 web-worker 的模式，只是我们在 js 里管理的是 web-worker 的句柄，而在 golang 里面我们要管理的是 channel,这里 golang 的一个优势是我可以把多个 channel 和一个 goroutine 绑定，而 web-worker 一个句柄就对应这个一个 web-worker 是不可能多对一的。
golang channel 的使用方式两种
内嵌结构体，当内嵌结构体不是指针时，是会有默认值得，这就符合了 golang 得概念，所有的变量都有默认值，指针的默认值是 nil.
上面代码运行是 ok 的。
两个 golang 问题 http://colobu.com/2018/03/08/two-issues-in-go-development/
golang 包的引入路径 GOPATH/src/...一层一层查找
bin 是可执行的文件， pkg 是编译生成的.a 文件的存放位置是静态库
src 是存放源文件的命令
安装问题 golang/x/tools > https://github.com/golang/tools
下载放到 src 下的 golang/x/下
安装问题 golang/x/net > https://github.com/golang/net
下载放到 src 下的 golang/x/下
golint go get -u -v github.com/golang/lint/golint
编译时的使用第三方源码包 编译时的探索
同其他语言 nodejs 一样，一个包被导入一次后就会被缓存，再次被导入会从缓存获取
init 函数的执行顺序
关于关闭 channel 有几点需要注意的是：
make 和 new
new 的作用是 初始化 一个指向类型的指针 (T)， make 的作用是为 slice, map 或者 channel 初始化，并且返回引用 T
make(T, args)函数的目的与 new(T)不同。它仅仅用于创建 Slice, Map 和 Channel，并且返回类型是 T（不是 T）的一个初始化的（不是零值）的实例。 这中差别的出现是由于这三种类型实质上是对在使用前必须进行初始化的数据结构的引用。 例如, Slice 是一个 具有三项内容的描述符，包括 指向数据（在一个数组内部）的指针，长度以及容量。在这三项内容被初始化之前，Slice 的值为 nil。对于 Slice，Map 和 Channel， make（）函数初始化了其内部的数据结构，并且准备了将要使用的值。
产品中一定不要使用默认的 http.Get
如果你觉得方便，直接使用 http.Get 或者类似的方法发送请求，可能会导致一些问题， 因为这默认是使用 DefaultClient 作为 client:
检查网络错误或者超时 net.Error 和 err.Timeout() 可以检查是不是超时错误
golang 命名返回值
实际上 a 相当于已经命名了，相当于
channel 关闭问题
golang 里面所有未赋值的变量都会赋值为默认值，就连内嵌 struct, infterface 也一样
若是要 marshal 时，不要输出 null 字段或者是为空的字段（结构体），需要把它赋值为指针才可以然后加上 omitempty
https://stackoverflow.com/questions/18088294/how-to-not-marshal-an-empty-struct-into-json-with-go?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
http://colobu.com/2017/05/12/call-private-functions-in-other-packages/ 突破 golang 的访问限制
reflect
http://www.01happy.com/p3206/
最后再次重复一遍反射三定律：
一旦你理解了这些定律，使用反射将会是一件非常简单的事情。它是一件强大的工具，使用时务必谨慎使用，更不要滥用。
只有可以 addressable 的变量才可以使用 reflect 进行赋值修改即：
wrong
yes
[go web 的一些建议](https://medium.com/@matryer/how-i-write-go-http-services-after-seven-years-37c208122831
Shared dependencies are fields of the structure
通过结构体的字段共享依赖，而不是到处引入（适用于所有的）
I have a single file inside every component called routes.go where all the routing can live:
This is handy because most code maintenance starts with a URL and an error report — so one glance at routes.go will direct us where to look.
If a particular handler has a dependency, take it as an argument. 若是有特殊依赖则作为参数传入
https://github.com/dgryski/go-perfbook/blob/master/performance.md
https://my.oschina.net/xinxingegeya/blog/729673 golang unsafe 包的 unsafe 特性
错误和异常，意料之内的是错误，意料之外的是异常(https://studygolang.com/articles/11753?fr=sidebar)
从标准输入读取
Reader 接口
也就是说，当 Read 方法返回错误时，不代表没有读取到任何数据。调用者应该处理返回的任何数据，之后才处理可能的错误。
io.EOF 变量的定义：var EOF = errors.New("EOF")，是 error 类型。根据 reader 接口的说明，在 n > 0 且数据被读完了的情况下，返回的 error 有可能是 EOF 也有可能是 nil。
Writer 接口
Write 将 len(p) 个字节从 p 中写入到基本数据流中。它返回从 p 中被写入的字节数 n（0 <= n <= len(p)）以及任何遇到的引起写入提前停止的错误。若 Write 返回的 n < len(p)，它就必须返回一个 非nil 的错误。
golang 比较行为
Slice, map, and function values are not comparable
func的receiver是 值时 无论调用者是指针还是值都可以调用func
如下若是使用指针作为receiver，则print 值时无法调用到String
bufio的readSlice返回的是bufio.Reader的里的buf（Reader缓存的slice），因此当再此读取以后返回的slice的值是改变的
最后n和slice的值相同
而ReadBytes和ReadString就不会出现这个问题了，他们都新开辟的空间
如果ReadSlice在找到界定符之前遇到了error，
它就会返回缓存中所有的数据和错误本身（经常是 io.EOF）。
如果在找到界定符之前缓存已经满了，ReadSlice会返回bufio.ErrBufferFull错误。
当且仅当返回的结果（line）没有以界定符结束的时候，ReadSlice返回err != nil，
也就是说，如果ReadSlice返回的结果line不是以界定符delim结尾，那么返回的err也一定不等于nil
（可能是bufio.ErrBufferFull或io.EOF）。
并且当下次在读取时会继续向前
然而使用ReadBytes和ReadString就没有这个问题了，bufio.reader会自动为我们处理。
golang排序
对基本类型排序
sort包有sort.Ints, sort.Float64s等方法排序，会改变原数组
程序中使用time.Time
程序中应使用 Time 类型值来保存和传递时间，而不是指针。就是说，表示时间的变量和字段，应为time.Time类型，而不是*time.Time.类型。一个Time类型值可以被多个go程同时使用
time 格式化
这是实际开发中常用到的。
解析
对于解析，要特别注意时区问题，否则很容易出 bug。比如：
t, _ := time.Parse("2006-01-02 15:04:05", "2016-06-13 09:14:00")
fmt.Println(time.Now().Sub(t).Hours())
2016-06-13 09:14:00 这个时间可能是参数传递过来的。这段代码的结果跟预期的不一样。
原因是 time.Now() 的时区是 time.Local，而 time.Parse 解析出来的时区却是 time.UTC（可以通过 Time.Location() 函数知道是哪个时区）。在中国，它们相差 8 小时。
所以，一般的，我们应该总是使用 time.ParseInLocation 来解析时间，并给第三个参数传递 time.Local。
string和number互转
number和byte (数字和字节互转)
想进行地址的加减操作就得使用uintptr
输出正确，直接使用 slice就错误（bts := []byte{2,3,4,5,6}）
原因是：bts为slice的时候 bts的内部结构是
也就是说转化为[]byte以后 只有Data的地址，Len和Cap的值被转化为了字节
string 和 []byte 无copy转换
// reflect.SliceHeader and reflect.StringHeader
golang json问题
json:"name,omitempty,type"json: "name,[option]"解决办法是使用 指针
当我们想给某操作加缓冲区时就可以使用bytes.Buffer
只有make的map才可以赋值， new的是不行的, var声明的也不行
可被json处理都是对外的字段
结构体实现String接口时内部不要调用，fmt的包，会无限递归，因为调用fmt.Println(p)时是会调用 p的String方法
send on closed channel
类型断言
time.Sleep 是以纳秒 为单位的
golang 面试题 https://zhuanlan.zhihu.com/p/35058068
(golang的奇葩1)[https://juejin.im/post/5b5bd2ddf265da0f716c2fea?utm_source=gold_browser_extension]
(golang奇葩2)[https://mp.weixin.qq.com/s/gjOTdEVyhHAiG4nK_ZrOVw]
channel 必须使用make初始化
PS在Tx中唯一绑定一个连接，不会re-prepare。
Tx和statement不能分离，在DB中创建的statement也不能在Tx中使用，因为他们必定不是使用同一个连接使用Tx必须十分小心，例如下面的代码：
*sql.Tx一旦释放，连接就回到连接池中，这里stmt在关闭时就无法找到连接。所以必须在Tx commit或rollback之前关闭statement。
tcp 设置超时时间
https://github.com/developer-learning/night-reading-go/blob/master/discuss/2018-06-07-dial-timeout-in-go.md
你需要知道的知识点有两个，一是go的参数都是值传递，二是只有用同一把锁才能对某个资源边界进行锁与解锁的操作。
使用 go tool vet ，出现“Get passes lock by value: ExecuterList contains sync.Map contains sync.Mutex”， 解决方案有两种：
1，sync.Map用指针
2， 也可以用 (e *ExecutorList) ,避免锁的复制。
context.withCancel http://www.zenlife.tk/with-cancel.md
go 为什么会有nil channel https://lingchao.xin/post/why-are-there-nil-channels-in-go.html
当我们需要确保某一个类型实现了某一固定接口时可以在代码顶部这么写
不用但声明，若没有实现编译时就会报错
copy内置的copy https://golang.org/ref/spec#Appending_and_copying_slices
https://wuyin.io/2018/03/07/50-shades-of-golang-traps-gotchas-mistakes/
The text was updated successfully, but these errors were encountered: