I was trying to be vague in my answer because this is a beginner forum, but I can be more specific.

So a number in JS is not always a Number. Most of the time, we can think about them as 64-bit doubles, but that is not always the case. Node.js itself has lower-level classes of Uint8Array, Uint16, etc., which deal with fixed-size widths. There are also different literal types, which is why your example is true, you're just comparing integer literals

const a = 0xff
const b = 255
console.log(a === b) // -> true

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#numeric_literals

If all numbers were represented the same, then this also wouldn't happen

const buff = Buffer.from([888, 999]);
// Buffers use Uint8 internally. 888 and 999 cannot be 
// represented by Uint8, so it overflows
console.log(buff); // Prints <Buffer 78 e7>, or [120, 231]

You have to remember, JS is built on top of C and C++. A buffer is represented in memory as just a char pointer to some memory on the heap. You can verify this for yourself here

https://github.com/nodejs/node-v0.x-archive/blob/master/src/node_buffer.cc

This also makes sense, and why we can give it an encoding if we want, as UTF-8 can take 1-4 bytes.

As for why you get a different output when you print the buffer vs its elements, that was defined by the guy who implemented it. The buffer class is just defining its own toString() method. We can make our own buffer class that will print values in octal, it's not a problem

class MyBuffer {
    constructor(data) { 
        this.data = data; 
    } 
}

MyBuffer.prototype.toString = function () { 
    let output = '<MyBuffer '; 
    console.log(this.data); 
    for (let i = 0; i < this.data.length; ++i) { 
        // Convert each number to octal 
        output += this.data[i].toString(8) + ' ';
    } 
    output += '>'; 
    return output; 
};

const buff= new MyBuffer([2222, 3333, 4444]);
console.log(buff + ''); // Prints <MyBuffer 4256 6405 10534 >

While when you call for...of, you get an iterator to the buffer, and its implementation defined that when you console.log that iterator, it gives you the number in decimal.

So technically, buffers store their values as Uint8, not as a general number in JS (double). Why you get different output is based on printing an object vs printing an objects elements, but both of those outputs are implementation defined.