12

I have a very simple Go project setup. At root directory I have go.mod file and main.go and a folder called main2. Inside main2 folder there is main2.go file.

/
|_ go.mod
|_ main.go
|_ main2
   |_ main2.go

From root directory I am trying to run go run command

go run main2/main2.go

and it throws error:

package command-line-arguments is not a main package

Can someone help?

blackgreen
  • 34,072
  • 23
  • 111
  • 129
mohit singla
  • 151
  • 1
  • 1
  • 7
  • 1
    Never use go run with filename arguments. – Volker Apr 28 '22 at 15:22
  • 7
    @Volker An explanation would be more helpful than a cryptic injunction. – jub0bs Apr 28 '22 at 16:42
  • 1
    @jub0bs `go run path/to/file.go` implies whatever file you're passing is the main package, and has a `main` function. If your main package(s) are somewhere in `cmd/foo/main.go`, it's highly likely you're either importing other packages, or there are other files in the main package containing functions that are being called from main. Say `cmd/foo/main.go` calls funcitons in `cmd/foo/helpers.go`, that file is not passed to `go run`, and thus the functions will be undefined, and go run will error. `go run` compiles and runs, so just `go build ./cmd/foo` and run the binary, easy and safer – Elias Van Ootegem Apr 28 '22 at 17:06

2 Answers2

9

The package of your main2.go file must be main. When there is a main package, and a function main in your project, the compiler knows it will be compiled as a executable, and not as a library.

So try to change package command-line-arguments to package main inside the main2/main2.go file.

Alex Lucchesi
  • 158
  • 8
  • Does it mean that we can only run main function of main package only and we can't run any other function of any other package other than main? – mohit singla Apr 28 '22 at 15:32
  • 1
    @mohitsingla You can create multiple functions in each package, and multiple packages. But to define the program entry point, you have to define a main package, and inside it you have to define a main function. See: https://go.dev/tour/basics/4 – Alex Lucchesi Apr 28 '22 at 15:50
6

Imagine a golang executable as a house with only a front door and many different rooms inside it. You can go through any door you want once you are in the house, but to get inside you have to go through the front door first. That front door is the main() function.

Golang's entry point into an executable is through main(). If you want to run different logic paths for a single executable, you can use main() as a routing function to the other packages using command line arguments:

package main

import (
    "os"
    "otherpackage"
    // Your child packages get imported here.
)

func main() {

    // The first argument
    // is always program name
    // So os.Args[1] is the first dynamic argument
    arg1 := os.Args[1]

    // use arg1 to decide which packages to call
    if arg1 == "option1" {
        // option1 code executes here.
        otherpackage.DoThis()
    }
    if arg1 == "option2" {
        // option2 code executes here.
        otherpackage.DoThat()
    }
}

Then you can run your program with something like:

go run main.go option1

From golang documentation:

Program execution A complete program is created by linking a single, unimported package called the main package with all the packages it imports, transitively. The main package must have package name main and declare a function main that takes no arguments and returns no value.

colsen
  • 573
  • 5
  • 13
  • Does it mean that we can only run main function of main package only and we can't run any other function of any other package other than main? – mohit singla Apr 28 '22 at 15:31
  • 1
    You can still run those other functions, but they have to be called somewhere along the call stack that originates from `main()` in `package main`. – colsen Apr 28 '22 at 17:28