Un guide complet sur la conversion de type et les conversions dans Go

Go, également connu sous le nom de Golang, est un langage typé statiquement. Cela signifie que le type de chaque variable est connu au moment de la compilation, ce qui assure la sécurité et la prévisibilité de votre code. Toutefois, cela nécessite également que toute conversion d’un type à un autre soit explicite et délibérée. Dans cet article, nous explorerons les différents mécanismes de conversion de type et de conversion disponibles dans Go, des conversions numériques de base aux conversions d'interface et de pointeur plus complexes.

1. Conversions de types de base

Go permet la conversion entre les types de base comme les entiers, les nombres à virgule flottante et les chaînes, mais ces conversions doivent être effectuées explicitement.

Types numériques

Les conversions entre différents types numériques sont simples mais doivent être explicites :

var i int = 42
var f float64 = float64(i)  // int to float64
var u uint = uint(i)        // int to uint

Dans cet exemple, nous convertissons un int en float64 et en un uint. Ces conversions sont explicites car Go n'effectue pas de conversions de type automatiques (implicites).

Tranche de chaîne et d'octet

Les chaînes Go sont immuables, mais elles peuvent être converties vers et depuis des tranches d'octets ([]byte), qui sont mutables :

var s string = "hello"
var b []byte = []byte(s)   // string to []byte
var s2 string = string(b)  // []byte to string

De même, vous pouvez convertir entre des chaînes et des tranches de rune ([]rune), où rune est un alias de type pour int32 :

var r []rune = []rune(s)   // string to []rune
var s3 string = string(r)  // []rune to string

2. Conversions de types personnalisés

Dans Go, vous pouvez définir vos propres types en fonction de ceux existants. Les conversions entre les types personnalisés et leurs types sous-jacents sont explicites :

type MyInt int
var i int = 10
var mi MyInt = MyInt(i)   // int to MyInt
var i2 int = int(mi)      // MyInt to int

Cette conversion explicite est nécessaire pour garantir que le compilateur puisse vérifier la sécurité de votre code.

3. Conversions de pointeurs

Les pointeurs en Go font référence à l'adresse mémoire d'une variable. Vous pouvez convertir entre une valeur et son pointeur :

var x int = 42
var p *int = &x     // int to *int (pointer to int)
var y int = *p      // *int to int (dereferencing)

4. Conversions de types d'interface

Les interfaces dans Go sont utilisées pour définir un ensemble de méthodes. Vous pouvez convertir entre les types concrets et les interfaces :

var a interface{} = 42    // int to interface{}
var b int = a.(int)       // interface{} to int (type assertion)

Assertions de type

Une assertion de type donne accès à la valeur concrète d'une interface :

if v, ok := a.(int); ok {
    fmt.Println("a is an int:", v)
}

Type de commutateur

Un commutateur de type vous permet d'effectuer différentes actions en fonction du type dynamique d'une interface :

switch v := a.(type) {
case int:
    fmt.Println("a is an int:", v)
case string:
    fmt.Println("a is a string:", v)
default:
    fmt.Println("a is of unknown type")
}

5. Conversions dangereuses

Le package unsafe vous permet de contourner la sécurité de type Go, permettant ainsi des conversions qui seraient autrement illégales :

import "unsafe"

var i int = 42
var p *int = &i
var fp *float64 = (*float64)(unsafe.Pointer(p))  // *int to *float64

Avertissement : les conversions non sécurisées doivent être utilisées avec parcimonie et uniquement lorsque cela est absolument nécessaire, car elles peuvent conduire à un comportement indéfini.

6. Conversions de types de canaux

Les canaux sont une fonctionnalité puissante de Go, permettant la communication entre les goroutines. Vous pouvez convertir entre les canaux bidirectionnels et unidirectionnels :

ch := make(chan int)
var sendOnlyChan chan<- int = ch  // bidirectional to send-only
var recvOnlyChan <-chan int = ch  // bidirectional to receive-only

7. Conversions de structures et de tableaux

Les conversions entre structures ou tableaux avec des dispositions identiques nécessitent un casting explicite :

type Point struct {
    X, Y int
}

type Coord struct {
    X, Y int
}

var p Point = Point{1, 2}
var c Coord = Coord(p)  // Convert Point to Coord (same field types)

8. Conversions de tranches

Les tranches sont des références à des tableaux, et bien que vous puissiez convertir entre des tranches du même type, la conversion entre différents types de tranches nécessite une conversion explicite :

var a []int = []int{1, 2, 3}
var b []int = a[1:]  // Convert a slice to another slice of the same type

9. Conversions d'interface nulles

Une valeur nulle dans Go peut être attribuée à n'importe quel type d'interface :

var x interface{} = nil
var y error = nil

10. Conversions de types de fonctions

Les fonctions Go peuvent être converties en différents types, à condition que les signatures soient compatibles :

type FuncType func(int) int

func square(x int) int {
    return x * x
}

var f FuncType = FuncType(square)  // Convert function to FuncType

11. Conversion tableau en tranche

Vous pouvez créer une tranche à partir d'un tableau, qui est essentiellement une référence au tableau :

var arr [5]int = [5]int{1, 2, 3, 4, 5}
var sl []int = arr[:]  // Convert array to slice

Conclusion

Le transtypage et les conversions dans Go sont explicites de par leur conception, ce qui rend le code plus sûr et plus facile à comprendre. En exigeant des conversions explicites, Go aide à prévenir les bogues subtils pouvant résulter d'une coercition de type implicite, courante dans certains autres langages de programmation. Comprendre ces conversions et les utiliser correctement est crucial pour écrire des programmes Go robustes et efficaces.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!