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.

:ref:`Recall <inheritance-tree>` 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:

.. code-block:: python

   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:

.. code-block:: javascript

   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

.. code-block:: javascript

   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:

.. code-block:: python

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

We can get something similar in JavaScript by writing:

.. code-block:: javascript

   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.

.. code-block:: javascript

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

   var Point = constructor_factory(point);