Como usar o comando GO INSTALL

A equipe da comunidade de código aberto da China fez sua primeira transmissão ao vivo, contando a história por trás da comunidade de código aberto da China em nome do compartilhamento."

Quer executar um programa Go como um binário executável completo? O comando Go install compila e instala o aplicativo no diretório bin do espaço de trabalho. Métodos como abaixo.

Traduzido de Golang: Como usar o comando Go Install , autor Jack Wallen.

A linguagem Go possui um comando especial que compila e instala o pacote binário de um aplicativo em um caminho acessível aos usuários do aplicativo.

Deixe-me explicar de uma forma que todos possamos entender.

Primeiro, vamos falar sobre PATH. PATH é uma lista especial de diretórios que instrui o sistema onde encontrar os arquivos executáveis necessários para executar um comando. Por exemplo: Para Linux, execute o comando...

echo $PATH

Você pode ver algo assim na saída:

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

Essencialmente, isso significa que qualquer arquivo executável localizado nesses diretórios pode ser executado em qualquer lugar na hierarquia do sistema de arquivos. Graças ao PATH, você não precisa usar o caminho completo para comandos como ls, que é:

/usr/bin/ls

Em vez disso, você pode simplesmente executar ls para usar o aplicativo.

Quando você instala o Go, ele assume que o caminho padrão do Go é um local específico. Para descobrir onde está esse caminho, emita o comando:

echo $GOPATH

Você deverá ver algo assim:

/home/jack/go/

Você pode definir esse caminho usando o seguinte comando:

go env -w GOPATH=$HOME/go

Observe que $HOME é equivalente a _/home/USER_ (onde _USER_ é seu nome de usuário do Linux). Você também pode configurá-lo no arquivo .bash_profile. Abra o arquivo para edição usando o seguinte comando:

nano ~/.bash_profile

Na parte inferior do arquivo, adicione o seguinte:

export GOPATH=$HOME/go

Use o seguinte comando para obter o arquivo:

source ~/.bash_profile

Você pode alterar esse caminho se quiser, mas é melhor sempre deixá-lo como está (principalmente no início).

Pronto, agora você sabe o que é GOPATH e como usá-lo?

deixe-me dizer-lhe.

Vamos escrever um programa para calcular uma aproximação de pi. Veja como este aplicativo funciona:

Importe pacotes fmt , math e math/rand .
Defina a semente do gerador de números aleatórios, definindo _totalPoints_ como 1 milhão e _pointsInsideCircle_ como 0.
Use um loop for para iterar sobre _totalPoints_, defina xey como um número de ponto flutuante aleatório de 64 e multiplique x_x e y_y usando esses números (usando a função _math.Sqrt_).
Defina _pi approx_ como 4 vezes o float64 de _pointsInsideCircle_ e _totalPoints_.
Por fim, imprima o valor.

Aqui está o código:

package main

import (
        "fmt"
        "math"
        "math/rand"
)

func main() {
        rand.Seed(42)
        totalPoints := 1000000
        pointsInsideCircle := 0

        for i := 0; i &lt; totalPoints; i++ {
                x := rand.Float64()
                y := rand.Float64()

                distance := math.Sqrt(x*x + y*y)

                if distance &lt; 1 {
                        pointsInsideCircle++
                }
        }

        piApprox := 4 * float64(pointsInsideCircle) / float64(totalPoints)
        fmt.Printf("Using this method, our approximate value of π: %f\n", piApprox)

}

Crie um novo diretório de projeto usando o seguinte comando:

mkdir ~/randompi

Mude para este diretório usando o seguinte comando:

cd randompi

Inicialize o projeto usando o seguinte comando:

go mod init randompi

Crie o arquivo main.go usando o seguinte comando:

nano main.go

Cole o código neste arquivo e salve-o.

Crie o aplicativo usando o seguinte comando:

go build

Agora você deve ver um executável binário chamado _randompi_. Você pode executar um novo aplicativo Go usando o seguinte comando:

./randompi

maravilhoso. Mas e se você quiser executar o comando em um diretório diferente? Como este é o Linux, você pode copiá-lo para o diretório /usr/local/bin, mas o Go já fornece um GOPATH para esse propósito. Para fazer isso, você pode usar go install, que moverá o novo binário para o seu GOPATH. Para fazer isso, emita o seguinte comando:

go install

Se você executar o comando ls, descobrirá que o executável _randompi_ desapareceu. Para onde foi? Go o moveu para seu GOPATH. Lembre-se de listar seu GOPATH usando:

echo $GOPATH

Isso deve imprimir seu GOPATH. O truque aqui é que Go não apenas copia o executável para a raiz do seu GOPATH. Em vez disso, ele o copia para o diretório bin nesse caminho. Na terminologia Linux, bin é um diretório comum para arquivos binários (bin = binário). Para verificar se o arquivo executável foi copiado para o caminho, emita o seguinte comando:

ls $GOPATH/bin

Você deverá ver _randompi_ listado.

Se você conhece Linux , provavelmente já entende o que acontece a seguir. Mesmo que você tenha configurado GOPATH, isso não significa que ele esteja no seu Linux PATH. Mesmo com esse aviso, Go ajuda você com o comando run. Se você emitir o seguinte comando:

go run randompi

Ele encontrará o executável binário em $GOPATH/bin e executará o aplicativo randompi, sua saída será semelhante a:

Using this method, our approximate value of π: 3.139740

Aqui está um pequeno truque.

Ao inicializar seu aplicativo usando go mod init randompi, ele criará um arquivo go.mod que conterá algo como:

module randompi

go 1.22.1

Digamos que você queira renomear seu aplicativo para gopi. Tudo que você precisa fazer é editar o arquivo go.mod e alterar o módulo randompi para o módulo gopi. Recrie e reinstale o aplicativo, então você poderá executá-lo usando:

go run gopi

É isso meus amigos do Go , go installo básico do uso de comandos. Isso se tornará uma ferramenta importante para você à medida que continua aprendendo a linguagem Go .

Este artigo foi publicado pela primeira vez em Yunyunzhongsheng ( https://yylives.cc/ ), todos são bem-vindos para visitar.

Como usar o comando GO INSTALL

Acho que você gosta