Comment convertir une chaîne en entier en Golang

Méthode de conversion : 1. Utilisez Atoi() pour convertir le type de chaîne entier en type int, la syntaxe est "strconv.Atoi(str)" ; 2. Utilisez ParseInt() pour convertir la chaîne en valeur entière Accepte. signes positifs et négatifs, la syntaxe "strconv.ParseInt(str,10,64)" ; 3. Utilisez ParseUnit() pour convertir la chaîne en valeur entière, n'accepte pas les signes positifs et négatifs, la syntaxe "strconv.ParseUint( str,10,64)”.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Le package strconv en langage Go implémente une conversion mutuelle entre les types de données de base et leurs représentations sous forme de chaîne.

Le package strconv implémente la conversion des types de données de base et de leurs représentations sous forme de chaîne. Il comprend principalement les fonctions suivantes couramment utilisées : Atoi(), Itia(), analyser les séries, formater les séries et ajouter les séries.

Ce qui suit présente plusieurs fonctions pour convertir des chaînes en entiers. La fonction

Atoi()

Atoi() est utilisée pour convertir un entier de type chaîne en type int. La signature de la fonction est la suivante.

func Atoi(s string) (i int, err error)

Si le paramètre de chaîne entrant ne peut pas être converti en type int, une erreur sera renvoyée.

package main

import "fmt"
import "strconv"

func main() {
   s1 := "100"
      i, err := strconv.Atoi(s1)
   if err != nil {
      fmt.Println("can't convert to int")
   } else {
      fmt.Printf("type:%T value:%#v\n", i, i) //type:int value:100
   }
}

Fonctions de série Parse

Les fonctions de classe Parse sont utilisées pour convertir des chaînes en valeurs d'un type donné : ParseBool(), ParseFloat(), ParseInt(), ParseUint(). Parmi eux, ParseInt() et ParseUnit() sont utilisés pour convertir des chaînes en entiers.

ParseInt()

ParseInt() est une fonction qui convertit une chaîne en nombre

func ParseInt(s string, base int, bitSize int) (i int64, err error)

Renvoie la valeur entière représentée par la chaîne, en acceptant les signes positifs et négatifs.

• base spécifie la base (2 à 36). Si la base est 0, elle sera jugée à partir du préfixe de la chaîne "0x" est hexadécimal, "0" est octal, sinon il est décimal ;

  bitSize spécifie le type entier auquel le résultat doit être attribué sans débordement. 0, 8, 16, 32 et 64 représentent respectivement int, int8, int16, int32 et int64 ; . Si la syntaxe est incorrecte, err.Error = ErrSyntax ; si le résultat dépasse la plage de types, err.Error = ErrRange.
ParseUnit()

• func ParseUint(s string, base int, bitSize int) (n uint64, err error)

  ParseUint est similaire à ParseInt mais n'accepte pas les signes et est utilisé pour les entiers non signés.

Exemple : Les fonctions

package main

import "fmt"
import "strconv"

func main() {
	i, err1 := strconv.ParseInt("-2", 10, 64)
	u, err2 := strconv.ParseUint("2", 10, 64)
	if err1 != nil {
      fmt.Println("can't convert to int")
    } else {
      fmt.Printf("type:%T value:%#v\n", i, i) //type:int64 value:2
    }
	if err2 != nil {
      fmt.Println("can't convert to int")
    } else {
      fmt.Printf("type:%T value:%#v\n", u, u) //type:uint64 value:0x2
    }
}

ParseInt() et ParseUnit() ont toutes deux deux valeurs de retour. La première valeur de retour est la valeur convertie et la deuxième valeur de retour est le message d'erreur de l'échec de la conversion.

Connaissances étendues : les entiers dans le langage go

Go fournit des types d'entiers signés et non signés, notamment int8, int16, int32 et int64. Quatre types d'entiers signés avec des tailles complètement différentes correspondant aux entiers signés de 8, 16. , 32 et 64 bits (bits binaires) respectivement, correspondant aux quatre types d'entiers non signés uint8, uint16, uint32 et uint64.

De plus, il existe deux types d'entiers, int et uint, qui correspondent respectivement à la longueur du mot (taille du mot machine) d'une plate-forme CPU spécifique. Int représente un entier signé, qui est le plus largement utilisé, et uint représente un. entier non signé. Dans le développement réel, en raison des différences entre les compilateurs et le matériel informatique, la taille entière que peuvent représenter int et uint varie entre 32 bits et 64 bits. Dans la plupart des cas, nous n'avons besoin que d'un type entier, qui peut être utilisé pour les compteurs de boucles (variables dans les boucles for qui contrôlent le nombre de boucles), les index dans les tableaux et les tranches, et tout opérateur entier à usage général, généralement l'int le type est également le plus rapide en termes de vitesse de traitement.

Le type rune utilisé pour représenter les caractères Unicode est équivalent au type int32 et est généralement utilisé pour représenter un point de code Unicode. Les deux noms peuvent être utilisés de manière interchangeable. De même, byte et uint8 sont également des types équivalents. Le type byte est généralement utilisé pour souligner que la valeur est une donnée primitive plutôt qu'un petit entier.

Enfin, il existe un type entier non signé uintptr, qui ne spécifie pas de taille de bit spécifique mais est suffisamment grand pour accueillir des pointeurs. Le type uintptr n'est nécessaire que dans la programmation de bas niveau, en particulier lorsque le langage Go interagit avec les bibliothèques de fonctions du langage C ou les interfaces du système d'exploitation.

Bien que les tailles de int, uint et uintptr puissent être égales dans certains environnements d'exploitation spécifiques, il s'agit toujours de types différents, tels que int et int32, bien que la taille du type int puisse également être de 32 bits, lorsque vous devez convertir. le int Le type doit être explicitement converti lorsqu'il est utilisé comme type int32 et vice versa.

Les entiers signés dans le langage Go sont représentés sous la forme de complément à 2, c'est-à-dire que le bit le plus élevé est utilisé pour représenter le bit de signe. La plage de valeurs d'un nombre signé à n bits va de -2(n-1) à 2. (n-1)-1. Tous les bits d'un entier non signé sont utilisés pour représenter des nombres non négatifs, avec des valeurs allant de 0 à 2n-1. Par exemple, un entier de type int8 va de -128 à 127, tandis qu'un entier de type uint8 va de 0 à 255.

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

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!