Go

https://go.dev/doc/
Admin
Go is an open-source, statically typed, compiled programming language designed for productivity,...
Tokens:702,545
Snippets:5,895
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install and run go-contrib-init

Source: https://go.dev/doc/contribute

Automated tool to walk through contributor setup steps. Run go install, then cd to the code directory and run go-contrib-init.

```shell
$ go install golang.org/x/tools/cmd/go-contrib-init@latest
$ cd /code/to/edit
$ go-contrib-init
```

--------------------------------

### Install and run the Go tour locally

Source: https://go.dev/doc/go1.12

The tour is no longer included in the binary distribution. Install it with go get and then run the tour command.

```bash
go get -u golang.org/x/tour
tour
```

--------------------------------

### Install packages with go get

Source: https://go.dev/doc/articles/go_command

Use `go get` to download and install packages from remote repositories. The example installs the codesearch index and GoLLRB libraries into $HOME/go.

```shell
$ go get github.com/google/codesearch/index
$ go get github.com/petar/GoLLRB/llrb
$
```

--------------------------------

### main function with router setup

Source: https://go.dev/doc/tutorial/web-service-gin

This code initializes a Gin router, associates the GET /albums path with the getAlbums handler, and starts the server on localhost:8080.

```go
func main() {
    router := gin.Default()
    router.GET("/albums", getAlbums)

    router.Run("localhost:8080")
}
```

--------------------------------

### Build and install with go install

Source: https://go.dev/doc/code

Builds and installs the hello command. The binary is placed in $HOME/go/bin/hello (or %USERPROFILE%\go\bin\hello.exe on Windows).

```bash
$ go install example/user/hello
$
```

--------------------------------

### Install the cover tool with go get

Source: https://go.dev/doc/go1.2

Command to install the cover tool from the go.tools subrepository. Run this before using coverage features.

```shell
$ go get code.google.com/p/go.tools/cmd/cover
```

--------------------------------

### Install command for basic command

Source: https://go.dev/doc/modules/layout

Shows how users install the command using go install with the module path and @latest.

```shell
$ go install github.com/someuser/modname@latest
```

--------------------------------

### Install the Tour of Go locally

Source: https://go.dev/doc/

Use the go install command to download and install the interactive Tour of Go binary into your GOPATH's bin directory.

```shell
$ go install golang.org/x/website/tour@latest
```

--------------------------------

### Compile and install the package with go install

Source: https://go.dev/doc/tutorial/compile-install

Run this command after updating the shell path to compile and install the package.

```shell
$ go install
```

--------------------------------

### Install and run the hello program

Source: https://go.dev/doc/code

Commands to install the hello program with go install and run it. The output shows the reversed message 'Hello, Go!'.

```shell
$ go install example/user/hello
```

```shell
$ hello
Hello, Go!
```

--------------------------------

### Discover the Go install path with go list

Source: https://go.dev/doc/tutorial/compile-install

Run this command to find the install path where the go command will install the current package. The output might be something like /home/gopher/bin/hello.

```shell
$ go list -f '{{.Target}}'
```

--------------------------------

### Build output example

Source: https://go.dev/doc/install/source

Example output after a successful build, showing the installed location and the need to add the bin directory to $PATH.

```text
---
Installed Go for linux/amd64 in /home/you/go.
Installed commands in /home/you/go/bin.
*** You need to add /home/you/go/bin to your $PATH. ***
```

--------------------------------

### Create and enter project directory

Source: https://go.dev/doc/tutorial/web-service-gin

Commands to create a directory named 'web-service-gin' and change into it.

```bash
$ mkdir web-service-gin
$ cd web-service-gin
```

--------------------------------

### Create and enter hello directory

Source: https://go.dev/doc/tutorial/getting-started

Creates a new directory named 'hello' and changes into it, preparing the workspace for your first Go source file.

```bash
mkdir hello
cd hello
```

--------------------------------

### Install and run godoc webserver manually

Source: https://go.dev/doc/go1.13

The godoc webserver is no longer included in the main binary distribution. Install it manually with `go get golang.org/x/tools/cmd/godoc` and then run `godoc`.

```shell
go get golang.org/x/tools/cmd/godoc
godoc
```

--------------------------------

### Operate on current directory with go list, go test -v, and go install

Source: https://go.dev/doc/articles/go_command

When no paths are given, go subcommands operate on the current directory. This example shows `go list`, `go test -v`, and `go install` in sequence, with the test output and the install command.

```shell
$ cd github.com/google/codesearch/regexp
$ go list
github.com/google/codesearch/regexp
$ go test -v
=== RUN   TestNstateEnc
--- PASS: TestNstateEnc (0.00s)
=== RUN   TestMatch
--- PASS: TestMatch (0.00s)
=== RUN   TestGrep
--- PASS: TestGrep (0.00s)
PASS
ok  	github.com/google/codesearch/regexp	0.018s
$ go install
$
```

--------------------------------

### Hello world program

Source: https://go.dev/doc/install/source

Simple Go program to test the installation. Save as hello.go and run with the go tool.

```go
package main

import "fmt"

func main() {
	fmt.Printf("hello, world\n")
}
```

--------------------------------

### Run the installed hello program

Source: https://go.dev/doc/code

Adds the install directory to PATH and runs the hello command, which prints 'Hello, world.' The command uses go list to find the target path.

```bash
# Windows users should consult /wiki/SettingGOPATH
# for setting %PATH%.
$ export PATH=$PATH:$(dirname $(go list -f '{{.Target}}' .))
$ hello
Hello, world.
$
```

--------------------------------

### Conversion parenthesization examples

Source: https://go.dev/ref/spec

Shows when parentheses are required to avoid ambiguity when the type starts with * or <-, or with func and no result list.

```go
*Point(p)        // same as *(Point(p))
(*Point)(p)      // p is converted to *Point
<-chan int(c)    // same as <-(chan int(c))
(<-chan int)(c)  // c is converted to <-chan int
func()(x)        // function signature func() x
(func())(x)      // x is converted to func()
(func() int)(x)  // x is converted to func() int
func() int(x)    // x is converted to func() int (unambiguous)
```

--------------------------------

### Equivalent go install commands

Source: https://go.dev/doc/code

Three equivalent ways to install the package from the working directory: using the full module path, a relative path '.', or no path at all.

```bash
$ go install example/user/hello
```

```bash
$ go install .
```

```bash
$ go install
```

--------------------------------

### Developers fetch module with go get

Source: https://go.dev/doc/modules/publishing

Example of how developers can resolve a dependency on the published module, specifying a particular version.

```bash
$ go get example.com/mymodule@v0.1.0
```

--------------------------------

### Go statement examples

Source: https://go.dev/ref/spec

Starts a goroutine with a function call or an anonymous function. The function executes concurrently; return values are discarded.

```go
go Server()
go func(ch chan<- bool) { for { sleep(10); ch <- true }} (c)
```

--------------------------------

### Go: Initialization order example

Source: https://go.dev/ref/spec

Demonstrates the initialization order (d, b, c, a) based on dependencies. The order of subexpressions in initialization expressions is irrelevant.

```go
var (
	a = c + b  // == 9
	b = f()    // == 4
	c = f()    // == 5
	d = 3      // == 5 after initialization has finished
)

func f() int {
	d++
	return d
}
```

--------------------------------

### Using Elem to get a settable value

Source: https://go.dev/blog/laws-of-reflection

This example shows that calling Elem on a pointer reflection value yields a settable reflection value.

```go
v := p.Elem()
fmt.Println("settability of v:", v.CanSet())
```

```text
settability of v: true
```

--------------------------------

### Initialize Go module

Source: https://go.dev/doc/tutorial/web-service-gin

Runs 'go mod init' with the module path 'example/web-service-gin', creating a go.mod file for dependency tracking. The output confirms the module creation.

```bash
$ go mod init example/web-service-gin
go: creating new go.mod: module example/web-service-gin
```

--------------------------------

### Goroutine during init

Source: https://go.dev/doc/go1

Go 1 allows goroutines to run during initialization. This example shows an init function that starts a goroutine and waits for a value on a channel, which was previously a deadlock risk.

```go
var PackageGlobal int

func init() {
    c := make(chan int)
    go initializationFunction(c)
    PackageGlobal = <-c
}

```

--------------------------------

### Install govulncheck with go install

Source: https://go.dev/doc/tutorial/govulncheck

Installs the latest version of govulncheck using the go install command.

```bash
$ go install golang.org/x/vuln/cmd/govulncheck@latest

```

--------------------------------

### Initialize hello module with go mod init

Source: https://go.dev/doc/tutorial/call-module-code

Runs go mod init with the module path example.com/hello. The output shows the creation of go.mod.

```bash
$ go mod init example.com/hello
go: creating new go.mod: module example.com/hello
```

--------------------------------

### go build -cover example with go.mod, myprogram.go, greetings.go, and build command

Source: https://go.dev/doc/build-cover

Shows a toy program with a main package, a local greetings package, and external dependencies. The go build -cover command includes only the main and greetings packages in the coverage profile.

```bash
$ cat go.mod
module mydomain.com

go 1.20

require rsc.io/quote v1.5.2

require (
    golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c // indirect
    rsc.io/sampler v1.3.0 // indirect
)

```

```go
$ cat myprogram.go
package main

import (
    "fmt"
    "mydomain.com/greetings"
    "rsc.io/quote"
)

func main() {
    fmt.Printf("I say %q and %q\n", quote.Hello(), greetings.Goodbye())
}

```

```go
$ cat greetings/greetings.go
package greetings

func Goodbye() string {
    return "see ya"
}

```

```bash
$ go build -cover -o myprogram.exe .
$
```

--------------------------------

### Install gopls with go install

Source: https://go.dev/doc/install/source

Installs the gopls tool from the golang.org/x/tools repository at the latest version. Requires Go to be installed and the go command available in the PATH.

```shell
$ go install golang.org/x/tools/gopls@latest
```
Tokens:
Raw