What is the Prototype in JavaScript and how do they work?

What is the Prototype in JavaScript and how do they work?

In this JavaScript basics tutorial, we'll learn what is a prototype in JavaScript, and how do they work. A prototype is a very beautiful feature in JavaScript since it allows many objects to share data with each other. But, you should be careful to handle the prototype because if you change the prototype, already-created instances have to be updated manually, and it would be easy to make a side-effect.

What is a prototype in JavaScript, and how do they work? In this post, I will talk about prototype in JavaScript.

What Is a Constructor in JavaScript?

To get to know about prototypes, let’s talk about constructors first.

The Constructor function in JavaScript is a function that returns a reference to the object that created the instance object. For example, if your object is an instance of an array, its constructor function refers to the array. This constructor always points to the function itself.

let a = [];
a.constructor === Array; // true

Let’s say there’s a function named Tree. You create a new object, using Tree function:

function Tree() {
  this.name = 'Tree';
}const tree = Tree();
console.dir(tree); // undefined

In the example above, nothing has been stored in tree because Tree doesn’t return any values. In JavaScript, a constructor function is a function object that is only called when the function, Tree, is called with the new keyword.

const tree = new Tree();
console.dir(tree); 

The result of console.dir(tree)

We can see the property name is set after we called Tree with the new keyword. Then what happened when we call a function with new ?

Basically, there are two ways of creating an object by calling a function. The first method is one everybody who knows JavaScript would probably know — just call it like this below.

tree();

Once you call it like that, then the new lexical environment of the function, Tree, will be created, and the JavaScript engine will execute all of the codes inside the tree from the top to the bottom. If there’s a return statement, then tree returns that specific value(s). If there are none, then undefined is returned by default.

However, with new keyword, there are a few steps that the engine takes.

  1. Create an empty object, {} , and assign it to this.
  2. Assign all of the values to this that are expressed like this inside the function. this.name = 'Tree'
  3. return this and store it to a variable that takes the return value of new Tree() .

So, if you call a function with new , the code works like this.

function Tree() {
  this = {};
  this.name = 'Tree';
  return this;
}
How can I know whether the function is called with new?

Since ECMAScript 2015, a new feature came out; new.target. This is a dead-simple feature to let you know if the function is called with new or not. new.target returns a reference to the constructor of the function.

function Tree() {
  if (!new.target) { 
    console.log('Need new !!!');
  }
}Tree(); // Need new !!!
new Tree(); // Tree {}
I understand what constructor is, but why does it matter?

So, if we call Tree with new , then the result looks like this.

function Tree() {
  this.name = 'Tree';
  this.age = 13;
}const tree = new Tree();
// same as
const tree = {
  name: 'Tree';
  age: 13
};

But, imagine that we want to create 10 more trees. If we have to create an object with a literal object every single time, isn’t it a pain in the neck?
Simply put every variables or method in a constructor function and create a new object by calling with new . It is not only good to maintain the code, but it’s also reusable.

What is a Prototype?

Let’s talk about the prototype. A prototype is a shared property amongst all the instances of a function object. When a function is invoked with new , a new property called prototype is generated then set to this . One interesting thing is that the constructor of the function itself is a default property of the prototype object. And every object, except for the object created by Object.create(null), has its prototype object.

This is what you can see when you make a new instance of Tree. If you aren’t familiar with prototype in JavaScript, just remember this: prototype is merely an object whose property, named constructor, refers to the function that it belongs to.

function Tree(name) {
	this.name = name;
}
Tree.prototype.sayName = function() {
	console.log(this.name);
}

const tree1 = new Tree('Maple');
const tree2 = new Tree('Bamboo');

tree1.sayName(); // Maple
tree2.sayName(); // Bamboo

Although Tree doesn’t have sayName function as its property, tree1 and tree2 have sayName.

Prototype chain of Tree

This is a full picture of the prototype chains of Tree. I know, it looks so confusing. I will explain it one by one.

  1. Tree has prototype property that is for sharing properties, such as variables and functions, with all of the instances that inherit properties from Tree.
  2. As I mentioned earlier, prototype is just an object that contains constructor function inside, that we talked about earlier in this post. And constructor points to the function itself. Tree’s prototype has constructor that links to Tree function.
  3. Every object includes a certain property named [[prototype]]. It goes by __proto__ in most browsers. What [[prototype]] indicates is the prototype property of an object that the function inherits properties from. For example, look at the picture. Tree’s [[prototype]] refers to Function.prototype because Tree is an instance of Function.
  4. The highest prototype is Object.prototype. Object.prototype doesn’t refer to anything. So Object.prototype.__proto__ is null.
  5. When a variable or a method is called or referred, JavaScript looks for it by looking through all of the prototypes from the very bottom to the very top until it finds what it looks for or it reaches out null from Object.prototype. This process is called Prototype Chain.
tree1.sayName(); // Maple

tree1 doesn’t have sayName as its property.

tree1.hasOwnProperty('sayName'); // false

When sayName is called, JavaScript looks for it within the scope of tree1 , but it can’t find it. Then JavaScript looks for [[prototype]] of tree1 that connects to Tree.prototype . JavaScript can find sayName within the scope of Tree.prototype , and execute it. If there wasn’t sayName in Tree.prototype , then JavaScript, again, looks for [[prototype]] of Tree that connects to Function.prototype . JavaScript keeps doing this until it finds what it was looking for or until it reaches null.

Can I add methods in the prototype even though I already created an object with new?

Absolutely. Look at the example.

function Tree(name) {
	this.name = name;
}
Tree.prototype.sayName = function() {
	console.log(this.name);
}

const tree1 = new Tree('Maple');
const tree2 = new Tree('Bamboo');

tree1.sayName(); // Maple
tree2.sayName(); // Bamboo

// add another method later
Tree.prototype.sayBye = function() {
  console.log(`Bye bye, ${this.name}`); 
}

tree1.sayBye(); // Bye bye, Maple
tree2.sayBye(); // Bye bye, Bamboo

You can add or remove variables or functions in Tree’s prototype anytime you want. All of its instances will dynamically refer to the updated prototype when they try to access it.

Can I replace the prototype?

Sure. You can reassign it with a new prototype object.

function Tree(name) {
	this.name = name;
}
Tree.prototype.sayName = function() {
	console.log(this.name);
}

const tree1 = new Tree('Maple');
const tree2 = new Tree('Bamboo');

tree1.sayName(); // Maple
tree2.sayName(); // Bamboo

Tree.prototype = {
	sayName: function() {
		console.log(`Bye bye, ${this.name}`)
    }
}

const tree3 = new Tree('Ginkgo');

tree1.sayName(); // Maple
tree2.sayName(); // Bamboo
tree3.sayName(); // Bye bye, Ginkgo

As you can see in the result, the prototype of Tree has been changed with a different one, and I made tree3. But the fun part is tree1 and tree2 still point out the previous sayName function that prints this.name , while tree3 points out the new sayName. So this is what you should make sure of before you replace the existing prototype with a new one. Because the existing instances still refer to the original prototype, they won’t work as you expect. Furthermore, GC, Garbage Collector, will not clean the original prototype since it’s still referred by someone else, tree1 and tree2 in this case. So it isn’t considered a best practice to change the prototype.

Conclusion

A prototype is a very beautiful feature in JavaScript since it allows many objects to share data with each other. But, you should be careful to handle the prototype because if you change the prototype, already-created instances have to be updated manually, and it would be easy to make a side-effect. Next post, I will talk about inheritance in JavaScript using the prototype.

JavaScript Tutorial: if-else Statement in JavaScript

JavaScript Tutorial: if-else Statement in JavaScript

This JavaScript tutorial is a step by step guide on JavaScript If Else Statements. Learn how to use If Else in javascript and also JavaScript If Else Statements. if-else Statement in JavaScript. JavaScript's conditional statements: if; if-else; nested-if; if-else-if. These statements allow you to control the flow of your program's execution based upon conditions known only during run time.

Decision Making in programming is similar to decision making in real life. In programming also we face some situations where we want a certain block of code to be executed when some condition is fulfilled.
A programming language uses control statements to control the flow of execution of the program based on certain conditions. These are used to cause the flow of execution to advance and branch based on changes to the state of a program.

JavaScript’s conditional statements:

  • if
  • if-else
  • nested-if
  • if-else-if

These statements allow you to control the flow of your program’s execution based upon conditions known only during run time.

  • if: if statement is the most simple decision making statement. It is used to decide whether a certain statement or block of statements will be executed or not i.e if a certain condition is true then a block of statement is executed otherwise not.
    Syntax:
if(condition) 
{
   // Statements to execute if
   // condition is true
}

Here, condition after evaluation will be either true or false. if statement accepts boolean values – if the value is true then it will execute the block of statements under it.
If we do not provide the curly braces ‘{‘ and ‘}’ after if( condition ) then by default if statement will consider the immediate one statement to be inside its block. For example,

if(condition)
   statement1;
   statement2;

// Here if the condition is true, if block 
// will consider only statement1 to be inside 
// its block.

Flow chart:

Example:

<script type = "text/javaScript"> 

// JavaScript program to illustrate If statement 

var i = 10; 

if (i > 15) 
document.write("10 is less than 15"); 

// This statement will be executed 
// as if considers one statement by default 
document.write("I am Not in if"); 

< /script> 

Output:

I am Not in if
  • if-else: The if statement alone tells us that if a condition is true it will execute a block of statements and if the condition is false it won’t. But what if we want to do something else if the condition is false. Here comes the else statement. We can use the else statement with if statement to execute a block of code when the condition is false.
    Syntax:
if (condition)
{
    // Executes this block if
    // condition is true
}
else
{
    // Executes this block if
    // condition is false
}


Example:

<script type = "text/javaScript"> 

// JavaScript program to illustrate If-else statement 

var i = 10; 

if (i < 15) 
document.write("10 is less than 15"); 
else
document.write("I am Not in if"); 

< /script> 

Output:

i is smaller than 15
  • nested-if A nested if is an if statement that is the target of another if or else. Nested if statements means an if statement inside an if statement. Yes, JavaScript allows us to nest if statements within if statements. i.e, we can place an if statement inside another if statement.
    Syntax:
if (condition1) 
{
   // Executes when condition1 is true
   if (condition2) 
   {
      // Executes when condition2 is true
   }
}

Example:

<script type = "text/javaScript"> 

// JavaScript program to illustrate nested-if statement 

var i = 10; 

if (i == 10) { 

// First if statement 
if (i < 15) 
	document.write("i is smaller than 15"); 

// Nested - if statement 
// Will only be executed if statement above 
// it is true 
if (i < 12) 
	document.write("i is smaller than 12 too"); 
else
	document.write("i is greater than 15"); 
} 
< /script> 

Output:

i is smaller than 15
i is smaller than 12 too
  • if-else-if ladder Here, a user can decide among multiple options.The if statements are executed from the top down. As soon as one of the conditions controlling the if is true, the statement associated with that if is executed, and the rest of the ladder is bypassed. If none of the conditions is true, then the final else statement will be executed.
if (condition)
    statement;
else if (condition)
    statement;
.
.
else
    statement;


Example:

<script type = "text/javaScript"> 
// JavaScript program to illustrate nested-if statement 

var i = 20; 

if (i == 10) 
document.wrte("i is 10"); 
else if (i == 15) 
document.wrte("i is 15"); 
else if (i == 20) 
document.wrte("i is 20"); 
else
document.wrte("i is not present"); 
< /script> 

Output:

i is 20

Building a Powerful Virtual Machine in JavaScript

Building a Powerful Virtual Machine in JavaScript

This JavaScript tutorial explains how to build a powerful Virtual Machine in JavaScript. A flexible, extensible, register-based virtual machine. Support for signed, unsigned and floating point operations. A call stack. Interrupt capabilities. Ability to do memory mapping for IO. An assembly language with macro and module support. A higher level, C like language. We'll use and expand the library from the parser combinators from scratch series. And finally, to be able to take the whole thing into the browser and exend it to create a sort of fantasy console - an emulator for a machine that never existed

16-Bit Virtual Machine in JavaScript 001

In this episode we begin implementing a 16-bit virtual machine from scratch in JavaScript. The concepts of computation are introduced, along with the basics of assembly language and machine code.

Memory Access and Branching (16-Bit VM in JavaScript 002)

In this video we establish the core instruction set of the VM, give the VM the capabilities to read and write to main memory, and also to make decisions about how the program should proceed with branching instructions.

What is the Stack and why do we need it? (16-Bit VM in JavaScript 003)

In this episode we understand what a stack is, how it can be implemented on the lowest level, and how it can then be harnessed to allow the Virtual Machine to run subroutines without losing state.

Implementing Stack Mechanics (16-Bit VM in JavaScript 004)

In this episode, we create an implementation for the stack mechanisms that were described in the last episode.

What is Memory Mapped I/O? (16-Bit VM in JavaScript 005)

This this episode we implement memory mapped I/O, where the address space is utilised as common bus for components to communicate.

Understanding JavaScript Decorators

Understanding JavaScript Decorators

Decorators are actually nothing more than functions that return another function, and that are called with the appropriate details of the item being decorated. Using decorators in your projects today requires some transpiler configuration. What is a Decorator? JavaScript Decorators and Property Descriptors. How to Write a Decorator. Handling API Errors. Decorating Classes. A Babel Workaround

Decorators aren’t a core feature of JavaScript yet; they’re working their way through ECMA TC39’s standardization process. That doesn’t mean we can’t get familiar with them, though. It looks like they’ll be supported natively by Node and browsers at some point in the near future, and in the meantime we’ve got Babel.

What is a Decorator?

Decorator is shorthand for “decorator function” (or method). It’s a function that modifies the behavior of the function or method passed to it by returning a new function. I said “function” a lot there. That’s an occupational hazard when you’re discussing higher-order functions.

You can implement decorators in any language that supports functions as first-class citizens, e.g. JavaScript, where you can bind a function to a variable or pass it as an argument to another function. A couple of those languages have special syntactic sugar for defining and using decorators; one of them is Python:


def cashify(fn):
    def wrap():
        print("$$$$")
        fn()
        print("$$$$")
    return wrap

@cashify
def sayHello():
    print("hello!")

sayHello()

# $$$$
# hello!
# $$$$

Let’s take a look at what’s going on there. Our cashify function is a decorator: it receives a function as an argument, and its return value is also a function. We use Python’s “pie” syntax to apply the decorator to our sayHello function, which is essentially the same thing as if we’d done this below the definition of sayHello:


def sayHello():
    print("hello!")

sayHello = cashify(sayHello)

The end result is that we print dollar signs before and after whatever we’re printing from the function we decorate.

Why am I introducing ECMAScript decorators using an example in Python? I’m glad you asked!

  • Python is a great way to explain the basics because its concept of decorators is a bit more straightforward than the way they work in JS.
  • JS and TypeScript both use Python’s “pie syntax” to apply decorators to methods and properties of classes, so it’s visually and syntactically similar.

Okay, what’s different about JS decorators?

JS Decorators and Property Descriptors

While Python decorators are passed whatever function they’re decorating as an argument, JS decorators receive quite a bit more information due to the way objects work in that language.

Objects in JS have properties, and those properties have values:


const oatmeal = {
  viscosity: 20,
  flavor: 'Brown Sugar Cinnamon',
};

But in addition to its value, each property has a bunch of other behind-the-scenes information that defines different aspects of how it works, called a property descriptor:


console.log(Object.getOwnPropertyDescriptor(oatmeal, 'viscosity'));

/*
{
  configurable: true,
  enumerable: true,
  value: 20,
  writable: true
}
*/

JS is tracking quite a few things related to that property:

  • configurable determines whether or not the type of the property can be changed, and whether it can be deleted from the object.
  • enumerable controls whether the property shows up when you enumerate the object’s properties (like when you call Object.keys(oatmeal) or use it in a for loop).
  • writable controls whether or not you can change the property’s value via the assignment operator =.
  • value is the static value of the property that you see when you access it. It’s usually the only part of the property descriptor that you see or are concerned with. It can be any JS value, including a function, which would make the property a method of the object it belongs to.

Property descriptors can also have two other properties that cause JS to treat them as “accessor descriptors” (more commonly known as getters and setters):

  • get is a function that returns the property’s value instead of using the static value property.
  • set is a special function that gets passed whatever you put on the right side of the equals sign as an argument when you assign a value to the property.

Decorating Without the Frills

JS has actually had an API for working with property descriptors since ES5, in the form of the Object.getOwnPropertyDescriptor and Object.defineProperty functions. For example, If I like the thickness of my oatmeal just the way it is, I can make it read-only using that API like so:


Object.defineProperty(oatmeal, 'viscosity', {
  writable: false,
  value: 20,
});

// When I try to set oatmeal.viscosity to a different value, it'll just silently fail.
oatmeal.viscosity = 30;
console.log(oatmeal.viscosity);
// => 20

I can even write a generic decorate function that lets me mess with the descriptor for any property of any object:


function decorate(obj, property, callback) {
  var descriptor = Object.getOwnPropertyDescriptor(obj, property);
  Object.defineProperty(obj, property, callback(descriptor));
}

decorate(oatmeal, 'viscosity', function(desc) {
  desc.configurable = false;
  desc.writable = false;
  desc.value = 20;
  return desc;
});

Adding the Shiplap and Crown Molding

The first major difference with the Decorators proposal is that it only concerns itself with ECMAScript classes, not regular objects. We’re going to need to over-engineer our breakfast in order to really demonstrate what we can accomplish, so let’s make some classes to represent our bowl of porridge:


class Porridge {
  constructor(viscosity = 10) {
    this.viscosity = viscosity;
  }

  stir() {
    if (this.viscosity > 15) {
      console.log('This is pretty thick stuff.');
    } else {
      console.log('Spoon goes round and round.');
    }
  }
}

class Oatmeal extends Porridge {
  viscosity = 20;

  constructor(flavor) {
    super();
    this.flavor = flavor;
  }
}

We’re representing our bowl of oatmeal using a class that inherits from the more generic Porridge class. Oatmeal sets the default viscosity higher than Porridge‘s default, and it adds a new flavor property. We’re also using another ECMAScript proposal, class fields, to override the viscosity value.

We can re-create our original bowl of oatmeal like so:


const oatmeal = new Oatmeal('Brown Sugar Cinnamon');

/*
Oatmeal {
  flavor: 'Brown Sugar Cinnamon',
  viscosity: 20
}
*/

Great, we’ve got our ES6 oatmeal, and we’re ready to write a decorator!

How to Write a Decorator

JS decorator functions are passed three arguments:

  1. target is the class that our object is an instance of.
  2. key is the property name, as a string, that we’re applying the decorator to.
  3. descriptor is that property’s descriptor object.

What we do inside of the decorator function depends on the purpose of our decorator. In order to decorate a method or property of an object, we need to return a new property descriptor. Here’s how we can write a decorator that makes a property read-only:


function readOnly(target, key, descriptor) {
  return {
    ...descriptor,
    writable: false,
  };
}

We’d use it by modifying our Oatmeal class like this:


class Oatmeal extends Porridge {
  @readOnly viscosity = 20;
  // (you can also put @readOnly on the line above the property)

  constructor(flavor) {
    super();
    this.flavor = flavor;
  }
}

Now our oatmeal’s glue-like consistency is immune to tampering. Thank goodness.

What if we want to do something that’s actually useful? I ran into a situation while working on a recent project where a decorator saved me a lot of typing and maintenance overhead:

Handling API Errors

In the MobX/React app I mentioned in the beginning, I have a couple of different classes that act as data stores. They each represent collections of different things that the user interacts with, and they each talk to different API endpoints for data from the server. In order to handle API errors, I made each of the stores follow a protocol when communicating over the network:

  1. Set the UI store’s networkStatus property to “loading.”
  2. Send a request to the API
  3. Handle the result
    • If successful, update local state with the response
    • If something goes wrong, set the UI store’s apiError property to the error we received
  4. Set the UI store’s networkStatus property to “idle.”

I found myself repeating this pattern a few times before I noticed the smell:


class WidgetStore {
  async getWidget(id) {
    this.setNetworkStatus('loading');

    try {
      const { widget } = await api.getWidget(id);
      // Do something with the response to update local state:
      this.addWidget(widget);
    } catch (err) {
      this.setApiError(err);
    } finally {
      this.setNetworkStatus('idle');
    }
  }
}

That’s a lot of error handling boilerplate. I decided that since I was already using MobX’s @action decorators on all the methods that updated observable properties (not shown here for the sake of simplicity), I might as well just tack on an additional decorator that allowed me to recycle my error handling code. I came up with this:


function apiRequest(target, key, descriptor) {
  const apiAction = async function(...args) {
    // More about this line shortly:
    const original = descriptor.value || descriptor.initializer.call(this);

    this.setNetworkStatus('loading');

    try {
      const result = await original(...args);
      return result;
    } catch (e) {
      this.setApiError(e);
    } finally {
      this.setNetworkStatus('idle');
    }
  };

  return {
    ...descriptor,
    value: apiAction,
    initializer: undefined,
  };
}

I could then replace the boilerplate that I was writing in each API action method with something like this:


class WidgetStore {
  @apiRequest
  async getWidget(id) {
    const { widget } = await api.getWidget(id);
    this.addWidget(widget);
    return widget;
  }
}

My error handling code is still there, but now I only need to write it once and ensure that each class that uses it has a setNetworkStatus and setApiError method.

A Babel Workaround

So what’s up with that line where I’m choosing between descriptor.value and calling descriptor.initializer? That’s a Babel thing. My hunch is that it won’t work that way when JS supports decorators natively, but it’s necessary right now because of how Babel handles arrow functions defined as class properties.

When you define a class property and assign an arrow function as its value, Babel does a little trick to bind that function to the correct instance of the class and give you the right this value. It does this by setting descriptor.initializer to a function that returns the function you wrote, with the correct this value in its scope.

An example should make things less muddy:


class Example {
  @myDecorator
  someMethod() {
    // In this case, our method would be referred to by descriptor.value
  }

  @myDecorator
  boundMethod = () => {
    // Here, descriptor.initializer would be a function that, when called, would return our `boundMethod` function, properly scoped so that `this` refers to the current instance of Example.
  };
}

Decorating Classes

In addition to properties and methods, you can also decorate an entire class. In order to do that, you really only need the first argument passed to your decorator function, target. For example, I can write a decorator that automatically registers the class it’s wrapping as a custom HTML element. I’m using a closure here to enable the decorator to receive whatever name we want to give the element as an argument:


function customElement(name) {
  return function(target) {
    customElements.define(name, target);
  };
}

We’d use it like this:


@customElement('intro-message');
class IntroMessage extends HTMLElement {
  constructor() {
    super();

    const shadow = this.attachShadow({ mode: 'open' });
    this.wrapper = this.createElement('div', 'intro-message');
    this.header = this.createElement('h1', 'intro-message__title');
    this.content = this.createElement('div', 'intro-message__text');
    this.header.textContent = this.getAttribute('header');
    this.content.innerHTML = this.innerHTML;

    shadow.appendChild(this.wrapper);
    this.wrapper.appendChild(this.header);
    this.wrapper.appendChild(this.content);
  }

  createElement(tag, className) {
    const elem = document.createElement(tag);
    elem.classList.add(className);
    return elem;
  }
}

Load that into our HTML, and we can use it like this:


<intro-message header="Welcome to Decorators">
  <p>Something something content...</p>
</intro-message>

Which gives us this in the browser:

Wrapping Up

Using decorators in your projects today requires some transpiler configuration. The most straightforward guide that I’ve seen is located in the MobX docs. It has info for TypeScript and two major versions of Babel.

Keep in mind that decorators are an evolving proposal at this point, so if you use them in production code now, you’ll probably either need to make some updates or keep using Babel’s decorators plugin in legacy mode once they become an official part of the ECMAScript specification. While it’s not even well-supported by Babel yet, the latest version of the decorators proposal already contains big changes that are not backward compatible with the previous version.

Decorators, like many bleeding edge JS features, are a useful tool to have in your kit. They can greatly simplify the sharing of behavior across different, unrelated classes. However, there’s always a cost associated with early adoption. Use decorators, but do so with a clear idea of the implications for your codebase.