Javascript class

Using javascript class will really improve your code readability, structure and making it shareable with others. ( see my other post: Coding standards: Meaningful Names in Javascript).

For many back end developers, this post would have probably been written over 10 years ago, as classes have always been present in many programming language ( c++, c# and java, etc..). Classes in javascript on the other hand, have just recently been introduced in the ECMAScript 6 release of 2015 and have not yet hit developers keyboards.

This post is aimed aimed to give an introduction to classes and it does not go in many details.

ECMAScrips for Javascript and its advantages

JavaScript does not have the best reputation amongst coding languages, but finally after the long waited version of the ECMAScript standard and good browser support, there is some light at the end of the tunnel, and it is time to deep into the enormous amount of changes that made into the standards.

In recent years, JavaScript developers have been busy creating a multitude of “hacks” and libraries to help us fulfil lack of features that made it hard produce a clean and structured code.

In June 2015 the ECMAScript standards 6 have finally provided a multitude of improvement to one of the most used language in the world, followed by a much smaller release (ECMAScript 7 in June 2016).

ECMAScript 6, took over 4 years to reach our desks, but it didn’t fail to impress and with current browsers finally introducing support for most of the changes, developers are now ready to get their hands dirty and help to improve JavaScript reputation.

Browser Support

Browser support has recently made a fantastic improvement, giving us all a chance to start and implement the great majority of the ECMAScript standards, without worry.

At the time of this post being published (June/2107) the support on desktop is almost complete ( click for full support table):
[progress_bar text=”Edge” percent=”96″]
[progress_bar text=”FireFox” percent=”97″]
[progress_bar text=”Chrome” percent=”97″]
[progress_bar text=”Safari” percent=”99″]
[progress_bar text=”IE11″ percent=”11″]

As shown by the table above, the support on desktop browser is quite complete, except the odd IE11 with an unacceptable level of support below 15%.

For mobile the situation is quite similar:
[progress_bar text=”Android” percent=”25″]
[progress_bar text=”iOS” percent=”99″]
[progress_bar text=”Chrome” percent=”99″]

Almost full support for the most common browser except on android where just a quarter of features are supported.

Classes Before ECMAScript 6

Even if Javascript class have not been precisely available, developers across the countries have implemented them by using functions, scope, prototype and many other method. This has lead to a multitude of different approaches being adopted by programmers, making the dream of having a possible “standards” a myth.

In this post we will start from an existing small “class” written before the ECMAScript 6, and then implement the newly introduced “classes features” to show the power and structure that they provide to your code.

The code below is an algebra helper for rectangles.

 var rectangle = function(width, height){
    var self= {};
    self.width = width,
    self.height = height;
    
    var calculateArea = function(){
        var area = 0;
        area = (self.width * self.height);
        return area;
    }

    var calculatePerimeter = function(){
        var perimeter = 0;
        perimeter = (self.width + self.height) * 2;
        return perimeter;
    }

    var getHeight = function(){
        return self.height;
    }

    var setHeight = function(height){
        self.width = height ;
    }
  
  return {
    calculatePerimeter: calculatePerimeter,
    calculateArea: calculateArea,
    getHeight: getHeight,
    setHeight: setHeight
  }
};

Classes in ECMAScript 6

In this section we are going to update the above code to use the javascript class feature.

Class

The first thing that we will have to do is create a base class called rectangle.

 class rectangle{
    
}

Contructor

Then we will create a constructor. In the previous version of Javscript to emulate the constructor we would have had to create an init function or a self calling function within the method. ( none of this example is shown above as this cover the basic to assign some values).

  constructor(width, height){
 this._width = width;
 this._height = height;
 }

Getter and Setter

Our class is starting to take share, we will now implement the GET and SET methods

    get height(){
        return this._height;
    }

    set height(height){
        this._height = height;
    }

This methods have been introduced in the ECMAScript 2015. They are commonly used across different programming language and do not require a function call to be initialised. An example usage of the above would be:

var r = new rectangle(10, 5);

r.getHeight;// Output 5
r.setHeight = 10
r.getHeight;//Will output 10

Methods declaration

Class methods have not changed and the declaration is very similar to the one showed in the initial javascript example. The main difference to note is that every method declared within a function will actually be set to PUBLIC. There are rumours of the implementation of public variables and methods for the next ECMA release ( Javascript new private class field). There are currently 4 different “solution” to make standards private methods, and they are all out of the scope of this post.

Method declared within a class will not require the “function” word, and do not require to be returned or specifically made available as they will be available as part of the object immediately after initialisation. Our example will be:

 
    calculateArea(){
        var area = 0;
        area = (this._width * this._height);
        return area;
    }

    calculatePerimeter(){
        var perimeter = 0;
        perimeter = (this._width + this._height) * 2;
        return perimeter;
    }

Conclusion

This post is aimed at sparkling some curiosity, and give just a small definition of javascript class. The final result is:

 class rectangle{

    constructor(width, height){
        this._width = width;
        this._height = height;
    }

    get getHeight(){
        return this._height;
    }

    set setHeight(height){
        this._height = height;
    }

    calculateArea(){
        var area = 0;
        area = (this._width * this._height);
        return area;
    }

    calculatePerimeter(){
        var perimeter = 0;
        perimeter = (this._width + this._height) * 2;
        return perimeter;
    }
}

var r = new rectangle(10, 5);

r.getHeight;// Output 5
r.setHeight = 10
r.getHeight;//Will output 10

Classes are maybe still not fully ready for big production environment ( mainly because of the absence of a private field), but we should start to use them to get confident in using them when time comes. There are still some amazing features like inheritance ( that has not been covered in this post) that make class worth using.

I personally like the use of class because they force to structure the code differently. They put a big distinction between normal functions and big chunk of work and are perfect to get around Object orientated programming.

I will keep posting my finding on the ECMAscript 6 and future release as for my opinion this is the real future of javascript.