I lettori come te aiutano a sostenere MUO. Quando effettui un acquisto utilizzando i link sul nostro sito, potremmo guadagnare una commissione di affiliazione. Per saperne di più.

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 gestire.

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 formato package implementa la formattazione standard per il file Vai al codice sorgente. Il pacchetto interagisce con il vai al formato strumento da riga di comando per la flessibilità nella formattazione del codice Go.

Il formato pacchetto è un sottomodulo nel pacchetto go. Ecco come puoi importarlo:

instagram viewer 
importare"vai/formatta"

È possibile sfogliare la documentazione del comando go fmt specificando il file aiuto comando prima del fmt comando:

vai aiuto 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.

vai su 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 -X flag al comando fmt. Il flag -x aiuta a scrivere le modifiche dal formattatore al file originale.

vai fmt -x main.go

IL -N flag funziona in modo simile a -x, ma non apporta modifiche. Invece, mostra i comandi che vanno fmt verrebbero eseguiti senza -n:

vai 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!".

// formatta un file chiamato main.go come mostrato nell'esempio precedente 
pacchetto principale
importare"fmt"
funzprincipale() {
var X int=5
per io:=0;io fmt. Stampaln("Ciao mondo!")
 }
}

Formattazione del codice sorgente Go

Il pacchetto di formato contiene un file Fonte funzione per la formattazione dei file Vai 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 l'estensione LeggiFile funzione del ioutil pacchetto. La funzione ReadFile accetta il nome del file e restituisce il contenuto del file e un errore per la gestione.

fileContent, err := ioutil. LeggiFile("principale.go")
Se errare!= zero {
 tronco d'albero. fatale("Si è verificato un errore durante la lettura del file", ehm)
}

Il passaggio del contenuto del file alla funzione Source restituisce il contenuto del file formattato e un errore per la gestione.

formattato, err := formato. Sorgente (contenuto file)
Se errare!= zero {
 tronco d'albero. fatale("Si è verificato un errore di formattazione con la funzione di origine", ehm)
}

È possibile scrivere il contenuto del file formattato nel file con estensione ScriviFile funzione del ioutil pacchetto. La funzione WriteFile accetta il nome del file, i contenuti e modalità di autorizzazione file, restituendo eventuali errori. La modalità di autorizzazione è rilevante solo se il file non esiste, nel qual caso WriteFile lo creerà.

IL 0644 la modalità di autorizzazione file 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. ScriviFile("principale.go", formattato, 0644)
Se errare!= zero {
 tronco d'albero. fatale("Si è verificato un errore durante la scrittura del file", ehm)
}

In alternativa, puoi passare il codice sorgente di Go alla funzione Source per la formattazione. Puoi specificare il codice in una porzione di byte utilizzando i segni di spunta (`):

pacchetto principale
importare (
"fmt"
"vai/formatta"
)


funzprincipale() {
// semplice programma che calcola l'area di un triangolo con la matematica
// funzione 
 formattato, err := formato. Fonte([]byte(`
pacchetto principale
importare(
"fmt"
"matematica"
)
funzprincipale(){
var UN galleggiante64=3
var B galleggiante64=4
var C galleggiante64=5
var S galleggiante64=(a+b+c)/2
var la zona galleggiante64= matematica. Sqrt (s*(s-a)*(s-b)*(s-c))
fmt. Stampaln("L'area del triangolo è: ",la zona)
}
`))
Se errare!= zero {
 tronco d'albero. fatale("Si è verificato un errore di formattazione con la funzione di origine", ehm)
 } altro {
 fmt. Stampaln(corda(formattato))
 }
}

Durante la formattazione, dovrai convertire la porzione di byte in stringa con l'estensione corda funzione. Ecco il codice sorgente formattato.

Personalizzazione del processo di formattazione

Puoi personalizzare il processo di formattazione con i pacchetti di formato Configurazione struct. La struttura Config contiene campi in cui è possibile specificare le opzioni di formato durante la creazione di un'istanza.

importare"vai/formatta"
config := &format. Configurazione{
// Tabwidth imposta il numero di spazi per tabulazione.
 Larghezza scheda: 8,


// UseTabs indica se il formattatore deve utilizzare le schede invece di
// spazi.
 Usa schede: falso,


// TabIndent viene utilizzato per determinare se deve essere il rientro iniziale
// fatto usando tabulazioni o spazi.
 Rientro tabulazione: VERO,


// NoFinalTab specifica se rimuovere una scheda finale da
// righe prima che vengano formattate.
 Nessuna scheda finale: VERO,


// Spaces specifica se gli spazi devono essere utilizzati per l'allineamento.
 Spazi: VERO,
// NoTrimTrailingSpace specifica se lo spazio vuoto finale dovrebbe
// essere ritagliato dalle righe prima che vengano formattate.
 NoTrimTrailingSpace: falso,
}

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.

funzprincipale() {
 fileContent, err := ioutil. LeggiFile("principale.go")
// nota che questo è un metodo Source del tipo `config`, non dal
// `format` pacchetto stesso sebbene la funzionalità sia la stessa, lo farai
// è necessario aderire a questo se è necessario configurare il formattatore 
 formattato, err := config. Sorgente (contenuto file)


Se errare!= zero {
 tronco d'albero. fatale("Si è verificato un errore di formattazione con il tipo di configurazione", ehm)
 }
 ioutil. ScriviFile("principale.go", formattato, 0644)
}

Chiamando il file config. La funzione Source() in questo modo formatta il contenuto del file main.go file 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.