Como formatar o Go Source para um código consistente mais limpo

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 pacote de formato implementa a formatação padrão para o código-fonte Go. O pacote interopera com a ferramenta de linha de comando go format para flexibilidade na formatação do código Go.

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

import "go/format"


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

go help 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.

go 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 sinalizador -x ao comando fmt. O sinalizador -x ajuda a gravar alterações do formatador no arquivo original.

go fmt -x main.go


O sinalizador -n funciona de maneira 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!”.

// formatting a file named main.go as shown in the example above


package main
import "fmt"
func main() {
  var x int=5
  for i:=0;i<x;i++{
    fmt.Println("Hello World!")
  }
}

Formatando o código-fonte do Go

O pacote de formato contém uma função Source 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 a função ReadFile do pacote ioutil . 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")


if err! = nil {
  log.Fatalln("There was an error reading the file", err)
}


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

formatted, err: = format.Source(fileContent)


if err! = nil {
  log.Fatalln("There was a formatting error with the source function", err)
}


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

O modo de permissão de arquivo 0644 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.

err = ioutil.WriteFile("main.go", formatted, 0644)


if err! = nil {
  log.Fatalln("There was an error writing the file", err)
}


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 ( ` ):

package main


import (
  "fmt"
  "go/format"
)

  if err! = nil {
    log.Fatalln("There was a formatting error with the source function", err)
  } else {
    fmt.Println(string(formatted))
  }
}


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

Personalizando o processo de formatação

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

import "go/format"


config: = &format.Config{
  // Tabwidth sets the number of spaces per tab.
  Tabwidth: 8,

  // NoTrimTrailingSpace specifies whether trailing white space should
  // be trimmed from lines before they are formatted.
  NoTrimTrailingSpace: false,
}


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.

func main() {
  fileContent, err: = ioutil.ReadFile("main.go")


  // note that this is a Source method of the `config` type, not from the
  // `format` package itself although the functionality is the same, you'll
  // need to adhere to this if you need to configure the formatter
  formatted, err: = config.Source(fileContent)

  ioutil.WriteFile("main.go", formatted, 0644)
}


Chamar a função config.Source() dessa forma formata o conteúdo do arquivo 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.