El formateo del código fuente agrega una característica importante a la calidad y legibilidad del código. En Golang, tenemos paquetes y comandos integrados para formatear automáticamente el código en el archivo fuente según los estándares y las mejores prácticas. Podemos usar el comando gofmt en la CLI para formatear automáticamente un archivo fuente de Golang. Podemos formatear automáticamente el código go con el paquete gofmt en Golang. Usando el comando gofmt desde la terminal o desde la línea de comandos, podemos formatear el archivo fuente go.
Uso de ir a fmt
Podemos usar el comando go fmt en el paquete gofmt en Golang para formatear automáticamente el archivo fuente go. go fmt es una utilidad de línea de comandos en Golang que nos permite formatear los archivos fuente de go según la semántica y la convención estándar.
Go
package main
import (
"fmt"
)
func main() {
var word string
fmt.Printf( "Enter any string: ")
fmt.Scan( &word)
num :=6
fmt.Println("The number is : ", num )
}
Aquí, teníamos un archivo, un archivo fuente de go con una sintaxis inconsistente y sin un estilo adecuado, al usar la utilidad go fmt desde la línea de comando, podemos obtener un código de go formateado y bien estructurado en el archivo proporcionado. El archivo de origen tenía algunos usos inconsistentes de los espacios en el operador de asignación y dentro del paréntesis, es decir , («») o («») . Una vez que se ha ejecutado el comando, se ha corregido el formato incorrecto e inconsistente y el código se ve un poco más limpio.
go fmt filename.go
Go
package main
import (
"fmt"
)
func main() {
var word string
fmt.Printf("Enter any string: ")
fmt.Scan(&word)
num := 6
fmt.Println("The number is : ", num)
}
Aquí, podemos ver que el comando go fmt se usa al analizar un parámetro como el archivo fuente go que necesitamos formatear correctamente. El comando go fmt arreglará las sangrías, la semántica de los operadores o cualquier otra inconsistencia sintáctica en el archivo automáticamente.
Esto parece algo pequeño desde el punto de vista del ejemplo, pero considere un proyecto grande con múltiples paquetes, módulos y archivos fuente, esto podría hacer que su proyecto sea mucho más legible y consistente.
Almacenar código formateado en archivo nuevo
Podemos almacenar el código formateado en un nuevo archivo usando el operador >. Este operador nos permite definir un archivo de refactorización y el archivo fuente original a formatear.
gofmt original_file.go > output_file.go
Como podemos ver, el código formateado se guarda en un archivo diferente al archivo fuente original. Esto ayuda a garantizar que el código permanezca seguro después de formatearlo al verificarlo con go vet filename.go. El comando go vet se utiliza para comprobar si hay errores de precompilación en el archivo fuente, lo que proporciona errores sintácticos o comprobaciones.
Generando un Diff desde el comando fmt
Incluso podemos generar la diferencia para el código formateado en un archivo diferente usando el parámetro -d en el comando fmt,
gofmt -d original_file.go
$ gofmt -d main.go
diff -u main.go.orig main.go
--- main.go.orig 2022-04-12 21:53:35.987557100 +0530
+++ main.go 2022-04-12 21:53:35.988557200 +0530
@@ -1,13 +1,13 @@
-package main
-
-import (
- "fmt"
-)
-
-func main() {
- var word string
- fmt.Printf("Enter any string: ")
- fmt.Scan(&word)
- num := 6
- fmt.Println("The number is : ", num)
-}
+package main
+
+import (
+ "fmt"
+)
+
+func main() {
+ var word string
+ fmt.Printf("Enter any string: ")
+ fmt.Scan(&word)
+ num := 6
+ fmt.Println("The number is : ", num)
+}
Esto generará la salida como una diferencia en la terminal. No cambiará el formato en el archivo fuente. Un archivo diff es básicamente un formato para almacenar los cambios en el archivo de origen con una marca de tiempo y metadatos de archivo. Para guardar los cambios de la diferencia en el archivo de origen en otro archivo de diferencia, podemos almacenarlo usando el operador >.
gofmt -d original_file.go > diff.go
Ahora, usamos la opción -d en el comando gofmt para crear un archivo diff.go que contiene todas las diferencias del código formateado en el archivo fuente. Entonces, aquí los cambios en el formato del código se almacenan en un archivo separado como se menciona en el comando después del operador >. Este comando agrega la salida del comando en el archivo mencionado, en este caso es diff.go o puede ser cualquier otro archivo que desee. Por lo tanto, podemos generar la diferencia de los cambios de código de formato en un archivo separado.