这种索引取值的写法本来是参数复用的，例如：

```
fmt.Printf("%[1]s 和 %[1]s 的朋友们", "Tom")
```

但是 OP 举的例子不是很恰当：通过打乱顺序来说明用法，即没有把本质原因表现出来，也容易误导读者倾向于炫技。

@LieEar 能理解 Java/JavaScript 中的 stream.filter(v -> v !=10 ) 应该对这种形式好理解了。（只是这种高阶函数的形式互通，不是说 go iter 和他们的 stream 功能类似）

@bagel 竟有此事？给个链接看看。

支持，我还以为是我系统的问题呢。

func (s *Stack) Pop() (int, bool) {
if s.IsEmpty() {
return 0, false
}
item := s.items[len(s.items)-1]
s.items = s.items[:len(s.items)-1]
return item, true
}

可能是 Java 八股文把依赖注入问烂了，导致很多人听到依赖注入就不辨是非的厌恶。

宽泛来说：构造方法传参就是一种依赖注入的行为，无论是否用到依赖注入框架。

希望依赖注入框架自身保持最小依赖，少整花里胡哨超纲的功能，保持 KISS 原则。

依赖注入，用框架也可以，自己依赖注入也可以：

```go
func Run(cfg Config) error {
db, err := mysql.Open(cfg.Database)
if err != nil {
return err
}
defer db.Close()

mq, err := kafka.Open(cfg.Kafka)
if err != nil {
return err
}
defer mq.Close()

rdb, err := redis.Open(cfg.Redis)
if err != nil {
return err
}
defer rdb.Close()

bar := NewBar(db, mq, rdb)

return bar.Foo()
}

func NewBar(db *sql.DB, mq *kafka.Client, rdb *redis.Client) *Bar {
return &Bar{
db: db,
mq: mq,
rdb: rdb,
}
}

type Bar struct {
db *sql.DB
mq *kafka.Client
rdb *redis.Client
}

func (b *Bar) Foo() error {
_, err := b.db.Exec("SELECT 1")
return err
}
```

@zzhaolei 12 年前就提过 https://github.com/golang/go/issues/3611

@bv 接 #1
1. 这个函数是 Init ，不是 init
2. 锁只锁了 std = NewLogger(opts) 语句，使用时没加锁，std 变量存在 race 问题。
3. func NewLogger(opts *Options) *zapLogger 可导出方法返回了不可导出的类型，不够优雅。

初学者还是应该拜读更规范的源码，免得入门时被低质量代码熏陶，一些错误理念会根深蒂固。

这代码没什么营养，不要纠结为何这么写。

下面这样，有点为了优化而优化，让人难以理解了：
function onSortChange(order, prop) {
let props = new Map([
["thisYearIncome", 1],
["lastYearIncome", 3],
["rate", 5],
]);

this.fetchData((order === "descending" ? 0 : 1) + props.get(prop))
}

以标准库为例：

```
package main

import (
"fmt"
"net/http"
)

func main() {
mux := http.NewServeMux()
mux.HandleFunc("/hi", Language)
mux.HandleFunc("/{lang}/hi", Language)

http.ListenAndServe(":9999", mux)
}

func Language(w http.ResponseWriter, r *http.Request) {
lang := r.PathValue("lang")
if lang == "" {
lang = r.Header.Get("Accept-Language")
}

fmt.Println(lang)
w.Write([]byte(lang))
}
```

@evercyan 感谢，这个规则我明白，Parse(text string) (*Template, error) 反响适配 Must 感觉很奇怪，我感觉 #15 的 Must 写法也不影响 Must 链式调用。

我的疑惑就是：如果 Parse 不返回 *Template ，也不影响 Must 的链式调用。

func Must(t *Template, s string) *Template {
if err := t.Parse(s); err != nil {
panic(err)
}
return t
}

type Template struct{}

func (t *Template) Parse(s string) error {
return nil
}

@evercyan 看到了，通过 Must 调用确实可以做到链式调用。但是这么设计总感觉是本末倒置呀。

@maocat 你确定是因为为了链式调用，Parse 返回了 (*Template, error) 两个参数，还怎么做链式调用？

前 3L 不知道想表达什么，我个人觉得这么定义 func (t *Template) Parse(text string) error 确实可行，但不清除设计这个接口时为何要返回 *Template

可能是通过 ja3 指纹