Relative imports in Go

I have a go Project with the following directory structure

utils(pkg)
   | auth.go (has a function names test1)
controllers(pkg)
   | login.go (has a function names test2)

I am trying to access function test1 from login.go. Here is what I have done

import "../utils"

func test2(c *gin.Context) bool{
      utils.test1()
}

But I always get Unresolved reference test1. I am new to go . Can anyone help why I am getting this error?

No there is no relative import in Go.
you should use the absolute path considering GOPATH:

The GOPATH environment variable specifies the location of your workspace. It is likely the only environment variable you'll need to set when developing Go code. To get started, create a workspace directory and set GOPATH accordingly. see: https://golang.org/doc/code.html#GOPATH

> ### Import paths > > An import path is a string that uniquely identifies a package. A package's import path corresponds to its location inside a workspace > or in a remote repository (explained below). > > The packages from the standard library are given short import paths > such as "fmt" and "net/http". For your own packages, you must choose a > base path that is unlikely to collide with future additions to the > standard library or other external libraries. > > If you keep your code in a source repository somewhere, then you should use the root of that source repository as your base path. For > instance, if you have a GitHub account at github.com/user, that should > be your base path. > > Note that you don't need to publish your code to a remote repository > before you can build it. It's just a good habit to organize your code > as if you will publish it someday. In practice you can choose any > arbitrary path name, as long as it is unique to the standard library > and greater Go ecosystem.

Example:

This example assumes you have set GOPATH=/goworkdir in your OS environment.

File: goworkdir/src/project1/utils/auth.go

package utils

func Test1() string {
	return "Test1"
}

File: goworkdir/src/project1/controllers/login.go

package controllers

import "project1/utils"

func Test2() string {
	return utils.Test1()
}

File: goworkdir/src/project1/main.go

package main

import (
	"fmt"
	"project1/controllers"
)

func main() {
	fmt.Println(controllers.Test2())
}

Now if you go run main.go you should see output:

Test1

This is now different since the introduction of go modules, from go 1.11.

Thus, if you switch to go modules, and if your module is called "m", then the idiomatic way to do relative imports in your project tree would be to use: import "m/utils" and import "m/controllers" in places where you need to import those packages in your project. For details, see: https://github.com/golang/go/wiki/Modules#do-modules-work-with-relative-imports-like-import-subdir

---

GoLand users - by default these forms of imports appear as errors in the IDE. You need to enable Go Modules integration in settings

Here is another example project structure with file contents required to import correctly:

test1/
   utils/
      texts.go
   main.go
   go.mod

with following contents:

go.mod:

module mycompany.com/mytest

go 1.15

utils/texts.go (to make a function visible from a different package, it needs to start with an uppercase letter):

package utils

func GetText() string {
  return "hello world"
}

main.go (only the full import name is supported, there is no shortcut to import from the same module easier):

package main

import (
  "fmt"
  "mycompany.com/mytest/test1/utils"
)

func main() {
  fmt.Println(utils.GetText())
}

Given this directory configuration:

.
├── controllers
│   └── login.go
├── main.go
└── utils
    └── auth.go

File main.go:

package main

import "./controllers"

func main() {
	controllers.Test2("Hello")
}

File controllers/login.go:

package controllers

import "../utils"

func Test2(msg string) {
	utils.Test1(msg)
}

File utils/auth.go:

package utils

import . "fmt"

func Test1(msg string) {
	Println(msg)
}

Result works:

$ go build -o program main.go 
$ ./program 
Hello

So what you wanted to do works. The only difference is that I've used upper case function names, because it's required to export symbols.

I think you can just crate a vendor directory next to your source file, which acts like a relative GOPATH, and then create a relative symlink, which links to the package you want to import inside the vendor directory, and then import the package as if the vendor directory is your $GOPATH/src/.

It's possible as of Go 1.16, although still not as straightforward as it could be, by editing the go.mod file to resolve the package name to a relative path:

if you have a hello and a greeting packages side by side (hello contains main.go):

<home>/
 |-- greetings/  
    |--go.mod       <- init this as infra/greetings
    |--greetings.go <- let's say that this package is called greetings
 |-- hello/
    |--go.mod   <- init this as whatever/hello
    |--main.go  <- import infra/greetings

then edit hello's go.mod file and get the package:

go mod edit -replace infra/greetings=../greetings
go get infra/greetings
go mod tidy

There's a full example in the official documentation but hey, this might change again in the next version of Go.