GoLang bitwise calculation - go

Question

I have a buffer :
buffer := bytes.NewBuffer([]byte{
0x85, 0x02, 0xFF, 0xFF,
0x00, 0x01, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x03,
0x41, 0x42, 0x43,
})
I am trying to return the int value of buffer[8:24]
I get
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
Not sure how to shift such a large section. of the byte.
new to this. Any help would be great. my initial approach was
requestid := (uint64(buffer.Bytes()[8]&0xff)<<24 + uint64(buffer.Bytes()[9]&0xff)<<16 + uint64(buffer.Bytes()[10]&0xff)<<8 + uint64(buffer.Bytes()[11]&0xff.....)))
but this got tedious, and I know there has to be an easier way.

Answer 1

You have to do the manual bit shifting and OR'ing, but your code can be cleaned up by removing all those buffer.Bytes() calls.
You also do not need the &0xff parts. What n&0xff does, is clear out all bits outside of the 0-255 range. Since each value in the buffer is already a byte (0-255), these operations do nothing at all. If we want to do 22 & 255, we get the following:
Hexadecimal | Decimal | Binary
--------------|-------------|----------------------
x 0x16 | 22 | 00010110
y 0xff | 255 | 11111111
--------------|-------------|---------------------- AND (&)
0x16 | 22 | 00010110 = x
As you can see, the operation has no effect at all. Replace x with any 8-bit value and you will see the same result. The outcome of x & 0xff is always x.
Additionally, when you assign to the requestId, you start by shifting by 24 bits. This tells me you are reading a 32-bit integer. Why then do you continue reading values beyond 32 bits and converting it all to a 64 bit integer?
If you are reading a 64-bit int in Big Endian, try this:
data := buf.Bytes()[8:]
requestid := uint64(data[0])<<56 | uint64(data[1])<<48 |
uint64(data[2])<<40 | uint64(data[3])<<32 |
uint64(data[4])<<24 | uint64(data[5])<<16 |
uint64(data[6])<<8 | uint64(data[7])
If you are reading a 64-bit int in Little Endian, try this:
data := buf.Bytes()[8:]
requestid := uint64(data[7])<<56 | uint64(data[6])<<48 |
uint64(data[5])<<40 | uint64(data[4])<<32 |
uint64(data[3])<<24 | uint64(data[2])<<16 |
uint64(data[1])<<8 | uint64(data[0])
If you are reading a 32-bit int in Big Endian, try this:
data := buf.Bytes()[8:]
requestid := uint32(data[0])<<24 | uint32(data[1])<<16 |
uint32(data[2])<<8 | uint32(data[3])
If you are reading a 32-bit int in Little Endian, try this:
data := buf.Bytes()[8:]
requestid := uint32(data[3])<<24 | uint32(data[2])<<16 |
uint32(data[1])<<8 | uint32(data[0])
binary package
Alternatively, you can use the encoding/binary package:
var value uint64
err := binary.Read(buf, binary.LittleEndian, &value)
....