strconv

Documentation officielle : strconv package - strconv - Go Packages

Le package strconv implémente la conversion entre les types de données de base et leur représentation sous forme de chaînes.

Import

import (
  "strconv"
)

Les exemples suivants démontreront comment l'utiliser.

Chaîne vers entier

func Atoi(s string) (int, error)

• s - la chaîne à convertir

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

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

Entier vers chaîne

func Itoa(i int) string

• i - le nombre entier à convertir

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

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

Chaîne vers booléen

func ParseBool(str string) (bool, error)

• s - la chaîne à convertir

Les chaînes convertibles sont les suivantes

"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

Booléen vers chaîne

func FormatBool(b bool) string

• b - la valeur booléenne

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

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

Conversion en chaîne Go

Les deux méthodes convertissent une chaîne en chaîne Go entre guillemets, la différence est que la seconde échappe les caractères non ASCII via \u.

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

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

Chaîne vers nombre à virgule flottante

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

• s - la chaîne à convertir
• bitSize - le nombre de 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

Nombre à virgule flottante vers chaîne

Lors de la conversion de nombres à virgule flottante en chaînes, Go propose plusieurs méthodes de formatage pour produire différents styles.

// 'b' (-ddddp±ddd, exposant binaire),
// 'e' (-d.dddde±dd, exposant décimal avec e minuscule),
// 'E' (-d.ddddE±dd, exposant décimal avec E majuscule),
// 'f' (-ddd.dddd, sans exposant), // généralement utilisé pour les besoins courants
// 'g' (format 'e' pour les grands exposants, format 'f' pour les petits exposants),
// 'G' (format 'E' pour les grands exposants, format 'f' pour les petits exposants),
// 'x' (-0xd.ddddp±ddd, fraction hexadécimale et exposant binaire),
// 'X' (-0Xd.ddddP±ddd, fraction hexadécimale et exposant binaire).

Fonction de conversion

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

• f - le nombre à virgule flottante à convertir
• fmt - le type de formatage
• prec - la précision, sauf pour g/G où elle représente le nombre maximum de chiffres significatifs, dans les autres cas elle représente le nombre de décimales à conserver
• bitSize - le nombre de bits

Généralement, on utilise le plus souvent f pour convertir directement le format décimal.

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

Chaîne vers nombre complexe

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

• s - la chaîne à convertir
• bitSize - le nombre de 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

Nombre complexe vers chaîne

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

c- nombre complexe

fmt - type de formatage, voir les types de formatage des nombres à virgule flottante

prec - voir la précision des nombres à virgule flottante

bitsize - nombre de 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

Ajout de données à une chaîne

Dans d'autres langages comme Java, le résultat de "1"+1 est "11", Java effectue automatiquement la conversion de type. En Go, cette opération n'est pas autorisée car les types de données sont différents. Il faut donc utiliser les fonctions Append de strconv. Les paramètres spécifiques sont les mêmes que pour les fonctions de conversion de données correspondantes mentionnées ci-dessus.

func TestAppend(t *testing.T) {
   bytes := []byte("ici quelques données:")
   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
ici quelques données:101.22false
--- PASS: TestAppend (0.00s)
PASS