我有一个类似的问题，我目前使用的解决方案使用Go 1.11模块。我有如下结构

- projects
  - go.mod
  - go.sum
  - project1
    - main.go
  - project2
    - main.go
  - package1
    - lib.go
  - package2
    - lib.go

我能够从project1和project2导入package1和package2

import (
    "projects/package1"
    "projects/package2"
)

运行go mod init项目后。我可以使用从project1和project2目录构建或者我可以使用build -o project1/exe project1/*。从项目目录。

这种方法的缺点是你所有的项目最终都会在go.mod中共享相同的依赖项列表。我仍在寻找这个问题的解决方案，但它看起来可能是根本性的。

也许您正在尝试模块化您的包。我假设package1和package2在某种程度上是同一个包的一部分，但为了可读性，您将它们拆分为多个文件。

如果前面的案例是你的，你可以在这些多个文件中使用相同的包名，就像有相同的文件一样。

这是一个例子:

add.go

package math

func add(n1, n2 int) int {
   return n1 + n2
}

subtract.go

package math

func subtract(n1, n2 int) int {
    return n1 - n2
}

donothing.go

package math

func donothing(n1, n2 int) int {
    s := add(n1, n2)
    s = subtract(n1, n2)
    return s
}

我不是围棋专家，这是我在stackoverflow的第一个帖子，所以如果你有一些建议，它会很受欢迎。

Run:

go mod init yellow

然后创建一个文件yellow.go:

package yellow

func Mix(s string) string {
   return s + "Yellow"
}

然后创建一个文件orange/orange.go:

package main
import "yellow"

func main() {
   s := yellow.Mix("Red")
   println(s)
}

然后构建:

go build

https://golang.org/doc/code.html

在bash终端中

mkdir <module name>  
cd <module name>  
go mod init <module name>  
touch <module name>.go

在<模块名>.go中创建go包

cd ..  
mkdir main  
cd main  
go mod init main  
touch main.go

创建导入<模块名>的主包

go mod edit -replace=<module name>=<module path>
go mod tidy

看看每一个动作。Mod，如果你想了解go的后台发生了什么 你的文件夹结构如下所示:

- Project  
  - <module name>  
    - <module name>.go  
    - go.mod  
  - main  
    - main.go  
    - go.mod  

go run .

OR

go build && 
./main.exe

Go依赖项管理总结:

Vgo，如果你的go版本是:x >= go 1.11 Dep或供应商，如果你的go版本是:go 1.6 >= x < go 1.11 如果你的go版本是:x < go 1.6，则手动操作

编辑3:Go 1.11有一个功能vgo将取代dep。

要使用vgo，请参阅模块文档。TLDR如下:

export GO111MODULE=on
go mod init
go mod vendor # if you have vendor/ folder, will automatically integrate
go build

这个方法创建一个名为go的文件。在项目目录中进行修改。然后，您可以使用go build构建您的项目。如果设置了GO111MODULE=auto，那么你的项目不能在$GOPATH中。

编辑2:自动售货方法仍然有效，没有问题。Vendor很大程度上是一个手动过程，因为这个dep和vgo被创建了。

编辑1:虽然我以前的方法有效，但它不再是“正确”的方法了。你应该使用Go 1.6中默认启用的供应商功能，vgo或dep(目前);看到的。你基本上是在供应商目录中添加你的“外部”或“依赖”包;编译时，编译器将首先使用这些包。

发现。我可以通过创建package1的子文件夹，然后用import导入，用GOPATH导入本地包。/package1”。去binary2。Go脚本如下:

binary1.go

...
import (
        "./package1"
      )
...

所以我的当前目录结构是这样的:

myproject/
├── binary1.go
├── binary2.go
├── package1/
│   └── package1.go
└── package2.go

我还应该注意到相对路径(至少在go 1.5中)也可以工作;例如:

import "../packageX"

要向项目中添加“本地”包，请添加一个文件夹(例如“package_name”)。然后把你的实现文件放到那个文件夹里。

src/github.com/GithubUser/myproject/
 ├── main.go
 └───package_name
       └── whatever_name1.go
       └── whatever_name2.go

在你的包main中这样做:

import "github.com/GithubUser/myproject/package_name"

其中package_name是文件夹名，它必须与whatever_name1文件中使用的包名匹配。Go和whatever_name . Go。换句话说，带有子目录的所有文件应该属于同一个包。

只要在导入中指定父文件夹的整个路径，就可以进一步嵌套更多子目录。