How do we expose read-only methods from ImmutableBuffer in Chapter 7?

[halpina]

Hello All,

Quick intro: I've been using Node.JS a few years but only recently got this book. It's a great book. It has exactly the content that I was looking for in terms of explaining the history and evolution of Node and also the readacross from GoF, etc.

I have a question with regard to the ImmutableBuffer class on page 251. I can see that the constructor creates a Buffer object but where is that object stored such that it is read back when doing the immutable.readInt8(0)?

i.e. it's not stored as an attribute (e.g. this.buffer) so is there some implicit behaviour that stores that data such that it can be read back when doing a readInt from the immutable object? Or have I completely missed something :) ?

Thanks for your help

Andrew

[halpina]

Sorry - just looking at it again and can answer my own question 😁 !! Because buffer[prop].bind(buffer) is assigned as a property to the ImmutableBuffer, that property is both the data object (buffer) and it's method (readInt8), so buffer is implicitly available when calling the readInt8 method on immutable.

[lmammino]

Hey @halpina, first of all, thanks for being a reader of the book and for posting this question (and even the answer 😜).

You got it absolutely right!

Just to add a little bit more depth (which may be useful for other readers), I think this is the most important part of that example:

const MODIFIER_NAMES = ['swap', 'write', 'fill']

// --snip--  

if (MODIFIER_NAMES.some(m => prop.startsWith(m))) {
  modifiers[prop] = buffer[prop].bind(buffer)  // 👈   a "mutating" method
} else {
  this[prop] = buffer[prop].bind(buffer) // 👈   a "read-only" method
}

This if statement is essentially responsible for distinguishing between read-only methods and methods that can actually mutate the buffer (swap*, write* and fill*).

When we find a method that can mutate the buffer we add it to the modifiers object. If the method is otherwise read-only we attach it to our ImmutableBuffer instance using this[prop] = buffer[prop].bind(buffer).

Then we expose the modifiers only at construction time using the Revealing constructor pattern. This makes the inner buffer mutable only at construction time.

Another important detail is that we DON'T expose the internal buffer (for instance by doing this.buffer = buffer). If we were to do that, then anyone would be able to mutate the internal buffer at any point in time by doing something like: immutableBufferInstance.buffer.writeInt8(...).

I hope this helps :)

[halpina]

Thanks Luciano