Yeah, avoid to both advance offsets and re-slice the buffer, it only gets confusing. I would write

function calculate(typedArray) {
  const view = new DataView(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
  let i = 0;
  // Skip 4 chars, they are for signature
  i += 4;

  while (i < view.byteLength) {
    // read length of the next block
    const blockLen = view.getUint16(i, false /* big endian */);

    // ensure correct format
    // index should be within buffer limits
    if (i + blockLen > view.byteLength) {
      throw new TypeError('Corrupt JPG, exceeded buffer limits');
    }
    // Every JPEG block must begin with a 0xFF
    if (view.getUint8(i + blockLen) !== 0xFF) {
      throw new TypeError('Invalid JPG, marker table corrupted');
    }

    // 0xFFC0 is baseline standard(SOF)
    // 0xFFC1 is baseline optimized(SOF)
    // 0xFFC2 is progressive(SOF2)
    const next = view.getUint8(i + blockLen + 1);
    if (next === 0xC0 || next === 0xC1 || next === 0xC2) {
      return extractSize(view, i + blockLen + 5);
    }

    // move to the next block
    i += blockLen + 2;
  }

  throw new TypeError('Invalid JPG, no size found');
}

Notice that this code, which is a straightforward translation of the source, is slightly confusing and buggy:

• i does not point to the start of the segment, but rather two bytes into the segment (after the marker)
• the code skips the first dynamic segment (which, admittedly, is required to be an APP0 segment anyway)
• the code assumes all segments to have a variable length specified in their header, and ignores standalone markers as well as fill bytes
• the code may cause RangeError exceptions from accessing bytes beyond the end of the buffer, as it only checks for the past block to be within limits

You can use the encoding/binary package. Ex: (http://play.golang.org/p/5s_-hclYJ0)

package main

import (
    "encoding/binary"
    "fmt"
)

func main() {
    buf := make([]byte, 1024)

    // Put uint16 320 (big endian) into buf at offster 127
    binary.BigEndian.PutUint16(buf[127:], 320)

    // Put uint16 420 (little endian) into buf at offster 127
    binary.LittleEndian.PutUint16(buf[255:], 420)

    // Retrieve the uint16 big endian from buf
    result := binary.BigEndian.Uint16(buf[127:])
    fmt.Printf("%d\n", result)

    // Retrieve the uint16 little endian from buf
    result = binary.LittleEndian.Uint16(buf[255:])
    fmt.Printf("%d\n", result)

    // See the state of buf (display only 2 bytes from the given often as it is uint16)
    fmt.Printf("%v, %v\n", buf[127:129], buf[255:257])
}

BE and LE stand for big endian and little endian. In big endian, the most significant byte is stored in the smallest address, and in little endian, the least significant byte is stored in the smallest address. That being said, endian does indicate the byte order. You can see the pattern in one of the examples in the documentation:

var buf = new Buffer(2);

buf[0] = 0x3;
buf[1] = 0x4;

buf.readUInt16BE(0);
buf.readUInt16LE(0);

// 0x0304
// 0x0403

You can use the encoding/binary package. Ex: (http://play.golang.org/p/5s_-hclYJ0)

package main

import (
    "encoding/binary"
    "fmt"
)

func main() {
    buf := make([]byte, 1024)

    // Put uint16 320 (big endian) into buf at offster 127
    binary.BigEndian.PutUint16(buf[127:], 320)

    // Put uint16 420 (little endian) into buf at offster 127
    binary.LittleEndian.PutUint16(buf[255:], 420)

    // Retrieve the uint16 big endian from buf
    result := binary.BigEndian.Uint16(buf[127:])
    fmt.Printf("%d\n", result)

    // Retrieve the uint16 little endian from buf
    result = binary.LittleEndian.Uint16(buf[255:])
    fmt.Printf("%d\n", result)

    // See the state of buf (display only 2 bytes from the given often as it is uint16)
    fmt.Printf("%v, %v\n", buf[127:129], buf[255:257])
}

This should be what you are looking for:

let Buf = Buffer.from("a4c1380a701400e4233c0ac5c2", "hex");
// Let Buf be the buffer from the Bluetooth thermometer.
// Sample data is used here, which matches in your problem.
let TemperatureC = Buf.readUInt16BE(6) / 10
let Humidity = Buf.readUIntBE(8,1)
let Battery = Buf.readUIntBE(9,1)
let BatteryV = (Buf.readUInt16BE(10)) / 1000
// Just to confirm it works...
console.log(TemperatureC,Humidity,Battery,BatteryV)
// Sample output: 22.8 35 60 2.757 (Correct)

Every byte is 1 on the offset. So, if we read 6 as 2 bytes and then 7, we are really reading the second byte from the temperature. Remember to take into account that 16 bits are 2 bytes; and NodeJS offsets by byte.

There are no such functions that I'm aware of, though there may be a package that does this. Using the standard library utilities, you can use struct.unpack and io.BytesIO for the conversion and handling of a (binary) buffer.

Below is an example (Python 3). Apologies if the lines feel a bit compact; I hope it's still straightforward to read.

import io
import struct

buf = io.BytesIO(bytearray([0x12, 0x34, 0x56]))

# < and > for little and big endian, H for 2-byte unsigned short.
assert format(struct.unpack(">H", buf.read(2))[0], '02x') == "1234"

# buf.seek to reset to byte 0 (1, 2) of the stream; also for file objects
buf.seek(0)
assert format(struct.unpack("<H", buf.read(2))[0], '02x') == "3412"

buf.seek(1)
assert format(struct.unpack(">H", buf.read(2))[0], '02x') == "3456"

buf.seek(1)
assert format(struct.unpack("<H", buf.read(2))[0], '02x') == "5634"

buf.seek(2)
try:
    format(struct.unpack("<H", buf.read(2))[0], '02x')
except struct.error as exc:
    assert exc.args[0] == "unpack requires a buffer of 2 bytes"
else:
    assert False, "exception failed to be raised"

More details at the documentation pages of the io and struct modules.