Paquete fmt en GoLang

Requisito previo: Paquetes en GoLang e Importación en GoLang 

Definiendo técnicamente, un paquete es esencialmente un contenedor de código fuente para algún propósito específico. Los paquetes son muy esenciales ya que en todos los programas se utilizan desde los programas más básicos hasta códigos complejos de alto nivel. Un paquete garantiza que no se repita ningún código y que el código principal sea lo más conciso posible de una manera bien estructurada. Go proporciona varios paquetes integrados a los usuarios para que puedan codificar fácilmente con paquetes de funcionalidad básica predefinidos. Uno de esos paquetes en el paquete » fmt «. fmt significa el paquete de formato. Este paquete permite formatear strings básicas, valores o cualquier cosa e imprimirlos o recopilar la entrada del usuario desde la consola, o escribir en un archivo usando un escritor o incluso imprimir mensajes de error personalizados. Este paquete tiene que ver con el formato de entrada y salida.

Independientemente del sistema que haya instalado Vaya, busque su $GOPATH y luego visite “$GOPATH/src/fmt/” en su sistema. Encontrará los siguientes archivos de paquete en este directorio en particular. Bueno, podemos decir que todos estos archivos pertenecen al paquete fmt.

La imagen muestra todos los archivos ubicados en el directorio “$GOPATH/src/fmt/” en su PC

Veamos las funciones que proporciona a sus usuarios junto con una breve descripción de cada función:

Además de las funciones, Go tiene algunas interfaces integradas en sus paquetes. El paquete “fmt” consta de las siguientes interfaces. La siguiente descripción proviene del sitio oficial de Go, puede hacer clic aquí para obtener más información.

Básicamente, en Go para implementar cualquier interfaz, acabamos de aprender que no tenemos que hacer nada explícitamente. En su lugar, llamar a métodos específicos implementa automáticamente las interfaces para el usuario. Y es a través de la implementación de los métodos en las interfaces que permiten que un valor particular tome múltiples formas. Esto se denomina simplemente como polimorfismo. Resumiendo todo esto, las interfaces en go se implementan implícitamente cuando se llaman a sus métodos y las interfaces contribuyen al concepto de polimorfismo.

Códigos de muestra para el paquete fmt:

1. Funciones de impresión

// Go code to visualise the differences
// between various print functions in fmt
  
package main
  
import "fmt"
  
func main() {
  
    // NOTE:
    // 1. Print(arg) prints arg as
    // it is on the console screen
    fmt.Print("Hello, welcome!")
    // OUTPUT: "Hello, welcome!"
      
    // Some variables to use in our code
    const x, id = "Ashika", 22
      
    // 2. Printf(arg) first formats arg
    // and then prints on the console screen
    fmt.Printf("\n1. Name %q and ID %d found!\n", x, id)
    // OUTPUT:
    // 1. Name "Ashika" and ID 22 found!
      
    // 3. Println(arg) does not format arg
    // It simply prints arg, appends any values
    // mentioned after arg and appends spaces in
    // between and also appends a new line at the end
    fmt.Println("2. Name %q and ID %d found!", x, id)
    // OUTPUT: 2. Name %q and ID %d found! Ashika 22
      
    // Print(arg) does not format, does not add
    // any spaces and does not append any newlines
    fmt.Print("3. Name %q and ID %d found!", x, id)
    // OUTPUT: 3. Name %q and ID %d found!Ashika22
      
    // 4. Sprint(arg) works similar to Print(arg)
    // The key difference is: Sprint returns arg as
    // it is as mentioned in the paranthesis and
    // Print(arg) prints on console screen.
    res := fmt.Sprint("\n4. Name %q and ID %d found!", x, id)
    fmt.Println(res)
    // OUTPUT:
    // 4. Name %q and ID %d found!Ashika22
      
    // 5. Sprintf(arg) works similar to Printf(arg)
    // The key difference is: Sprintf returns arg as
    // a formatted string as mentioned in the paranthesis
    // and Printf prints formatted arg on console screen
    res = fmt.Sprintf("5. Name %q and ID %d found!", x, id)
    fmt.Println(res)
    // OUTPUT: 5. Name "Ashika" and ID 22 found!
      
    // 6. Sprintln(arg) works similar to Println(arg)
    // The key difference is: Sprintln returns arg as
    // it is as mentioned in paranthesis and adds spaces
    // between variables and appends a newline to arg &
    // returns arg value while Println directly prints arg
    // onto the console screen.
    res = fmt.Sprintln("6. Name %q and ID %d found!", x, id)
    fmt.Print(res)
    // OUTPUT: 6. Name %q and ID %d found! Ashika 22
      
    fmt.Print("Goodbye!")
    // OUTPUT: "Goodbye!"
}

Producción:

Hello, welcome!
1. Name "Ashika" and ID 22 found!
2. Name %q and ID %d found! Ashika 22
3. Name %q and ID %d found!Ashika22
4. Name %q and ID %d found!Ashika22
5. Name "Ashika" and ID 22 found!
6. Name %q and ID %d found! Ashika 22
Goodbye!

2. Funciones de escaneo

// Go code to demonstrate use & differences
// between various scan functions in fmt package
  
package main
  
import "fmt"
  
// Main function
func main() {
  
    fmt.Print("Hello, welcome!\n")
    var y, z, age int
    var name string
      
    // Scan function will collect input
    // until a space is encountered
    // from console and stores it in y
    fmt.Scan(&y)
    fmt.Printf("Scan: Y = %d\n", y)
      
    // Scanf collects user input in
    // the specified format and stores it
    // in name and age respectively
    fmt.Scanf("%s", &name)
    fmt.Scanf("%d", &age)
    fmt.Printf("Scanf: Name = %s , Age = %d\n", name, age)
      
    // Scanln will not do nothing if
    // a newline is encountered else
    // it stores input value in z
    fmt.Scanln(&z)
    // In our case after entering age we press
    // enter so this Scanln gets skipped and
    // thus 0 is stored in z as 0 is the
    // default value of int variable in Go
    fmt.Printf("Scanln: Z = %d\n", z)
  
    var a string
    var g int
      
    // GFG is stored in a
    // 10 is stored in g
    // In case of any error, error message
    // is stored in err1
    // Number of values encountered is stored in res1
    res1, err1 := fmt.Sscan("GFG 10", &a, &g)
    // In case of any error, this block will execute
    if err1 != nil {
        panic(err1)
    }
    fmt.Printf("Sscan -> n = %d , string = %s %d \n", res1, a, g)
      
    // GFG is stored in a
    // 5 is stored in g
    // In case of any error, error message
    // is stored in err2
    // Number of values encountered is stored in res2
    res2, err2 := fmt.Sscanf("String is GFG with 5 iterations", 
                    "String is %s with %d iterations", &a, &g)
    // In case of any error, this block will execute
    if err2 != nil {
        panic(err2)
    }
    fmt.Printf("Sscanf -> n = %d , string = %s %d \n", res2, a, g)
      
    // GFG is stored in a
    // 17 is stored in g
    // In case a newline is encountered,
    // then Sscanln will raise a newline
    // panic error message
    // In case of any error, error message
    // is stored in err3
    // Number of values encountered is stored in res3
    res3, err3 := fmt.Sscanln("GFG 17", &a, &g)
    // In case of any error, this block will execute
    if err3 != nil {
        panic(err3)
    }
    fmt.Printf("Sscanln -> n = %d , string = %s %d \n", res3, a, g)
  
    fmt.Println("Goodbye!")
}

Aporte:

10
Ashika
20

Producción:

Hello, welcome!
Scan: Y = 10
Scanf: Name = Ashika , Age = 20
Scanln: Z = 0
Sscan -> n =2 , string = GFG 10
Sscanf -> n = 2 , string = GFG 5
Sscanln -> n = 2 , string = GFG 17
Goodbye!

3. Demostración de la función Errorf

// Go code to demonstrate
// the use of errorf function
// in fmt package
package main
  
import "fmt"
  
// Main function
func main() {
    const lazy = "I'm very lazy today"
      
    // Errorf formats according to the format specifier and
    // returns the string as a value that satisfies the error
    // and this error string are stored in err
    err := fmt.Errorf("Throwing error because: %q", lazy)
  
    // err.Error() will return the error message
    // and Println will print it on the output console
    fmt.Println(err.Error())
}

Producción:

Throwing error because: "I'm very lazy today"

Salidas visuales de códigos de muestra en el código de Visual Studio:

Salida del código de ejemplo de funciones de impresión

Nota: El valor scanln muestra 0 como salida. Es así porque scanln podría incluso recopilar la entrada del usuario, la nueva línea de la entrada anterior ha obligado a scanln a dejar de recopilar la entrada del usuario. Y el valor predeterminado en Go for int es 0, por lo tanto, el valor 0 para Z.

Salida del código de ejemplo de funciones de escaneo

Salida del código de muestra de la función errorf