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 muito definidas. Você pode usar o pacote de formatação integrado e o comando go fmt para formatar involuntariamente seu código. Isso ajudará a prometer que outros programadores Go possam lê-lo o mais facilmente verosímil.
O pacote de formatos e o comando fmt
o formato O pacote implementa a formatação padrão para o código-fonte Go. O pacote interopera com o vai formatar instrumento de risco de comando para flexibilidade na formatação do código Go.
O pacote format é um submódulo do pacote go. Veja porquê você pode importá-lo:
import "go/format"
Você pode velejar na documentação do comando go fmt especificando o ajuda comando antes do fmt comando:
go help fmt
Especifique um nome de registro posteriormente o comando fmt para formatar esse registro. 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 registro fornecido e liste os nomes dos arquivos que ele altera.
Você pode juntar o -x flag para o comando fmt. O sinalizador -x ajuda a gravar alterações do formatador no registro original.
go fmt -x main.go
o -n sinalizador 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.
Cá está um programa Go simples que percorre inteiros de zero a cinco e imprime a string “Hello World!”.
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 um Nascente função para formatar arquivos Go de programas. Você terá que ler o registro e passar o teor porquê argumentos para a função Source.
A função Source retornará o teor do registro formatado que você pode gravar no registro ou em um novo.
Você pode ler arquivos com o ReadFile função do ioutil pacote. A função ReadFile recebe o nome do registro e retorna o teor do registro 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 teor do registro para a função Source retorna o teor do registro 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 teor do registro formatado no registro com a WriteFile função do ioutil pacote. A função WriteFile assume o nome do registro, o teor e o modo de permissão do registro, retornando qualquer erro. O modo de permissão só é relevante se o registro não viver, caso em que WriteFile o criará.
o 0644 o modo de permissão de registro fornece:
- As permissões de leitura e gravação do proprietário do registro.
- 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)
}
Porquê selecção, 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 mainimport (
"fmt"
"go/format"
)
func main() {
formatted, err := format.Source([]byte(`
package main
import(
"fmt"
"math"
)
func main(){
var a float64=3
var b float64=4
var c float64=5
var s float64=(a+b+c)/2
var area float64=math.Sqrt(s*(s-a)*(s-b)*(s-c))
fmt.Println("The area of the triangle is: ",area)
}
`))
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á transformar a fatia de byte em string com o corda função. Cá 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 feitio struct. A estrutura Config contém campos onde você pode especificar opções de formato na instanciação.
import "go/format"config := &format.Config{
Tabwidth: 8,
UseTabs: false,
TabIndent: true,
NoFinalTab: true,
Spaces: true,
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 feitio.
func main() {
fileContent, err := ioutil.ReadFile("main.go")
formatted, err := config.Source(fileContent)
if err != nil {
log.Fatalln("There was a formatting error with the config type", err)
}
ioutil.WriteFile("main.go", formatted, 0644)
}
Invocar a função config.Source() dessa forma formata o teor do main.go usando as opções de feitio. Ele retorna o teor formatado porquê 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.
