Why can't I substitute a class's prototype with another class's?

Question

Given two classes where I want to give the methods of one to another:

class a {}
class b {say() {console.log('hello')}}
var foo = new a();

How come this works:

a.prototype.say = b.prototype.say;
foo.say();    //'hello'

But this doesn't?

a.prototype = b.prototype;
foo.say();    //foo.say is not a function

To be clear, I'm not asking how to give one class's methods to another, but why prototype behaves like this.

Bonus question: what's the difference between defining a method inside a class block and defining it by directly assigning it to the prototype?

Answer 1

The reason for this is that prototype on a class is a non-writable, non-configurable property:

class a {}
class b {say() {console.log('hello')}}

console.log(Object.getOwnPropertyDescriptor(a,'prototype'))

Non-writable means you can't reassign the property prototype and non-configurable means you can't change the property to make writable: true or delete the property.

The result is that this has no effect:

class a {}
class b {say() {console.log('hello')}}

a.prototype = b.prototype;
console.log(a.prototype === b.prototype)

But non-writable only means you can't change the value associate with the property a.prototype — it will always point to the same object — it doesn't mean that you can't add properties to that object. This is why you can still add a.prototype.say.