How to deal with byte operators in Golang?

Question

I would like to create a buffer which will contain information like nickname and password. Let's say I have created empty buffer, which is

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

By then I would like to fill it up with data, like buffer << nickname(string) << password(string) , so in result I'm getting

08 75 73 65 72 6e 61 6d 65 08 70 61 73 73 77 6f 72 64

which is len.nickname actual_nickname len.password password

Now, after I have created such buffer I would like to parse it to variables. That would look like buffer >> nickname(string) >> password(string)

I made something once in c++ which was using operators, but I am not sure how to do so in Golang.

These buffers would be used as packets body in my networking app. I don't want to use structs, but kind of above.

I hope I explained my issue properly. I also do not want to use splitters like : to get these into array table.

Thank you.

Answer 1

Try using a bytes.Buffer , to which you can write as necessary, including using fmt.Fprintf if necessary. When everything is written to the buffer, you can get the bytes back out.

buf := bytes.NewBuffer(nil)
fmt.Fprint(buf, nickname)
fmt.Fprint(buf, password)
fmt.Print(buf.Bytes())

Working example here: https://play.golang.org/p/bRL6-N-3qH_n

Answer 2

You can do fixed-size encoding using the encoding/binary package, including choosing endianness.

The example below writes two strings preceded by the length stored as a uint32 in network byte order. This would be appropriate to send over the wire. You can use uint16 , or even uint8 if you're certain this will be enough to represent the string lengths.

Warning : I'm ignoring all errors in this sample code. Please do not do that in yours.

package main

import (
    "bytes"
    "encoding/binary"
    "fmt"
)

func main() {
    user := "foouser"
    password := "barpassword"

    // Write "len(user) user len(password) password".
    // Lengths are unsigned 32 bit ints in network byte order.
    var buf bytes.Buffer
    binary.Write(&buf, binary.BigEndian, (uint32)(len(user)))
    buf.WriteString(user)
    binary.Write(&buf, binary.BigEndian, (uint32)(len(password)))
    buf.WriteString(password)

    var output []byte = buf.Bytes()
    fmt.Printf("% x\n", output)

    // Now read it back (we could use the buffer,
    // but let's use Reader for clarity)
    input := bytes.NewReader(output)
    var uLen, pLen uint32

    binary.Read(input, binary.BigEndian, &uLen)
    uBytes := make([]byte, uLen)
    input.Read(uBytes)
    newUser := string(uBytes)

    binary.Read(input, binary.BigEndian, &pLen)
    pBytes := make([]byte, pLen)
    input.Read(pBytes)
    newPassword := string(pBytes)

    fmt.Printf("User: %q, Password: %q", newUser, newPassword)
}

This outputs the byte array and the strings extracted from it:

00 00 00 07 66 6f 6f 75 73 65 72 00 00 00 0b 62 61 72 70 61 73 73 77 6f 72 64
User: "foouser", Password: "barpassword"

playground link