Existe algum depurador interativo Golang? [fechadas]

O título resume tudo. Estou testando o Go e realmente sinto falta de ser capaz de definir pontos de interrupção e entrar / sair / sair tanto quanto eu quero em um ambiente interativo. Eu sei que posso usar o gdb para depurar o Go, mas isso é muito irritante em comparação com o uso de um IDE que pode ser conectado ao gdb para fazer breakpoint.

Tentei pesquisar um e só consegui encontrar plug-ins ou pequenos IDEs com realce de sintaxe, mas sem depuração.

Atualização : Pessoalmente, embora o GDB funcione, não sou um fã de usá-lo no Go e vai fazer você cuspir um pouco de sangue. Confira algumas das outras respostas para boas alternativas.

Sim, claro :)

Go tem um depurador (GDB)

Aqui está o tutorial oficial de como usá-lo.

Se você quiser 'depuração gráfica' (isto é, definir pontos de interrupção no editor), alguns IDEs permitem fazer isso (com GDB em segundo plano).

Especificamente, Eclipse, LiteIDE e Zeus permitem definir pontos de interrupção e depurar a partir de seu ambiente de codificação (fonte) . Aqui está um vídeo sobre como fazer isso com o Zeus .

O suporte do GDB para go tem muitos problemas que não serão corrigidos pela equipe go.

Para mais informações, leia a postagem de Rob Pike :

Embora nos esforcemos para manter a funcionalidade básica do gdb (rastreamentos de pilha, valores de impressão) funcionando nas plataformas suportadas, a capacidade de usar o depurador para entender o ambiente completo de um programa Go provavelmente nunca funcionará e melhorar o suporte do gdb não é uma prioridade para a equipe .

Eles estão procurando outras opções de depuração, mas não têm planos concretos agora. A documentação está desatualizada e o runtime-gdb.pyscript que vem com go 1.2 não funciona para um GDB que foi compilado com suporte a python3 (Ubuntu atual, por exemplo).

Atualização de 2017: o projeto godebug mencionado abaixo agora é oficialmente substituído por derekparker / delve .

Resposta original:

Você agora (março de 2015) tem outra abordagem, baseada na instrumentação do código.

mailgun / godebug :

godebugusa geração de código- fonte para instrumentar seu programa com chamadas de depuração .
go tool coveradota uma abordagem semelhante para cobertura de código.

• Quando você executa godebug, ele analisa seu programa, instrumentos de chamadas de função, declarações de variáveis ​​e linhas de instrução e produz o código resultante em algum lugar (atualmente stdout ou no local sobre seus arquivos originais).
• Ao executar esse código modificado, supondo que você colocou um ponto de interrupção em algum lugar, você pode percorrê-lo e inspecionar as variáveis.

Mais tarde: avalie expressões Go arbitrárias e grave em variáveis.

Atualização de junho de 2015:

Embora possa não ser tão interativo como "alguns" podem esperar, ainda é apreciado (e tem o recurso "entrar em" ).
Consulte " Go tem um depurador - e é incrível! " (Cloudfare)

Aqui está a parte legal: em vez de lutar com meia dúzia de ptraceinterfaces diferentes que não seriam portáveis, godebugreescreve seu código-fonte e injeta chamadas de função como godebug.Lineem cada linha, godebug.Declareem cada declaração de variável e godebug.SetTracepara pontos de interrupção (ou seja, onde quer que você digite _ = "breakpoint").

Acho essa solução brilhante.
O que você ganha com isso é um binário habilitado para depuração (possivelmente com compilação cruzada) que você pode colocar em um servidor de teste da mesma forma que faria com um binário regular .

Quando um ponto de interrupção é atingido, o programa para em linha e espera por você no stdin.

É a filosofia de binário único e dependência zero do Go que adoramos aplicada à depuração. Compila em qualquer lugar, é executado em qualquer lugar, sem necessidade de ferramentas ou permissões no servidor.

ifdef GODEBUG  
    GOPATH="${PWD}" go install github.com/mailgun/godebug
    GOPATH="${PWD}" ./bin/godebug build -instrument "${GODEBUG}" -o bin/rrdns rrdns

A depuração está apenas a uma make bin/rrdns GODEBUG=rrdns/...distância.

ATUALIZAR:

Eu verifiquei e tenho o prazer de informar que a versão: 2016.1.3, Build: 145.1617.8, lançado: 5 de junho de 2016 funciona com Delve! Você pode baixá-lo aqui: https://www.jetbrains.com/idea/download/ . Siga também as instruções de instalação do Delve aqui: https://github.com/derekparker/delve/tree/master/Documentation/installation

É um pouco esquisito. Logo depois que recebi o prompt de login do OSX, a depuração interativa começou a funcionar. Às vezes, preciso depurar um programa .go simples para iniciá-lo. Mas funciona e é a melhor experiência de depuração interativa para Go que já vi.

POSTAGEM ORIGINAL:

Existe algum depurador interativo Golang? Sim.

Existe algum depurador interativo Golang que valha a pena usar? Não.

Configurar o GDB no mac é tedioso, mas factível.

No entanto, assim que começar a usá-lo, você logo perceberá que perdeu tempo instalando-o.

Você pode até configurar o IntelliJ para usá-lo.

O único valor que IntelliJ, LiteIDE, CGDB, etc. parecem fornecer é que você pode verificar mais rapidamente que o suporte à depuração de GDB para Go é extremamente pobre.

Você pode usá-lo para percorrer algum código Go, mas tente imprimir o valor de qualquer coisa que não seja valores de variáveis ​​muito simples e você estará perdendo seu tempo desejando um depurador decente.

Aqui está um exemplo do que acontece quando você tenta imprimir o valor de uma estrutura de dados de string de mapa [string] usando CGDB:

(gdb) print params
$1 = (github.com/go-martini/martini.Params) 0x15582 <runtime.reentersyscall+450>

... o que é completamente inútil.

Em seguida, tente isto:

(gdb) print params["UserID"]

... e você obterá "Erro de ônibus".

Delve ( https://github.com/derekparker/delve ) parece promissor, já que foi escrito em Go, mas você o dirige usando o console, não por meio de um IDE.

Eu pagaria com prazer pela versão corporativa do IntelliJ (ou qualquer outro IDE) que fez um trabalho decente no suporte à depuração interativa em Go.

A partir de agora, fmt.Printf("%v", variable)é o melhor que pode acontecer.

EDITAR

O depurador GO agora é um plugin simples no IntelliJ ou PyCharm, não há necessidade de instalar mais nada. Procure o plugin Go nas preferências de plugin.

Resposta original (novembro de 2015)

para quem procura as novidades a partir do final de novembro de 2015:

se aprofundar

https://github.com/derekparker/delve

e siga as instruções de construção / configuração:

https://github.com/derekparker/delve/wiki/Building

Obtenha o IntelliJ (15) ou PyCharm (5) mais recente

https://www.jetbrains.com/idea/download/

e obtenha o plug-in go-lang no IDE de sua escolha:

Pycharm -> Preference -> plugins -> search for go
current version is Version: 0.10.749
IntelliJ -> Preference -> plugins -> search for go
current version is Version: 0.10.749

1. Configure um novo projeto Go ou importe um projeto.
2. Configure o Go SDK conforme solicitado
3. Configure sua biblioteca Go (geralmente em GOROOT / src
4. Defina uma configuração de execução de aplicativo no canto superior direito pelo ícone 'play':
5. Editar configurações -> clique em + -> Ir para o aplicativo

Defina seu pacote ou arquivo a ser executado.

Depois de concluir a configuração, o ícone Play e o ícone Debug agora devem estar ativos, e você pode definir o ponto de interrupção, relógios, etc.

Felicidades

Estou felizmente usando CGDB, um pequeno invólucro de maldições em torno do GDB.

• Página oficial: cgdb - o depurador de curses
• Vídeo: depuração mais fácil na linha de comando com CGDB

IDE DEBUG ON GO É POSSÍVEL (NOVAMENTE), FUNCIONA REALMENTE !

Delve funciona muito bem no Mac OS X e é suportado pelo plugin IntelliJ IDEA Go Lang .

Eu testei isso no Mac OSX, IntelliJ Idea 14, Go 1.5.1, Delve 0.5

Tive que executar os loops usuais de criação de um certificado autoassinado, adicionando-o ao anel do sistema, etc (necessário para executar um depurador no Mac OS X). No final, eu defini um projeto GO dentro do IntelliJ e fui recompensado em recuperar os recursos normais do IDE + depurador: definir pontos de interrupção, inspecionar variáveis, passo único.

Isso é muito melhor do que imprimir valores para depurar o código.

1. Opção um - GDB https://golang.org/doc/gdb

2. Aprofundar

3. Código do Visual Studio com seu plug-in go (ainda usa o delve).

Eu pessoalmente uso a opção 3. Para isso, você precisará ter o delve instalado.

Este vídeo mostra a depuração em ação: https://youtu.be/uBjoTxosSys?t=16m11s (o vídeo inteiro é muito interessante).

Estou muito feliz com o Gogland ( https://www.jetbrains.com/go/ ), que é basicamente Intellij com suporte para Go. Ele tem um depurador funcionando que fica cada vez melhor à medida que eles o desenvolvem. Estou usando-o desde janeiro de 2017 e está praticamente estável para mim em um MBP 2016.

Goland é o codinome de um novo IDE comercial da JetBrains que visa fornecer um ambiente ergonômico para o desenvolvimento Go.