One place for hosting & domains

      Cómo instalar Go y configurar un entorno de programación local en macOS


      Introducción

      Go es un lenguaje de programación que se creó a partir de una frustración en Google. Continuamente, los desarrolladores tenían que elegir entre un lenguaje que se ejecutaba de forma eficiente, pero tardaba mucho en realizar compilaciones, y uno que ofrecía programación sencilla, pero se ejecutaba de forma ineficiente en la producción. Go se diseñó para tener las tres características disponibles al mismo tiempo: compilación rápida, facilidad de programación y ejecución eficiente en producción.

      Si bien Go es un lenguaje de programación versátil que puede utilizarse para muchos proyectos de programación distintos, es especialmente adecuado para los programas de redes o de sistemas distribuidos, y se ha ganado la reputación de “lenguaje de la nube”. Se centra en ayudar al programador moderno a ampliar sus capacidades con un conjunto sólido de herramientas, eliminar debates sobre el formato al incorporarlo en las especificaciones del lenguaje y permitir una implementación sencilla al realizar compilaciones en un único binario. Aprender a usar Go es sencillo, ya que cuenta con un conjunto de palabras claves muy reducido, por lo que es una excelente elección tanto para desarrolladores principiantes como experimentados.

      Este tutorial le servirá como guía para la instalación de Go en su máquina macOS local y la configuración de un espacio de trabajo de programación a través de la línea de comandos.

      Requisitos previos

      Necesitará un equipo con macOS que disponga de conexión a Internet y acceso administrativo.

      Paso 1: Abrir Terminal

      Completaremos la mayor parte de nuestra instalación y configuración en la línea de comandos, que es una alternativa para interactuar con la computadora sin gráficos. Es decir que, en lugar de hacer clic en botones, escribirá texto y recibirá retroalimentación de la computadora, también en texto. La línea de comandos, también conocida como shell, puede ayudar a modificar y automatizar muchas de las tareas que se realizan en un equipo a diario, y es una herramienta esencial para los desarrolladores de software.

      Terminal, de macOS, es una aplicación que puede usar para acceder a la interfaz de la línea de comandos. Al igual que cualquier otra aplicación, la puede encontrar accediendo a Finder, dirigiéndose a la carpeta Aplicaciones e ingresando en la carpeta Utilidades. Allí, haga doble clic en Terminal para abrirla como cualquier otra aplicación. De forma alternativa, puede usar Spotlight manteniendo presionadas la tecla CMD y la BARRA ESPACIADORA, y escribiendo “Terminal” en el cuadro que aparece para encontrarla.

      Terminal de macOS

      Hay muchos más comandos de Terminal que puede aprender para realizar tareas que tengan efectos más potentes. A través del artículo “Introducción al terminal de Linux“ puede orientarse mejor respecto del terminal de Linux, que es similar al de macOS.

      Ahora que abrió Terminal, puede descargar e instalar Xcode, un paquete de herramientas para desarrolladores que necesitará para instalar Go.

      Paso 2: Instalar Xcode

      Xcode es un entorno de desarrollo integrado (IDE) conformado por herramientas de desarrollo de software para macOS. Puede verificar si Xcode ya está instalado escribiendo lo siguiente en la ventana de Terminal:

      El siguiente resultado indica que Xcode está instalado:

      Output

      /Library/Developer/CommandLineTools

      Si aparece un error, instale Xcode desde App Store en su navegador web y acepte las opciones predeterminadas.

      Una vez que Xcode esté instalado, regrese a la ventana de Terminal. A continuación, deberá instalar la aplicación de herramientas de línea de comandos separada de Xcode, lo que podrá hacer escribiendo lo siguiente:

      En este punto, Xcode y su aplicación de herramientas de la línea de comandos están totalmente instalados, y estamos listos para instalar el administrador de paquetes Homebrew.

      Paso 3: Instalar y configurar Homebrew

      Si bien Terminal de macOS tiene mucho de la funcionalidad de los terminales de Linux y otros sistemas de Unix, no se entrega con un administrador de paquetes que admita prácticas recomendadas. Un administrador de paquetes es un conjunto de herramientas de software que automatizan los procesos de instalación, entre los que se incluyen la instalación inicial de software, su actualización y configuración, y su eliminación según sea necesario. Conservan las instalaciones en una ubicación central y pueden mantener todos los paquetes de software del sistema en formatos que se utilizan comúnmente. Homebrew proporciona un sistema de gestión de paquetes de software gratuito y de código abierto que simplifica la instalación de software en macOS.

      Para instalar Homebrew, escriba lo siguiente en la ventana de su terminal:

      • /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

      Homebrew está hecho con Ruby, por lo que modificará la ruta a Ruby de su computadora. El comando curl extrae un secuencia de comandos de la URL especificada. Esta secuencia de comandos proporcionará una explicación de lo que hará y luego pausará el proceso para solicitar su confirmación. Esto le proporciona mucha información sobre lo que la secuencia de comandos hará en el sistema y le da la oportunidad de verificar el proceso.

      Si debe ingresar su contraseña, tenga en cuenta que las pulsaciones de teclas no se mostrarán en la ventana de Terminal, pero sí se registrarán. Simplemente, pulse la tecla Intro una vez que ingrese la contraseña. Alternativamente, presione la letra y (“sí”) cuando se solicite para confirmar la instalación.

      Veamos los indicadores relacionados con el comando curl:

      • El indicador -f o --fail indica a la ventana de Terminal que no proporcione resultados de documentos HTML sobre errores del servidor.
      • El indicador -s o --silent silencia curl para que no muestre el medidor de progreso y, en combinación con el indicador -S o --show-error, controla que curl muestre un mensaje de error si falla.
      • El indicador -L o --location indica a curl que vuelva a realizar la solicitud a un nuevo lugar si el servidor indica que la página solicitada se movió a una ubicación distinta.

      Una vez que el proceso de instalación esté completo, dispondremos el directorio de Homebrew en la parte superior de la variable de entorno PATH. Esto garantizará que las instalaciones de Homebrew se realicen con herramientas que macOS pueda seleccionar automáticamente y que podrían entrar en conflicto con el entorno de desarrollo que crearemos.

      Debe crear o abrir el archivo ~/.bash_profile con el editor de texto de la línea de comandos *nano *usando el comando nano:

      Una vez que el archivo se abra en la ventana de Terminal, escriba lo siguiente:

      export PATH=/usr/local/bin:$PATH
      

      Para guardar sus cambios, mantenga presionadas las teclas CTRL y o, y luego pulse INTRO cuando se solicite. Ahora, puede cerrar nano manteniendo presionadas la tecla CTRL y la letra x.

      Active estos cambios ejecutando lo siguiente en Terminal:

      Una vez que lo haga, los cambios que realizó en la variable de entorno PATH surtirán efecto.

      Puede verificar que Homebrew se haya instalado correctamente escribiendo lo siguiente:

      Si no se requieren actualizaciones en este momento, el resultado de Terminal será el siguiente:

      Output

      Your system is ready to brew.

      También puede recibir una advertencia para ejecutar otro comando, como brew update, para garantizar que su instalación de Homebrew esté actualizada.

      Una vez que Homebrew esté listo, podrá instalar Go.

      Paso 1: Instalar Go

      Puede usar Homebrew para buscar todos los paquetes disponibles con el comando brew search. Para los fines de este tutorial, buscará paquetes o módulos relacionados con Go:

      Nota: Para este tutorial no se utiliza brew search go, dado que con este comando se muestran demasiados resultados. Debido a que go es una palabra muy pequeña y coincidiría con muchos paquetes, una opción que se ha vuelto común es la de usar golang como término de búsqueda. También se usa con frecuencia para buscar artículos relacionados con Go en Internet. El término Golang surgió del dominio de Go, golang.org.

      Terminal mostrará una lista de lo que puede instalar:

      Output

      golang golang-migrate

      Go será uno de los elementos de la lista. Proceda a instalarlo:

      En la ventana de Terminal encontrará información sobre el proceso de instalación de Go. Es posible que la instalación tarde unos minutos en completarse.

      Para verificar la versión de Go que instaló, escriba lo siguiente:

      Esto mostrará la versión específica de Go instalada, que por defecto será la más reciente y estable disponible.

      En el futuro, para actualizar Go, puede ejecutar los siguientes comandos a fin de actualizar Homebrew primero y luego Go. No es necesario hacerlo ahora, ya que acaba de instalar la versión más reciente:

      • brew update
      • brew upgrade golang

      El comando brew update actualizará las fórmulas para Homebrew, lo cual garantizará que cuente con la información más reciente de los paquetes que desee instalar. El comando brew update golang actualizará el paquete golang a la última versión del paquete.

      Es recomendable asegurarse de que la versión de Go esté actualizada.

      Una vez que instale Go en su computadora, estará listo para crear un espacio de trabajo para sus proyectos de Go.

      Paso 5: Crear su espacio de trabajo de Go

      Ahora que instaló Xcode, Homebrew y Go, podrá crear su espacio de trabajo de programación.

      El espacio de trabajo de Go contendrá dos directorios en su root:

      • src: directorio que contiene los archivos de origen de Go. Un archivo de origen es un archivo que se escribe con el lenguaje de programación Go. El compilador de Go utiliza los archivos de origen para crear un archivo binario ejecutable.
      • bin: directorio que contiene ejecutables compilados e instalados con las herramientas de Go. Los ejecutables son archivos binarios que se ejecutan en el sistema y realizan tareas. Normalmente, son programas compilados por su código fuente propio u otro código fuente de Go descargado.

      El subdirectorio src puede contener varios repositorios de control de versiones (como Git, Mercurial y Bazar). Verá directorios como github.com o golang.org cuando su programa importe bibliotecas de terceros. Si usa un repositorio de códigos como github.com, también dispondrá sus proyectos y archivos de origen en ese directorio. Esto permite una importación canónica de código en su proyecto. Las importaciones canónicas son las que hacen referencia a un paquete completo, como github.com/digitalocean/godo.

      Un espacio de trabajo típico puede tener el siguiente aspecto:

      .
      ├── bin
      │   ├── buffalo                                      # command executable
      │   ├── dlv                                          # command executable
      │   └── packr                                        # command executable
      └── src
          └── github.com
              └── digitalocean
                  └── godo
                      ├── .git                            # Git reposistory metadata
                      ├── account.go                      # package source
                      ├── account_test.go                 # test source
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go
      

      El directorio predeterminado para el espacio de trabajo de Go a partir de la versión 1.8 es su directorio principal de usuario con un subdirectorio go o $HOME/go. Si usa una versión de Go anterior a la 1.8, de todos modos se recomienda que utilice la ubicación $HOME/go para su espacio de trabajo.

      Emita el siguiente comando para crear la estructura de directorios para su espacio de trabajo de Go:

      • mkdir -p $HOME/go/{bin,src}

      La opción -p indica a mkdir que cree todos los parents en el directorio, incluso si todavía no existen. Con {bin,src}, se crea un conjunto de argumentos en mkdir y se indica a este que cree los directorios bin y src.

      Esto garantizará la creación de la siguiente estructura de directorios:

      └── $HOME
          └── go
              ├── bin
              └── src
      

      Antes de la versión 1.8 de Go, se debía establecer una variable de entorno local llamada $GOPATH. Si bien ya no es explícitamente necesario hacerlo, sigue siendo recomendable porque muchas herramientas de terceros aún dependen de que esta variable esté configurada.

      Puede configurar su $GOPATH al añadirlo a ~/.bash_profile.

      Primero, abra ~/.bash_profile con nano o con el editor de texto que elija:

      Configure su $GOPATH añadiendo lo siguiente al archivo:

      ~/.bash_profile

      export GOPATH=$HOME/go
      

      Cuando Go compile e instale herramientas, las dispondrá en el directorio $GOPATH/bin. Para mayor comodidad, es común añadir el subdirectorio /bin del espacio de trabajo a su PATH en ~/.bash_profile:

      ~/.bash_profile

      export PATH=$PATH:$GOPATH/bin
      

      Ahora, debería contar con las siguientes entradas en su ~/.bash_profile:

      ~/.bash_profile

      export GOPATH=$HOME/go
      export PATH=$PATH:$GOPATH/bin
      

      Esto le permitirá ejecutar cualquier programa que realice compilaciones o descargas con las herramientas de Go en cualquier lugar de su sistema.

      Para actualizar su shell, emita el siguiente comando a fin de cargar las variables globales que acaba de crear:

      Puede verificar que $PATH esté actualizado al usando el comando echo e inspeccionando el resultado:

      Debería ver su $GOPATH/bin, que aparecerá en el directorio principal. Si iniciara sesión como sammy, vería /Users/sammy/go/bin en la ruta.

      Output

      /Users/sammy/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

      Ahora que creó el root del espacio de trabajo y estableció la variable de entorno $GOPATH establecida, creará sus futuros proyectos con la estructura de directorios siguiente. En este ejemplo, se supone que usa github.com como repositorio:

      $GOPATH/src/github.com/username/project
      

      Si trabajara en el proyecto https://github.com/digitalocean/godo, lo dispondría en el siguiente directorio:

      $GOPATH/src/github.com/digitalocean/godo
      

      Si estructura sus proyectos de esta manera, estarán disponibles con la herramienta go get. También facilitará la lectura más adelante.

      Puede verificar esto usando el comando go get para buscar la biblioteca godo:

      • go get github.com/digitalocean/godo

      Podemos ver que descargó correctamente el paquete godo haciendo un listado del directorio:

      • ls -l $GOPATH/src/github.com/digitalocean/godo

      Recibirá un resultado similar a este:

      Output

      -rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 CHANGELOG.md -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md . . . -rw-r--r-- 1 sammy staff 4893 Apr 5 15:56 vpcs.go -rw-r--r-- 1 sammy staff 4091 Apr 5 15:56 vpcs_test.go

      A través de este paso, creó un espacio de trabajo de Go y configuró las variables de entorno necesarias. En el siguiente paso, probaremos el espacio de trabajo con código.

      Paso 6: Crear un programa simple

      Ahora que configuró su espacio de trabajo de Go, es hora de crear un programa “Hello, World!” simple. Esto garantizará que su espacio de trabajo funcione y le brindará la oportunidad de familiarizarse más con Go.

      Debido a que creará un único archivo de origen de Go, no un proyecto real, no es necesario que se encuentre en su espacio de trabajo para hacerlo.

      Desde el directorio principal, abra un editor de texto de línea de comandos, como nano y cree un archivo nuevo:

      Una vez que el archivo de texto se abra en Terminal, escriba su programa:

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Hello, World!")
      }
      

      Cierre nano con las teclas control y x, y cuando se le solicite guardar el archivo pulse y.

      Este código usará el paquete fmt e invocará la función Println con Hello, World! como argumento. Esto hará que se imprima la frase Hello, World! en el terminal cuando se ejecute el programa.

      Una vez que salga de nano y regrese a su shell, ejecute el programa:

      El programa hello.go que acaba de crear hará que el terminal genere el siguiente resultado:

      Output

      Hello, World!

      En este paso, utilizó un programa básico para verificar que su espacio de trabajo de Go se configure de forma correcta.

      Conclusión

      ¡Felicitaciones! En este punto, contará con un espacio de trabajo de programación de Go configurado en su máquina local con macOS y podrá iniciar un proyecto de codificación.



      Source link

      Установка Go и настройка локальной среды программирования в macOS


      Введение

      Go — это язык программирования, созданный Google в результате разочарования в других языках. Разработчикам постоянно приходилось выбирать между эффективным языком программирования с очень длительным временем компиляции и удобным языком программирования, не отличающимся эффективностью в производственной среде. Язык Go был разработан, чтобы одновременно обеспечить все три преимущества: высокую скорость компиляции, удобство программирования и эффективное исполнение в производственной среде.

      Go — это универсальный язык программирования, который можно использовать для различных проектов программирования. Он особенно хорошо подходит для сетевых программ/распределенных систем и заработал себе репутацию «языка облака». Он дает современным программистам больше возможностей благодаря мощному набору инструментов, позволяет устранить разногласия по поводу форматирования, делая формат частью спецификации языка, а также упрощает развертывание за счет компиляции в единый двоичный файл. Язык Go очень простой в обучении и имеет небольшой набор ключевых слов, что делает его идеальным вариантом как для начинающих, так и для опытных программистов.

      В этом руководстве вы научитесь устанавливать Go на локальном компьютере macOS и настраивать среду программирования через командную строку.

      Предварительные требования

      Вам потребуется компьютер macOS с административным доступом и подключением к Интернету.

      Шаг 1 — Открытие терминала

      Основную часть установки и настройки мы будем выполнять через командную строку — текстовый интерфейс взаимодействия с компьютером. Вместо нажатия на кнопки вы вводите текст и получаете от компьютера обратную связь в текстовом формате. Командная строка, также называемая «оболочка», помогает изменять и автоматизировать многие повседневные задачи, выполняемые на компьютерах. Это необходимый и очень важный инструмент для разработчиков программного обеспечения.

      Терминал macOS — это приложение, которое вы можете использовать для доступа к интерфейсу командной строки. Вы можете найти его в Finder, как и любое другое приложение. Для этого перейдите в папку «Приложения», а затем в папку «Утилиты». В этой папке дважды нажмите на приложение Terminal, чтобы открыть его как любое другое приложение. Также вы можете использовать поиск Spotlight, удерживая клавиши CMD и ПРОБЕЛ и вводя Terminal в появляющемся поле.

      Терминал macOS

      Существует множество разнообразных команд терминала, с помощью которых вы можете выполнять множество различных задач. Статья Введение в терминал Linux поможет вам лучше сориентироваться в работе с терминалом Linux, который похож на терминал macOS.

      Вы открыли терминал и теперь вы можете загрузить и установить пакет инструментов для разработчиков Xcode, который вам потребуется для установки Go.

      Шаг 2 — Установка Xcode

      Xcode — это интегрированная среда разработки (IDE), состоящая из различных инструментов разработки программного обеспечения для macOS. Вы можете проверить установку Xcode, введя в окне терминала следующую команду:

      Следующие результаты означают, что среда разработки Xcode установлена:

      Output

      /Library/Developer/CommandLineTools

      Если вы получили сообщение об ошибке, выполните установку Xcode через App Store в браузере, используя параметры по умолчанию.

      После установки Xcode вернитесь в окно терминала. Теперь вам нужно установить отдельное приложение Command Line Tools Xcode с инструментами командной строки. Для этого введите следующую команду:

      Теперь вы установили Xcode и приложение Command Line Tools, и мы готовы к установке диспетчера пакетов Homebrew.

      Шаг 3 — Установка и настройка Homebrew

      Хотя терминал macOS обладает многими функциями, совпадающими с функциями терминалов Linux и других систем Unix, в нем отсутствует встроенный диспетчер пакетов, основанный на передовом опыте. Диспетчер пакетов — это набор программных инструментов для автоматизации процессов установки, в число которых входят начальная установка программного обеспечения, обновление и настройка программного обеспечения, а также удаление программного обеспечения в случае необходимости. Диспетчер пакетов обеспечивает централизованное хранение установочных файлов и может обслуживать все программные пакеты в системе в распространенных форматах. Homebrew — это бесплатная система управления пакетами с открытым исходным кодом для macOS, упрощающая установку программного обеспечения в macOS.

      Для установки Homebrew введите в окно терминала следующее:

      • /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

      Диспетчер Homebrew создан на языке Ruby и поэтому он изменит путь Ruby на вашем компьютере. Команда curl извлекает скрипт из заданного URL. Этот скрипт объясняет, какие операции будут выполнены, а затем приостанавливает процесс в ожидании вашего подтверждения. Так вы получаете большой объем обратной связи по работе скрипта в вашей системе, а также возможность проверить выполнение процесса.

      Если вам потребуется ввести пароль, учтите, что нажимаемые клавиши не отображаются в окне терминала, но их ввод регистрируется. Просто нажмите клавишу Return после завершения ввода пароля. В противном случае нажмите клавишу y («Да»), чтобы подтвердить установку.

      Просмотрим флаги, связанные с командой curl:

      • Флаг -f или --fail предписывает окну терминала не выводить документы HTML при ошибках сервера.
      • Флаг -s или --silent заглушает вывод curl так, что команда не отображает счетчик выполнения. В сочетании с флагом -S или --show-error этот флаг гарантирует вывод командой curl сообщения об ошибке в случае сбоя.
      • Флаг -L или --location предписывает команде curl повторить запрос в новое место, если сервер сообщает, что запрошенная страница перемещена в другое место.

      После завершения процесса установки мы поместим директорию Homebrew на верхний уровень переменной среды PATH. Благодаря этому установка Homebrew будет вызываться для инструментов, которые macOS может автоматически выбирать и которые могут запускаться против создаваемой нами среды разработки.

      Вам следует создать или открыть файл ~/.bash_profile с помощью текстового редактора командной строки nano, используя команду nano:

      Когда файл откроется в окне терминала, введите следующую команду:

      export PATH=/usr/local/bin:$PATH
      

      Для сохранения изменений нажмите клавишу CTRL и букву o, а затем нажмите клавишу RETURN, когда система предложит вам сделать это. Теперь вы можете выйти из nano, нажав клавишу CTRL и букву x.

      Для активации этих изменений выполните в терминале следующую команду:

      После этого внесенные вами изменения переменной среды PATH вступят в силу.

      Вы можете убедиться в успешной установке Homebrew с помощью следующей команды:

      Если никакие обновления не требуются, на экране терминала появится следующее:

      Output

      Your system is ready to brew.

      В ином случае может быть выведено предупреждение о необходимости запуска другой команды, например brew update для проверки актуальности установленной версии Homebrew.

      После завершения установки Homebrew вы можете переходить к установке Go.

      Шаг 4 — Установка Go

      Вы можете использовать Homebrew для поиска всех доступных пакетов с помощью команды brew search. В этом руководстве мы будем искать пакеты или модули, связанные с Go:

      Примечание. В этом руководстве не используется команда brew search go, поскольку она возвращает слишком много результатов. Поскольку go — очень короткое слово, и ему может соответствовать много пакетов, в качестве поискового запроса обычно используют golang. Эта практика также обычно применяется при поиске статей по Go в Интернете. Термин Golang происходит от названия домена Go, а именно golang.org.

      Терминал выведет список модулей, которые вы можете установить:

      Output

      golang golang-migrate

      В этом списке будет и Go. Переходите к установке:

      В окне терминала будет отображаться информация по процессу установки Go. Установка может занять несколько минут.

      Чтобы проверить, какую версию Go вы установили, введите следующую команду:

      Эта команда выводит номер установленной версии Go. По умолчанию устанавливается самая последняя стабильная версия Go.

      В будущем для обновления Go вы можете использовать следующие команды, которые сначала обновляют Homebrew, а затем — Go. Сейчас это не требуется, поскольку вы только что установили последнюю версию:

      • brew update
      • brew upgrade golang

      brew update обновляет версию Homebrew, благодаря чему у вас будет самая актуальная информация о пакетах, которые вы хотите установить. Команда brew upgrade golang обновит пакет golang до последней доступной версии.

      Рекомендуется регулярно проверять актуальность установленной версии Go.

      Теперь вы установили Go на своем компьютере и можете перейти к созданию рабочего пространства для ваших проектов Go.

      Шаг 5 — Создание рабочего пространства Go

      Вы установили Xcode, Homebrew и Go и теперь можете переходить к созданию рабочего пространства для программирования.

      На корневом уровне рабочего пространства Go имеются две директории:

      • src: это директория с исходными файлами Go. Исходный файл или файл исходного кода — это файл, который вы пишете на языке программирования Go. Компилятор Go использует исходные файлы для создания исполняемого двоичного файла.
      • bin: директория, содержащая исполняемые файлы, которые были созданы и установлены инструментами Go. Исполняемые файлы — это двоичные файлы, которые запускаются в системе и выполняют задачи. Обычно это программы, скомпилированные из вашего исходного кода или из другого загруженного исходного кода Go.

      Субдиректория src может содержать несколько репозиториев контроля версий (например, Git, Mercurial и Bazaar). При импорте сторонних двоичных файлов вашей программой вы увидите такие директории, как github.com или golang.org. Если вы используете репозиторий кода, например github.com, вы также помещаете в эту директорию свои проекты и файлы исходного кода. Это обеспечивает канонический импорт кода в ваш проект. Канонический импорт — это операция импорта, которая ссылается на полностью квалифицированный пакет, например github.com/digitalocean/godo.

      Вот так выглядит типичное рабочее пространство:

      .
      ├── bin
      │   ├── buffalo                                      # command executable
      │   ├── dlv                                          # command executable
      │   └── packr                                        # command executable
      └── src
          └── github.com
              └── digitalocean
                  └── godo
                      ├── .git                            # Git reposistory metadata
                      ├── account.go                      # package source
                      ├── account_test.go                 # test source
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go
      

      Директория по умолчанию рабочего пространства Go в версии 1.8 совпадает с домашней директорией вашего пользователя с субдиректорией go или имеет адрес $HOME/go. Если вы используете версию Go ниже 1.8, лучше всего использовать для рабочего пространства адрес $HOME/go.

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

      • mkdir -p $HOME/go/{bin,src}

      Опция -p предписывает команде mkdir создать в директории все родительские элементы, даже если их еще не существует. При использовании параметров {bin,src} для команды mkdir создается набор аргументов, предписывающий ей создать директорию bin и директорию src.

      Таким образом, обеспечивается размещение следующей структуры директорий:

      └── $HOME
          └── go
              ├── bin
              └── src
      

      До выпуска версии Go 1.8 обязательно было создавать локальную переменную среды с именем $GOPATH. Хотя это больше явно не требуется, создать такую переменную все равно полезно, поскольку многие сторонние инструменты зависят от ее использования.

      Вы можете задать переменную $GOPATH посредством ее добавления в файл ~/.bash_profile.

      Откройте файл ~/.bash_profile с помощью nano или другого предпочитаемого текстового редактора:

      Чтобы задать переменную $GOPATH, добавьте в файл следующую строку:

      ~/.bash_profile

      export GOPATH=$HOME/go
      

      При компиляции и установке инструментов Go помещает их в директорию $GOPATH/bin. Для удобства субдиретория /bin рабочего пространства обычно добавляется в переменную PATH в файле ~/.bash_profile:

      ~/.bash_profile

      export PATH=$PATH:$GOPATH/bin
      

      Теперь в файле ~/.bash_profile должны быть следующие записи:

      ~/.bash_profile

      export GOPATH=$HOME/go
      export PATH=$PATH:$GOPATH/bin
      

      Это позволит вам запускать любые компилируемые или загружаемые программы через инструменты Go в любом месте в вашей системе.

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

      Вы можете проверить обновление переменной $PATH, запустив команду echo и просмотрев результаты:

      Вы должны увидеть директорию $GOPATH/bin в своей домашней директории. Если вы вошли в систему под именем пользователя sammy, вы увидите путь /Users/sammy/go/bin.

      Output

      /Users/sammy/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

      Вы создали корневую директорию рабочего пространства и задали переменную среды $GOPATH. Теперь вы сможете создавать будущие проекты со следующей структурой директорий. В этом примере предполагается, что вы используете github.com в качестве репозитория:

      $GOPATH/src/github.com/username/project
      

      Если вы работаете над проектом https://github.com/digitalocean/godo, он помещается в следующую директорию:

      $GOPATH/src/github.com/digitalocean/godo
      

      Такая структура проектов делает их доступными с помощью инструмента go get. Также она делает проекты удобнее для чтения.

      Для проверки вы можете использовать команду go get для доставки библиотеки godo:

      • go get github.com/digitalocean/godo

      Мы можем увидеть успешную загрузку пакета godo посредством вывода директории:

      • ls -l $GOPATH/src/github.com/digitalocean/godo

      Результат должен выглядеть примерно так:

      Output

      -rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 CHANGELOG.md -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md . . . -rw-r--r-- 1 sammy staff 4893 Apr 5 15:56 vpcs.go -rw-r--r-- 1 sammy staff 4091 Apr 5 15:56 vpcs_test.go

      На этом шаге вы создали рабочее пространство Go и настроили необходимые переменные среды. На следующем шаге мы протестируем рабочее пространство, запустив в нем код.

      Шаг 6 — Создание простой программы

      Вы настроили рабочее пространство Go и теперь можете создать простую программу “Hello, World!” Так вы убедитесь, что ваше рабочее пространство работает, и сможете лучше познакомиться с Go.

      Поскольку вы создаете один исходный файл Go, а не фактический проект, вам не нужно находиться в рабочем пространстве.

      Откройте в домашней директории редактор nano или другой текстовый редактор командной строки и создайте новый файл:

      Когда текстовый файл откроется в терминале, введите код программы:

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Hello, World!")
      }
      

      Для выхода из nano нажмите клавиши control и х, а когда система предложит вам сохранить файл, нажмите клавишу y.

      Этот код использует пакет fmt и вызывает функцию Println с Hello, World! в качестве аргумента. В результате фраза Hello, World! распечатывается на терминале при запуске программы.

      После выхода из nano и возврата в оболочку запустите программу:

      Созданная программа hello.go выведет на терминале следующее:

      Output

      Hello, World!

      На этом шаге вы использовали простую программу для подтверждения правильности настройки рабочего пространства Go.

      Заключение

      Поздравляем! Вы настроили рабочее пространство программирования Go на своем локальном компьютере macOS и теперь можете начинать проект по программированию.



      Source link

      How To Install Ruby on Rails with rbenv on macOS


      Introduction

      Ruby on Rails is a popular application stack for developers looking to create sites and web apps. The Ruby programming language, combined with the Rails development framework, makes app development quick and efficient.

      One way to install Ruby and Rails is with the command-line tool rbenv. Using rbenv will provide you with a well-controlled and robust environment for developing your Ruby on Rails applications, allowing you to easily switch the version of Ruby for your entire team when needed.

      rbenv provides support for specifying application-specific versions of Ruby, lets you change the global Ruby for each user, and allows you to use an environment variable to override the Ruby version.

      In this tutorial, you will use rbenv to install and set up Ruby on Rails on your local macOS machine.

      Prerequisites

      To follow this tutorial, you will need:

      Step 1 — Installing rbenv

      In this step, you will install rbenv and make sure that it starts automatically at boot. To do this on macOS, this tutorial will use the package manager Homebrew.

      To download the rbenv package with Homebrew, run the following command:

      This will install rbenv and the ruby-build plugin. This plugin adds therbenv install command, which streamlines the installation process for new versions of Ruby.

      Next, you'll add the command eval "$(rbenv init -)" to your ~/.bash_profile file to make rbenv load automatically when you open up the Terminal. To do this, open your .bash_profile in your favorite text editor:

      Add the following line to the file:

      ~/.bash_profile

      eval "$(rbenv init -)"
      

      Save and quit the file.

      Next, apply the changes you made to your ~/.bash_profile file to your current shell session:

      To verify that rbenv is set up properly, use the type command, which will display more information about the rbenv command:

      Your terminal window will display the following:

      Output

      rbenv is a function rbenv () { local command; command="${1:-}"; if [ "$#" -gt 0 ]; then shift; fi; case "$command" in rehash | shell) eval "$(rbenv "sh-$command" "$@")" ;; *) command rbenv "$command" "$@" ;; esac }

      At this point, you have both rbenv and ruby-build installed on your machine. This will allow you to install Ruby from the command line in the next step.

      Step 2 — Installing Ruby

      With the ruby-build plugin now installed, you can install any version of Ruby you may need through a single command. In this step, you will choose a version of Ruby, install it on your machine, and then verify the installation.

      First, use the -l flag to list all the available versions of Ruby:

      The output of that command will be a long list of versions that you can choose to install.

      For this tutorial, install Ruby 2.6.3:

      Installing Ruby can be a lengthy process, so be prepared for the installation to take some time to complete.

      Once it's done installing, set it as your default version of Ruby with the global sub-command:

      Verify that Ruby was properly installed by checking its version number:

      Your output will look something like this:

      Output

      ruby 2.6.3p62 (2019-04-16 revision 67580) [x86_64-darwin18]

      To install and use a different version of Ruby, run the rbenv commands with a different version number, such as rbenv install 2.3.0 and rbenv global 2.3.0.

      You now have one version of Ruby installed and have set your default Ruby version. Next, you will set yourself up to work with Ruby packages and libraries, or gems, which will then allow you to install Rails.

      Step 3 — Working with Gems

      Gems are packages of Ruby libraries and programs that can be distributed throughout the Ruby ecosystem. You use the gem command to manage these gems. In this step, you will configure the gem command to prepare for the Rails installation.

      When you install a gem, the installation process generates local documentation. This can add a significant amount of time to each gem's installation process, so turn off local documentation generation by creating a file called ~/.gemrc which contains a configuration setting to turn off this feature:

      • echo "gem: --no-document" > ~/.gemrc

      With that done, use the gem command to install Bundler, a tool that manages gem dependencies for projects. This is needed for Rails to work correctly:

      You'll see output like this:

      Output

      Fetching: bundler-2.0.2.gem Successfully installed bundler-2.0.2 1 gem installed

      You can use the gem env command to learn more about the environment and configuration of gems. To see the location of installed gems, use the home argument, like this:

      You'll see output similar to this:

      /Users/sammy/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0
      

      Now that you have set up and explored your gem workflow, you are free to install Rails.

      Step 4 — Installing Rails

      In this step, you will install Rails, verify the installation, and prepare it for use.

      To install the most recent version of Rails, use the gem install command:

      The gem command installs the gem you specify, as well as every dependency. Rails is a complex web development framework and has many dependencies, so the process will take some time to complete. Eventually you'll see a message stating that Rails is installed, along with its dependencies:

      Output

      ... Successfully installed rails-5.2.3 38 gems installed

      Note: If you would like to install a specific version of Rails, you can list its valid versions by doing a search, which will output a long list of options:

      • gem search '^rails$' --all

      You could then install a specific version, such as 4.2.7:

      • gem install rails -v 4.2.7

      rbenv works by creating a directory of shims, or libraries that intercept calls and change or redirect them. In this case, shims point Ruby commands to the files used by the Ruby version that's currently enabled. Through the rehash sub-command, rbenv maintains shims in that directory to match every Ruby command across every installed version of Ruby on your server. Whenever you install a new version of Ruby or a gem that provides commands, such as Rails, you should use rehash.

      To rehash the directory of shims, run the following command:

      Verify your installation of Rails by printing its version with this command:

      You will see the version of Rails that was installed:

      Output

      Rails 5.2.3

      With Rails successfully installed, you can begin testing your Ruby on Rails installation and start to develop web applications. In the next step, you will learn how to update and uninstall rbenv and Ruby.

      Step 5 — Updating and Uninstalling rbenv and Ruby

      When maintaining projects, it is useful to know how to update and uninstall when the need arises. In this step, you will upgrade rbenv, then uninstall Ruby and rbenv from your machine.

      You can upgrade rbenv and ruby-build using Homebrew by running the following command:

      • brew upgrade rbenv ruby-build

      If rbenv or ruby-build need to be updated, Homebrew will do it for you automatically. If your set up is already up to date, you will get output similar to the following:

      Output

      Error: rbenv 1.1.2 already installed Error: ruby-build 20190615 already installed

      This will ensure that we are using the most up-to-date version of rbenv available.

      As you download additional versions of Ruby, you may accumulate more versions than you would like in your ~/.rbenv/versions directory. Using the ruby-build plugin's uninstall subcommand, you can remove these previous versions.

      For example, run the following to uninstall Ruby version 2.1.3:

      With the rbenv uninstall command you can clean up old versions of Ruby so that you do not have more installed than you are currently using.

      If you've decided you no longer want to use rbenv, you can remove it from your system.

      To do this, first open your ~/.bash_profile file in your editor:

      Find and remove the following line from the file to stop rbenv from starting when you open the Terminal:

      ~/.bash_profile

      ...
      eval "$(rbenv init -)"
      

      Once you have deleted this line, save the file and exit the editor.

      Run the following command to apply the changes to your shell:

      Next, remove rbenv and all installed Ruby versions with this command:

      Finally, remove the rbenv package itself with Homebrew:

      Check the rbenv version to make sure that it has been uninstalled:

      You will get the following output:

      Output

      -bash: /usr/local/bin/rbenv: No such file or directory

      This means that you have successfully removed rbenv from your machine.

      Conclusion

      In this tutorial you installed Ruby on Rails with rbenv on macOS. From here, you can learn more about coding in Ruby with our How To Code in Ruby series. You can also explore how to use Ruby on Rails with PostgreSQL rather than its default sqlite3 database, which provides more scalability, centralization, and stability for your applications.



      Source link