Disclaimer: I have written very little ECMAScript, I'm using this post as a place to store my notes. The odds that I have some of the details wrong is high. See http://developer.yahoo.com/yui/theater/video.php?v=crockonjs-3 (and related) videos for a nice description of different aspects of ECMAScript, and https://developer.mozilla.org/en/JavaScript/Reference and http://javascript-reference.info/ for terse language references.

Like Python, ECMAScript is an interpreted language, but in the case of ECMAScript the interpreter is typically a browser (leading to a lot of headaches associated with different implementation offering different features). ECMAScript version 5 is coming, but not supported by current browsers. One should ideally target the subset of ECMAScript that plays well with sandboxed systems (such as http://code.google.com/p/google-caja ) which promise to make it much easier to write secure code.

Objects and Inheritance

• Both languages are object-oriented and dynamically typed.
• Both have immutable strings, and numbers
• Python has primitive types that do not act like other objects (you cannot add attributes to them)

Python has user-defined types (via class definitions). ECMAScript uses prototypal inheritance, which means that each object has a "prototype" object. There are cases in which these types of inheritance can have very different behaviors, but in many contexts the languages are very similar because they both follow a cascade when looking for an attribute within an object.

In both languages you can add key/value pairs to an object (in python you cannot extend the primitive types or any user-defined class that uses the slots declaration). In Python these are referred to as attributes (and are stored in a __dict__ dictionary for the instance and class). In ECMAScript these key/value pairs are called properties, and you can think of every object as the equivalent of a python dictionary. In either language, o. x has a syntactic equivalent. In python it is getattr ( o, 'x' ) , in ECMAScript it is o [ "x" ] . Python's o. __dict__ [ 'x' ) only checks the instance-specific dictionary of attributes, and there is no (simple) equivalent of this in ECMAScript.

If you try to "read" one of these attributes, then the interpreter checks the instance's dictionary. If the attribute is not found, then the interpreter checks the next object in the cascade. In Python, this "next object in the cascade" is the class of the object (and if it is not found there it checks for the attribute in the class' superclass...). In ECMAScript the "next object in the cascade" is the prototype (and if the property is not there then the interpreter checks the prototype of the prototype...).

Python's attribute retrieval cascade for o. x is equivalent to getattr ( o, 'x' ) . The full cascade in python is better described as:

1. If the o.__class__. __getattribute__ is defined call return o. __getattribute__ ( 'x' )
2. If the 'x' in o. __dict__ return o. __dict__ [ 'x' ]
3. Try to return getattr ( o.__class__, 'x' ) , but if this raises an AttributeError and o.__class__. __getattr__ is defined, then return return o. __getattr__ ( 'x' )

(It is actually more complicated than this because you can inherit from multiple classes). Thus, __getattribute__ allows one to deal with every attribute lookup, while __getattr__ is a hook that lets you deal with lookup that fail using the "normal" procedures. Prototypal inheritance can be implemented in python (see http://solo.gardentheory.com/2010/10/crockfords-javascript-prototypal.html ).

ECMAScript objects can be created using an object literal syntax that looks very much like a python dictionary (the difference being that keys need not be quoted).

var x = {b : 4};
document.write(x.b); // writes 4
document.write(x['b']); // writes 4

In Python, you can (but generally do not) update an object's __dict__ using a similar syntax:

class A:
    pass
x = A()
x.__dict__.update({'b':4})

Syntax

if (var i = < x) {
    ...
}
else if {
    ...
}

if i <= x:
    ...

for (var i = 0; i < x; ++i) {
    ...
}

for i in xrange(x):
    ...

while (var i =< x) {
    ...
}

while i <= x:
    ...

import sys
print sys.argv

import math
math.log(x)

'''x
'''

"""x
"""

function x() {
    ...
    }

def  x():
	...
 

x = {}
x[str(i)]

function A() {
    ...

class A:
	def __init__(self):

var x = new RegExp('\s+')
var matchArray = x.exec(stringToSearchThrough);

x = /\s+/;
var matchArray = x.exec(stringToSearchThrough);

import re; 
x = re.compile(r'\s+')
m = x.search(stringToSearchThrough)
if m:
    matchList = [m.group()] + list( m.groups())
else:
    matchList = None

function (x) {
	this.i = x;
}

class A(object):
	def f(self, x):
	    self.i = x

try {
	someOp();
}
catch (e) {
    switch (e.name) {
        case 'Error':
        case 'EvalError':
        case 'RangeError':
        case 'SyntaxError':
        case 'URIError':
        case 'TypeError':
        default:
            throw e;
    }

try:
    someOp()
except ValueError as e:
    raise
except Exception:
    print "Some non ValueError Except"
finally:
    # optional code block.
    # always executed

Functions

class B:
    def f(self, i):
        return 4 + i
b = B()
b.f(1)
B.f(b, 2)
x = b.f
x(1)
y = B.f
y(b, 2)

var z = {x : 1, 
        f : function(y) {
            return this.x + y;
        }
}
z.f(2); // returns 3 because this.x is 1
var w = {x : 3};
w.y = z.f;
w.y(2); // returns 5 because this.x is 3
var a = z.f;
a(1); // returns globalobject.x + 1. Probably NaN.

ECMAScript function invocation styles

Bare functions

Method form

Constructor invocation

apply and call

Arguments

var foo = function (a, b) {
	...
}

def foo(a=None, b=None, **arguments) {
	...
}

Gotchas

ECMAScriptGotchas

• Integers can overflow at 10E15.
• Array. sort uses String ( x ) < String ( y ) as default comparison
• delete [ 0 , 1 , 2 ] [ 1 ] results in [ 0 , undefined , 2 ] . Use [ 0 , 1 , 2 ] . splice ( 1 , 1 ) ;
• Implicit ; added to the end of lines. So

  return
  	2;

  will return undefined rather than 2.
• In a bare function invocation this refers to the global object!
• In ECMAScript, String. search , String. split , and String. replace all can take a regular expression as their first argument. But only String. search automatically converts any string to a regular expression!
• constructor is a property of all objects.
• ECMAScript is not what anyone calls it

PythonGotchas

• The whitespace thing -- never mix tabs and spaces for indentation!
• Integer division is the defaut in Python 2 if both operands are integers. So 2 / 3 results in 0 while 2 / 3.0 results in 0.66666666666666667. In Python 3 conversion to float is becoming the default for all division with the / operator. In both Python 2 and 3 the // produces "floor division." If both operands are ints then the result will be an int. The remainder is discarded (in both float and int floor division).
• Grouping at tuple definition are both done with parentheses. So x = ( 3 + 1 ) sets x to 4, but x = ( 3 + 1 , 1 ) sets x to the tuple ( 4 , 1 )

Tools

• Interactive interpreter http://www.mozilla.org/rhino/download.html

Obscure notes: Property markup (not what ECMAScript programmers call it).

One rarely needs, this but it is interesting to note that a property of an ECMAScript object can be flagged as constant, or not to be included when looping over all of the properties

From a python programmer's perspective, an ECMAScript's object acts as if it defined __setattribute__ so that every the value is boxed into a richer object that describes it. Thus, ECMAScript-style attribute access in Python would (roughly) be mimicked by:

class JavaScriptProperty:
    def __init__(self, value):
        self.value = value
        self.writeable = True
        self.enumerable = True
        self.configurable = True
 
class JavaScriptObject:
    def __init__(self):
        self.__dict__['prototype'] = None
    def __getattribute__(x, name):
        v = self.__dict__.get(name)
        if v is None:
            if self.__dict__['prototype'] is None:
                raise AttributeError(name)
            return getattr(self.__dict__['prototype'], name)
        return v.value
    def __setattribute__(x, name, value):
        self.__dict__[name] = JavaScriptProperty(value)