int, int8…int64, uint, uint8…uint64, uintptr în Go

int     int8   int16   int32   int64
uint    uint8  uint16  uint32  uint64  uintptr

var n int = 42
var b uint8 = 255
x := int64(n)

Ce face int, int8…int64, uint, uint8…uint64, uintptr

Tipurile întregi cu semn sunt int8 (−128…127), int16 (−32768…32767), int32 (circa ±2,1 miliarde) și int64 (circa ±9,2 miliarde de miliarde). Cele fără semn, uint8…uint64, pornesc de la 0 și ajung la dublu. int și uint au 32 sau 64 de biți după platformă; pe calculatoarele și serverele actuale au 64. byte este alt nume pentru uint8, iar rune pentru int32.

int este tipul implicit: îl primesc constantele întregi (x := 5), iar len și indicii folosesc int. Alege-l pe el dacă nu ai un motiv anume. Tipurile cu dimensiune fixă apar la formate binare, fișiere, protocoale de rețea și baze de date. uintptr este un întreg suficient de mare cât să țină o adresă de memorie; apare doar în cod de nivel jos, cu unsafe sau syscall.

Depășirea limitei nu dă eroare la rulare: valoarea „se învârte” (int8(127) + 1 devine −128). Împărțirea întreagă taie zecimalele (7 / 2 este 3), iar % dă restul. Între tipuri întregi diferite trebuie conversie explicită (int64(n)).

Exemple

Exemplul 1: Operații și conversii

package main

import "fmt"

func main() {
    bomboane, copii := 17, 5
    fmt.Println("fiecare primește", bomboane/copii, "și rămân", bomboane%copii)

    var mic int8 = 100
    var mare int64 = 5_000_000_000 // separatorul _ ajută la citire
    total := int64(mic) + mare
    fmt.Println(total)

    var octet uint8 = 0b1111_0000
    fmt.Println(octet, 0xFF, 0o17)
    fmt.Printf("%T %T %T\n", bomboane, mic, total)
}

Rezultat

fiecare primește 3 și rămân 2
5000000100
240 255 15
int int8 int64

Exemplul 2: Depășirea limitei

Valorile trec de la maxim la minim fără nicio eroare; ai grijă la tipurile mici.

package main

import (
    "fmt"
    "math"
)

func main() {
    var a int8 = 127
    a++
    fmt.Println("int8 după 127:", a)

    var b uint8 = 0
    b--
    fmt.Println("uint8 sub 0:", b)

    var c int64 = math.MaxInt64
    c++
    fmt.Println("int64 după maxim:", c)
}

Rezultat

int8 după 127: -128
uint8 sub 0: 255
int64 după maxim: -9223372036854775808

Exemplul 3: Dimensiunea în memorie

unsafe.Sizeof dă numărul de octeți ai fiecărui tip pe platforma curentă (64 de biți).

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    fmt.Println("int8:", unsafe.Sizeof(int8(0)), "int16:", unsafe.Sizeof(int16(0)))
    fmt.Println("int32:", unsafe.Sizeof(int32(0)), "int64:", unsafe.Sizeof(int64(0)))
    fmt.Println("int:", unsafe.Sizeof(0), "uint:", unsafe.Sizeof(uint(0)), "uintptr:", unsafe.Sizeof(uintptr(0)))
}

Rezultat

int8: 1 int16: 2
int32: 4 int64: 8
int: 8 uint: 8 uintptr: 8

Greșeli frecvente

• a + b cu a int și b int64: mismatched types int and int64.
• 7 / 2 așteptând 3.5: împărțirea întreagă dă 3. Scrie 7.0 / 2 sau float64(a) / float64(b).
• Folosirea lui uint pentru valori care nu pot fi negative, apoi o scădere: uint(3) - uint(5) dă un număr uriaș, nu −2.
• Constantă prea mare: var x int8 = 200 dă cannot use 200 (untyped int constant) as int8 value in variable declaration (overflows).

Comenzi înrudite

• tipuri de bază: Tipurile simple din Go: bool, string, întregi cu și fără semn, numere reale, complexe, byte și rune.
• float32 și float64: Numere reale în virgulă mobilă: float64 (precizie dublă, tipul implicit) și float32 (precizie simplă).
• constante netipizate: Constantele fără tip se adaptează tipului de care e nevoie și sunt calculate cu precizie mare la compilare.
• string-uri, rune și byte: Textul în Go este UTF-8: len dă octeți, range dă rune (caractere), byte este un octet, rune un caracter.