Discutez de diverses situations de conversion d'octets dans Golang

Golang est un langage de programmation permettant de développer des performances, une concurrence et une maintenabilité élevées. En Golang, le problème de la conversion des octets est aussi un problème souvent rencontré, car en Golang, contrairement à d'autres langages, l'octet est bien un type de données indépendant. Par conséquent, dans le codage réel, nous devons maîtriser les méthodes de conversion mutuelle entre les octets et d’autres types de données couramment utilisés afin de mieux traiter les données.

Cet article discutera de diverses situations de conversion d'octets dans Golang, des fonctions impliquées et de leur utilisation, et de la manière dont nous devons utiliser correctement ces fonctions dans le développement réel.

1. Conversion mutuelle entre octet et chaîne

Dans Golang, l'octet et la chaîne sont les deux types les plus couramment utilisés. L'octet étant la plus petite unité de données, il est très couramment utilisé dans Golang et la chaîne est un type essentiel pour les modules de traitement de texte. Par conséquent, dans le développement réel, nous devons souvent effectuer une conversion entre octet et chaîne.

Pour convertir le type octet en type chaîne, vous pouvez utiliser la fonction string(). Par exemple :

b := []byte{'g', 'o', 'l', 'a', 'n', 'g'}
s := string(b)
fmt.Println(s) //输出"golang"

Le type chaîne peut être converti en type octet à l'aide de la fonction []byte(). Par exemple :

s := "golang"
b := []byte(s)
fmt.Println(b) //输出[103 111 108 97 110 103]

2. Conversion entre les types byte, int et uint

Dans Golang, la conversion entre les types byte, int et uint est également souvent utilisée. Dans le développement réel, il est souvent nécessaire de transmettre des données via un octet et de convertir l'octet en type int ou uint à la réception.

Pour convertir le type byte en type int, vous pouvez utiliser la fonction int(). Après avoir converti l'octet en int, nous pouvons obtenir la valeur du code ASCII du nombre représenté par l'octet. Par exemple : le type

b := byte('a')
i := int(b)
fmt.Println(i) //输出97

byte peut être converti en type uint à l'aide de la fonction uint(). Par exemple : le type

b := byte(255)
u := uint(b)
fmt.Println(u) //输出255

Int peut être converti en type octet à l'aide de la fonction byte(). Par exemple : le type

i := 97
b := byte(i)
fmt.Println(b) //输出97

uint peut être converti en type octet à l'aide de la fonction byte(). Par exemple :

u := uint(255)
b := byte(u)
fmt.Println(b) //输出255

Il est à noter que lorsque l'entier de type int est supérieur à 255, la conversion en type octet entraînera une perte de précision, et seuls les huit chiffres inférieurs seront conservés. De même, lorsque l’entier de type uint est supérieur à 255, les nombres d’ordre élevé seront ignorés.

3. Conversion mutuelle entre les types octet et booléen

Dans Golang, le type booléen n'a que deux valeurs : vrai et faux. Cependant, dans certains cas, nous devons convertir la valeur du type booléen en type octet. À ce stade, vrai peut être converti en 1 et faux peut être converti en 0.

Pour convertir le type booléen en type octet, vous pouvez utiliser la fonction byte(). Par exemple :

b := true
var v byte
if b {
    v = 1
} else {
    v = 0
}
fmt.Println(v) //输出1

La conversion du type octet en type bool est déterminée par la situation réelle spécifique. Nous devons souvent déterminer si l'octet est 0 ou 1, puis le convertir en type bool via l'instruction if. Par exemple :

b := byte(1)
var v bool
if b == 1 {
    v = true
} else {
    v = false
}
fmt.Println(v) //输出true

4, conversion entre les types byte et float32 et float64

Dans Golang, la conversion entre les types byte et float32 et float64 est également très courante. Nous devons généralement transmettre des données via un octet et le récepteur doit convertir l'octet en type float32 ou float64.

Pour convertir le type d'octet en type float32, vous pouvez utiliser la fonction math.Float32frombits(). Par exemple :

b := []byte{222, 162, 163, 66}
f := math.Float32frombits(binary.LittleEndian.Uint32(b))
fmt.Println(f) //输出3.14

Pour convertir le type octet en type float64, vous pouvez utiliser la fonction math.Float64frombits(). Par exemple :

b := []byte{35, 224, 71, 66, 235, 81, 184, 64}
f := math.Float64frombits(binary.LittleEndian.Uint64(b))
fmt.Println(f) //输出3.141592653589793

Il convient de noter que lors de l'utilisation des fonctions math.Float32frombits() et math.Float64frombits() pour convertir le type d'octet en types float32 et float64, binaire.LittleEndian.Uint32() et binaire.LittleEndian.Uint64 doit être utilisé () pour convertir l'ordre des octets du tableau d'octets, sinon des erreurs de précision peuvent survenir.

Pour convertir le type float32 en type octet, vous pouvez utiliser la fonction math.Float32bits(). Par exemple :

f := float32(3.14)
b := make([]byte, 4)
binary.LittleEndian.PutUint32(b, math.Float32bits(f))
fmt.Println(b) //输出[222 162 163 66]

Pour convertir le type float64 en type octet, vous pouvez utiliser la fonction math.Float64bits(). Par exemple :

f := float64(3.141592653589793)
b := make([]byte, 8)
binary.LittleEndian.PutUint64(b, math.Float64bits(f))
fmt.Println(b) //输出[35 224 71 66 235 81 184 64]

Lorsque vous utilisez les fonctions math.Float32bits() et math.Float64bits() pour convertir les types float32 et float64 en types octets, vous devez appeler les fonctions binaire.LittleEndian.PutUint32() et binaire.LittleEndian.PutUint64() pour s'assurer que l'ordre des octets du tableau d'octets est correct.

Résumé

Dans Golang, le type octet est très largement utilisé. Nous devons maîtriser les méthodes de conversion entre octet et d'autres types courants afin de mieux traiter les données. Cet article présente en détail les méthodes de conversion mutuelle et les fonctions correspondantes entre byte et string, int, uint, bool, float32 et float64. J'espère qu'il sera utile à tout le monde.

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!