En JavaScript, todo objeto tiene una propiedad %%'__proto__'%% que referencia el objeto al cual el objeto delega. Por defecto, el padre de cada objeto es Object:

<code>
> o = {}
> o.__proto__
Object
> Object
function Object() { [native code] }
</code>

La propiedad %%'__proto__'%% se puede setear explicitamente para especificar quien es el objeto padre:
<code>
> o.x
undefined
> o.__proto__ = { x : 10 }
> o.x
10
</code>

También se puede especificar el padre en la sintaxis literal:

<code>
> a = { x : 10 }
> b = { y : 20, __proto__ : a }
> b.x
10
</code>

Las funciones son objetos, entonces tienen una propiedad %%'__proto__'%%, la cual por defecto apunta a una función con cuerpo vacío:

<code>
> f = function (x) { return x; }
> f.__proto__
function Empty() {}
> f.__proto__()
undefined
</code>

Como una función es un objeto, también puede delegar a otro objeto:
<code>
> f.__proto__ = { x : 10 }
> f.x
10
</code>

Una función no solamente parte con %%'__proto__'%%, sino que ademas parte con una propiedad llamada 'prototype'. Esta por defecto apunta a Object. Esta propiedad se usa para setear el %%'__proto__'%% de los objetos creados via 'new' con esta función:
<code>
> f = function() {}
> f.prototype
Object
> o = new f
> o.__proto__
Object
</code>

Ojo que //reasignar// el 'prototype' de una función no afecta el %%'__proto__'%% de los objetos ya creados a partir de esa función. Pero si, //mutar// este 'prototype' afecta los objetos ya creados.
<code>
> f.prototype = { x : 10 }
> o2 = new f
> o.x
undefined
> o2.x
10
> f.prototype.y = 20
> o2.y
20
</code>