Come formattare Go Source per un codice coerente più pulito
La formattazione del codice è un modo importante per migliorarne la leggibilità, la coerenza e la riusabilità. Il codice correttamente formattato è più facile da capire, modificare e mantenere.
Una delle grandi caratteristiche di Go sono le sue convenzioni di formattazione ben definite. È possibile utilizzare il pacchetto di formattazione integrato e il comando go fmt per formattare automaticamente il codice. Ciò contribuirà a garantire che altri programmatori Go possano leggerlo il più facilmente possibile.
Il pacchetto Format e il comando fmt
Il pacchetto di formato implementa la formattazione standard per il codice sorgente di Go. Il pacchetto interagisce con lo strumento della riga di comando go format per la flessibilità nella formattazione del codice Go.
Il formato pacchetto è un sottomodulo nel pacchetto go. Ecco come puoi importarlo:
import "go/format"
È possibile sfogliare la documentazione del comando go fmt specificando il comando help prima del comando fmt :
go help fmt
Specificare un nome file dopo il comando fmt per formattare quel file. Questo regolerà gli spazi bianchi e il rientro del codice per conformarsi agli standard Go.
go fmt main.go
Dietro le quinte, go fmt è un alias per il comando gofmt, in particolare:
gofmt -l -w
Questi flag fanno sì che gofmt scriva qualsiasi modifica a ciascun file fornito ed elenchi i nomi dei file che modifica.
Puoi aggiungere il flag -x al comando fmt. Il flag -x aiuta a scrivere le modifiche dal formattatore al file originale.
go fmt -x main.go
Il flag -n funziona in modo simile a -x, ma non apporta modifiche. Invece, mostra i comandi che vanno fmt verrebbero eseguiti senza -n:
go fmt -n main.go
Il flag indica al formattatore di mostrare le modifiche, il che consente di rivederle prima di applicarle.
Ecco un semplice programma Go che scorre i numeri interi da zero a cinque e stampa la stringa “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!")
}
}
Formattazione del codice sorgente Go
Il pacchetto di formato contiene una funzione Source per la formattazione dei file Go dai programmi. Dovrai leggere il file e passare i contenuti come argomenti alla funzione Source.
La funzione Source restituirà il contenuto del file formattato che puoi scrivere nel file o in uno nuovo.
Puoi leggere i file con la funzione ReadFile del pacchetto ioutil . La funzione ReadFile accetta il nome del file e restituisce il contenuto del file e un errore per la gestione.
fileContent, err: = ioutil.ReadFile("main.go")
if err! = nil {
log.Fatalln("There was an error reading the file", err)
}
Il passaggio del contenuto del file alla funzione Source restituisce il contenuto del file formattato e un errore per la gestione.
formatted, err: = format.Source(fileContent)
if err! = nil {
log.Fatalln("There was a formatting error with the source function", err)
}
È possibile scrivere il contenuto del file formattato nel file con la funzione WriteFile del pacchetto ioutil . La funzione WriteFile accetta il nome del file, i contenuti e la modalità di autorizzazione del file, restituendo eventuali errori. La modalità di autorizzazione è rilevante solo se il file non esiste, nel qual caso WriteFile lo creerà.
La modalità di autorizzazione file 0644 fornisce:
- Il proprietario del file ha i permessi di lettura e scrittura.
- Autorizzazioni di lettura per altri utenti nello stesso gruppo del proprietario.
- Nessuna autorizzazione ad altri utenti.
err = ioutil.WriteFile("main.go", formatted, 0644)
if err! = nil {
log.Fatalln("There was an error writing the file", err)
}
In alternativa, puoi passare il codice sorgente di Go alla funzione Source per la formattazione. È possibile specificare il codice in una porzione di byte utilizzando i tick ( ` ):
package main
import (
"fmt"
"go/format"
)
func main() {
// simple program that calculates the area of a triangle with the math
// function
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))
}
}
Durante la formattazione, dovrai convertire la porzione di byte in stringa con la funzione stringa . Ecco il codice sorgente formattato.
Personalizzazione del processo di formattazione
È possibile personalizzare il processo di formattazione con la struttura Config del pacchetto di formato . La struttura Config contiene campi in cui è possibile specificare le opzioni di formato durante la creazione di un’istanza.
import "go/format"
config: = &format.Config{
// Tabwidth sets the number of spaces per tab.
Tabwidth: 8,
// UseTabs indicates whether the formatter should use tabs instead of
// spaces.
UseTabs: false,
// TabIndent is used to determine if the initial indentation should be
// done using tabs or spaces.
TabIndent: true,
// NoFinalTab specifies whether a final tab should be removed from
// lines before they are formatted.
NoFinalTab: true,
// Spaces specifies whether spaces should be used for alignment.
Spaces: true,
// NoTrimTrailingSpace specifies whether trailing white space should
// be trimmed from lines before they are formatted.
NoTrimTrailingSpace: false,
}
Puoi utilizzare i campi per personalizzare il comportamento del tuo formattatore impostando le opzioni in base alle tue esigenze.
È quindi possibile utilizzare il metodo Source di questa struttura per formattare una porzione di byte in base alla configurazione.
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)
if err! = nil {
log.Fatalln("There was a formatting error with the config type", err)
}
ioutil.WriteFile("main.go", formatted, 0644)
}
Chiamando la funzione config.Source() in questo modo si formatta il contenuto del file main.go utilizzando le opzioni di configurazione. Restituisce il contenuto formattato come una porzione di byte e un errore.
Puoi formattare e manipolare la stringa in Go
Il pacchetto di formato e il comando go fmt possono aiutarti ad automatizzare il processo di formattazione del codice.
Go fornisce anche un pacchetto fmt per la formattazione delle stringhe e un pacchetto strings per la manipolazione delle stringhe.
Il pacchetto fmt implementa un I/O formattato più semplice con funzioni analoghe alle funzioni printf e scanf del C. La funzione strings implementa semplici funzioni per manipolare stringhe con codifica UTF-8.
Lascia un commento