Classes

In Python, class is a language primitive. JavaScript has no built-in concept of class. Therefore, if we are to have classes in JavaScript then we (or some library) must implement them. Here we give an outline implementation of classes in JavaScript, so that the basic language features can be understood.

Recall that each object has a parent, which in turn has a parent, all the way up to the root object (which has no parent). In Python (and other languages), classes are a way for instances to share data and methods. As a first approximation, let us say two objects belong to the same class if they have the same parent.

As well as sharing class data, each instance of a class has its own data, which is added to the instance as part of its creation. In Python, this is usually done using the __init__ method (although sometimes __new__ is also used).

Point in Python

In Python we might write:

class Point(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, dx, dy):
       '''Move point by changes dx and dy.'''
        self.x += dx
        self.y += dy

mypoint = Point(2, 3)
mypoint.move(1, 1)

Point in JavaScript

To implement a similar class in JavaScript we need a function Point that returns a point, and an object that is a parent for all the points created by the Point function. In Python we had a single object, namely the class Point, that performed both roles. In JavaScript we need a constructor function and a parent object.

Parent object

We’ll start with the parent object:

var base = {};               // Grandparent for all instances.
var point = create(base);    // Parent to all points.

point.__init__ = function(x, y){
    this.x = x;
    this.y = y;
};

point.move = function(dx, dy){
    this.x += dx;
    this.y += dy;
};

See [link] for why we use this rather than self.

Constructor

We also need a constructor function

var Point = function(x, y){

    var instance = create(point);
    instance.__init__(x, y);
    return instance;
};

In production we would use arguments and apply rather than directly calling __init__. Do you know why?

Advanced features

This can be omitted at a first reading.

Improved toString

In Python we have, for example:

py> from point import Point
py> Point(2, 3)
<point.Point object at 0x20ead90>

We can get something similar in JavaScript by writing:

point.__classname__ = 'Point';
base.toString = function(){
    return '<' + this.__classname__ + ' object>'
};

Constructor factory

Here is a factory function for producing constructor functions, such as Point above.

var constructor_factory(parent){
    return function(){
        var instance = create(parent);
        instance.__init__.apply(instance, arguments);
        return instance;
    };
};

var Point = constructor_factory(point);