Objects
=======

JavaScript and Python have rather different object models and here we
give a broad view of the differences.  The simplest way to create a
JavaScript object **jso** is to write:

.. code-block:: javascript

   jso = {}


The closest builtin equivalent to jso in Python is the dictionary such
as **pyo**, which is created using:

.. code-block:: python
  
   pyo = {}


The two objects jso and pyo have important similarities and
differences (mostly differences).


Late news
---------

Not incorporated in this document is a recent discovery, that 

    **JavaScript objects are like Python classes with custom item
    methods (on the metaclass) that are never instantiated.**

I've put this material in a page on :doc:`javascript-objects`.


Similarities
------------

Both objects can be used to store data.  Here's a lightly edited
command line session (using the SpiderMonkey JavaScript interpreter):

.. code-block:: javascript

   js> jso = {}
   js> jso['A'] = 'apple'
   js> jso['A']
   apple


Here's the corresponding Python session (with *sys.ps1 = 'py> '*):

.. code-block:: python

   py> pyo = {}
   py> pyo['A'] = 'apple'
   py> pyo['A']
   'apple'

In the examples above *A* is the **key** and **apple** is the value.
In both cases we are able to store values against keys.  In both cases
the value can be any object.  In most other respects, jso and pyo are
different.

Differences
-----------

Keys
^^^^

In JavaScript all keys are converted to strings.

.. code-block:: javascript

   js> jso = {}
   js> jso['1'] = 'one'
   js> jso[1]
   one

Here's an even more surprising example:

.. code-block:: javascript

   js> jso = {}
   js> a = {} ; b = {};
   js> jso[a] = 'apple'
   apple
   js> jso[b]
   apple


What's going on here?  Well, objects *a* and *b* are converted to
strings, and they have the same string representation, namely *[object
Object]*.  (We'll see later how we can change this.)  So let's try
this out (continuing the previous example):

.. code-block:: javascript

   js> jso['[object Object]']
   apple

Here, for comparison, is what happens with Python:

.. code-block:: python

   py> pyo = {}
   py> pyo['1'] = 'one'
   py> pyo[1]
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   KeyError: 1
   py> a = {}; b = {}
   py> pyo[a] = 'apple'
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: unhashable type: 'dict'



Here JavaScript, faced with input of the wrong type, has converted it
to the required type, which is a string.

.. note::

   In JavaScript anything can be a key, and all keys are converted to
   strings before lookup.  In Python, keys are unchanged, and have to
   be hashable.

.. note::

   Python built-in objects throw an error when given incorrect input.
   JavaScript converts the input to something that might work.

.. _object-missing-keys:

Missing keys
^^^^^^^^^^^^
The notation *a[b]* is called **indexing**.  In Python, indexing with
a key that is not present in the dictionary raises an exception.

.. code-block:: python

   py> pyo = {}
   py> pyo['dne']
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   KeyError: 'dne'


In JavaScript, we get *undefined*, which is a special JavaScript
object (which is diferent from the *null* JavaScript object).

.. code-block:: javascript
   
   js> jso = {}
   [object Object]
   js> jso['dne']
   js> jso['dne'] === undefined
   true

(SpiderMonkey does not echo *undefined* at the command prompt, just as
Python does not echo *None*.  Therefore we use equality to show that
we truly get undefined.)

.. note::

   In JavaScript you won't get a KeyError (or IndexError).  Instead,
   you get **undefined**.

In practice, JavaScript left to itself rarely throws an error.  It
most commonly happens with code such as

.. code-block: javascript
   
   obj_a.method(args)
   obj_b.name

where respectively *obj_a.method* and *obj_name* are undefined.


Attributes
^^^^^^^^^^

In JavaScript an object has a single set of properties, which can be
accessed both by indexing and as attributes.  Here is an example:

.. code-block:: javascript

   js> jso = {}
   js> jso['a'] = 'apple'
   js> jso.a
   apple
   js> jso.b = 'banana'
   banana
   js> jso['b']
   banana

In Python a dictionary has a set of key-value pairs and in addition it
has dictionary attributes, which are methods.


.. note::

   In JavaScript the three statements below are completely equivalent
   (except for assignment to *tmp* as a side effect).

   .. code-block:: javascript

      x = a.b
      x = a['b']
      tmp = 'b'; x = a[tmp]
      
   In addition, when *a.b* is a function then
 
   .. code-block:: javascript

      x = a.b(arg1, arg2, arg3)
      tmp = 'b'; x = a[tmp](arg1, arg2, arg3)

   are equivalent.
        
   But note also that 

   .. code-block:: javascript

      x = a.b(arg1, arg2, arg3)
      tmp = a.b; x = tmp(arg1, arg2, arg3
     
   are sometimes completely different.