Leitores como você ajudam a apoiar o MUO. Quando você faz uma compra usando links em nosso site, podemos ganhar uma comissão de afiliado. Consulte Mais informação.

Formatar seu código é uma maneira importante de aprimorar sua legibilidade, consistência e reutilização. Código formatado corretamente é mais fácil de entender, modificar e manter.

Um dos grandes recursos do Go são suas convenções de formatação bem definidas. Você pode usar o pacote de formatação integrado e o comando go fmt para formatar automaticamente seu código. Isso ajudará a garantir que outros programadores Go possam lê-lo o mais facilmente possível.

O pacote de formatos e o comando fmt

O formatar pacote implementa formatação padrão para o Ir código-fonte. O pacote interopera com o vai formatar ferramenta de linha de comando para flexibilidade na formatação do código Go.

O pacote format é um submódulo do pacote go. Veja como você pode importá-lo:

importar"ir/formatar"

Você pode navegar na documentação do comando go fmt especificando o ajuda comando antes do fmt comando:

instagram viewer 
vai ajudar fmt

Especifique um nome de arquivo após o comando fmt para formatar esse arquivo. Isso ajustará o espaço em branco e o recuo do seu código para estar em conformidade com os padrões do Go.

ir fmt main.go

Nos bastidores, go fmt é um alias para o comando gofmt, especificamente:

gofmt -l -w

Esses sinalizadores fazem com que o gofmt grave quaisquer alterações em cada arquivo fornecido e liste os nomes dos arquivos que ele altera.

Você pode adicionar o -x flag para o comando fmt. O sinalizador -x ajuda a gravar alterações do formatador no arquivo original.

go fmt -x main.go

O -n sinalizador funciona de forma semelhante a -x, mas não faz alterações. Em vez disso, ele exibe os comandos que o go fmt executaria sem o -n:

go fmt -n main.go

O sinalizador informa ao formatador para mostrar as alterações, o que permite revisá-las antes de aplicá-las.

Aqui está um programa Go simples que percorre inteiros de zero a cinco e imprime a string “Hello World!”.

// formatando um arquivo chamado main.go como mostrado no exemplo acima 
pacote principal
importar"fmt"
funçãoprincipal() {
var x int=5
para eu:=0;eu fmt. Imprimirln("Olá Mundo!")
 }
}

Formatando o código-fonte do Go

O pacote de formato contém um Fonte função para formatar arquivos Go de programas. Você terá que ler o arquivo e passar o conteúdo como argumentos para a função Source.

A função Source retornará o conteúdo do arquivo formatado que você pode gravar no arquivo ou em um novo.

Você pode ler arquivos com o ReadFile função do ioutil pacote. A função ReadFile recebe o nome do arquivo e retorna o conteúdo do arquivo e um erro de manipulação.

fileContent, err := ioutil. ReadFile("main.go")
se erro != nada {
 registro. Fataln("Ocorreu um erro ao ler o arquivo", erro)
}

Passar o conteúdo do arquivo para a função Source retorna o conteúdo do arquivo formatado e um erro de manipulação.

formatado, erro := formato. Origem (arquivoConteúdo)
se erro != nada {
 registro. Fataln("Ocorreu um erro de formatação com a função de origem", erro)
}

Você pode gravar o conteúdo do arquivo formatado no arquivo com a WriteFile função do ioutil pacote. A função WriteFile recebe o nome do arquivo, conteúdo e modo de permissão de arquivo, retornando qualquer(s) erro(s). O modo de permissão só é relevante se o arquivo não existir, caso em que WriteFile o criará.

O 0644 o modo de permissão de arquivo fornece:

  • As permissões de leitura e gravação do proprietário do arquivo.
  • Permissões de leitura para outros usuários no mesmo grupo que o proprietário.
  • Sem permissões para outros usuários. 
erro = ioutil. WriteFile("main.go", formatado, 0644)
se erro != nada {
 registro. Fataln("Ocorreu um erro ao gravar o arquivo", erro)
}

Como alternativa, você pode passar o código-fonte Go para a função Source para formatação. Você pode especificar o código em uma fatia de byte usando ticks (`):

pacote principal
importar (
"fmt"
"ir/formatar"
)


funçãoprincipal() {
// programa simples que calcula a área de um triângulo com a matemática
// função 
 formatado, erro := formato. Fonte([]byte(`
pacote principal
importar(
"fmt"
"matemática"
)
funçãoprincipal(){
var a float64=3
var b float64=4
var c float64=5
var s float64=(a+b+c)/2
var área float64= matemática. Sqrt (s*(s-a)*(s-b)*(s-c))
fmt. Imprimirln("A área do triângulo é: ",área)
}
`))
se erro != nada {
 registro. Fataln("Ocorreu um erro de formatação com a função de origem", erro)
 } outro {
 fmt. Imprimirln(corda(formatado))
 }
}

Na formatação, você precisará converter a fatia de byte em string com o corda função. Aqui está o código-fonte formatado.

Personalizando o processo de formatação

Você pode personalizar o processo de formatação com o pacote de formatos configuração struct. A estrutura Config contém campos onde você pode especificar opções de formato na instanciação.

importar"ir/formatar"
config := &formato. Configuração{
// Tabwidth define o número de espaços por tabulação.
 Largura da guia: 8,


// UseTabs indica se o formatador deve usar tabs em vez de
// espaços.
 Usar guias: falso,


// TabIndent é usado para determinar se o recuo inicial deve ser
// feito usando tabulações ou espaços.
 TabIndent: verdadeiro,


// NoFinalTab especifica se uma tabulação final deve ser removida de
// linhas antes de serem formatadas.
 NoFinalTab: verdadeiro,


// Espaços especifica se espaços devem ser usados ​​para alinhamento.
 Espaços: verdadeiro,
// NoTrimTrailingSpace especifica se o espaço em branco à direita deve
// ser cortado das linhas antes de serem formatadas.
 NoTrimTrailingSpace: falso,
}

Você pode usar os campos para personalizar o comportamento do seu formatador definindo as opções com base em seus requisitos.

Você pode usar o método Source dessa estrutura para formatar uma fatia de byte com base em sua configuração.

funçãoprincipal() {
 fileContent, err := ioutil. ReadFile("main.go")
// note que este é um método Source do tipo `config`, não do
// pacote `format` em si, embora a funcionalidade seja a mesma, você
// precisa aderir a isso se precisar configurar o formatador 
 formatado, erro := config. Origem (arquivoConteúdo)


se erro != nada {
 registro. Fataln("Ocorreu um erro de formatação com o tipo de configuração", erro)
 }
 ioutil. WriteFile("main.go", formatado, 0644)
}

Chamando o config. A função Source() como esta formata o conteúdo do main.go usando as opções de configuração. Ele retorna o conteúdo formatado como uma fatia de byte e um erro.

Você pode formatar e manipular string em Go

O pacote format e o comando go fmt podem ajudá-lo a automatizar o processo de formatação do código.

Go também fornece um pacote fmt para formatação de strings e um pacote de strings para manipulação de strings.

O pacote fmt implementa E/S formatada mais simples com funções análogas às funções printf e scanf do C. A função strings implementa funções simples para manipular strings codificadas em UTF-8.