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

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

1. 如果我有一个包Func，其中包含一堆返回文字（SQL 字符串）的函数，但在main 中只使用了几个函数，编译时是否会全部包含在可执行二进制文件中？

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

1. 如果我有一个包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+F INSERT 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

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