Late binding happens whether or not the function is a part of the Object's prototype chain or directly attached. JS is built so that's all mostly the same thing. That's why late binding exists. Maybe you copy a function from one prototype to another to create a new sort of prototype with a bit of "code-sharing", which is the same if you want to copy a function directly from one object to another. You want that function to work in all these cases, you don't want to redefine the function explicitly for a different kind of prototype or a different kind of object, you want to pick up what it is bound to by how it is called (thus late binding). Late binding is an ancient feature of JS that feels like a bug if you think `class` works like it does in OO languages like C++ or Java or C#. Late binding feels like a bug if you think of an Object's prototype as being a strongly formed contract and not a runtime object that itself can change at any time, or can be used as a lego brick to construct other types of objects and code-sharing beyond traditional class-based OOP "inheritance" models.

The difference between a "regular object" and thing constructed from a `class` in JS is effectively nonexistent. It's the same stuff, just a few syntax niceties. (In the old days, it was a lot harder to build a clean prototype, `class` makes it a lot cleaner. But that's all it does, it makes it cleaner to write, but under the hood it is entirely the same as it was.)

> in the constructor, using arrow functions?

The example above was the related but similar thing of doing `this.a = this.a.bind(this)` in a class constructor. It's very similar to using `this.a = () => …` arrow functions to early bind `this`. (Assigning a function to itself in a constructor with a `bind()` is also an idiom pattern that predates arrow functions and class syntax. Constructors predate class syntax, but they used to look a lot different. You can still write that form of constructor if you want, but class syntax is a lot cleaner.)

Late binding is an old feature that feels like a bug today, so a lot of people work very hard to early bind functions or only ever use arrow functions because they don't trust late binding.