Conversion de types en langage Go

La conversion de type est utilisée pour convertir une variable d'un type de données en une variable d'un autre type.

Le format de base de la conversion de type en Go est le suivant :

type_name(expression)

type_name est le type, et expression est l'expression.

Conversion de types numériques

Convertir un entier en nombre à virgule flottante :

var a int = 10
var b float64 = float64(a)

Dans l'exemple suivant, convertissez un entier en un type à virgule flottante, calculez le résultat et affectez le résultat à une variable à virgule flottante :

Exemple

package main

import "fmt"

func main() {
var sum int = 17
var count int = 5
var mean float32

mean = float32(sum)/float32(count)
fmt.Printf("La valeur de mean est : %f\n"\n",mean)
}

La sortie de l'exemple ci-dessus est :

mean 的值为: 3.400000

Conversion de type chaîne

Pour convertir une chaîne en un autre type, vous pouvez utiliser la syntaxe suivante :

var str string = "10"
var num int
num, _ = strconv.Atoi(str)

Le code ci-dessus convertit la variable de chaîne str en une variable entière num.

Remarque,strconv.AtoiLa fonction renvoie deux valeurs : la première est la valeur entière convertie, et la seconde est une erreur éventuelle. Nous pouvons utiliser l'identifiant vide._pour ignorer cette erreur

。

L'exemple suivant convertit une chaîne en un entier

Exemple

package main

import (
"fmt"
"strconv"
)

func main() {
str := "123"
num, err := strconv.Atoi(str)
if err != nil {
fmt.Println("Erreur de conversion :", err)
} else {
fmt.Printf("La chaîne '%s' convertie en entier est : %d\n"\n", str, num)
}
}

La sortie de l'exemple ci-dessus est :

字符串 '123' 转换为整数为：123

L'exemple suivant convertit un entier en chaîne :

Exemple

package main

import (
"fmt"
"strconv"
)

func main() {
num := 123
str := strconv.Itoa(num)
fmt.Printf("L'entier %d converti en chaîne est : '%s'"\n", num, str)
}

La sortie de l'exemple ci-dessus est :

整数 123  转换为字符串为：'123'

L'exemple suivant convertit une chaîne en nombre à virgule flottante :

Exemple

package main

import (
"fmt"
"strconv"
)

func main() {
str := "3.14"
num, err := strconv.ParseFloat(str, 64)
if err != nil {
fmt.Println("Erreur de conversion :", err)
} else {
fmt.Printf("La chaîne '%s' convertie en flottant est : %f"\n", str, num)
}
}

La sortie de l'exemple ci-dessus est :

字符串 '3.14' 转为浮点型为：3.140000

L'exemple suivant convertit un nombre à virgule flottante en chaîne :

Exemple

package main

import (
"fmt"
"strconv"
)

func main() {
num := 3.14
str := strconv.FormatFloat(num, 'f', 2, 64)
fmt.Printf(Le flottant %f converti en chaîne est : '%s'\n", num, str)
}

La sortie de l'exemple ci-dessus est :

浮点数 3.140000 转为字符串为：'3.14'

Conversion de type d'interface

Il y a deux cas de conversion de type d'interfaceAssertion de typeetConversion de type。

Assertion de type

L'assertion de type est utilisée pour convertir un type d'interface en un type spécifié. Sa syntaxe est :

value.(type) 
或者 
value.(T)

Ici, value est une variable de type interface, et type ou T est le type cible vers lequel convertir.

Si l'assertion de type réussit, elle renvoie la valeur convertie et une valeur booléenne indiquant si la conversion a réussi.

Exemple

package main

import "fmt"

func main() {
var i interface{} = "Hello, World"
str, ok := i.(string)
if ok {
fmt.Printf("'%s' is a string\n", str)
} else {
fmt.Println("conversion failed")
}
}

Dans l'exemple ci-dessus, nous définissons une variable de type interface i et lui affectons la chaîne "Hello, World". Ensuite, nous utilisons une assertion de type pour convertir i en type string et affectons la valeur convertie à la variable str. Enfin, nous utilisons la variable ok pour vérifier si la conversion de type a réussi. Si elle a réussi, nous affichons la chaîne convertie ; sinon, nous affichons un message indiquant que la conversion a échoué.

Conversion de type

La conversion de type est utilisée pour convertir une valeur d'un type d'interface en un autre type d'interface. Sa syntaxe est :

T(value)

T est le type d'interface cible, et value est la valeur à convertir.

Lors d'une conversion de type, nous devons veiller à ce que la valeur à convertir soit compatible avec le type d'interface cible ; sinon, le compilateur signalera une erreur.

Exemple

package main

import "fmt"

// Définir une interface Writer
type Writer interface {
Write([]byte) (int, error)
}

// La structure StringWriter implémente l'interface Writer
type StringWriter struct {
str string
}

// Implémenter la méthode Write
func (sw *StringWriter) Write(data []byte) (int, error) {
sw.str += string(data)
return len(data), nil
}

func main() {
// Créer une instance de StringWriter et l'affecter à une variable d'interface Writer
var w Writer = &StringWriter{}

// Convertir le type d'interface Writer en type StringWriter
sw := w.(*StringWriter)

// Modifier le champ de StringWriter
sw.str = "Hello, World"

// Afficher la valeur du champ de StringWriter
fmt.Println(sw.str)
}

Analyse :

Définir une interface et une structure：
- WriterL'interface définitWriteméthode.
- StringWriterLa structure implémenteWriteméthode.
Conversion de type：
- vaStringWriterassigner l'instance àWritervariable d'interfacew。
- Utilisationw.(*StringWriter)vaWriterType d'interface converti enStringWritertype.
Accès aux champs：
- modifierStringWriterle champstr, et afficher sa valeur.

type d'interface vide

Interface videinterface{}Elle peut contenir des valeurs de n'importe quel type. Dans les applications pratiques, l'interface vide est souvent utilisée pour gérer des valeurs de plusieurs types.

Exemple

package main

import (
"fmt"
)

func printValue(v interface{}) {
switch v := v.(type) {
case int:
fmt.Println("Entier :", v)
case string:
fmt.Println("Chaîne :", v)
default:
fmt.Println("Unknown type")
}
}

func main() {
printValue(42)
printValue("hello")
printValue(3.14)
}

Dans cet exemple, la fonction printValue accepte un paramètre de type d'interface vide et utilise l'assertion de type et le type switch pour gérer différents types.

autres extensions