The official node.js documentation for Buffer is the best place to check for something like this. As previously noted, Buffer currently supports these encodings: 'ascii', 'utf8', 'utf16le'/'ucs2', 'base64', 'base64url', 'latin1'/'binary', and 'hex'.

Let's get the basics:

• When you call Buffer.from("hello"), you map (encode) the string hello into bytes.
  (Note that hello is interpreted as a UTF8 encoded string by default, so that the above expression is equivalent to Buffer.from("hello", "utf8")).
  The resultant buffer is:
  <Buffer 68 65 6c 6c 6f>.
• When you call Buffer.from("hello").toString(), you map (encode) hello into bytes, and then map (decode) those bytes back into a string.
  Again, note that UTF8 is the default, so the above expression is equivalent to Buffer.from("hello").toString("utf8") as well as to Buffer.from("hello", "utf8").toString("utf8").
  The resultant string is unsurprisingly:
  "hello".
  However, change it to Buffer.from("hello").toString("base64"), and you'll get:
  aGVsbG8=.

Now, let's move forward to fs.writeFileSync:

• fs.writeFileSync(file, data[, options]) writes a file, that is: bytes. In other words, when data is a string, writeFileSync maps (encodes) that string into bytes, and then writes those bytes into the file.
  Again, the default encoding is UTF8, but when you pass some other encoding, data will be mapped (encoded) into bytes using this encoding.
  By the way, when you "open the file", be it using some text editor or even the debugger itself, you probably do it (without knowing) using UTF8 encoding.

Hopefully, You can now understand that:

• fs.writeFileSync("myFile.xml", Buffer.from("hello","utf8").toString("base64")) maps (encodes) hello into bytes (using UTF8 encoding), and then maps (decodes) those bytes into a string (using Base64 encoding), which is aGVsbG8=.
  This is what you see when you open the file created in your last snippet.

• fs.writeFileSync("myFile.xml", Buffer.from("hello","utf8").toString("base64"), "base64") maps (encodes) hello into bytes (using UTF8 encoding), then maps (decodes) those bytes into a string (using Base64 encoding), then maps (encodes) this string into bytes (using Base64 encoding). This is what you do in your penultimate snippet.

  To illustrate, note that this series of "mappings" is equivalent to:

  var bytes = Buffer.from(Buffer.from("hello").toString("base64"), "base64")
  

  Which gives:
  <Buffer 68 65 6c 6c 6f>.

  Then, when you open the file, you (i.e., probably your text editor) read those bytes as UTF8 by default, which is equivalent to:

  bytes.toString()  // 'bytes' is defined above
  

  Which gives:
  "hello".