strconv

Documentación oficial: strconv package - strconv - Go Packages

El paquete strconv implementa la conversión entre cadenas y representaciones de tipos de datos básicos.

Importar

import (
  "strconv"
)

A continuación se mostrará cómo usar con ejemplos.

Cadena a entero

func Atoi(s string) (int, error)

• s - La cadena a convertir

func TestAoti(t *testing.T) {
  ints, err := strconv.Atoi("456789")
  fmt.Println(ints, err)
}

=== RUN   TestAoti
456789 <nil>
--- PASS: TestAoti (0.00s)
PASS

Entero a cadena

func Itoa(i int) string

• i - El número entero a convertir

func TestIota(t *testing.T) {
   str := strconv.Itoa(114)
   fmt.Println(str)
}

=== RUN   TestIota
114
--- PASS: TestIota (0.00s)
PASS

Cadena a booleano

func ParseBool(str string) (bool, error)

• s - La cadena a convertir

Las cadenas que se pueden convertir son las siguientes

"1", "t", "T", "true", "TRUE", "True" // true
"0", "f", "F", "false", "FALSE", "False" // false

func TestAtob(t *testing.T) {
   parseBool, err := strconv.ParseBool("1")
   fmt.Println(parseBool, err)

   b, err := strconv.ParseBool("true")
   fmt.Println(b, err)

   b2, err := strconv.ParseBool("FALSE")
   fmt.Println(b2, err)
}

=== RUN   TestAotb
true <nil>
true <nil>
false <nil>
--- PASS: TestAotb (0.00s)
PASS

Booleano a cadena

func FormatBool(b bool) string

• b - Valor booleano

func TestBota(t *testing.T) {
   fmt.Println(strconv.FormatBool(true))
   fmt.Println(strconv.FormatBool(false))
}

=== RUN   TestBota
true
false
--- PASS: TestBota (0.00s)
PASS

Convertir a cadena de Go

Ambos convertirán la cadena a una cadena de Go entre comillas. La diferencia es que el último escapará los caracteres no ASCII a través de \u.

func TestQuote(t *testing.T) {
  fmt.Println(strconv.Quote("hello 世界"))
  fmt.Println(strconv.QuoteToASCII("hello 世界"))
}

=== RUN   TestQuote
"hello 世界"
"hello \u4e16\u754c"
--- PASS: TestQuote (0.00s)
PASS

Cadena a punto flotante

func ParseFloat(s string, bitSize int) (float64, error)

• s - La cadena a convertir
• bitSize - Bits

func TestParseFloat(t *testing.T) {
   float, err := strconv.ParseFloat("1.145114", 64)
   fmt.Println(float, err)

   float, err = strconv.ParseFloat("2.3333333333333333333", 64)
   fmt.Println(float, err)
}

=== RUN   TestFloat
1.145114 <nil>
2.3333333333333335 <nil>
--- PASS: TestFloat (0.00s)
PASS

Punto flotante a cadena

Al convertir punto flotante, la implementación oficial proporciona varios formatos para producir diferentes estilos.

// 'b' (-ddddp±ddd, exponente binario),
// 'e' (-d.dddde±dd, exponente decimal en e minúscula),
// 'E' (-d.ddddE±dd, exponente decimal en E mayúscula),
// 'f' (-ddd.dddd, sin exponente), // Sin requisitos especiales, generalmente se usa este
// 'g' (usa formato 'e' para exponentes grandes, formato 'f' para exponentes pequeños),
// 'G' (usa formato 'E' para exponentes grandes, formato 'f' para exponentes pequeños),
// 'x' (-0xd.ddddp±ddd, fracción hexadecimal y exponente binario),
// 'X' (-0Xd.ddddP±ddd, fracción hexadecimal y exponente binario).

Función de conversión

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

• f - El punto flotante a convertir
• fmt - Tipo de formato
• prec - Precisión, excepto en los casos g/G donde indica el número máximo de dígitos significativos, en otros casos indica los decimales a保留
• bitSize - Bits

Por supuesto, en general, se usa f para convertir directamente el formato decimal.

func TestFormatFloat(t *testing.T) {
   f := 1315643.14159261234567891011
   fmt.Println(strconv.FormatFloat(f, 'f', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'b', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'e', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'x', 6, 64))
   fmt.Println(strconv.FormatFloat(f, 'g', 6, 64))
   fmt.Println(strconv.FormatFloat(1.111, 'g', 6, 64))
}

=== RUN   TestFormatFloat
1315643.141593
5650644266346967p-32
1.315643e+06
0x1.4133b2p+20
1.31564e+06
1.111
--- PASS: TestFormatFloat (0.00s)
PASS

Cadena a número complejo

func ParseComplex(s string, bitSize int) (complex128, error)

• s - La cadena a convertir
• bitSize - Bits

func TestParseComplex(t *testing.T) {
   fmt.Println(strconv.ParseComplex("1+2i", 128))
   fmt.Println(strconv.ParseComplex("1+2j", 128))
}

=== RUN   TestParseComplex
(1+2i) <nil>
(0+0i) strconv.ParseComplex: parsing "1+2j": invalid syntax
--- PASS: TestParseComplex (0.00s)
PASS

Número complejo a cadena

func FormatComplex(c complex128, fmt byte, prec, bitSize int) string

c - Número complejo

fmt - Tipo de formato, consulte el tipo de formato de punto flotante

prec - Consulte la precisión de punto flotante

bitsize - Bits

func TestFormatComplex(t *testing.T) {
   fmt.Println(strconv.FormatComplex(complex(1.1, 12), 'f', 2, 128))
   fmt.Println(strconv.FormatComplex(complex(5.6, 2.8), 'b', 2, 128))
   fmt.Println(strconv.FormatComplex(complex(18.88999, 89.7), 'g', 2, 128))
}

=== RUN   TestFormatComplex
(1.10+12.00i)
(6305039478318694p-50+6305039478318694p-51i)
(19+90i)
--- PASS: TestFormatComplex (0.00s)
PASS

Agregar datos a cadena

En otros lenguajes como Java, el resultado de "1"+1 es "11". Java completará automáticamente la conversión de tipo, mientras que en Go tal operación no está permitida porque los tipos de datos son diferentes. Por lo tanto, es necesario usar la función Append de strconv. Los parámetros específicos son consistentes con las funciones de conversión de datos anteriores.

func TestAppend(t *testing.T) {
   bytes := []byte("Aquí hay algunos datos:")
   bytes = strconv.AppendInt(bytes, 10, 10)
   bytes = strconv.AppendFloat(bytes, 1.2222, 'f', 2, 64)
   bytes = strconv.AppendBool(bytes, false)
   fmt.Println(string(bytes))
}

=== RUN   TestAppend
Aquí hay algunos datos:101.22false
--- PASS: TestAppend (0.00s)
PASS