conversion de type golang ok

Le langage

Go (Golang) est un langage de programmation open source influencé par des langages tels que C, Java et Python. Il a été développé par Google pour créer des logiciels efficaces et fiables. Un programme est étroitement lié au langage dans lequel il est écrit. Tout comme le langage qui exprime les émotions et les pensées, les langages de programmation ont également leurs propres caractéristiques. La conversion de type est un concept très important dans le langage Go, car la conversion de type est appliquée dans de nombreuses situations. Cet article présentera les connaissances pertinentes sur la conversion de type Golang.

1. Présentation de la conversion de type

La conversion de type est le processus de conversion d'une valeur d'un type de données en une valeur d'un autre type de données. Dans le langage Go, les types de données sont divisés en types de données de base et types composites. Les types de données de base incluent int, float, string, bool et d’autres types. Les types composites incluent des tableaux, des tranches, des dictionnaires, des structures, des interfaces et des fonctions. Dans le langage Go, les valeurs entre différents types ne peuvent pas être directement exploitées et comparées. Par conséquent, il est nécessaire de convertir les valeurs entre différents types. Golang prend en charge la conversion d'entiers signés, d'entiers non signés, de nombres à virgule flottante, de booléens, de chaînes et d'autres types. La syntaxe de conversion de type est : T(x), où T représente le type à convertir et x représente la valeur à convertir.

2. Conversion de type de données de base

1. Conversion de type entier

Dans le langage Go, les types entiers incluent les entiers signés et les entiers non signés. les types entiers prenant en charge la conversion sont int8, int16, int32, int64, uint8, uint16, uint32 et uint64. Parmi eux, int8 et uint8 sont appelés types d'octets, int16 et uint16 sont appelés types entiers courts, int32 et uint32 sont appelés types entiers longs et int64 et uint64 sont appelés types entiers longs.

Vous devez faire attention aux deux points suivants lors de la conversion de types entiers :

• Si la plage de valeurs dépasse la plage de la valeur de type à convertir lors de la conversion, il débordera, ce qui rendra le résultat inexact. Par exemple, la conversion d'une valeur supérieure à la plage int8 en type int8 entraînera des valeurs inexactes dans la plage [-128, 127]. Les problèmes de débordement avec les types entiers doivent être évités.
• Seules les conversions du même type ou de types de faible précision vers des types de haute précision sont sûres. Par exemple, la conversion de int8 en int16 est sûre, mais la conversion de int16 en int8 n'est pas sûre car certaines données peuvent être interceptées lors de la conversion en int8, ce qui entraîne des résultats inexacts.

Voici quelques exemples de conversion de type entier :

package main

import "fmt"

func main() {
    var a int32 = 100
    var b int64 = int64(a)   // int32转换成int64
    var c int8 = int8(a)     // int32转换成int8，可能溢出
    var d uint16 = uint16(a) // int32转换成uint16
    fmt.Println(b, c, d)
}

Le résultat de sortie est :

100 100 100

2. conversion# 🎜🎜#

Dans le langage Go, les types de nombres à virgule flottante incluent float32 et float64, et les seuls types de nombres à virgule flottante qui prennent en charge la conversion sont float32 et float64. Il y a deux points à noter lors de la conversion de types à virgule flottante :

Si la plage de valeurs est trop grande ou trop petite lors de la conversion, un débordement peut se produire.
• Peut uniquement être converti d'un type de basse précision à un type de haute précision. La conversion d'un type de haute précision à un type de basse précision peut entraîner une perte de précision.

Ce qui suit est un exemple de conversion de type à virgule flottante :

package main

import "fmt"

func main() {
    var a float32 = 3.1415926
    var b float64 = float64(a) // float32转换成float64
    fmt.Println(b)
}

Le résultat de sortie est :

3.1415927410125732

3. conversion# 🎜🎜#

Dans le langage Go, le type booléen n'a que deux valeurs : vrai et faux, et les seuls types qui prennent en charge la conversion sont les types int et string. Lors de la conversion d'une valeur booléenne en int, true est converti en 1 et false est converti en 0. Lors de la conversion d'une valeur booléenne en chaîne, true est converti en « true » et false est converti en « false ».

Ce qui suit est un exemple de conversion de type booléen :

package main

import "fmt"

func main() {
    var a bool = true
    var b int = int(a)     // true转换成int，值为1
    var c string = string(a) // true转换成字符串，值为"true"
    fmt.Println(b, c)
}

Le résultat de sortie est :

1 true

4. # 🎜🎜#Dans le langage Go, une chaîne est un tableau (immuable) composé de séquences de caractères, et les seuls types prenant en charge la conversion sont les types primitifs. La conversion de chaînes peut être réalisée via le package strconv. Lors de la conversion d'entiers en chaînes, vous pouvez utiliser la fonction strconv.Itoa(), et lors de la conversion de nombres à virgule flottante en chaînes, vous pouvez utiliser la fonction strconv.FormatFloat().

Ce qui suit est un exemple de conversion de type de chaîne :

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var a int = 100
    var b string = strconv.Itoa(a) // 将整数转换成字符串
    var c float64 = 3.1415926
    var d string = strconv.FormatFloat(c, 'f', 6, 64) // 将浮点数转换成字符串，保留6位小数
    fmt.Println(b, d)
}

Le résultat de sortie est :

100 3.141593

3. # 🎜🎜#1. Conversion de type de tableau

En langage Go, un tableau est une séquence de longueur fixe composée d'éléments du même type. Les valeurs peuvent être attribuées directement entre les tableaux, mais il convient de noter que la taille et le type des tableaux doivent être les mêmes, sinon une erreur de compilation se produira.

Ce qui suit est un exemple de conversion de type de tableau :

package main

import "fmt"

func main() {
    var a [3]int = [3]int{1, 2, 3}
    var b [3]int = a // 数组之间可以直接赋值
    fmt.Println(b)
}

Le résultat de sortie est :

[1 2 3]

2. #🎜 🎜#Dans le langage Go, une tranche est une structure qui contient un pointeur vers un tableau. La longueur et la capacité de la tranche sont une séquence de longueur variable. Les valeurs peuvent être attribuées directement entre les tranches, mais il convient de noter que les types d'éléments des tranches doivent être les mêmes.

Ce qui suit est un exemple de conversion de type de tranche :

package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a // 切片之间可以直接赋值
    fmt.Println(b)
}

Le résultat de sortie est :

[1 2 3 4]

3. #🎜 🎜#En langage Go, un dictionnaire est un ensemble de paires clé-valeur. Les valeurs peuvent être attribuées directement entre les dictionnaires, mais il convient de noter que les types de clé et de valeur des dictionnaires doivent être les mêmes.

Ce qui suit est un exemple de conversion de type de dictionnaire :

package main

import "fmt"

func main() {
    a := map[string]int{"apple": 1, "banana": 2}
    b := a // 字典之间可以直接赋值
    fmt.Println(b)
}

Le résultat de sortie est :

map[apple:1 banana:2]

IV.

En langage Go, la conversion de type est un concept très important. La conversion de type peut convertir des valeurs entre différents types pour répondre aux besoins du programme. Cependant, il convient de noter que lors de la conversion de type, il est nécessaire d'éviter les problèmes de débordement de plage de types de données et de perte de précision, et en même temps, il est nécessaire de s'assurer que le type après conversion est compatible avec le type avant conversion. La conversion de type est appliquée entre les types de données de base et les types de données composites. La maîtrise des connaissances pertinentes en matière de conversion de type est très importante pour la programmation Golang.

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!