@james122333 有啊

@james122333 这里说的 Result 是提供判断是否为 Error 还是为 result 的能力的，同时判断两者为 nil 就是非 error 并且 *T 为 nil 的情况啊？

这里说的这个 Result 在 go 里是不存在的，不是结构体那样的东西。结构体和多返回值是一回事。

@james122333 #111 除非你在 err!=nil 的时候也返回了一个 T ，否则我们说的 Result 是涵盖了你说的这种情况的。

@james122333 #108

你说的这几个其实都不是问题。

单返回值也可以表示 return nil, nil ， 只要这个 Result 是 *T | Error 就行。你是想的 int | Error 不能 nil ，nil ，但你定义为 *int | Error 肯定可以 nil ，nil 。nil 也是一个 *int 。

所以 rust 的解决方法是加了一个 ? 操作符，在 Err 时候直接把 Err 返回上层，中止当前函数。

@yu1miao #100 准确的说这里有 6 种情况，你 benchmark 跑一下就能看出来泛型实现的问题了。

这里跟 writeGeneric 直接传结构体的性能跟用接口，并且编译器没有进行 devirtualize 是相同的，并不会像你说的那样专门生成一个 writeGeneric(w *Buffer) error

如果你传进去的是一个接口，调用开销直接就翻倍了。


func Benchmark_interface_0(b *testing.B) {
var buf = &Buffer{}
for i := 0; i < b.N; i++ {
write(buf)
}
}

func Benchmark_interface_1(b *testing.B) {
var buf io.ByteWriter = &Buffer{}
for i := 0; i < b.N; i++ {
write(buf)
}
}

func Benchmark_interface_2(b *testing.B) {
var buf IBuffer = &Buffer{}
for i := 0; i < b.N; i++ {
write(buf)
}
}

func Benchmark_generic_0(b *testing.B) {
var buf = &Buffer{}
for i := 0; i < b.N; i++ {
writeGeneric(buf)
}
}

func Benchmark_generic_1(b *testing.B) {
var buf io.ByteWriter = &Buffer{}
for i := 0; i < b.N; i++ {
writeGeneric(buf)
}
}

func Benchmark_generic_2(b *testing.B) {
var buf IBuffer = &Buffer{}
for i := 0; i < b.N; i++ {
writeGeneric(buf)
}
}

Benchmark_interface_0-16 232742709 5.139 ns/op 0 B/op 0 allocs/op
Benchmark_interface_1-16 434387566 2.794 ns/op 0 B/op 0 allocs/op
Benchmark_interface_2-16 85636600 14.67 ns/op 0 B/op 0 allocs/op
Benchmark_generic_0-16 85636600 13.97 ns/op 0 B/op 0 allocs/op
Benchmark_generic_1-16 54496902 24.23 ns/op 0 B/op 0 allocs/op
Benchmark_generic_2-16 49954623 24.91 ns/op 0 B/op 0 allocs/op

@yu1miao #100 你把上面那个也改成 var buf io.ByteWriter = &Buffer{} 就看出区别了

var _ IBuffer = (*Buffer)(nil)
var _ io.ByteWriter = (*Buffer)(nil)

func write(w io.ByteWriter) {
for i := byte(0); i < 10; i++ {
_ = w.WriteByte(i)
}
}

func writeGeneric[W io.ByteWriter](w W) {
for i := byte(0); i < 10; i++ {
_ = w.WriteByte(i)
}
}

func BenchmarkExtract(b *testing.B) {
var buf io.ByteWriter = &Buffer{}
for i := 0; i < b.N; i++ {
write(buf)
}
}

func BenchmarkExtra(b *testing.B) {
var buf IBuffer = &Buffer{}
for i := 0; i < b.N; i++ {
writeGeneric(buf)
}
}

BenchmarkExtract-16 1000000000 4.872 ns/op 0 B/op 0 allocs/op
BenchmarkExtra-16 1000000000 25.43 ns/op 0 B/op 0 allocs/op

@yu1miao #78 go 的泛型在面对接口的时候不是这么处理的，可以跑一下这个 bench 试试。这里的 BenchmarkExtra 多了一次接口虚表查询。

https://go.dev/play/p/jMm3oAbaLX0

我是不明白为什么有人反对 go 的泛型用中括号的。难道之前没用过 map 用吗？


@yu1miao 有个槽点是接口泛型可能会导致调用接口的时候变慢…

借楼问一下，不需要桌面环境，直接开个 http 服务器搭配浏览器的 nodejs 程序用什么工具比较合适？之前一直用的 pkg ，现在 pkg 停止维护了

bt 协议的连接有两种，一种是出去的，一种是进来的。如果连进来的链接是你 k8s 转发进来的，那就会显示为入口节点的 ip 。

是不是流量被你本地某个转发了，然后就被识别为内网地址了？

bt 协议并没有什么办法伪装自己的 ip ，qb 只能从 tcp 连接或者 udp 包的来源读到对方的地址，如果显示为内网说明流量确实是从外网经过你的某个进程绕了一圈才到的 qb 。

你这里可以要求调用者用 IsEmpty 来保证 pop 不为空，然后发现为空直接 panic 。

@phpbestforlong #38 你说的这个 go 是 golang 的 go 还是围棋的 go...

在证书安全，加密算法没漏洞的情况下，中间人看不到 url 域名以外的东西。

历史上的确是把 cpu 跟很多东西“焊”在了一起，但都是南桥北桥这种东西，散热器不值得这么做。

进程是跑在容器里的话可以用 cAdvisor

问题是 GPL 的传染途径是有限的，不是你写个什么 linux 程序就需要开源的。

他如果不改 debian 的 GPL 组件，自己从头写一个，那你也管不到他啊。

软文!