I usually see ./... in golang
for example go test ./...or go fmt ./...
only know the meaning of one or two dots
It means perform the action on all packages under a directory. So for example go test ./... runs go test on the current dir + all subdirectories.
The Go tool documentation is here:
https://golang.org/doc/cmd
./... means a recursive action ( ... ) from your current directory ( ./ )
An import path beginning with ./ or ../ is called a relative path. The toolchain supports relative import paths as a shortcut in two ways.
First, a relative path can be used as a shorthand on the command line. If you are working in the directory containing the code imported as "unicode" and want to run the tests for "unicode/utf8", you can type "go test ./utf8" instead of needing to specify the full path. Similarly, in the reverse situation, "go test .." will test "unicode" from the "unicode/utf8" directory. Relative patterns are also allowed, like "go test ./..." to test all subdirectories. See 'go help packages' for details on the pattern syntax.
Second, if you are compiling a Go program not in a work space, you can use a relative path in an import statement in that program to refer to nearby code also not in a work space. This makes it easy to experiment with small multipackage programs outside of the usual work spaces, but such programs cannot be installed with "go install" (there is no work space in which to install them), so they are rebuilt from scratch each time they are built. To avoid ambiguity, Go programs cannot use relative import paths within a work space.
Run go help importpath or see the docs here https://pkg.go.dev/cmd/go#hdr-Relative_import_paths
Related
Is it possible to set the workdir to a different path?
For example, I want to run go build from the root path, but my source code is under a different directory, and I do not want to cd to it.
npm, for example, has the --prefix, which serves for this purpose.
Yes, its possible.
go build -o [output file path/name] [source code file path/name]
For example, if your source code file is located in projectdir/code/src/ and want to build and save output to projectdir/code/out, do following:
$ go build -o projectdir/code/out/main projectdir/code/src/main.go
As per go build documentation:
If the named output is an existing directory or ends with a slash or
backslash, then any resulting executables will be written to that
directory.
So our above build command can be rewritten like this:
go build -o projectdir/code/out/ projectdir/code/src/main.go
and it will generate executable named main in projectdir/code/out/ directory.
For more details, run go help build
No, this is not possible with 1.19. Just cd into it.
Go 1.20 (yet unreleased) brings the -C flag which might be what you want.
I write some code then build the app to an output file, but sometimes I just want to check if the app is buildable, i.e. has no errors and produces a compiled output, but without actually writing the output file.
I tried this variant and it seemed to work:
go build -o /dev/null myapp
But I suspect there must be a more "official" Go way to check if it can build.
Please advise!
To check if a package or app is buildable, go build is the "official" way.
What you did is the easiest way. In my opinion, you should stick to it. Alternatively you may do:
go build -o delme && rm delme
But it's somewhat slower as it has to write the result which is then deleted, but this solution is platform independent (as /dev/null does not exist on windows).
When building a command (main package), by definition go build will create and leave the result in the current working directory. If you build a "normal" package (non-main), the results will be discarded. See details here: What does go build build?
So if it bothers you that you have to use the -o /dev/null param or manually delete the result, you may "transform" your main package to a non-main, let's call it main2. And add a new main package which should do nothing else but import and call main2.Main(). Building the main2 package will not leave any files behind.
E.g. myapp/main.go:
package main
import "myapp/main2"
func main() { main2.Main() }
myapp/main2/main2.go:
// Every content you originally had in main.go
package main2
func Main() {
// ...
}
How to check if a go app is buildable?
As I understand your question, you wanted to see if the file you're editing has no error.
then you can use vim-go plugin for vim.
And then setup your .vimrc for creating the shortcut :
"shortcut for vim-go
au FileType go nmap <leader>r <Plug>(go-run)
au FileType go nmap <leader>b <Plug>(go-build)
au FileType go nmap <leader>t <Plug>(go-test)
au FileType go nmap <leader>c <Plug>(go-coverage)
I use this as my daily work life when I want to see my file has no error I just type \+b. and then it will output the error without typing go build in the terminal.
hope it helps.
One way would be gofmt -e my_file.go on all files, but:
that would not scale well
This doesn't actually report all errors that go build might.
Meaning: go build -o /dev/null might still be the more thorough approach.
For just validating syntax and structure: see gotype
I use VSCode and I've found it to be the better than Sublime when it comes to Go with this extension.
When I save the document, it formats it well. It shows the the errors as I write code with the help of golint making development very manageable.
You can also use golint separately just like gofmt.
You can also try go vet. There are debates going on around what to use when but I'd just advise to use both if you can.
This question already has answers here:
What do three dots "./..." mean in Go command line invocations?
(2 answers)
Closed 6 years ago.
I am having trouble understanding what the following command does.
go list ./...
When I look at the official documentation https://golang.org/cmd/go/#hdr-List_packages, it is not clear to me what the ./... argument is telling the command.
go list requires an import path for a package and can give you some listing info for the packages matched this way (you may be interested in its -f flag).
./... is a wildcard that matches the current folder and all of its subfolders (execute go help packages to read more about this somewhat hidden feature), and that can be used with all the built-in Go commands.
So go list ./... can list all the Go packages in the current folder and its sub-folders - you may want to call it from GOPATH for example.
go list ./...
Here ./ tells to start from the current folder, ... tells to go down recursively.
go list ...
In any folder lists all the packages, including packages of the standard library first followed by external libraries in your go workspace.
When you have multiple .go files in a main package, i need to list them all out when doing a go run.
So when i have main.go, a.go, b.go and they all belong to the main package, i need to type go run main.go a.go b.go in order to use functions and structs inside the other 2 go files. The go build command however, is smart enough to link all files together automatically.
Have i misunderstood something about Go, or is this normal (listing out all the files in the main package when doing a go run)?
The short answer is: you need to list them all out. You can do this with shell tricks, if you're desperate. I usually just write a shell script to go build and then run the resulting executable, after it gets too annoying.
# this works unless you have _test.go files
go run *.go
# if you really want to... enable extended glob
shopt -s extglob
# so you can do something like this (matches all .go except *_test.go files)
go run !(*_test).go
Check out this thread: https://groups.google.com/forum/#!topic/golang-nuts/EOi0VAQNA4c
If your source is in $GOPATH/src
as in
$GOPATH/src/somedir/main.go
$GOPATH/src/somedir/a.go
$GOPATH/src/somedir/b.go
doing "go install somedir" will compile and install the somedir binary in to $GOPATH/bin
no need to list out the files individually
"go install" finds all the files on it's own.
My common work cycle with go is (from my bash prompt):
$ clear; go install myproj && $GOPATH/bin/myproj
which, clears the screen, builds and installs "myproj" and then runs it
so, after I change code, I just hit Ctrl-C, Up arrow, and enter.
Entire cycle time is ~1 second (for small to start stuff)
go tool can create a binary and place it to GOBIN if package contains a main sub package (or if package is a main). Is there a possibility to create a few (at least two) binaries with single go install package command? Meaning without using GNU make for this purposes.
Thank you.
It is definitely possible if all commands are under a common directory, using go install root/.... The trailing three dots tell the go command to do this for all packages under this directory. The same three-dots notation works for go get or go build and probably all go commands.
An import path is a pattern if it includes one or more "..." wildcards, each of which can match any string, including the empty string and strings containing slashes. Such a pattern expands to all package directories found in the GOPATH trees with names matching the patterns. As a special case, x/... matches x as well as x's subdirectories. For example, net/... expands to net and packages in its subdirectories.
http://golang.org/cmd/go/
AFAIK this is not possible. The usual convential is that you put your binaries into packages that have cmd as their last path element. People can then install all the binaries like this:
go get code.google.com/p/codesearch/cmd/{cindex,csearch,cgrep}