golang101 / golang101 Goto Github PK

basic-code-elements-introduction.html
" 一些程序员不是很喜欢这些限制。但是这些限制有两个害处"应改为
" 一些程序员不是很喜欢这些限制。但是这些限制有两个好处"

出自：https://gfw.go101.org/article/basic-types-and-value-literals.html 基本数值类型字面量的适用范围 这一小节。

英文是：“A numeric literal can be used to represent as an integer value only if it needn't be rounded. ”

当时读的时候感觉怪怪的，似乎翻译成“一个数值型的字面量只有在不需要舍入时，才能用来表示一个整数基本类型的值。” 更好些。

BTW：请问这本书是现有的英文还是中文呢？ 作者应该是**人的样子

更新qr code 。

因为主群群已满500人，目前只能先加入临时群（将更名为2群）。
有意入群者请扫描下面的临时群二维码。

Github图床二维码: https://raw.githubusercontent.com/wiki/golang101/golang101/go101-group-qr-2024-04-08.png
（如https被墙，请clone [email protected]:golang101/golang101.wiki.git 或者 https://github.com/golang101/golang101.wiki.git 至本地并找到最新的二维码图片）

暂行群规：

1. 尽量不要发Go无关话题；
1. 不要发盗版资源；
1. 一般请不要发广告，招聘等；
1. 尽量不要无谓发言发大水扫屏。

违规一次发红包（10元加）。不愿发或者第二次违规踢出群。谢各位多合作。

事情是这样的，我在github上Fork了您的项目，然后前两天下载github上的东西太慢就都转到码云上了，如果侵权的话我马上删除，麻烦联系下。

我们只有在T1的尺寸不大于T2并且此转换具有实际意义的时候才应该实施这样的转换。

官网的文档是这样说的 https://golang.google.cn/pkg/unsafe/#pointer

Provided that T2 is no larger than T1 and that the two share an equivalent memory layout, this conversion allows reinterpreting data of one type as data of another type. An example is the implementation of math

你好，关于非类型安全指针一文中的使用模式六，有个疑问，前来请教。

一个使用了reflect.SliceHeader的例子：

package main

import (
	"fmt"
	"unsafe"
	"reflect"
	"runtime"
)

func main() {
	a := [6]byte{'G', 'o', '1', '0', '1'}
	bs := []byte("Golang")
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&bs))
	hdr.Data = uintptr(unsafe.Pointer(&a))
	runtime.KeepAlive(&a) // 必不可少！
	hdr.Len = 2
	hdr.Cap = len(a)
	fmt.Printf("%s\n", bs) // Go
	bs = bs[:cap(bs)]
	fmt.Printf("%s\n", bs) // Go101
}

注意：上例中的runtime.KeepAlive调用必不可少。 否则，在转换uintptr(unsafe.Pointer(&a))被执行之前，分配给数组a的内存可能已经被回收。

这里对于a被回收的原因有些疑问，因为后面hdr.Cap = len(a)有引用到a，为何a仍然可能会被回收呢？难道说是因为len(a)操作在编译期变成了常量6，导致没有对a产生引用？

我改变主意了。欢迎各位对本书感兴趣的gopher以个人名义加入本书的中文翻译组。
不过在加入之前请斟酌以下条款：

• 本人(Tapir Liu)保留本书的纸质和电子版出版权以及网络中文版和英文版的发布权。
• 本书的写作和翻译目前没有任何切实收益计划。本人目前暂时不保证参与本书的翻译会到任何报酬。

另外请注意:

• 每开始翻译一篇文章之前，请先在本issue中提前打好招呼。
• 每开始翻译一篇文章之前，请将英文版中对应的文章的最新版本copy过来。

对于 指针 一章中的 “一个指针类型的值不能被随意转换为另一个指针类型” 这一小节：

2.类型T1和T2都为非定义类型并且它们的底层类型的基类型一致（忽略结构体字段的标签）。

原文是：

2.Type T1 and T2 are both non-defined pointer types and the underlying types of their base types are identical (ignoring struct tags).

转换条件第二条里“底层类型的基类型”这一处翻译可能反了，原文是"the underlying types of their base types"，应该是“基类型的底层类型”。

同理，下面对示例解释的第三点里也出现了。

1.关于作者将通道归为的三类我可以进行如下理解吗？
零值（nil）通道 —— 非缓冲通道
非零值但已关闭的通道 —— 已关闭的缓冲通道
非零值并且尚未关闭的通道 —— 未关闭的缓冲通道
2.通道操作情形A和通道操作情形B，我在文字理解的基础上绘制成了流程图，可以麻烦作者看下，理解是否有误呢？
通道操作情形A： 当一个协程Gr尝试从一个非零且尚未关闭的通道接收数据的时候，结果为阻塞或者成功接收

通道操作情形B： 当一个协程Gs尝试向一个非零且尚未关闭的通道发送数据的时候，结果为阻塞或者成功接收

舍弃

• fix：必须被全被舍弃 -> 必须被全部舍弃？

• link

• 同时，可以解释一下，这里舍弃的含义是什么？比如我将协程的返回值保存到全局变量，那算舍弃吗？

情景转换

• fix：情景转换 -> 上下文切换？

• link

关于结构体值的赋值
当一个（源）结构体值被赋值给另外一个（目标）结构体值时，其效果和逐个将源结构体值的各个字段赋值给目标结构体值的各个对应字段的效果是一样的。

func f() {
	book1 := Book{pages: 300}
	book2 := Book{"Go语言101", "老貘", 256}

	book2 = book1
	// 上面这行和下面这三行是等价的。
	book2.title = book1.title
	book2.author = book1.author
	book2.pages = book1.pages
}

两个结构体值只有在它们的类型的底层类型一样（要考虑字段标签）并且其中至少有一个结构体值的类型为非定义类型时才可以互相赋值。

加粗字是什么意思？上面book2 = book1都是定义类型吧

我readme所在目录 运行go run . 出现以下错误

请问这是为什么？

我觉得原因应该是这个

recover函数并未直接在一个延迟函数调用中调用。

如果把defer去掉， 直接recover是OK的。因为你没有直接在函数对应的defer中调用， 而是在defer.defer中调用了recover

closed, 我理解错了

协程和延迟调用的实参的估值时刻
一个协程调用或者延迟调用的实参是在此调用发生时被估值的。更具体地说，

• 对于一个延迟函数调用，它的实参是在此调用被推入延迟调用堆栈的时候被估值的。
• 对于一个协程调用，它的实参是在此协程被创建的时候估值的。
  一个匿名函数体内的表达式是在此函数被执行的时候才会被逐个估值的，不管此函数是被普通调用还是延迟/协程调用。

看了笔者举的例子， 分析过后觉得是栈的问题并不是笔者提出的这个两个结论

希望能得到您的回复

此处是否应该为

「包裹在一个接口值中的非接口值的类型信息也和此『非』接口值一起被包裹在此接口值中。」

64位操作系统的理论最大内存容量应为2^64，书中位2^34

你好，我在看书的时候，对其中 channel 容量的有些疑问，所以想问一下我的理解哪里有问题，谢谢

• 第一处

func source() <-chan int32 {
	c := make(chan int32, 1) // 必须为一个缓冲通道
	go func() {
		ra, rb := rand.Int31(), rand.Intn(3)+1
		time.Sleep(time.Duration(rb) * time.Second)
		c <- ra
	}()
	return c
}

不知道为什么必须为 1，即使为 0 也完全正常

• 第二处

c := make(chan struct{}, 1) // 容量必须严格为1

此处的容量为什么严格为1，容量为 0 没有问题呀？

上面两处的容量为 0 都可以正常运行，而且不存在 “数据请求者因为种种原因未及时准备好接收，则所有回应者的尝试发送都将失败，从而所有回应的数据都将被错过。”

请问gfw.go101.org上的内容是实时更新的吗？

我找到的一点资料是
这里第一个表达式计算完了，作为一个 receiver 来调用第二个表达式
ref
但是感觉解释得还是不够

@lxt1045 发现 sync标准库包中提供的并发同步技术一文中下面代码片段中的Lock和Unlock的本意为RLock和RUnlock。确实是这样。

	for i := 0; i < N; i++ {
		d := time.Second * time.Duration(rand.Intn(10)) / 10
		go func(i int) {
			time.Sleep(d)
			cond.L.(*sync.RWMutex).Lock()
			values[i] = string('a' + i)
			cond.L.(*sync.RWMutex).Unlock()
			cond.Signal()
		}(i)
	}

别着急，;D，我得先看看具体的形式是否便于更新。
上面已经说了，只要能保证这三点就行：

• 注意时常更新
• 非盈利目的
• 本书的自我宣传字样不能删除

Originally posted by @dotaheor in #20 (comment)

《Golang 101》 已经按照转载规定进行转载 -- 非盈利，保留宣传字样和赞助二维码，并时常关注当前仓库更新状态进行跟进更新。

BookStack 阅读地址： https://www.bookstack.cn/books/golang101

微信小程序阅读二维码：

• BookStack 开源地址：https://github.com/TruthHun/BookStack
• BookChat 开源地址：https://gitee.com/truthhun/BookChat

数组、切片和映射章节

// 第三种方法（不保持剩余元素的次序）：
copy(s[from:to], s[len(s)+from-to:])
s = s[:len(s)+from-to]

当from-to个数 大于to至尾个数时，第三种方法不正确。

我个人最近正好在学习 golang，很惊喜能发现一份由华人作者写的资料，非常感谢！
开这个 issue 主要是想列一下我在用 mac 看书的时候遇到的一些排版问题。目前我只用了 mac ，其他设备还没有试过。我对电子书的排版原理其实了解不多，所以下面只说效果。

• kindle，.azw3
  这个格式在kindle下正文字体是没问题的，应该是受 kindle 控制。但是代码区域就没法看了，字体太小而且不是等宽，我尝试看了一会就放弃了。
  
• Apple Books, .equb
  代码区和正文几乎用一种方式来排版了，也是没法看。我尝试用zoom来解决，结果只有糟和更糟😁
  
• PDF Expert, .pdf
  这个组合勉强能看了，但是字体无疑还是挺糟糕的，主要是字重问题。这里强烈建议使用思源宋体和思源黑体。代码字体或许可以从比较流行的等宽字体里找一款更好的。
  
• 本地部署 web 版
  这个版本的问题是行高不够，文字感觉太密集。不知作者是否考虑过部署到 Gitbook 呢？

上面就是我阅读的时候发现的一些排版问题，希望作者能考虑我的意见，再次感谢您辛苦写书！

一条break语句可以用来提前跳出包含此break语句的最内层for循环。 下面这段代码同样逐行打印出0到9十个数字。

i := 0
for {
	if i >= 10 {
		break
	}
	i++
	fmt.Println(i)
}

此程序将打印出 1 至 10

英文版本中没有后面一句，但是中文版本应改为：

i := 0
for {
	if i >= 10 {
		break
	}
	fmt.Println(i)
	i++
}

最后，万分感谢作者，此书风格是我最喜欢的技术文章风格。

First thanks for all effort you made for this book. And I find out uncountable new knowledge from here.
But I am pretty sure the author's language teacher must come from Mars. I do understand making all professional content to be clear is not an easy thing, but bro, every time I plucked up my courage to continue reading, I feel uncomparable extremely dull, turgid, boring and so hard to understand, and the more miserable thing is I have to read most of the sentence again and again until I frothed at my mouth and fell convulsed. Of course, the same story will be started again the next day.

首先感谢你为这本书所做的一切努力。从这里我发现了数不清的新知识。
但我很肯定作者的语言老师一定来自火星。我明白把所有的专业内容弄清楚不是一件容易的事，但还是男人，每次我鼓起勇气继续读下去，我都觉得无比乏味，浮肿，坦率地说无聊，难以理解，更可悲的是，我不得不一遍又一遍地读这句话的大部分内容，直到我口吐白沫，抽搐起来。当然，同样的故事会在第二天重新开始。

你好我是www.topgoer.com的站长，申请转载golang101到我的文档网站，非常感谢

在Go的内存顺序保证一节中，讲了一个通道关闭的例子，如下
下面是一个通道关闭的例子。在这个例子中，赋值语句k = 1的执行保证在赋值语句y = 1执行之前结束，但不能保证在赋值语句x = 1执行之前结束。

func f6() {
    var k, x, y int
    c := make(chan bool, 1)
    go func() {
        c <- true
        k = 1
        close(c)
    }()
    go func() {
        <-c
        x = 1
        <-c
        y = 1
    }()
}

我自己写了一遍跑了下 但是还是不能理解为什么 赋值语句k = 1的执行保证在赋值语句y = 1执行之前结束，
感觉

        k = 1
        close(c)

和

        x = 1
        <-c
        y = 1

这两部分的执行顺序完全不能确定啊 请教我谢谢

https://gfw.go101.org/article/container.html

遍历容器元素中有个书写错误：这个变种形势没有太大实用价值。
形势->形式

运算操作符章节中-->关于算数运算的结果-->一个移位算术运算的例子中的示例代码，const A和B从3左移两位的结果应该是12而不是6

大佬你好，首选感谢的文章。读后受益匪浅。在《如何优雅地关闭通道》一章中。情形四小节，有如下代码
closing := make(chan struct{}) // 信号通道
closed := make(chan struct{})

// 此stop函数可以被安全地多次调用。
stop := func() {
	select {
	case closing<-struct{}{}:
		<-closed
	case <-closed:
	}
}

// 一些第三方协程
for i := 0; i < NumThirdParties; i++ {
	go func() {
		r := 1 + rand.Intn(3)
		time.Sleep(time.Duration(r) * time.Second)
		stop()
	}()
}

这些第三方协程调用stop函数后是否都被阻塞了，从而造成了goroutine的泄漏。本人才疏学浅，请不吝赐教！感谢

作者，你好！

我写了一个 VuePress 的主题（VuePress Theme Mix），为了方便用户快速使用该主题，我打算建一个使用了该主题组织文档的 GitHub Template 仓库，对于这个文档模板的示例文档内容，我想使用 Go101 的中英文内容，并且会在首页注明内容来源。

请问这样可以吗？

在这里的事实三提到的一个值的地址在程序运行中可能改变。不过这里说的是栈空间变化的情况，那么如果一个对象是分配在堆中的，是否还可能发生变化呢？前阵子对go的内存分配进行了一点浅薄的研究，感觉按这种划分内存的方式，似乎可以不进行内存的整理，那是否代表一个对象分配在堆中的话，那么地址应该不会发生变化？

如果想把数据地址保存在uintptr,通过偏移量来操作数据，需要做些什么考虑呢(比如什么情况下这个地址不会被修改,之前有在boltdb中看到类似下面的做法,是因为boltdb用的是mmap，数据不被gc管理，所以才可以这样？)

谢谢大佬！

我在使用counter这个例子的时候，发现在一般的情况是没有问题的，但是在一种 64位 机器上：
返回的其实就是 x[8] 的地址值，那么对于 int64 来说它是 64位的，超出Counter结构体 8位。

unsafe.Pointer(uintptr(unsafe.Pointer(&c.x)) + 8 - uintptr(unsafe.Pointer(&c.x))%8)

如果在使用 counter 的时候，如下 T1 ，恰好有一个 Alignment 等于1 的字段 f 在 Counter 后面，那么操作 f 字段的时候会变成直接操作 Counter 里面对应 int64 的最高位，这样也就无法保证在任意编译器都可以随意进行原子操作：

type Counter struct {
	x [15]byte // 模拟：x uint64
}

func (c *Counter) xAddr() *uint64 {
	// 此返回结果总是8字节对齐的。
	return (*uint64)(unsafe.Pointer(
		uintptr(unsafe.Pointer(&c.x)) + 8 -
			uintptr(unsafe.Pointer(&c.x))%8))
}

func (c *Counter) Add(delta uint64) {
	p := c.xAddr()
	atomic.AddUint64(p, delta)
}

func (c *Counter) Value() uint64 {
	return atomic.LoadUint64(c.xAddr())
}

type T1 struct {
	a Counter
	f int8
}

func main() {
	c := T1{}
	c.f  = 1
	fmt.Println(c.f)
	fmt.Println(c.a.Value())
}

谢谢作者为大家提供了这么好的学习资料！
提个建议：每一页文档的底部增加”上一篇“和”下一篇“的链接，方便导航

内存块 - Go语言101

每一个协程在将维护一个栈（stack）里面的在好像是多余的

未来的Go自定义泛型
Go语言核心设计和开发团队并不排斥在Go中加入自定义泛型， 未来的Go版本中还是很可能会支持自定义### 范性的。 事实上，自定义泛型设计已经朝着更成熟的方向演化了好几个版本了。 我们现在甚至已经可以在这里在线试验开发版特性中的自定义泛型特性。 我们也可以自行编译Go项目的dev.go2go分支在本地试验这些特性。

范性

长难句。

常量和变量 - Go语言101 中的

var a, b, c = b+1, c+1, y // 7 6 5 8

最后的 8 似乎是多余的，这里只有三个变量

您好，Golang 101 是一本非常不错的开源技术书籍，内容很扎实。书栈网·BookStack（ https://www.bookstack.cn ）在此提出内容转载申请。转载遵循 CC-BY-NC 协议：署名、注明来源以及非商用，并且保留原书中的打赏赞助二维码。

同时，书栈网程序也是使用Go语言开发，基于 Apache 2.0 开源协议开源：https://github.com/TruthHun/BookStack

第一题：
package main

func main() {
f := func() bool {
return false
}

switch f()
{
case false: println("F")
case true: println("T")
}
}

明明打印出F，却说是T，我怀疑你在钓鱼！

对于反射一文中的示例，closed变量名会造成困扰。

我们可以使用reflect.Select函数在运行时刻来模拟具有不定case分支数量的select流程控制代码块。

package main

import "fmt"
import "reflect"

func main() {
	c := make(chan int, 1)
	vc := reflect.ValueOf(c)
	succeeded := vc.TrySend(reflect.ValueOf(123))
	fmt.Println(succeeded, vc.Len(), vc.Cap()) // true 1 1

	vSend, vZero := reflect.ValueOf(789), reflect.Value{}
	branches := []reflect.SelectCase{
		{Dir: reflect.SelectDefault, Chan: vZero, Send: vZero},
		{Dir: reflect.SelectRecv, Chan: vc, Send: vZero},
		{Dir: reflect.SelectSend, Chan: vc, Send: vSend},
	}
	selIndex, vRecv, closed := reflect.Select(branches)
	fmt.Println(selIndex)    // 1
	fmt.Println(closed)      // true
	fmt.Println(vRecv.Int()) // 123
	vc.Close()
	// 再模拟select流程控制代码块。因为vc已经关闭了，
	// 所以需将最后一个case分支去除，否则它可能会造成一个恐慌。
	selIndex, _, closed = reflect.Select(branches[:2])
	fmt.Println(selIndex, closed) // 1 false
}

selIndex, vRecv, closed := reflect.Select(branches)一句，reflect.Select函数第三个返回值表示返回值是否有效，使用closed描述会产生误解，因为示例中调用vc.Close()之后，最后一行打印closed为false，如果与官方文档保持一致recvOK，或者叫做isValid会更有助于理解。

我在添加托管配置文件的时候，一直显示输入不合法，这是为什么

是最新的clash版本

请问可以增加一个页面日间效果和夜间效果的转换吗

下面这个例子验证了上述第一个和第二个事实。
package main

import "fmt"

func main() {
type Person struct {
name string
age int
}
persons := [2]Person {{"Alice", 28}, {"Bob", 25}}
for i, p := range persons {
fmt.Println(i, p)
// 此修改将不会体现在这个遍历过程中，
// 因为被遍历的数组是persons的一个副本。
persons[1].name = "Jack"
// 此修改不会反映到persons数组中，因为p
// 是persons数组的副本中的一个元素的副本。
p.age = 31
}
fmt.Println("persons:", &persons)
}
输出结果：
0 {Alice 28}
1 {Bob 25}
persons: &[{Alice 28} {Jack 25}]

文章地址：http://go101.studygolang.com/article/channel.html
其中“数据通道操作”小结中说到：
“
2. 使用下面的语法向数据通道ch发送一个值v：

ch <- v

v必须能够赋值给数据通道ch的元素类型。 ch不能为单向接收数据通道。 <-称为数据发送操作符。
”

这里“ch不能为单向接收数据通道”是不是写反了？应该是“ch不能为单向发送数据通道”吧？

https://gfw.go101.org 经常访问访问不了，我按照教程，在国内搭了一个镜像。

http://go101.studygolang.com

文章中提到一个协程的panic不会影响其它panic,但是在后边的代码有举例说明了，主协程因为子协程panic而导致程序提前退出，而现实确实这样的。前边说的 ”一个协程不会蔓延到另一个协程“是不是有问题了？

书中提到

package main

import "fmt"

func main() {
	defer fmt.Println("reachable")
	var f func() // f == nil
	defer f()    // 将产生一个恐慌
	// 下面的代码不会被执行。
	fmt.Println("not reachable")
	f = func() {}
}

但是我自己实际测试（go version go1.13 darwin/amd64 以及 go version go1.12.9 darwin/amd64)以及 https://play.golang.org/p/bXxaq04Vffm 在线测试，fmt.Println("not reachable") 是会输出的。即使在最后加一行输出也是可以输出的。

如题，该表述在 自动插入分号的规则是什么呢？ 这个部分，白皮书原文中写的 rune， 在这里应该翻译成码字更准确