Comment convertissez-vous entre les chaînes et d'autres types de données dans GO?

Comment convertissez-vous entre les chaînes et d'autres types de données dans GO?

Dans GO, la conversion entre les chaînes et d'autres types de données est une tâche courante. Go fournit plusieurs fonctions et méthodes intégrées pour effectuer ces conversions. La clé pour comprendre ces conversions réside dans la connaissance des fonctions et méthodes spécifiques fournies par la langue. Voici quelques principes et exemples généraux:

1. De la chaîne à d'autres types:

   • Pour convertir une chaîne en un entier, vous pouvez utiliser la fonction strconv.Atoi() .
   • Pour convertir une chaîne en un numéro de point flottant, vous pouvez utiliser strconv.ParseFloat() .
   • Pour convertir une chaîne en booléen, vous pouvez utiliser strconv.ParseBool() .

2. Des autres types à la chaîne:

   • Pour convertir les entiers en chaînes, vous pouvez utiliser strconv.Itoa() ou fmt.Sprintf() .
   • Pour convertir les nombres à virgule flottante en chaînes, vous pouvez utiliser strconv.FormatFloat() ou fmt.Sprintf() .
   • Pour convertir les booléens en chaînes, vous pouvez utiliser strconv.FormatBool() ou fmt.Sprintf() .

3. Tranches d'octets aux cordes:

   • Go fournit la fonction string() pour convertir directement une tranche d'octet ( []byte ) en une chaîne.

Voici quelques exemples pour illustrer ces conversions:

 <code class="go">// String to Integer strNum := "123" num, err := strconv.Atoi(strNum) if err != nil { fmt.Println("Error converting string to integer:", err) } else { fmt.Println("Converted integer:", num) } // Integer to String num := 123 strNum := strconv.Itoa(num) fmt.Println("Converted string:", strNum) // String to Float strFloat := "123.45" floatNum, err := strconv.ParseFloat(strFloat, 64) if err != nil { fmt.Println("Error converting string to float:", err) } else { fmt.Println("Converted float:", floatNum) } // Float to String floatNum := 123.45 strFloat := strconv.FormatFloat(floatNum, 'f', -1, 64) fmt.Println("Converted string:", strFloat) // String to Boolean strBool := "true" boolValue, err := strconv.ParseBool(strBool) if err != nil { fmt.Println("Error converting string to boolean:", err) } else { fmt.Println("Converted boolean:", boolValue) } // Boolean to String boolValue := true strBool := strconv.FormatBool(boolValue) fmt.Println("Converted string:", strBool) // Byte Slice to String byteSlice := []byte{72, 101, 108, 108, 111} str := string(byteSlice) fmt.Println("Converted string:", str)</code>

Ces exemples montrent l'utilisation de diverses fonctions de package strconv pour effectuer des conversions de type. Le package strconv est particulièrement utile pour ces opérations en Go.

Quelles sont les fonctions spécifiques utilisées pour convertir les entiers en chaînes en Go?

En Go, il y a deux fonctions principales utilisées pour convertir les entiers en chaînes:

1. strconv.Itoa() : Cette fonction convertit une valeur entière en sa représentation de chaîne. Il est simple et ne fonctionne qu'avec des entiers.

   Exemple:

    <code class="go">num := 42 str := strconv.Itoa(num) fmt.Println(str) // Output: 42</code>

2. fmt.Sprintf() : Cette fonction est plus polyvalente et peut être utilisée pour convertir divers types de données, y compris les entiers, en chaînes. Il utilise des spécificateurs de format pour formater la sortie.

   Exemple:

    <code class="go">num := 42 str := fmt.Sprintf("%d", num) fmt.Println(str) // Output: 42</code>

Les deux fonctions sont couramment utilisées, mais strconv.Itoa() est spécialement conçue pour la conversion entière à corde et est plus concise à cet effet.

Comment pouvez-vous convertir une chaîne en un flotteur dans la programmation GO?

Pour convertir une chaîne en un flotteur en Go, vous pouvez utiliser la fonction strconv.ParseFloat() à partir du package strconv . Cette fonction prend deux arguments: la chaîne à convertir et la taille du bit du flotteur (32 ou 64).

Voici comment utiliser strconv.ParseFloat() :

 <code class="go">strFloat := "123.45" floatNum, err := strconv.ParseFloat(strFloat, 64) if err != nil { fmt.Println("Error converting string to float:", err) } else { fmt.Println("Converted float:", floatNum) }</code>

Dans cet exemple, strconv.ParseFloat(strFloat, 64) tente de convertir la chaîne "123.45" en float64 . La fonction renvoie deux valeurs: le flotteur converti et une erreur. Vous devez toujours vérifier l'erreur pour gérer les cas où la conversion échoue (par exemple, si la chaîne contient des caractères non numériques).

Quelles méthodes sont disponibles pour convertir les tranches d'octets en chaînes en Go?

Dans Go, vous pouvez convertir une tranche d'octets ( []byte ) en une chaîne en utilisant la fonction string() . Il s'agit de la méthode la plus courante et la plus simple pour effectuer cette conversion.

Voici un exemple:

 <code class="go">byteSlice := []byte{72, 101, 108, 108, 111} str := string(byteSlice) fmt.Println(str) // Output: Hello</code>

Dans cet exemple, la tranche d'octets {72, 101, 108, 108, 111} correspond aux valeurs ASCII pour la chaîne "bonjour", qui est correctement convertie en chaîne "bonjour".

La fonction string() est efficace et convertit directement la tranche d'octets en sa représentation de chaîne sans aucun traitement ou allocation de mémoire supplémentaire. Il est important de noter que cette conversion ne copie pas les données sous-jacentes; Il crée une nouvelle valeur de chaîne qui fait référence à la même mémoire que la tranche d'octets.

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!