Quelqu'un sait-il comment obtenir la taille de la mémoire de la variable (int
, string
, []struct
, etc.) et l'imprimer? C'est possible?
var i int = 1
//I want to get something like this:
fmt.Println("Size of i is: %?", i)
//Also, it would be Nice if I could store the value into a string
Vous pouvez utiliser la fonction unsafe.Sizeof pour this . Elle renvoie la taille en octets, occupée par la valeur que vous y entrez . Voici un exemple de travail :
package main
import "fmt"
import "unsafe"
func main() {
a := int(123)
b := int64(123)
c := "foo"
d := struct {
FieldA float32
FieldB string
}{0, "bar"}
fmt.Printf("a: %T, %d\n", a, unsafe.Sizeof(a))
fmt.Printf("b: %T, %d\n", b, unsafe.Sizeof(b))
fmt.Printf("c: %T, %d\n", c, unsafe.Sizeof(c))
fmt.Printf("d: %T, %d\n", d, unsafe.Sizeof(d))
}
Prenez note que certaines plates-formes interdisent explicitement l’utilisation de fichiers non sécurisés, car c’est… bien, non sécuritaires. Cela incluait AppEngine. Je ne sais pas si c'est toujours le cas aujourd'hui, mais j'imagine que oui.
Comme @Timur Fayzrakhmanov le note, reflect.TypeOf(variable).Size()
vous donnera les mêmes informations. Pour le package reflect
, la même restriction s'applique que pour le package unsafe
. C'est-à-dire que certaines plates-formes peuvent ne pas permettre son utilisation.
Vous pouvez le faire avec soit unsafe.Sizeof()
, ou reflect.Type.Size()
La taille d'une variable peut être déterminée à l'aide de unsafe.Sizeof(a)
. Le résultat restera le même pour un type donné (c'est-à-dire int
, int64
, string
, struct
etc.), quelle que soit la valeur qu'il détient. Toutefois, pour le type string
, la taille de la chaîne référencée par la variable peut vous intéresser. Cette opération est déterminée à l'aide de la fonction len(a)
sur une chaîne donnée. L'extrait suivant montre que la taille d'une variable de type chaîne est toujours égale à 8 mais que la longueur d'une chaîne référencée par une variable peut varier:
package main
import "fmt"
import "unsafe"
func main() {
s1 := "foo"
s2 := "foobar"
fmt.Printf("s1 size: %T, %d\n", s1, unsafe.Sizeof(s1))
fmt.Printf("s2 size: %T, %d\n", s2, unsafe.Sizeof(s2))
fmt.Printf("s1 len: %T, %d\n", s1, len(s1))
fmt.Printf("s2 len: %T, %d\n", s2, len(s2))
}
Sortie:
s1 size: string, 8
s2 size: string, 8
s1 len: string, 3
s2 len: string, 6
La dernière partie de votre question concerne l’affectation de la longueur (c’est-à-dire une valeur int
) à un string
. Cela peut être fait par s := strconv.Itoa(i)
où i
est une variable int
et la string
renvoyée par la fonction est affectée à s
.
Remarque: le nom de la fonction de convertisseur est Itoa
, éventuellement une forme abrégée pour Integer to ASCII. La plupart des programmeurs de Golang risquent de mal interpréter le nom de la fonction en tant que Iota
.
unsafe.Sizeof () est la solution correcte.
var i int
var u uint
var up uintptr
fmt.Printf("i Type:%T Size:%d\n", i, unsafe.Sizeof(i))
fmt.Printf("u Type:%T Size:%d\n", u, unsafe.Sizeof(u))
fmt.Printf("up Type:%T Size:%d\n", up, unsafe.Sizeof(up))
Les types int, uint et uintptr ont généralement une largeur de 32 bits sur les systèmes 32 bits et de 64 bits sur les systèmes 64 bits. Lorsque vous avez besoin d'une valeur entière, vous devez utiliser int, sauf si vous avez une raison spécifique d'utiliser un type entier de taille ou non signé.