One place for hosting & domains

      GOPATH

      Entendendo o GOPATH


      Introdução

      Este artigo irá orientá-lo para entender o que é o GOPATH, como ele funciona e como configurá-lo. Este é um passo crucial para configurar um ambiente de desenvolvimento em Go, além de entender como o Go encontra, instala e compila arquivos fonte. Neste artigo, usaremos o GOPATH ao fazer referência ao conceito da estrutura de pastas sobe a qual iremos discutir. Vamos usar $GOPATH para nos referir à variável de ambiente que o Go usa para encontrar a estrutura de pasta.

      É através de um Go Workspace que o Go gerencia nossos arquivos fonte, binários compilados e objetos em cache usados para obter uma compilação mais rápida posteriormente. O normal e também o recomendável é ter somente um Go Workspace, embora seja possível ter vários espaços. O GOPATH atua como a pasta raiz de um espaço de trabalho.

      Configurando a variável de ambiente $GOPATH

      A variável de ambiente $GOPATH lista locais para o Go procurar por Go Workspaces.

      Por padrão, o Go pressupõe que o nosso local da GOPATH fique em $HOME/go, na qual $HOME é o diretório raiz da nossa conta de usuário em nosso computador. Podemos alterar isso definindo a variável de ambiente $GOPATH. Para um estudo mais aprofundado, siga este tutorial no artigo sobre Como ler e definir variáveis de ambiente em Linux.

      Para obter mais informações sobre a configuração da variável $GOPATH, consulte a documentação do Go.

      Além disso, esta série traz orientações sobre a instalação do Go e a configuração de um ambiente de desenvolvimento em Go.

      $GOPATH não é $GOROOT

      O $GOROOT é onde o código,o compilador e as ferramentas do Go se encontram — este** não **é o nosso código fonte. O $GOROOT é geralmente algo como /usr/local/go. Nosso $GOPATH é geralmente algo como $HOME/go.

      Embora não precisemos mais configurar especificamente a variável $GOROOT, ela ainda é mencionada em materiais mais antigos.

      Agora, vamos discutir a estrutura do Go Workspace.

      Anatomia do Go Workspace

      Dentro de um Go Workspace, ou GOPATH, há três diretórios: bin, pkg e src. Cada um desses diretórios tem um significado especial para a cadeia de ferramentas Go.

      .
      ├── bin
      ├── pkg
      └── src
        └── github.com/foo/bar
          └── bar.go
      

      Vamos ver cada um desses diretórios.

      O diretório $GOPATH/bin é onde o Go coloca binários que o go install compila. Nosso sistema operacional usa a variável de ambiente $PATH para encontrar aplicativos binários que possam ser executados sem um caminho completo. É recomendável adicionar esse diretório à nossa variável global $PATH.

      Por exemplo, se não adicionarmos $GOPATH/bin ao $PATH para executar um programa dali, teríamos que executar:

      Quando o $GOPATH/bin é adicionado ao $PATH, podemos fazer a mesma chamada desta forma:

      O diretório $GOPATH/pkg é onde o Go armazena arquivos de objeto pré-compilados para acelerar a compilação subsequente de programas. Normalmente, a maioria dos desenvolvedores não precisará acessar esse diretório. Se tiver problemas com a compilação, você pode excluir esse diretório com segurança e o Go irá então recompilá-lo.

      O diretório src é onde todos os nossos arquivos .go, ou código fonte, devem estar localizados. Isso não deve ser confundido com o código fonte que as ferramentas do Go usa, as quais ficam localizadas no $GOROOT. À medida que escrevermos aplicativos, pacotes e bibliotecas em Go, colocaremos esses arquivos em $GOPATH/src/path/to/code.

      O que são pacotes?

      O código do Go é organizado em pacotes. Um pacote representa todos os arquivos em um único diretório no disco. Um diretório pode conter apenas certos arquivos do mesmo pacote. Os pacotes são armazenados com todos os arquivos Go fonte gravados pelo usuário, sob o diretório $GOPATH/src. Podemos entender a resolução de pacotes importando pacotes diferentes.

      Se nosso código reside em $GOPATH/src/blue/red, então seu nome de pacote deve ser red.

      A instrução de importação para o pacote red seria:

      import "blue/red"
      

      Os pacotes que residem em repositórios de código fonte, como o GitHub e o BitBucket, têm o local completo do repositório como parte de seu caminho de importação.

      Por exemplo, importaríamos o código fonte em https://github.com/gobuffalo/buffalo usando o seguinte caminho de importação:

      import "github.com/gobuffalo/buffalo"
      

      Portanto, esse código fonte estaria no seguinte local em disco:

      $GOPATH/src/github.com/gobuffalo/buffalo
      

      Conclusão

      Neste artigo, discutimos o GOPATH como um conjunto de pastas dentro das quais o Go espera que o nosso código fonte resida, bem como o que são e o que contêm tais pastas. Discutimos como alterar essa localização do padrão $HOME/go para o que for escolhido pelo usuário, definindo a variável de ambiente $GOPATH. Por fim, discutimos como o Go procura pacotes dentro daquela estrutura de pastas.

      Apresentado no Go 1.11, o objetivo do Go Modules é substituir o Go Workspaces e o GOPATH. Embora seja recomendável começar a usar módulos, alguns ambientes, como ambientes corporativos, podem não estar prontos para usá-los.

      O GOPATH é um dos aspectos mais complicados da configuração do Go. Porém, uma vez configurado, normalmente podemos esquecer que ele existe.



      Source link

      Información sobre GOPATH


      Introducción

      Este artículo le servirá como guía para comprender GOPATH, su funcionamiento y su configuración. Este paso es crucial para configurar un entorno de desarrollo de Go, así como para comprender cómo se ubican, instalan y construyen archivos de origen en Go. En este artículo, usaremos GOPATH al hacer referencia al concepto de estructura de carpetas que analizaremos. Usaremos $GOPATH para hacer referencia a la variable de entorno que se utiliza en Go para encontrar la estructura de carpetas.

      Un espacio de trabajo de Go es la alternativa con la que se administran en Go nuestros archivos de origen, binarios compilados y objetos almacenados en caché que se utilizan para acelerar la compilación posteriormente. Es habitual, y también aconsejable, tener solo un espacio de trabajo de Go, aunque es posible contar con varios. GOPATH funciona como una carpeta root de un espacio de trabajo.

      Configurar la variable de entorno $GOPATH

      En la variable de entorno $GOPATH se listan las ubicaciones para que en Go se busquen los espacios de trabajo de Go.

      Por defecto, en Go se supone que nuestra ubicación de GOPATH se encuentra en $HOME/go, donde $HOME es el directorio root de nuestra cuenta de usuario en nuestra computadora. Podemos cambiarlo configurando la variable de entorno $GOPATH. Para obtener más información, siga este tutorial sobre lectura y configuración de variables de entorno en Linux.

      Para obtener más información sobre la configuración de la variable $GOPATH, consulte la documentación de Go.

      Además, en esta serie se analizan la instalación de Go y la configuración de un entorno de desarrollo del mismo.

      $GOPATH No es $GOROOT

      $GOROOT es el punto en el que se encuentran el código, el compilador y las herramientas de Go, no es nuestro código fuente. $GOROOT generalmente es similar a /usr/local/go. Nuestra $GOPATH generalmente es similar a $HOME/go.

      Aunque ya no necesitamos configurar la variable $GOROOT específicamente , todavía se hace referencia a esta en documentos anteriores.

      Ahora, revisaremos la estructura del espacio de trabajo de Go.

      Anatomía del espacio de trabajo de Go

      Dentro de un espacio de trabajo de Go, o GOPATH, hay tres directorios: bin, pkg y src. Cada uno de estos directorios tiene un significado especial para las herramientas de Go.

      .
      ├── bin
      ├── pkg
      └── src
        └── github.com/foo/bar
          └── bar.go
      

      Revisemos cada uno de estos directorios.

      En el directorio $GOPATH/bin es donde Go dispone los binarios que se compilan en go install. Nuestro sistema operativo utiliza la variable de entorno $PATH para encontrar aplicaciones binarias que pueden ejecutarse sin una ruta completa. Se recomienda añadir este directorio a nuestra variable global $PATH.

      Por ejemplo, si no añadimos $GOPATH/bin a $PATH para ejecutar un programa desde este, tendríamos que ejecutar lo siguiente:

      Cuando $GOPATH/bin se añade a $PATH, podemos realizar la misma invocación como se muestra a continuación:

      En el directorio $GOPATH/pkg se almacenan los archivos de objetos previamente compilados de Go para acelerar la compilación posterior de los programas. Normalmente, la mayoría de los desarrolladores no necesitarán acceder a este directorio. Si experimenta problemas relacionados con la compilación, puede eliminar este directorio sin peligro; Go lo reconstruirá.

      El directorio src es el punto en el que todos nuestros archivos .go o de código fuente deben ubicarse. Esto no debe confundirse con el código fuente que se utiliza en la herramienta de Go, el cual se encuentra en el $GOROOT. A medida que escribamos aplicaciones, paquetes y bibliotecas de Go, dispondremos estos archivos en $GOPATH/src/path/to/code.

      ¿Qué son los paquetes?

      El código de Go se organiza en paquetes. Un paquete representa todos los archivos en un solo directorio en el disco. Un directorio solo puede contener ciertos archivos del mismo paquete. Los paquetes se almacenan, con todos los archivos de origen de Go escritos por los usuarios, en el directorio $GOPATH/src. Podemos comprender la resolución de paquetes importando diferentes paquetes.

      Si nuestro código reside en $GOPATH/src/blue/red, entonces el nombre de su paquete debería ser red.

      La instrucción import para el paquete red sería la siguiente:

      import "blue/red"
      

      Los paquetes que se alojan en los repositorios de código fuente, como GitHub y BitBucket, tienen la ubicación completa del repositorio como parte de su ruta de importación.

      Por ejemplo, importaríamos el código fuente de https://github.com/gobuffalo/buffalo usando la siguiente ruta de importación:

      import "github.com/gobuffalo/buffalo"
      

      Por lo tanto, este código fuente se encontraría en la siguiente ubicación en el disco:

      $GOPATH/src/github.com/gobuffalo/buffalo
      

      Conclusión

      A través de este artículo, analizamos GOPATH como un conjunto de carpetas en las que Go prevé que se encuentra nuestro código fuente, y también vimos qué son y qué contienen estas carpetas. Analizamos la forma de cambiar esa ubicación de la predeterminada $HOME/go por la que el usuario prefiera configurando la variable de entorno $GOPATH. Por último, analizamos la forma en que Go se busca paquetes dentro de esa estructura de carpetas.

      Los Go Modules se introdujeron en Go 1.11 y su propósito es sustituir los espacios de trabajo de Go y GOPATH. Si bien se recomienda comenzar a usar módulos, es posible que algunos entornos, como los corporativos, no estén listos para utilizar módulos.

      GOPATH es uno de los aspectos más complicados de la configuración de Go, pero una vez que está listo normalmente no hay de qué preocuparse.



      Source link

      Знакомство с GOPATH


      Введение

      Из этой статьи вы узнаете о GOPATH, принципах работы и настройке GOPATH. Это важный шаг для настройки среды разработки Go и понимания процесса поиска, установки и сборки исходных файлов Go. В этой статье мы будем использовать термин GOPATH для описания обсуждаемой концепции структуры папок. Термин $GOPATH будет означать переменную среды, используемую Go для поиска структуры папок.

      Рабочее пространство Go используется Go для управления исходными файлами, скомпилированными двоичными файлами и кэшированными объектами, используемыми впоследствии для ускорения компиляции. Обычно рекомендуется использовать только одно рабочее пространство Go, хотя их может быть и несколько. GOPATH выступает в качестве корневой папки рабочего пространства.

      Настройка переменной среды $GOPATH

      Переменная среды $GOPATH перечисляет места, где Go ищет рабочие пространства Go.

      По умолчанию Go использует в качестве GOPATH расположение $HOME/go, где $HOME — корневой каталог учетной записи пользователя нашего компьютера. Для изменения этой настройки следует изменить переменную среды $GOPATH. Дополнительную информацию можно найти в обучающем модуле по чтению и настройке переменных среды в Linux.

      Дополнительную информацию по настройке переменной $GOPATH можно найти в документации по Go.

      Кроме того, из этой серии вы можете подробно узнать об установке Go и настройке среды разработки Go.

      $GOPATH — это не $GOROOT

      Переменная $GOROOT определяет расположение кода Go, компилятора и инструментов, а не нашего исходного кода. Переменная $GOROOT обычно имеет значение вида /usr/local/go. Переменная $GOPATH обычно имеет значение вида $HOME/go.

      Хотя явно задавать переменную $GOROOT больше не нужно, она все еще упоминается в старых материалах.

      Теперь поговорим о структуре рабочего пространства Go.

      Анатомия рабочего пространства Go

      Внутри рабочего пространства Go или GOPATH содержится три каталога: bin, pkg и src. Каждый из этих каталогов имеет особое значение для цепочки инструментов Go.

      .
      ├── bin
      ├── pkg
      └── src
        └── github.com/foo/bar
          └── bar.go
      

      Давайте посмотрим на каждый из этих каталогов.

      Каталог $GOPATH/bin — это место, где Go размещает двоичные файлы, компилируемые go install. Операционная система использует переменную среды $PATH для поиска двоичных приложений, которые могут выполняться без полного пути. Рекомендуется добавить этот каталог в глобальную переменную $PATH.

      Например, если мы не добавим $GOPATH/bin в $PATH для выполнения программы, нам нужно будет выполнять запуск следующим образом:

      При добавлении $GOPATH/bin в $PATH мы можем вызвать программу примерно так:

      Каталог $GOPATH/pkg используется Go для хранения предварительно скомпилированных объектных файлов для ускорения последующей компиляции программ. Большинству разработчиков этот каталог не потребуется. Если у вас возникнут проблемы при компиляции, вы можете спокойно удалить этот каталог, и Go воссоздаст его.

      В каталоге src должны находиться все наши файлы .go или исходный код. Их не следует путать с исходным кодом, который используют инструменты Go, и который находится в каталоге $GOROOT. При написании приложений, пакетов и библиотек Go мы помещаем эти файлы в каталог $GOPATH/src/path/to/code.

      Что такое пакеты?

      Код Go организован в виде пакетов. Пакет представляет собой все файлы в одном каталоге на диске. Один каталог может содержать только определенные файлы из этого же пакета. Пакеты хранятся вместе со всеми созданными пользователем исходными файлами Go в каталоге $GOPATH/src. Импорт разных пакетов поможет легко понять принципы обработки пакетов.

      Если наш код находится в каталоге $GOPATH/src/blue/red, его имя пакета будет red.

      Выражение импорта пакета red будет выглядеть следующим образом:

      import "blue/red"
      

      Пакеты, находящиеся в репозиториях исходного кода, таких как GitHub и BitBucket, содержат полный адрес репозитория как часть пути импорта.

      Например, мы можем импортировать исходный код по адресу https://github.com/gobuffalo/buffalo, используя следующий путь импорта:

      import "github.com/gobuffalo/buffalo"
      

      Поэтому исходный код будет располагаться в следующем каталоге на диске:

      $GOPATH/src/github.com/gobuffalo/buffalo
      

      Заключение

      В этой статье мы рассказали о GOPATH как о наборе папок, где Go ожидает видеть наш исходный код, описали эти папки и рассказали об их содержимом. Также мы показали, как можно сменить расположение по умолчанию $HOME/go на выбранное пользователем расположение посредством настройки переменной среды $GOPATH. В заключение мы показали, как Go ищет пакеты в структуре папок.

      В версии Go 1.11 были введены модули Go, призванные заменить рабочие пространства Go и GOPATH. Хотя мы рекомендуем начать использовать модули, некоторые среды, в том числе среды корпоративных сетей, могут быть еще не готовы к использованию модулей.

      GOPATH — один из сложных аспектов настройки Go, однако после завершения настройки о нем можно забыть.



      Source link