new Buffer(number)            // Old
Buffer.alloc(number)          // New

new Buffer(string)            // Old
Buffer.from(string)           // New

new Buffer(string, encoding)  // Old
Buffer.from(string, encoding) // New

new Buffer(...arguments)      // Old
Buffer.from(...arguments)     // New

Note that Buffer.alloc() is also faster on the current Node.js versions than new Buffer(size).fill(0), which is what you would otherwise need to ensure zero-filling.

There are three changes I would suggest.

First, if you are using Node v6, use Buffer.from() instead of new Buffer(), as the latter is deprecated.

Second, you don't need to pass an argument for totalLength to Buffer.concat(), since it will be calculated automatically from the length of all of the buffers passed. While the docs note it will be faster to pass a total length, this will really only be true if you pass a constant value. What you are doing above is computing the length and then passing that, which is what the concat() function will do internally anyway.

Finally, I would recommend putting this in a function that works like Array.prototype.join(), but for buffers.

function joinBuffers(buffers, delimiter = ' ') {
  let d = Buffer.from(delimiter);

  return buffers.reduce((prev, b) => Buffer.concat([prev, d, b]));
}

And you can use it like this:

let buf1 = Buffer.from('Foo');
let buf2 = Buffer.from('Bar');
let buf3 = Buffer.from('Baz');

let joined = joinBuffers([buf1, buf2, buf3]);

console.log(joined.toString()); // Foo Bar Baz

Or set a custom delimiter like this:

let joined2 = joinBuffers([buf1, buf2, buf3], ' and ');

console.log(joined2.toString()); // Foo and Bar and Baz

Looking at the implementation of Buffer.concat: It seems to be doing exactly what you suggested as replacement in implementation 2/first case: Create a new buffer with the calculated total length, then copy all buffers into the output.

So, based on that it seems reasonable to continue to use Buffer.concat directly, because the code is more concise, easier to follow, and describes better what you want to do ("concatenate all these buffers!")

For the writer case: Your suggested implementations aren't equivalent -- the first one would leave space at the end for adding new data, while the second implementation provides exactly the space needed for the existing buffers. If you need the extra space (optimization for expected future writes, for example), then stick to the first variant, otherwise the same argument applies: Using concat is more concise and easier to read.