How can I convert an int64 into a byte array in go?

Question

I have an id that is represented at an int64. How can I convert this to a []byte? I see that the binary package does this for uints, but I want to make sure I don't break negative numbers.

Solution 1

Converting between int64 and uint64 doesn't change the sign bit, only the way it's interpreted.

You can use Uint64 and PutUint64 with the correct ByteOrder

http://play.golang.org/p/wN3ZlB40wH

i := int64(-123456789)

fmt.Println(i)

b := make([]byte, 8)
binary.LittleEndian.PutUint64(b, uint64(i))

fmt.Println(b)

i = int64(binary.LittleEndian.Uint64(b))
fmt.Println(i)

output:

-123456789
[235 50 164 248 255 255 255 255]
-123456789

Solution 2

You can use this too:

var num int64 = -123456789

b := []byte(strconv.FormatInt(num, 10))

fmt.Printf("num is: %v, in string is: %s", b, string(b))

Output:

num is: [45 49 50 51 52 53 54 55 56 57], in string is: -123456789

Solution 3

If you don't care about the sign or endianness (for example, reasons like hashing keys for maps etc), you can simply shift bits, then AND them with 0b11111111 (0xFF):

(assume v is an int32)

b := [4]byte{
        byte(0xff & v),
        byte(0xff & (v >> 8)),
        byte(0xff & (v >> 16)),
        byte(0xff & (v >> 24))}

(for int64/uint64, you'd need to have a byte slice of length 8)

Solution 4

The code:

var num int64 = -123456789

// convert int64 to []byte
buf := make([]byte, binary.MaxVarintLen64)
n := binary.PutVarint(buf, num)
b := buf[:n]

// convert []byte to int64
x, n := binary.Varint(b)
fmt.Printf("x is: %v, n is: %v\n", x, n)

outputs

x is: -123456789, n is: 4

Solution 5

Here's a simple function that should accomplish what you are wanting:

func Int64ToBytes(number int64) []byte {
    big := new(big.Int)
    big.SetInt64(number)
    return big.Bytes()
}

View more solutions

Comments

[starriet]

in short: int or uint is just how CPU "interprets" the underlying bits. The underlying bits(11100101...) in the memory remain the same. If it's uint, the interpreting is straightforward. But if it's int, there are several ways to interpret/represent negative numbers from/to bits (two's complement is a popular way).

[mh-cbon]

Hi, should i use the constants MaxVarintLenXX to determine the size of buffer before put ?

[John Balvin Arias]

what is the b := buf[:n] line for?

[JimB]

@JohnBalvinArias: it's because this example uses a variable length encoding

[Marcus Ilgner]

No, PutUint64 uses fixed length encoding. You only need MaxVarintLenXX when using PutVarint.

[Martin Zvarík]

I have slice of 6 bytes... is that possible? And I need timestamp from that... [224, 221, 199, 147, 195, 47] should get to 1632933900000

[c-o-d]

very inefficient answer

[Jorvy]

func Int64ToBytes(number int64) []byte { big := new(big.Int) return big.SetInt64(number).Bytes() }