How to get same result than Java .readUTF() in node.js?

Question

I'm making a game server information section on a webpage using node.js, to get the server information i send a request for information to the server using net.socket and it send them back. The game client is written in java and parse the data send by the server like that:

public static Object[] readParameters(DataInputStream paramDataInputStream) throws IOException {
        int i;
        Object[] arrayOfObject = new Object[i = paramDataInputStream.readInt()];
        
        for (byte b = 0; b < i; b++) {
          byte[] arrayOfByte; byte b1;
          switch (b1 = (byte)paramDataInputStream.read()) {
            case 2:
              arrayOfObject[b] = Long.valueOf(paramDataInputStream.readLong());
              break;
            case 4:
              arrayOfObject[b] = paramDataInputStream.readUTF();
              break;
            case 3:
              arrayOfObject[b] = Float.valueOf(paramDataInputStream.readFloat());
              break;
            case 1:
              arrayOfObject[b] = Integer.valueOf(paramDataInputStream.readInt());
              break;
            case 5:
              arrayOfObject[b] = Boolean.valueOf(paramDataInputStream.readBoolean());
              break;
            case 6:
              arrayOfObject[b] = Byte.valueOf(paramDataInputStream.readByte());
              break;
            case 7:
              arrayOfObject[b] = Short.valueOf(paramDataInputStream.readShort());
              break;
            
            case 8:
              arrayOfByte = new byte[paramDataInputStream.readInt()];
              paramDataInputStream.readFully(arrayOfByte);
              arrayOfObject[b] = arrayOfByte;
              break;
            default:
              throw new IllegalArgumentException("Type: " + arrayOfByte + " unknown. parameter " + b + " of " + i);
          } 
        
        } 
        return arrayOfObject;
    }

the webpage is hosted using node.js with express and i adapted the parsing function like that:

//data is a buffer
function readParameter(data){
    var indexI = 0;
    function sRead(buffer){
        var tempVar = buffer.readUInt8(indexI);
        indexI += 1;
        return tempVar;
    }
    function sReadByte(buffer){
        var tempVar = buffer.readInt8(indexI);
        indexI += 1;
        return tempVar;
    }
    function sReadShort(buffer){
        var tempVar = buffer.readInt16BE(indexI);
        indexI += 2;
        return tempVar;
    }
    function sReadInt(buffer){
        var tempVar = buffer.readInt32BE(indexI);
        indexI += 4;
        return tempVar;
    }
    function sReadFloat(buffer){
        var tempVar = buffer.readFloatBE(indexI);
        indexI += 4;
        return tempVar;
    }
    function sReadLong(buffer){
        var tempVar = buffer.readBigInt64BE(indexI);
        indexI += 8;
        return tempVar;
    }
    function sReadBoolean(){
        var tempA = buffer.readUInt8(indexI);
        indexI += 1;
        if(tempA==0){
            return false;
        }else{
            return true;
        }
    }
    function sReadFully(buffer){
        var tempA = buffer.slice(indexI);
        indexI = tempA.length;
        return tempA;
    }
    
    var i = sReadInt(data);
    var arrayOfObject = [];
    for(var b = 0; b < i; b++){
        var arrayOfByte = [];
        var b1 = sRead(data);
        switch(b1){
            case 1:
                arrayOfObject[b] = sReadInt(data);
                break;
            case 2:
                arrayOfObject[b] = sReadLong(data);
                break;
            case 3:
                arrayOfObject[b] = sReadFloat(data);
                break;
            case 4:
                //Don't know how to handle it, want result similar to DataInputStream.readUTF() from java
                break;
            case 5:
                arrayOfObject[b] = sReadBoolean(data);
                break;
            case 6:
                arrayOfObject[b] = sReadByte(data);
                break;
            case 7:
                arrayOfObject[b] = sReadShort(data);
                break;
            case 8:
                sReadInt(data);
                arrayOfByte = sReadFully(data);
                arrayOfObject[b] = arrayOfByte;
                break;
            default:
                console.log("Type :" + arrayOfByte + "unknown. parameter " + b + " of " + i);
                break;
        }
    }
    return arrayOfObject;
}

but i have no idea how to achieve the same result than readUTF() from java at the 'case 4:' in node.js.

How could i do it?

Thanks in advance for your help !

Answer 1

DataInput.readUTF is fully specified in https://docs.oracle.com/javase/7/docs/api/java/io/DataInput.html#readUTF() :

It has two parts. The first part is a 16 bit length field that tells you the number of bytes in the second part. The second part is a byte string that encodes text with a scheme similar to UTF-8.

You can read the bytes easily:

        case 4:
            var length = sReadShort(data);
            // Read 'length' bytes
            var bytes = buffer.slice(indexI, indexI+length)
            indexI=indexI+length
            break;

Fully replicating the non standard text encoding used by readUTF is not trivial.