Reuse Javascript TypedArray (e.g. Uint32Array)

I'm using typed arrays in a Javascript game to send data between the client (running in a browser) and the server (running node.js). I can send messages back and forth no problem but I'm interested in reusing my typed arrays rather than creating a new one each time I send a message.

Here's my sendMessage code:

function sendMessage(socket, data) {

    // data is JSON
    var encoded = BISON.encode(data);
    if (socket.isBinary) {
        var len = encoded.length,
            bytes = new Uint32Array(len);

        for (var i = 0; i < len; ++i) {
            bytes[i] = encoded.charCodeAt(i);
        }
    }

    if (server && socket.isBinary) {
        socket.send(bytes, { binary: true, mask: false });
    } else {
        socket.send(encoded);
    }

}

and here's my readMessage code:

function readMessage(data) {

    if (data instanceof ArrayBuffer) {
        var bytes = new Uint32Array(data);
        data = String.fromCharCode.apply(null, bytes);
    }
    var message = JSON.stringify(BISON.decode(data));
    return JSON.parse(message);
}

Each time I send a message I create a new Uint32Array, initializing it to the length of the message I intend to send. Rather than create a new array each time I'd like reuse this array for each message.

My current line of thought on this is to determine my maxMessageSize and initialize the array with this length. maxMessageSize would be the largest allowed message that one could send over the socket.

The Question(s)

Most messages are not likely to be exactly maxMessageSize in size. In these cases would I need to pad the length of the message with some value (null?). When reading the value on the other end of the socket how would I know when this padding began?

In writing all of this out another question has occurred to me: is this even worth the effort?

Libraries Used

• ws for websockets in node.js
• BISON for binary encoding of json.