One place for hosting & domains

      Windows

      Como instalar o Go e configurar um ambiente de programação local no Windows 10


      Introdução

      O Go é uma linguagem de programação que nasceu de frustrações no Google. Os desenvolvedores tinham que escolher continuamente entre uma linguagem eficaz na execução, mas que levava muito tempo para compilar ou escolher uma linguagem fácil de programar, mas que não era eficaz na produção. A linguagem Go foi projetada para ter todas as três vantagens disponíveis ao mesmo tempo: velocidade de compilação, facilidade da programação e a eficiência da execução na produção.

      Embora o Go seja uma linguagem de programação versátil que pode ser usada para muitos projetos de programação diferentes, ela é adequada particularmente para programas de sistemas de rede/distribuídos e ganhou uma reputação como “a linguagem da nuvem”. Essa linguagem se dedica a ajudar o programador moderno a produzir mais com um conjunto forte de ferramentas, tirando de cena os debates sobre a formatação e fazendo da formatação parte das especificações da linguagem, além de tornar a implantação fácil por meio da compilação em um binário único. A linguagem Go é fácil de aprender, com uma série pequena de palavras-chave que a tornam uma ótima escolha tanto para desenvolvedores iniciantes, quanto para experientes.

      Este tutorial guiará você na instalação do Go em sua máquina local do Windows 10 e na configuração de um ambiente de programação através da linha de comando.

      Pré-requisitos

      Você precisará de uma máquina com Windows 10 – com acesso administrativo e conectada à Internet.

      Passo 1 — Abrindo e configurando o PowerShell

      Você concluirá a maior parte da instalação e configuração em uma interface de linha de comando, que é uma maneira não gráfica de interagir com seu computador. Ou seja, em vez de clicar em botões, você vai digitar em texto e receberá o feedback de seu computador por texto também. A linha de comando, também conhecida como shell, pode ajudar você a modificar e automatizar muitas das tarefas que você faz em um computador diariamente. Trata-se de uma ferramenta essencial para os desenvolvedores de software.

      O PowerShell é um programa da Microsoft que fornece uma interface de shell de linha de comando. As tarefas administrativas são realizadas executando cmdlets, pronunciadas command-lets, que são classes especializadas do . NET Framework (software), que pode realizar as operações. De código aberto em agosto de 2016, o PowerShell agora está disponível para uso entre as plataformas, tanto para sistemas em Windows, como em Unix (incluindo Mac e Linux).

      Para encontrar o Windows PowerShell, clique com o botão direito no ícone Start (Iniciar), no canto inferior esquerdo de sua tela. Quando o menu aparecer, clique em Search (Pesquisa) e, em seguida, digite PowerShell na barra de busca. Quando as opções forem exibidas para você, clique com o botão direito no Windows PowerShell do aplicativo Desktop. Para os fins deste tutorial, selecione Run as Administrator (Executar como administrador). Quando a caixa de diálogo surgir com a questão Do you want to allow this app to make changes to your PC? (Deseja permitir que este aplicativo faça alterações no seu computador?) clique em Yes (Sim).

      Assim que fizer isso, verá uma interface baseada em texto que tem uma string de palavras que se parece com esta:

      Windows 10 PowerShell

      Troque de pasta de sistema, digitando o seguinte comando:

      Então, você estará em um diretório home, como o PS C:Userssammy.

      Para continuar com o processo de instalação, primeiro você deve definir as permissões através do PowerShell. Configurado para executar no modo mais seguro por padrão, existem alguns níveis de permissões que você pode configurar como administrador:

      • Restricted (Restrita) é a política de execução padrão. Sob este modo, você não poderá executar scripts e o PowerShell funcionará apenas como uma shell interativa.
      • AllSigned (Todas Assinadas) permitirá que você execute todos os scripts e arquivos de configuração assinados por um fornecedor confiável, o que significa que possivelmente poderia abrir sua máquina para o risco de executar scripts maliciosos que podem ser assinados por um fornecedor confiável.
      • RemoteSigned (Assinatura Remota), permitirá que você execute scripts e arquivos de configuração baixados da Internet - assinados por fornecedores confiáveis, abrindo novamente sua máquina a vulnerabilidades se esses scripts confiáveis, na verdade, forem maliciosos.
      • Unrestricted (Irrestrito) executará todos os scripts e arquivos de configuração baixados da Internet desde que você confirme que entendeu que o arquivo foi baixado da Internet. Neste caso, não será necessária uma assinatura digital. Dessa maneira, você pode estar abrindo sua máquina para o risco de executar scripts não assinados e potencialmente maliciosos baixados da Internet.

      Neste tutorial, você usará a política de execução RemoteSigned para definir as permissões do usuário atual. Isso permitirá que o PowerShell aceite scripts confiáveis sem criar as permissões tão amplas quanto elas seriam com uma permissão Unrestricted. Digite o seguinte no PowerShell:

      • Set-ExecutionPolicy -Scope CurrentUser

      O PowerShell solicitará que você forneça uma política de execução. Digite o seguinte para usar o RemoteSigned:

      Assim que pressionar ENTER, será solicitado que confirme a mudança para a política de execução. Digite a letra y para permitir que as alterações entrem em vigor. Você pode confirmar se isso funcionou, solicitando as permissões atuais na máquina:

      • Get-ExecutionPolicy -List

      Você deve receber um resultado que se parece com este:

      Output

      Scope ExecutionPolicy ----- --------------- MachinePolicy Undefined UserPolicy Undefined Process Undefined CurrentUser RemoteSigned LocalMachine Undefined

      Isso confirma que o usuário atual pode executar scripts confiáveis baixados da Internet. Agora, você pode seguir em frente para baixar os arquivos que precisaremos para configurar nosso ambiente de programação em Go.

      Passo 2 — Instalando o gerenciador de pacotes Chocolatey

      Um gerenciador de pacotes é uma coleção de ferramentas de software que funcionam para automatizar processos de instalação. Isso inclui a instalação inicial, o upgrade e a configuração do software, bem como a remoção de software - conforme necessário. Eles mantêm as instalações de software em um local central e podem manter todos os pacotes de software no sistema, nos formatos em que são habitualmente usados.

      O Chocolatey é um gerenciador de pacotes de linha de comando criado para o Windows que funciona como o apt-get funciona no Linux. Disponível em uma versão de código aberto, o Chocolatey ajudará você a instalar aplicativos e ferramentas rapidamente. Você o usará para baixar o que for necessário para o seu ambiente de desenvolvimento.

      Antes de instalar o script, leia-o para confirmar que está satisfeito com as alterações que ele fará em sua máquina. Para fazer isso, use o framework de script .NET para baixar e exibir o script do Chocolatey na janela do seu terminal.

      Comece criando um objeto WebClient chamado $script que compartilha as configurações de conexão da Internet com o Internet Explorer:

      • $script = New-Object Net.WebClient

      Examine as opções disponíveis, canalizando o objeto $script com uma | para a classe Get-Member:

      Isso retornará todos os membros (propriedades e métodos) deste objeto WebClient:

      Snippet of Output

      . . . DownloadFileAsync Method void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur... DownloadFileTaskAsync Method System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa... DownloadString Method string DownloadString(string address), string DownloadString(uri address) #method we will use DownloadStringAsync Method void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy... DownloadStringTaskAsync Method System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy… . . .

      Examinando o resultado, você consegue identificar o método DownloadString, usado para exibir o script e a assinatura na janela do PowerShell. Use este método para verificar o script:

      • $script.DownloadString("https://chocolatey.org/install.ps1")

      Após verificar o script, instale o Chocolatey, digitando o seguinte no PowerShell:

      • iwr https://chocolatey.org/install.ps1 -UseBasicParsing | iex

      O cmdlet iwr, ou Invoke-WebRequest, permite que você extraia dados da Web. Isso passará o script para iex, ou o cmdlet Invoke-Expression, que executará o conteúdo do script e a instalação para o gerenciador de pacotes Chocolatey.

      Permita que o PowerShell instale o Chocolatey. Assim que ele estiver totalmente instalado, comece a instalar as ferramentas adicionais com o comando choco.

      Se você precisar fazer o upgrade do Chocolatey no futuro, execute o seguinte comando:

      Com o gerenciador de pacotes instalado, instale o resto do que for necessário para o ambiente de programação em Go.

      Passo 3 — Instalando o editor de texto Nano (opcional)

      Neste passo, você instalará o nano, um editor de texto que usa uma interface de linha de comando. Você pode usar o nano para escrever programas diretamente dentro do PowerShell. Este não é um passo obrigatório, já que é possível usar um editor de texto com uma interface de usuário gráfica, como o Bloco de notas. Este tutorial recomenda que use o nano, uma vez que ele ajudará você a se acostumar a usar o PowerShell.

      Use o Chocolatey para instalar o nano:

      O identificador -y confirma automaticamente que você deseja executar o script, sem ser solicitado a confirmar.

      Assim que o nano estiver instalado, utilize o comando nano para criar novos arquivos de texto. Você usará isso mais tarde neste tutorial para escrever seu primeiro programa Go.

      Passo 4 — Instalando o Go

      Assim como fez com o nano no passo anterior, você usará o Chocolatey para instalar o Go:

      Nota: como o go é uma palavra muito pequena, tornou-se comum usar golang como um termo para instalar pacotes e procurar artigos relacionados ao Go na Internet. O termo Golang nasceu do domínio para a linguagem Go, que é o golang.org.

      O PowerShell instalará o Go, gerando resultados dentro do PowerShell durante o processo. Assim que a instalação for concluída, você deve ver o seguinte resultado:

      Output

      Environment Vars (like PATH) have changed. Close/reopen your shell to see the changes (or in powershell/cmd.exe just type `refreshenv`). The install of golang was successful. Software installed as 'msi', install location is likely default. Chocolatey installed 1/1 packages. See the log for details (C:ProgramDatachocolateylogschocolatey.log).

      Com a instalação finalizada, você agora confirmará que Go está instalado. Para ver as alterações, feche e abra novamente o PowerShell como administrador e, em seguida, verifique a versão do Go disponível em sua máquina local:

      Você receberá um resultado parecido com este:

      Output

      go version go1.12.1 windows/amd643.7.0

      Assim que o Go estiver instalado, você poderá configurar um espaço de trabalho para seus projetos de desenvolvimento.

      Passo 5 — Criando seu espaço de trabalho em Go

      Agora que você tem o Chocolatey, o nano e Go instalados, crie seu espaço de trabalho de programação.

      O espaço de trabalho em Go terá dois diretórios como sua raiz:

      • src: o diretório que contém os arquivos fonte do Go. Um arquivo fonte é um arquivo que você escreve usando a linguagem de programação Go. Os arquivos fonte são usados pelo compilador Go para criar um arquivo binário executável.
      • bin: o diretório que contém executáveis compilados e instalados pelas ferramentas do Go. Os executáveis são arquivos binários que são executados no seu sistema e executam tarefas. Esses são programas tipicamente compilados pelo seu código fonte ou outro código fonte baixado do Go.

      O subdiretório src pode conter vários repositórios de controle de versão (tais como o Git, o Mercurial, e o Bazaar). Você verá diretórios como o github.com ou golang.org quando seu programa importar bibliotecas de terceiros. Se estiver usando um repositório de códigos como o github.com, você também colocará seus projetos e arquivos fonte sob aquele diretório. Isso permite uma importação canônica do código no seu projeto. As importações Canônicas são importações que referenciam um pacote totalmente qualificado, como o github.com/digitalocean/godo.

      Aqui está como um espaço de trabalho típico se parece:

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

      A partir da versão 1.8, o diretório padrão para o espaço de trabalho do Go é o seu diretório home de usuário com um subdiretório go, ou $HOME/go. Se estiver usando uma versão anterior à versão 1.8 do Go, ainda é considerada como melhor prática usar o local $HOME/go como o seu espaço de trabalho.

      Emita o comando seguinte para navegar até o diretório $HOME:

      Em seguida, crie a estrutura de diretório para seu espaço de trabalho do Go:

      Isso garantirá que a seguinte estrutura de diretório em funcionamento:

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

      Antes do Go 1.8, era necessário definir uma variável local do ambiente chamada $GOPATH. Embora já não seja necessário fazer isso, ainda é considerada uma boa prática, já que muitas ferramentas de terceiros ainda precisam que seja definida.

      Como você usou o Chocolatey para a instalação, essa variável de ambiente já deverá estar definida. Verifique isso com o seguinte comando:

      Você deve ver o seguinte resultado, com seu nome de usuário no lugar de sammy:

      Output

      C:Userssammygo

      Quando o Go compila e instala ferramentas, ele as coloca no diretório $GOPATH/bin. Por conveniência, é comum adicionar o subdiretório bin do espaço de trabalho ao seu $PATH. É possível fazer isso usando o comando setx no PowerShell:

      • setx PATH "$($env:path);$GOPATHbin"

      Isso permitirá que você execute qualquer programa que compilar ou baixar através das ferramentas Go - em qualquer lugar em seu sistema.

      Agora que você tem a raiz do espaço de trabalho criada e sua variável de ambiente $GOPATH definida, crie seus projetos futuros com a seguinte estrutura de diretório. Este exemplo supõe que esteja usando o github.com como seu repositório:

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

      Se estivesse trabalhando no projeto https://github.com/digitalocean/godo, você o colocaria no seguinte diretório:

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

      Estruturar seus projetos dessa maneira irá torná-los disponíveis com a ferramenta go get. Isso também ajudará mais adiante com a legibilidade.

      É possível verificar isso usando o comando go get para buscar a biblioteca godo:

      • go get github.com/digitalocean/godo

      Nota: se não tiver o git instalado, o Windows abrirá uma caixa de diálogo perguntando se deseja instalá-lo. Clique em Yes para continuar e siga as instruções de instalação.

      É possível ver se ele baixou corretamente o pacote godo, listando o diretório:

      • ls $env:GOPATH/src/github.com/digitalocean/godo

      Você receberá um resultado semelhante a este:

      Output

      Directory: C:Userssammygosrcgithub.comdigitaloceangodo Mode LastWriteTime Length Name ---- ------------- ------ ---- d----- 4/10/2019 2:59 PM util -a---- 4/10/2019 2:59 PM 9 .gitignore -a---- 4/10/2019 2:59 PM 69 .travis.yml -a---- 4/10/2019 2:59 PM 1592 account.go -a---- 4/10/2019 2:59 PM 1679 account_test.go -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 . . . -a---- 4/10/2019 2:59 PM 5076 vpcs.go -a---- 4/10/2019 2:59 PM 4309 vpcs_test.go

      Neste passo, você criou um espaço de trabalho em Go e configurou as variáveis do ambiente necessárias. No próximo passo, você testará o espaço de trabalho com algum código.

      Passo 6 — Criando um programa simples

      Agora que você tem o espaço de trabalho em Go configurado, crie um programa “Hello, World!” simples. Isso garantirá que seu espaço de trabalho fique devidamente configurado, bem como dará a você a oportunidade de se familiarizar com o Go. Como está criando um único arquivo fonte em Go e não um projeto real, você não precisa estar em seu espaço de trabalho para fazer isso.

      Do seu diretório home, abra um editor de texto de linha de comando, como o nano e crie um novo arquivo:

      Assim que o arquivo de texto abrir no nano, digite seu programa:

      hello.go

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

      Saia do nano, pressionando as teclas CTRL e X. Quando solicitado a salvar o arquivo, pressione Y e, então, ENTER.

      Esse código usará o pacote fmt e chamará a função Println com o Hello, World! como argumento. Isso fará a frase Hello, World! imprimir no terminal quando o programa for executado.

      Assim que sair do nano e retornar ao seu shell, execute o programa:

      O programa hello.go que você acabou de criar deve fazer com que o PowerShell produza o seguinte resultado:

      Output

      Hello, World!

      Neste passo, você usou um programa básico para verificar se seu espaço de trabalho em Go foi configurado corretamente.

      Conclusão

      Parabéns! Neste ponto, você tem um espaço de trabalho de programação em GO configurado em sua máquina local (com Windows) e pode começar um projeto de codificação!



      Source link

      Cómo instalar Go y configurar un entorno de programación en Windows 10


      Introducción

      Go es un lenguaje de programación que se creó a partir de la 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 con Windows 10 local y la configuración de un entorno de programación mediante la línea de comandos.

      Requisitos previos

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

      Paso 1: Abrir y configurar PowerShell

      Completará la mayor parte de la instalación y configuración en la interfaz de 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.

      PowerShell es un programa de Microsoft que proporciona una interfaz shell de línea de comandos. Las tareas administrativas se realizan ejecutando cmdlets, que se pronuncia command-lets: clases especializadas del marco de software .NET que puede realizar operaciones. PowerShell se ofrece en código abierto desde agosto del 2016 y ahora está disponible para diferentes plataformas para sistemas Windows y UNIX (incluyendo Mac y Linux).

      Para hallar PowerShell de Windows, puede hacer clic con el botón secundario del mouse sobre el ícono del menú de inicio, en la esquina inferior izquierda de la pantalla. Cuando aparezca el menú, haga clic en Buscar y luego escriba PowerShell en la barra de búsqueda. Cuando aparezcan las opciones, haga clic sobre Windows PowerShell desde la aplicación de escritorio. Para este tutorial seleccione, Ejecutar como administrador. Cuando aparezca un cuadro de diálogo que contenga la pregunta ¿Desea permitir que esta aplicación realice cambios en el equipo?, haga clic en .

      Una vez que haga esto, verá una interfaz basada en texto que tiene una cadena de palabras que tiene este aspecto:

      PowerShell en Windows 10

      Salga de la carpeta del sistema escribiendo el siguiente comando:

      Luego, se posicionará en un directorio de inicio como PS C:Userssammy.

      Para continuar con el proceso de instalación, primero debe establecer permisos a través de PowerShell. Está configurado para ejecutarse en el modo más seguro de forma predeterminada y e existen varios niveles de permisos que puede establecer como administrador.

      • Restricted es la política de ejecución predeterminada. En este modo, no podrá ejecutar secuencias de comandos y PowerShell funcionará solo como un shell interactivo.
      • AllSigned le permitirá ejecutar todas las secuencias de comandos y archivos de configuración que estén firmados por un editor de confianza, lo cual significa que podría exponer su máquina al riesgo de ejecutar secuencias de comandos maliciosas que estén firmadas por un editor de confianza.
      • RemoteSigned le permitirá ejecutar secuencias de comandos y archivos de configuración que se descarguen de Internet y estén firmados por editores de confianza, con lo cual su equipo quedará de nuevo expuesto a vulnerabilidades si estas secuencias de comandos de confianza son en realidad maliciosas.
      • Unrestricted ejecutará las secuencias de comandos y los archivos de configuración descargados de Internet tan pronto como confirme que comprende que el archivo se descargó de Internet. En este caso, no se requiere firma digital, de modo que podría dejar su equipo expuesto al riesgo de ejecutar secuencias de comandos no firmadas y potencialmente maliciosas descargadas de Internet.

      A través de este tutorial, usará la política de ejecución RemoteSigned para establecer los permisos para el usuario actual. Esto permitirá que PowerShell acepte secuencias de comandos de confianza sin hacer que los permisos sean tan amplios como en el caso de la categoría Unrestricted. Introduzca lo siguiente en PowerShell:

      • Set-ExecutionPolicy -Scope CurrentUser

      PowerShell le pedirá que proporcione una política de ejecución. Introduzca lo siguiente para usar RemoteSigned:

      Una vez que pulse ENTER, se le solicitará confirmar el cambio en la política de ejecución. Escriba la letra y para permitir que se apliquen los cambios. Puede confirmar que esto funcionó pidiendo los permisos actuales en la computadora:

      • Get-ExecutionPolicy -List

      Debería ver un resultado que tenga este aspecto:

      Output

      Scope ExecutionPolicy ----- --------------- MachinePolicy Undefined UserPolicy Undefined Process Undefined CurrentUser RemoteSigned LocalMachine Undefined

      Esto confirma que el usuario actual puede ejecutar las secuencias de comandos de confianza descargadas de Internet. Ahora, podrá descargar los archivos que necesitaremos para configurar nuestro entorno de programación de Go.

      Paso 2: Instalar el administrador de paquetes Chocolatey

      Un administrador de paquetes es un conjunto de herramientas de software cuyo propósito es automatizar los procesos de instalación. Esto incluye la instalación inicial, la actualización, la configuración y la desinstalación del software según sea necesario. Conservan las instalaciones de software en una ubicación central y pueden mantener todos los paquetes de software del sistema en formatos que se utilizan comúnmente.

      Chocolatey es un administrador de paquetes de línea de comandos creado para Windows que funciona como apt-get en Linux. Chocolatey se encuentra disponible como versión de código abierto y le permitirá instalar rápidamente aplicaciones y herramientas. Lo utilizará para descargar lo que necesita para su entorno de desarrollo.

      Antes de instalar la secuencia de comandos, léala para confirmar que está de acuerdo con los cambios que realizará en su equipo. Para hacer esto, utilice el marco de secuencias de comandos NET para descargar y mostrar la secuencia de comandos Chocolatey en la ventana del terminal.

      Comience creando un objeto WebClient llamado $script que comparta los ajustes de conexión de Internet con Internet Explorer:

      • $script = New-Object Net.WebClient

      Eche un vistazo a las opciones disponibles enlazando el objeto $script con | a la clase Get-Member:

      Con esto, se mostrarán todos los miembros (propiedades y métodos) de este objeto WebClient:

      Snippet of Output

      . . . DownloadFileAsync Method void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur... DownloadFileTaskAsync Method System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa... DownloadString Method string DownloadString(string address), string DownloadString(uri address) #method we will use DownloadStringAsync Method void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy... DownloadStringTaskAsync Method System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy… . . .

      Mirando el resultado, puede identificar el método DownloadString usado para mostrar la secuencia de comandos y la firma en la ventana PowerShell. Utilice este método para inspeccionar la secuencia de comandos:

      • $script.DownloadString("https://chocolatey.org/install.ps1")

      Tras inspeccionar la secuencia de comandos, instale Chocolatey escribiendo lo siguiente en PowerShell:

      • iwr https://chocolatey.org/install.ps1 -UseBasicParsing | iex

      El cmdlet iwr, o Invoke-WebRequest, le permite extraer datos de la web. Esto pasará la secuencia de comandos a iex, o el cmdlet Invoke-Expression, que ejecutará los contenidos de la secuencia de comandos y ejecutará la instalación para el administrador de paquetes Chocolatey.

      Permita que PowerShell instale Chocolatey. Una vez que se complete la instalación, puede comenzar a instalar herramientas adicionales con el comando choco.

      Si necesita actualizar Chocolatey en cualquier momento en el futuro, ejecute el siguiente comando:

      Una vez que instale el administrador de paquetes, podrá realizar las demás instalaciones que necesite para el entorno de programación de Go.

      Paso 3: Instalar el editor de texto Nano (opcional)

      En este paso, instalará nano, un editor de texto que utiliza una interfaz de línea de comandos. Puede usar nano para escribir programas directamente en PowerShell. Éste no es un paso obligatorio, ya que puede usar un editor de texto con interfaz de usuario gráfica, como Notepad. En este tutorial se recomienda usar nano, pues le servirá para acostumbrarse a usar PowerShell.

      Utilice Chocolatey para instalar nano:

      El indicador -y confirma automáticamente que desea ejecutar la secuencia de comandos sin que se le pida confirmación.

      Una vez que nano esté instalado, podrá usar el comando nano para crear nuevos archivos de texto. Lo utilizará posteriormente en este tutorial para escribir su primer programa Go.

      Paso 1: Instalar Go

      Como hizo con nano en el paso anterior, usará Chocolatey para instalar Go:

      Nota: Debido a que go es una palabra muy corta, una práctica que se ha vuelto común es la de usar golang como término para instalar paquetes y para la búsqueda de artículos relacionados con Go en Internet. El término Golang surgió del dominio de Go, golang.org.

      PowerShell ahora instalará Go y generará un resultado en PowerShell durante ese proceso. Una vez completada la instalación, debería ver el siguiente resultado:

      Output

      Environment Vars (like PATH) have changed. Close/reopen your shell to see the changes (or in powershell/cmd.exe just type `refreshenv`). The install of golang was successful. Software installed as 'msi', install location is likely default. Chocolatey installed 1/1 packages. See the log for details (C:ProgramDatachocolateylogschocolatey.log).

      Después de la instalación, confirmará que Go está instalado. Para ver los cambios, cierre y vuelva a abrir PowerShell como administrador, y luego compruebe la versión de Go disponible en su equipo local:

      Recibirá un resultado similar al siguiente:

      Output

      go version go1.12.1 windows/amd643.7.0

      Una vez instalado Go, podrá configurar un espacio de trabajo para sus proyectos de desarrollo.

      Paso 5: Crear su espacio de trabajo de Go

      Ahora que instaló Chocolatey, nano 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 creados 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 repository 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, se recomienda utilizar la ubicación $HOME/go para su espacio de trabajo.

      Ejecute el siguiente comando para acceder al directorio $HOME:

      A continuación, cree la estructura de directorios para su espacio de trabajo de Go:

      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.

      Debido a que usó Chocolatey para la instalación, esta variable de entorno deberá estar configurada. Puede verificar esto con el siguiente comando:

      Debería ver el siguiente resultado, con su nombre de usuario en lugar de sammy:

      Output

      C:Userssammygo

      Cuando Go compile e instale herramientas, las dispondrá en el directorio $GOPATH/bin. Por conveniencia, es común añadir el subdirectorio bin del espacio de trabajo a su $PATH. Puede hacer esto usando el comando setx en PowerShell:

      • setx PATH "$($env:path);$GOPATHbin"

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

      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

      Nota: Si no instaló git, Windows abrirá un cuadro de diálogo en el que se le preguntará si desea instalarlo. Haga clic en para continuar y siga las instrucciones de instalación.

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

      • ls $env:GOPATH/src/github.com/digitalocean/godo

      Recibirá un resultado similar a este:

      Output

      Directory: C:Userssammygosrcgithub.comdigitaloceangodo Mode LastWriteTime Length Name ---- ------------- ------ ---- d----- 4/10/2019 2:59 PM util -a---- 4/10/2019 2:59 PM 9 .gitignore -a---- 4/10/2019 2:59 PM 69 .travis.yml -a---- 4/10/2019 2:59 PM 1592 account.go -a---- 4/10/2019 2:59 PM 1679 account_test.go -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 . . . -a---- 4/10/2019 2:59 PM 5076 vpcs.go -a---- 4/10/2019 2:59 PM 4309 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ó el espacio de trabajo de Go, cree un programa “Hello, World!” simple. Mundo!”. Esto garantizará que su espacio de trabajo se configure correctamente 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 nano, escriba su programa:

      hello.go

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

      Cierre nano presionando las teclas CTRL y X. Cuando se le pregunte si desea guardar el archivo, presione Y y luego INTRO.

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

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

      El programa hello.go que acaba de crear debería hacer que PowerShell genere el siguiente resultado:

      Output

      Hello, World!

      Siguiendo 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 equipo local con Windows y podrá iniciar un proyecto de creación de código.



      Source link

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


      Введение

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

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

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

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

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

      Шаг 1 — Открытие и настройка PowerShell

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

      PowerShell — это программа Microsoft, обеспечивающая оболочку интерфейса командной строки. Административные задачи выполняются посредством запуска cmdlets или командлетов, которые представляют собой специализированные классы программной структуры . NET, предназначенные для выполнения операций. Исходный код программы PowerShell был раскрыт в августе 2016 г., и теперь она доступна для разных платформ Windows и UNIX (включая Mac и Linux).

      Чтобы найти Windows PowerShell, щелкните правой кнопкой мыши значок меню Пуск в левом нижнем углу экрана вашего компьютера. Когда появится меню, нажмите Search (Найти) и введите PowerShell в панель поиска. В списке вариантов щелкните правой кнопкой мыши приложение Windows PowerShell. Для целей настоящего обучающего руководства нажмите Run as Administrator (Запуск от имени администратора). Когда откроется диалоговое окно Разрешить этому приложению вносить изменения на вашем устройстве?, нажмите Да.

      После этого вы увидите текстовый интерфейс со строкой следующего вида:

      Windows 10 PowerShell

      Выйдите из системной папки с помощью следующей команды:

      Теперь вы находитесь в домашнем каталоге, например, PS C:Userssammy.

      Чтобы продолжить установку, вам нужно настроить разрешения через PowerShell. По умолчанию система настроена для работы в самом безопасном режиме, однако в качестве администратора вы можете настроить несколько уровней разрешений:

      • Restricted — политика ограничения исполнения, заданная по умолчанию. В этом режиме вы не можете запускать скрипты, и PowerShell работает только как интерактивная оболочка.
      • AllSigned — вы можете запускать все скрипты и файлы конфигурации, подписанные доверенным издателем, т. е. вы можете сделать свою систему уязвимой для вредоносных скриптов, которые выглядят как подписанные доверенным издателем.
      • RemoteSigned — вы можете запускать загруженные из интернета скрипты и файлы конфигурации, подписанные доверенными издателями, что также делает вашу систему уязвимой к таким скриптам, если они носят вредоносный характер.
      • Unrestricted — режим без ограничений, позволяющий запускать все скрипты и файлы конфигурации, загруженные из интернета сразу после того, как вы подтвердите, что понимаете, что файл загружен из интернета. В этом случае цифровая подпись не требуется, и ваша система становится уязвима для неподписанных и потенциально вредоносных скриптов, загруженных из интернета.

      В этом обучающем руководстве мы используем политику исполнения RemoteSigned для установки разрешений для текущего пользователя. Она позволяет PowerShell принимать скрипты из доверенных источников, но не делает уровень разрешений таким широким, как при использовании политики Unrestricted. Введите в PowerShell следующую команду:

      • Set-ExecutionPolicy -Scope CurrentUser

      PowerShell предложит вам указать политику исполнения. Введите следующее, чтобы использовать политику RemoteSigned:

      После нажатия клавиши ENTER вам будет предложено подтвердить изменение политики исполнения. Введите букву y для вступления изменений в силу. Вы можете проверить вступление изменений в силу, запросив текущий уровень разрешений в системе:

      • Get-ExecutionPolicy -List

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

      Output

      Scope ExecutionPolicy ----- --------------- MachinePolicy Undefined UserPolicy Undefined Process Undefined CurrentUser RemoteSigned LocalMachine Undefined

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

      Шаг 2 — Установка диспетчера пакетов Chocolatey

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

      Chocolatey — созданный для Windows диспетчер пакетов с интерфейсом командной строки, работающий наподобие диспетчера apt-get в Linux. Диспетчер пакетов Chocolatey с открытым исходным кодом поможет вам быстро устанавливать приложения и инструменты. Вы сможете использовать его для загрузки всего необходимого для вашей среды разработки.

      Прежде чем устанавливать скрипт, прочитайте его и убедитесь, что вас устроят изменения, которые он внесет в вашу систему. Используйте систему скриптов . NET для загрузки и отображения скрипта Chocolatey в окне терминала.

      Вначале создайте объект WebClient с именем $script, имеющий общие с Internet Explorer параметры подключения к интернету:

      • $script = New-Object Net.WebClient

      Для просмотра доступных опций передайте объект $script с помощью | в класс Get-Member:

      В результате будут возвращены все члены (свойства и методы) этого объекта WebClient:

      Snippet of Output

      . . . DownloadFileAsync Method void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur... DownloadFileTaskAsync Method System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa... DownloadString Method string DownloadString(string address), string DownloadString(uri address) #method we will use DownloadStringAsync Method void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy... DownloadStringTaskAsync Method System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy… . . .

      Просматривая результат, вы увидите метод DownloadString, который используется для отображения скрипта и подписи в окне PowerShell. Используйте этот метод для просмотра скрипта:

      • $script.DownloadString("https://chocolatey.org/install.ps1")

      После проверки скрипта установите Chocolatey, введя в PowerShell следующую команду:

      • iwr https://chocolatey.org/install.ps1 -UseBasicParsing | iex

      Командлет iwr, или Invoke-WebRequest, позволяет извлекать данные из веб-источников. Эта команда передает скрипт в командлет iex, или Invoke-Expression, который запускает содержимое скрипта и выполняет установку диспетчера пакетов Chocolatey.

      Разрешите PowerShell выполнить установку Chocolatey. После завершения установки вы можете начать установку дополнительных инструментов с помощью команды choco.

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

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

      Шаг 3 — Установка текстового редактора Nano (необязательно)

      На этом шаге вы выполните установку текстового редактора nano с интерфейсом командной строки. Вы можете использовать nano для написания программ в PowerShell. Это необязательно, поскольку вы также можете использовать Notepad или другой текстовый редактор с графическим интерфейсом. В этом обучающем модуле мы рекомендуем использовать nano, поскольку это поможет вам привыкнуть к работе с PowerShell.

      Используйте Chocolatey для установки nano:

      Флаг -y автоматически подтверждает, что вы хотите запустить скрипт, не получая запросов подтверждения.

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

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

      Как и в случае с nano, вы будете использовать Chocolatey для установки Go:

      Примечание: поскольку go — очень короткое слово, обычно в качестве термина при установке пакетов и при поиске в Интернете статей вместо него обычно используется термин golang. Термин Golang происходит от названия домена Go, а именно golang.org.

      Теперь PowerShell выполнит установку Go и будет отображать ход выполнения в PowerShell. После завершения установки вы должны увидеть следующее:

      Output

      Environment Vars (like PATH) have changed. Close/reopen your shell to see the changes (or in powershell/cmd.exe just type `refreshenv`). The install of golang was successful. Software installed as 'msi', install location is likely default. Chocolatey installed 1/1 packages. See the log for details (C:ProgramDatachocolateylogschocolatey.log).

      После завершения установки вы можете подтвердить установку Go. Чтобы увидеть изменения, закройте и заново откройте PowerShell от имени администратора, а затем проверьте версию Go на локальном компьютере:

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

      Output

      go version go1.12.1 windows/amd643.7.0

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

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

      Вы установили Chocolatey, nano и 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 repository 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

      Выполните следующую команду для перехода в каталог $HOME:

      Затем создайте структуру каталогов для рабочего пространства Go:

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

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

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

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

      Вы должны увидеть следующие результаты с вашим именем пользователя вместо sammy:

      Output

      C:Userssammygo

      При компиляции и установке инструментов Go помещает их в каталог $GOPATH/bin. Для удобства стоит добавить подкаталог bin рабочего пространства в $PATH. Для этого вы можете использовать команду setx в PowerShell:

      • setx PATH "$($env:path);$GOPATHbin"

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

      Вы создали корневой каталог рабочего пространства и задали переменную среды $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

      Примечание: если вы не установили git, Windows откроет диалоговое окно с предложением выполнить установку. Нажмите Да, чтобы продолжить, и следуйте указаниям по установке.

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

      • ls $env:GOPATH/src/github.com/digitalocean/godo

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

      Output

      Directory: C:Userssammygosrcgithub.comdigitaloceangodo Mode LastWriteTime Length Name ---- ------------- ------ ---- d----- 4/10/2019 2:59 PM util -a---- 4/10/2019 2:59 PM 9 .gitignore -a---- 4/10/2019 2:59 PM 69 .travis.yml -a---- 4/10/2019 2:59 PM 1592 account.go -a---- 4/10/2019 2:59 PM 1679 account_test.go -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 . . . -a---- 4/10/2019 2:59 PM 5076 vpcs.go -a---- 4/10/2019 2:59 PM 4309 vpcs_test.go

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

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

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

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

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

      hello.go

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

      Закройте nano с помощью клавиш CTRL и X. Когда вам будет предложено сохранить файл, нажмите Y и затем ENTER.

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

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

      Программа hello.go, которую вы только что создали, выведет в окне PowerShell следующее:

      Output

      Hello, World!

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

      Заключение

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



      Source link