Instale o ambiente de desenvolvimento de linguagem go no Ubuntu

arredores

VirtualBox
Ubuntu 18.04

Instale golang

Use a ferramenta de gerenciamento de pacotes do sistema para instalar o golang. A vantagem disso é que, mesmo que não seja a versão mais recente, não afetará o uso normal.

$ sudo apt-get install golang

Após a conclusão da instalação, use o comando go version para visualizar a versão

$ go version

Criar espaço de trabalho

Criar espaço de trabalho

O código Go deve ser colocado na área de trabalho. Na verdade, é um diretório, que contém três subdiretórios:

• O diretório src contém arquivos de origem Go, que são organizados em pacotes (cada diretório corresponde a um pacote),
• O diretório pkg contém objetos de pacote,
• diretório bin contém comandos executáveis

Use o comando mkdir para criar um espaço de trabalho

$ mkdir $HOME/go

Configurar a variável de ambiente GOPATH

A variável de ambiente GOPATH indica a localização da sua área de trabalho (observe que esta localização não pode ser igual ao seu diretório de instalação go)

$ export GOPATH=$HOME/go

Adicione o subdiretório bin desta área de trabalho ao seu PATH

$ export PATH=$PATH:$GOPATH/bin

Em seguida, execute a configuração

$ source $HOME/.profile

Depois que a configuração for bem-sucedida, você pode usar go env para verificar a configuração

$ go env

Criar caminho de pacote

Crie uma pasta no espaço de trabalho para armazenar seus arquivos de origem

$ mkdir -p $GOPATH/src/github.com/user

Crie o Hello World!

Primeiro selecione o caminho do pacote e, em seguida, crie o arquivo na pasta correspondente

$ mkdir $GOPATH/src/github.com/user/hello

Crie um arquivo
hello.go hello.go no diretório hello

package main

import "fmt"

func main() {
	fmt.Printf("Hello World!\n")
}

Em seguida, entre no diretório hello para executar o arquivo

$ go run hello.go

Instale as ferramentas e plug-ins necessários

Instale o git

$ sudo apt-get install git

Baixe o código fonte

# 创建文件夹（该命令要加-p，因为文件目录还不存在）
$ mkdir -p $GOPATH/src/golang.org/x/
# 下载源码
$ go get -d github.com/golang/tools
# copy 
$ cp $GOPATH/src/github.com/golang/tools $GOPATH/src/golang.org/x/ -rf

Kit de instalação

$ go install golang.org/x/tools/go/buildutil

Instale e execute o programa hello

$ go install github.com/user/hello

Este comando irá criar um arquivo binário executável denominado hello, instalá-lo no arquivo bin do espaço de trabalho e construir um comando hello.

Nota: Ao alterar seu arquivo, você deve reconstruir seu programa, caso contrário, ele será executável O binário ainda é o arquivo anterior e o resultado da execução do arquivo não mudará

Instale go tour

$ go get github.com/Go-zh/tour/gotour
$ gotour

Meu primeiro pacote e teste

Sua primeira biblioteca

Escreva sua própria biblioteca e deixe o programa hello usá-la.
Selecione o caminho do pacote e crie um diretório

$ mkdir $GOPATH/src/github.com/user/stringutil

Crie o arquivo reverse.go no diretório

// stringutil 包含有用于处理字符串的工具函数。
package stringutil

// Reverse 将其实参字符串以符文为单位左右反转。
func Reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

Crie o arquivo com o comando go build

$ go build github.com/user/stringutil

Modifique o programa hello anterior e use a biblioteca recém-criada

package main

import (
	"fmt"

	"github.com/user/stringutil"
)

func main() {
	fmt.Printf(stringutil.Reverse("!oG ,olleH"))
}

Reinstale o arquivo hello com go install

$ go install github.com/user/hello

teste

Go tem uma estrutura de teste leve, que consiste no comando go test e no pacote de teste.

Você pode escrever um teste criando um arquivo cujo nome termina em _test.go e contém funções chamadas TestXXX e assinadas como func (t * testing.T). O framework de teste executará cada uma dessas funções; se a função chamar uma função que indica falha, como t.Error ou t.Fail, o teste indica falha.

Podemos adicionar testes para stringutil criando o arquivo $ GOPATH / src / github.com / user / stringutil / reverse_test.go

package stringutil

import "testing"

func TestReverse(t *testing.T) {
	cases := []struct {
		in, want string
	}{
		{"Hello, world", "dlrow ,olleH"},
		{"Hello, 世界", "界世 ,olleH"},
		{"", ""},
	}
	for _, c := range cases {
		got := Reverse(c.in)
		if got != c.want {
			t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want)
		}
	}
}

Use go test para testar

$ go test github.com/user/stringutil

Resumo do problema

1. Preste atenção à exatidão do caminho ao criar o espaço de trabalho e arquivos de diretório. Se o caminho não existir ao criar o arquivo, adicione o parâmetro -p
. 2. Cada vez que você modificar o programa, você deve reinstalar a instrução temporária para atualizar a instrução temporária. Caso contrário, ainda execute o arquivo executável anterior