golang包中未使用的const/函数是否包含在可执行二进制文件中

Question

golang包中未使用的const/function/struct方法是否包含在可执行二进制文件中？

例如：

1. 如果我有一个包Const，它包含一堆常量(包含SQL查询(，但在main中只使用了其中的几个常量，那么在编译时，它会全部包含在可执行二进制文件中吗

package Const
const (
InsertA = `insert into ...` 
InsertB = `insert into ...`
UpdateA1 = `update ...` // certain column
UpdateA2 = `update ...` // other columns, different where, etc..
...
)
// in main, only some of them used/prepared

2. 如果我有一个包Func，它包含一堆返回文本(SQL字符串(的函数，但在main中只使用了其中的几个，那么在编译时，它会全部包含在可执行二进制文件中吗

package Func
func InsertA() string { return `insert into ...` }
func InsertB() string { return `insert into ...` }
func UpdateA() string { return `Update ...` }
...

3. 如果我有一个包mix，它包含一堆返回/使用所有常量的函数，如数字1所示，但只有main中使用的一些函数在编译时会全部包含在可执行二进制文件中吗

package mix
const (
insertA = `insert into ...`
insertB = `insert into ...`
updateA = `update ...`
...
)
func InsertA() string { return insertA }
func InsertB() string { return insertB }
func UpdateA() string { return updateA }
// in main, only some of the const are prepared

4. 如果我有一个包Struct，它包含很多带有一堆方法的结构(按表分类SQL(，但只有main中调用的一些结构，那么在编译时，所有常量、结构定义和方法都会包含在可执行二进制文件中吗

package Struct
const (
insertA = `insert into ...`
insertB = `insert into ...`
updateA = `update ...`
...
)
// in main only some of them prepared
type A struct {db *DB}
func (a *A) Prepare() error {} 
func (a *A) InsertA(...) error {} 
func (a *A) UpdateA(...) error {} 
type B struct {db *DB}
func (b *B) Prepare() error {} 
func (b *B) InsertB(...) error {} 
// in main only some of them used (eg. only struct `A` used)

上下文/用例用于重构旧的代码库，因此它可以更好地为新程序员调试/理解代码(通过合并到每个表的一个结构或每个表的另一个包中，轻松地知道哪些函数/方法可以修改该表(，而不牺牲二进制大小，因为目前所有的命令查询都分散在多个二进制文件/包中(必须手动ctrl+FINSERT INTO tablename或UPDATE tablename或DELETE FROM tablename来查看哪些函数/方法写入/修改该表上的记录(。因此，我可以决定是每个表(250+(有一个包更好，还是一个单独的包，其中多个文件包含每个表的空结构。

旧的代码库是这样的：

package hugeX
func foo() map[constQ]string {
return map[constQ]string{
insertB: `insert into...`,
updateA: `update ...`,
...
}
}
package hugeY
func foo() map[constQ]string {
return map[constQ]string{
insertA: `insert into...`,
updateB: `update ...`,
...
}
}
package foo
const (
insertB = `insert into..`
updateA = `update ...`
...
)
package bar // importing hugeX
const ( 
insertA = `insert into ...` 
updateA = `update ...` // by something, sometimes duplicates
... 
)
package baz 
const (
...
)
... and so on..

Answer 1

测试后并使用strings和grep

strings binaryName | grep CONSTANTSPREFIX
strings binaryName | grep CONSTANTRETURNEDBYFUNCS
strings binaryName | grep CONSTANTRETURNEDBYMETHODS

代码类似于这个

package a
const (
A0 = `ZAAA0` // use this on main
A1 = `ZAAA1`
A2 = `ZAAA2`
A3 = `ZAAA3`
A4 = `ZAAA4`
A5 = `ZAAA5`
A6 = `ZAAA6`
)
func B1() string { return A1 } // call this on main
func B2() string { return A2 }
func B3() string { return `ZBBB3` } // call this on main
func B4() string { return `ZBBB4` }
type C1 struct{}
func (c *C1) C3() string { return A3 } // call this on main
func (c *C1) C4() string { return A4 }
type D1 struct{}
func (c *D1) D5() string { return A5 }
func (c *D1) D6() string { return A6 }

主要：

package main
import "a"
import "fmt"
func main() {
c := a.C1{}
fmt.Println(a.A0,a.B1(),a.B3(),c.C3())
}

结果

$ go version
go version go1.15.6 linux/amd64
$ go build main.go
$ strings main | grep ZAAA
ZAAA0ZAAA1ZAAA3ZBBB3

只有那些被调用的才包括在可执行二进制文件中。