Typescript inheritance deep dive 🐋

How inheritance in Typescript works behind the curtain?

Kevin Kreuzer
Nov 7, 2018 · 10 min read
Image for post
Image for post

Typescript and JavaScript are both impressive languages. Typescript feels more familiar to a wide range of developers because it offers concepts we usually encounter in traditional programming languages. Inheritance is one of them.

But TypeScript doesn’t run in the Browser. We need to compile it to JavaScript. Mostly ES5, which doesn’t contain classes nor an extend keyword.

So how does this work then? Typescript uses syntactic sugar to “mimic” the class and inheritance behavior. It creates kind of an illusion of those concepts. Let’s see what I mean by that.

In this blogpost we will dive deep. On our way we will encounter a lot of concepts. It is important to wrap your head around those concepts. Take your time and make some breaks if necessary. You don’t have to understand everything in one read.

Let’s set up a new TypeScript project to illustrate what happens behind the curtain. To create a new empty Typescript project let’s run the following command:

tsc --init

This establishes us a which the TypeScript compiler will use to compile our code. Currently, it won’t do anything because we haven’t written any code yet. Let’s go on and do so by adding an index.ts:

Image for post
Image for post

The class acts as a base class which derives of. accepts a name and favorite food as a constructor parameter. It passes the name via a super call to and assigns the favorite food parameter to private property.

We then instantiate and and call greet and talk. is only able to greet because it extends . Nothing fancy here.

The code above shows the syntactic sugar I was talking about in the beginning. It allows us to write inheritance in a classical way that we are used from other languages like Java or C#.

But how does this work then? Let’s run the command to have a look at the „unsugared“ version.

Image for post
Image for post

Don’t spend too much time to investigate this code — we will cover that later.

Wow! That’s a lot of extra code. On first glance we can see that all the sugar disappeared — no classes anymore. But at least we recognize some of the things we wrote before.

We can still see Foo and Bar which now turned into “iffe’s”. IFFE stands for “immediately invoked function expression”. As the name indicates it represents a function that gets immediately executed 😉

But there’s a lot of extra stuff added. What’s the purpose of this method?

To understand this code let’s first take a step back and write the same functionality in plain old JavaScript. Back to the roots! ❤️

Inheritance in vanilla JavaScript

Image for post
Image for post

This code does the same as the Typescript version. Even though the code seems to be simple, there are a lot of things to understand. It is important that we get the mental concept behind it.

To visualize those concepts, we will use the same graphical representation Kyle Simpson (Kyle) used on his „You don’t know JS“ series.

By the way. If you haven’t read them yet, I highly recommend you to do so. They are great!

In his book about “this and object prototypes” Kyle represents functions with circles and object with squares. So let’s see how the JS code from above would be represented in such a graphical representation.

👀 Follow me on Twitter or medium to get notified about the newest blog posts and interesting frontend stuff!

  1. When line one executes, it’s going to create a function . Notice that it also creates an object which is the prototype of the function.
function Foo(name) {
this.name = name;
}
Image for post
Image for post

The function contains a linkage to an object. As the linkage indicates, the object acts as Foo’s prototype. But what about the property?

Don’t get confused by its name. It has nothing to do with construction. It’s just an internal linkage from the prototype back to the function.

2. Let’s go to line 5. In this line, we add the greet function to the prototype.

Foo.prototype.greet = function () {
console.log(`Hi I am ${this.name}`);
};
Image for post
Image for post

3. Line 9 then creates the function:

function Bar(name, favouriteFood) {
this.favouriteFood = favouriteFood;
Foo.call(this, name);
}
Image for post
Image for post

4. Line 14 is where things become interesting.

Bar.prototype = Object.create(Foo.prototype);

is a method that’s around since ES5. It creates a brand new object and links it to the prototype we pass in as an argument. In other words, we create a brand new object that is linked to Foo’s prototype.

We then take this Object and assign it to Bar’s prototype. This results in the following picture.

Image for post
Image for post

Notice that the linkage between and is represented by . The is just an internal linkage from one object to another object.

Probably you already heard about “Protoype Chain”? The prototype chain is the reason why instances of bar can call the greet function. It allows objects to delegate a method call to a different object. The is part of this chain.

So basically if somebody calls greet on bar it will be checked if greet exists on . If not — it follows the internal linkage until it finds a greet method or until the chain ends. If the chain ends it returns undefined.

While is an internal linkage there is also a public linkage called . This linkage was invented by Mozilla but has never been standardized. Nevertheless everybody adopted it except IE. 🤪

5. Currently, is quite friendly, it is linked to and therefore able to greet. But it is still very shy. Line 16 to 18 changes that. will now tell you what his favorite food is, which indeed is very useful ;)

Bar.prototype.talk = function () {
console.log(`${this.name}: I love ${this.favouriteFood}!`);
};
Image for post
Image for post

6. Ok. Cool. We created this whole concept but the current code does nothing. So let’s create objects and call some methods on it.

var bar1 = new Bar('bar one');
var bar2 = new Bar('bar two');
Image for post
Image for post

The picture is now complete 👨‍🎨 (actually there is still more stuff going on, but that’s beyond the scope of this post)

Click here to tweet about this article 🐥

and also get linked to . Thanks to the linkages we now have the correct prototype chain and can call and on and .

We now clearly understand what the vanilla JS code does and what the mental concept behind the code is.

Cool, but what about the Typescript code?

Yes, the goal of this blog post is to take a deep dive to Typescript inheritance. We will do so in a second. The things we have done so far were just necessary steps to better understand the next section. So now that we are ready, let’s dive! 🐠

Image for post
Image for post

Let’s start by looking closer at the lines from 15 to 36. Our Typescript classes disappeared and almost turned into our ES5 code we wrote before.

and are now wrapped inside an IIFE (Immediately-invoked function expression). The IIFE allows us to capture the base object as a variable.

If we compare it with the plain JS code we wrote, we can see that our method is gone. Instead, we now see a method which is called inside . This method is important to understand as it is responsible for the “inheritance” magic. So let’s have a closer look.

__extends

We will split method into two parts. First, we have a look at the method, and then we move on to the function that gets returned.

extendStatics

Image for post
Image for post

is a function that gets called with two parameters — and . represents the derived class () and the base class ().

First, it is checked if exists. If not then

({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; })

will be applied. If both checks return false we will apply the third function which is

function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };

All of those function achieve the same. The checks are necessary due to backward compatibility.

The last method is the one that will be used if the first two are not supported. It is also the most readable and explains best what does.

It checks if a property exists on the base class. If so, this property will be copied to the derived class. Generally spoken it copies the static members of the base class to the child class.

Ok. This was the easy part. Let’s have a look at the harder part. We can do this! 💪

Rebuild prototypical inheritance

Image for post
Image for post

This part is quite tricky and may require some reads to understand it.

We skip the first line as it is clear. We call the method described above.

On line 3 we create a named function called . We will discuss the meaning of it soon. I think the best way to understand this code is by looking at the last line first.

d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

Read this method carefully multiple times. Don’t worry if you don’t know what this method does. This line of code contains a lot of logic.

To explain this method better, I prefer to refactor this line to a more readable version. Let’s refactor!

if (b === null) {
d.prototype = Object.create(b);
} else {
__.prototype = b.prototype;
d.prototype = new __();
}

Ok. As we already know — equals and equals . By the time we enter this function is and therefore defined, which results in the execution of the else part.

To visualize things I am again going to use the notation of functions as circles and objects as squares. At the time we enter the function, and are already defined.

Image for post
Image for post

Next we the following line gets executed:

function __() { this.constructor = d }
Image for post
Image for post

This results in another function called and its prototype. We also get the already covered and linkages.

Then the first line inside the else statement of our refactored code gets called.

__.prototype = b.prototype;
Image for post
Image for post

We change the linkage of to .

Great! Almost there. Only one line left. To understand the last line one more prerequisite is required. We need to understand the effects of the new keyword on a function call.

The new keyword in JavaScript differs from the new keyword in traditional languages. In JavaScript, a constructor is just a function that gets called with a new Keyword.

Each regular function can be called with a Keyword. There are four things happening when you call a function with the Keyword.

  1. A brand new object gets created.
  2. This object gets [[Prototype]] linked.
  3. The object gets set as this binding.
  4. The object gets returned.

In the last line, we call with new

d.prototype = new __();
Image for post
Image for post

By calling new on we create a brand new object out of thin air. This object then gets linked to the prototype of the function which is . We then take this object and assign it to .

Wow, looks quite familiar to the ES5 diagram, doesn’t it? But what happened to the talk method? Shouldn’t it be on ’s prototype?

The reason it is not on is simple. It hasn’t yet been added.

Image for post
Image for post

We can see that get’s added after we executed the extends method. In the end, we then create and . The complete diagram then looks like the following:

Image for post
Image for post

As you may have noticed it is the same as the plain ES5 diagram.

Conclusion

Typescript is an excellent language and offers us a lot of benefits over Javascript. Nevertheless, I have seen way too many frontend developers that use TypeScript but have no clue about JavaScript.

Always remember that at runtime it is JavaScript that gets executed. Therefore, in my opinion, it is essential to have a solid JavaScript understanding.

🧞‍ 🙏 By the way, click on the 👏🏻 clap 👏🏻button on the left side if you enjoyed this post.

Claps help other people finding it and encourage me to write more posts 😜

Feel free to check out some of my other blogs:

HackerNoon.com

#BlackLivesMatter

Sign up for Get Better Tech Emails via HackerNoon.com

By HackerNoon.com

how hackers start their afternoons. the real shit is on hackernoon.com. Take a look

By signing up, you will create a Medium account if you don’t already have one. Review our Privacy Policy for more information about our privacy practices.

Check your inbox
Medium sent you an email at to complete your subscription.

Thanks to Tomas Trajan

Kevin Kreuzer

Written by

Passionate freelance frontend engineer. ❤️ Always eager to learn, share and expand knowledge.

HackerNoon.com

Elijah McClain, George Floyd, Eric Garner, Breonna Taylor, Ahmaud Arbery, Michael Brown, Oscar Grant, Atatiana Jefferson, Tamir Rice, Bettie Jones, Botham Jean

Kevin Kreuzer

Written by

Passionate freelance frontend engineer. ❤️ Always eager to learn, share and expand knowledge.

HackerNoon.com

Elijah McClain, George Floyd, Eric Garner, Breonna Taylor, Ahmaud Arbery, Michael Brown, Oscar Grant, Atatiana Jefferson, Tamir Rice, Bettie Jones, Botham Jean

Medium is an open platform where 170 million readers come to find insightful and dynamic thinking. Here, expert and undiscovered voices alike dive into the heart of any topic and bring new ideas to the surface. Learn more

Follow the writers, publications, and topics that matter to you, and you’ll see them on your homepage and in your inbox. Explore

If you have a story to tell, knowledge to share, or a perspective to offer — welcome home. It’s easy and free to post your thinking on any topic. Write on Medium

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store