readonly properties is working partially in typescript?

Question

Let's take a look at this code

interface ImmutableValue<T> {
    readonly value: T;
}

let i: ImmutableValue<string> = { value: "hi" };
i.value = "Excellent, I can't change it"; // compile-time error

The above is pretty straight forward, we have an interface ImmutableValue and since i is implementing that interface, i.value will be getting compilation error

Now consider the below code

interface Greetable {
  readonly name: string;
}

class Person implements Greetable {
  name: string;

  constructor(n: string) {
    this.name = n;
  }
}

let user1 = new Person('isaac');

user1.name = 'jon'
console.log(user1)

For the code above, clearly Person is implementing Greetable which has a name of readonly and user1.name = 'jon' is a value reassignment and we should get an error. But TS is compiling perfectly fine, any idea why is that?

Person extends Greetable, including allowing writing to name. — jonrsharpe
– jonrsharpe, Commented Aug 7, 2021 at 8:37
I don't mean extends, I mean in the sense of adding behaviour. Anything that expects a Greetable, something that has a readable name property, can still use Person. They don't be be able to write through that interface, the fact that another consumer accessing the same value through Person could is irrelevant. — jonrsharpe
– jonrsharpe, Commented Aug 7, 2021 at 8:53

4 revs · Accepted Answer · 2021-08-07 09:59:58Z

1

TypeScript ignores readonly when determining whether two types are compatible, so Person is compatible with Greetable despite Greetable making name readonly while Person doesn't. From this page on readonly:

It’s important to manage expectations of what readonly implies. It’s useful to signal intent during development time for TypeScript on how an object should be used. TypeScript doesn’t factor in whether properties on two types are readonly when checking whether those types are compatible, so readonly properties can also change via aliasing.

(my emphasis)

More generally, though, a subtype can add features on top of its supertype. As jonrsharpe points out in a comment, any code that uses a Greetable can still use a Person. Code with a Greetable reference to Person won't be able to change name through that reference:

function example(g: Greetable) {
    g.name = "example"; // Error
}
example(new Person("Joe"));

but being publicly readonly doesn't guarantee that something won't change, just that code that has readonly access to it can't change it, which is subtly different.

edited Aug 7, 2021 at 9:59

community wiki

4 revs
T.J. Crowder

Sign up to request clarification or add additional context in comments.

2 Comments

Isaac Over a year ago

hmm interesting...my understanding of an interface was that, it is to be used to enforce Person to have similar signature as Greetable. If it's inheritance by extends, the part about definition overriding I can understand, but here is nothing to do with inheritance isnt it

T.J. Crowder Over a year ago

@Isaac - Overriding is related to inheritance, yes, although I think overriding is a bit tangential to this particular aspect and I should probably just reword it out of the answer. :-)

Collectives™ on Stack Overflow

readonly properties is working partially in typescript?

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related