Detalles del modelo de objetos

Los lenguajes orientados a objetos basados en clases, como Java y C++, se basan en el concepto de dos entidades distintas: clases e instancias.

• Una clase define todas las propiedades (considerando como propiedades los métodos y campos de Java, o los miembros de C++) que caracterizan un determinado conjunto de objetos. Una clase es una entidad abstracta, más que cualquier miembro en particular del conjunto de objetos que describe. Por ejemplo, la clase Empleado puede representar al conjunto de todos los empleados.
• Una instancia, por otro lado, es la instanciación de una clase; es decir, uno de sus miembros. Por ejemplo, Victoria podría ser una instancia de la clase Empleado, representando a un individuo en particular como un empleado. Una instancia tiene exactamente las mismas propiedades de su clase padre (ni más, ni menos).

Un lenguaje basado en prototipos, como JavaScript, no hace esta distinción: simplemente tiene objetos. Un lenguaje basado en prototipos toma el concepto de objeto prototípico, un objeto que se utiliza como una plantilla a partir de la cual se obtiene el conjunto inicial de propiedades de un nuevo objeto. Cualquier objeto puede especificar sus propias propiedades, ya sea cuando es creado o en tiempo de ejecución. Adicionalmente, cualquier objeto puede ser utilizado como el prototipo de otro objeto, permitiendo al segundo objeto compartir las propiedades del primero.

En los lenguajes basados en clases defines una clase en una definición de clase separada. En esa definición puedes especificar métodos especiales, llamados constructores, para crear instancias de la clase. Un método constructor puede especificar valores iniciales para las propiedades de la instancia y realizar otro procesamiento de inicialización apropiado en el momento de la creación. Se utiliza el operador new junto al constructor para crear instancias de clases.

JavaScript sigue un modelo similar, pero sin tener la definición de clase separada del constructor. En su lugar, se define una función constructor para crear objetos con un conjunto inicial de propiedades y valores. Cualquier función JavaScript puede utilizarse como constructor. Se utiliza el operador new con una función constructor para crear un nuevo objeto.

En un lenguaje basado en clases, creas una jerarquía de clases a través de la definición de clases. En una definición de clase, puedes especificar que la nueva clase es una subclase de una clase existente. Esta subclase hereda todas las propiedades de la superclase y - además -puede añadir nuevas propiedades o modificar las heredadas. Por ejemplo, supongamos que la clase Employee tiene sólo las propiedades name y dept, y que Manager es una subclase de Employee que añade la propiedad reports. En este caso, una instancia de la clase Manager tendría las tres propiedades: name, dept, y reports.

JavaScript implementa la herencia permitiendo asociar un objeto prototípico con cualquier función constructor. De esta forma puedes crear una relación entre Employee y Manager, pero usando una terminología diferente. En primer lugar, se define la función constructor para Employee, especificando las propiedades name y dept. Luego, se define la función constructor para Manager, especificando la propiedad reports. Por último, se asigna un nuevo objeto derivado de Employee.prototype como el prototype para la función constructor de Manager. De esta forma, cuando se crea un nuevo Manager, este hereda las propiedades name y dept del objeto Employee.

En lenguajes basados en clases típicamente se crea una clase en tiempo de compilación y luego se crean instancias de la clase, ya sea en tiempo de compilación o en tiempo de ejecución. No se puede cambiar el número o el tipo de propiedades de una clase una vez que ha sido definida. En JavaScript, sin embargo, en tiempo de ejecución se pueden añadir y quitar propiedades a un objeto. Si se añade una propiedad a un objeto que está siendo utilizado como el prototipo de otros objetos, los objetos para los que es un prototipo también tienen la nueva propiedad añadida.

La siguiente tabla muestra un pequeño resumen de algunas de estas diferencias. El resto de este capítulo describe los detalles del uso de los constructores JavaScript y los prototipos para crear una jerarquía de objetos, y compara esta forma de herencia no basada en clases con la basada en clases que utiliza Java.

El resto de este capitulo utiliza la jerarquía employee que se muestra en la siguiente figura.

Figura 8.1: Una jerarquía de objetos sencilla

Este ejemplo utiliza los siguientes objetos:

• Employee tiene las propiedades name (cuyo valor por defecto es un string vacío) y dept (cuyo valor por defecto es "general").
• Manager está basado en Employee. Añade la propiedad reports (cuyo valor por defecto es un array vacío, en la que se pretende almacenar un array de objetos Employee como su valor).
• WorkerBee también está basado en Employee. Añade la propiedad projects (cuyo valor por defecto es un array vacío en el que se pretende almacenar un array de strings como su valor).
• SalesPerson está basado en WorkerBee. Añade la propiedad quota (cuyo valor por defecto es 100). También reemplaza la propiedad dept con el valor "sales", indicando que todas las salespersons están en el mismo departamento.
• Engineer se basa en WorkerBee. Añade la propiedad machine (cuyo valor por defecto es un string vacío) y también reemplaza la propiedad dept con el valor "engineering".

Hay varias formas de definir funciones constructor para implementar la jerarquía Employee. Elegir una u otra forma depende sobre todo de lo que quieras y puedas ser capaz de hacer con tu aplicación.

Esta sección muestra como utilizar definiciones muy sencillas (y comparativamente inflexibles) para mostrar como hacer funcionar la herencia. En estas definiciones no puedes especificar valores de propiedades cuando creas un objeto. El nuevo objeto que se crea simplemente obtiene valores por defecto, que puedes cambiar posteriormente. La figura 8.2 muestra la jerarquía con estas definiciones sencillas.

En una aplicación real probablemente definirías constructores que proporcionen valores a las propiedades en el momento de la creación del objeto (para más información ver Constructores más flexibles). Por ahora, estas definiciones sencillas nos sirven para mostrar como funciona la herencia.

Figura 8.2: Definiciones de los objetos de la jerarquía Employee

Las siguientes definiciones de Employee en Java y en Javascript son similares, la única diferencia es que en Java necesitas especificar el tipo para cada propiedad, no así en Javascript (esto es debido a que Java es un lenguaje fuertemente tipado, mientras que Javascript es un lenguaje débilmente tipado).

JavaScript

function Employee () {
  this.name = "";
  this.dept = "general";
}

Java

public class Employee {
   public String name;
   public String dept;
   public Employee () {
      this.name = "";
      this.dept = "general";
   }

Las definiciones de Manager y WorkerBee ilustran la diferencia a la hora de especificar el siguiente objeto en la jerarquía de herencia. En JavaScript se añade una instancia prototípica como el valor de la propiedad prototype de la función constructora, así sobre escribe prototype.constructor con la función constructora. Puede hacerse en cualquier momento una vez definido el constructor. En Java se especifica la superclase en la definición de la clase. No se puede cambiar la superclase fuera de la definición de la clase.

JavaScript

function Manager () {
  this.reports = [];
}
Manager.prototype = new Employee;

function WorkerBee () {
  this.projects = [];
}
WorkerBee.prototype = new Employee;

Java

public class Manager extends Employee {
   public Employee[] reports;
   public Manager () {
      this.reports = new Employee[0];
   }
}

public class WorkerBee extends Employee {
   public String[] projects;
   public WorkerBee () {
      this.projects = new String[0];
   }

Las definiciones de Engineer y SalesPerson crean objetos que descienden de WorkerBee y por tanto de Employee. Un objeto de éste tipo tiene todas las propiedades de los objetos por encima de él en la cadena. Además, estas definiciones reemplazan los valores heredados de la propiedad dept con nuevos valores específicos para estos objetos.

JavaScript

function SalesPerson () {
   this.dept = "sales";
   this.quota = 100;
}
SalesPerson.prototype = new WorkerBee;

function Engineer () {
   this.dept = "engineering";
   this.machine = "";
}
Engineer.prototype = new WorkerBee;

Java

public class SalesPerson extends WorkerBee {
   public double quota;
   public SalesPerson () {
      this.dept = "sales";
      this.quota = 100.0;
   }
}

public class Engineer extends WorkerBee {
   public String machine;
   public Engineer () {
      this.dept = "engineering";
      this.machine = "";
   }
}

Usando estas definiciones puedes crear instancias de estos objetos, que adquieren valores por defecto para sus propiedades. La figura 8.3 revela el uso de estas definiciones JavaScript para crear nuevos objetos y muestra los valores de las propiedades de estos nuevos objetos.

La jerarquía de objetos que se muestra en la figura se corresponde con el código escrito en el lado derecho.

Figura 8.3: Creación de objetos mediante definiciones simples

Objetos individuales = Jim, Sally, Mark, Fred, Jane, etc. "Instancias" creadas con constructor

Esta sección describe cómo heredan los objetos sus propiedades de otros objetos en la cadena de prototipos y qué ocurre cuando se añade una propiedad en tiempo de ejecución.

Supongamos que creas el objeto mark como un WorkerBee (como se muestra en la Figura 8.3) con la siguiente sentencia:

var mark = new WorkerBee;

Cuando el intérprete de JavaScript encuentra el operador new, crea un nuevo objeto genérico y establece implícitamente el valor de la propiedad interna [[Prototype]] con el valor de WorkerBee.prototype y pasa este nuevo objeto como this a la función constructora de WorkerBee. La propiedad interna [[Prototype]] (que puede observarse como __proto__, la propiedad cuyo nombe tiene dos guiones al principio y al final) determina la cadena de prototipo usada para devolver los valores de la propiedades cuando se accede a ellas. Una vez que estas propiedades tienen sus valores, JavaScript devuelve el nuevo objeto y la sentencia de asignación asigna el nuevo objeto ya inicializado a la variable mark.

Este proceso no asigna explícitamente valores al objeto mark (valores locales) para las propiedades que mark hereda de la cadena de prototipos. Cuando solicitas valor de una propiedad, JavaScript primero comprueba si existe un valor para esa propiedad en el objeto. Si existe, se devuelve ese valor; sino, JavaScript comprueba la cadena de prototipos (usando la propiedad __proto__). Si un objeto en la cadena de prototipos tiene un valor para esa propiedad, se devuelve ese valor. Si no existe en ningún objeto de la cadena de prototipos un valor para esa propiedad, JavaScript dice que el objeto no tiene esa propiedad. En el caso de nuestro objeto mark, éste tiene las siguientes propiedades y valores:

mark.name = "";
mark.dept = "general";
mark.projects = [];

El objeto mark hereda valores para las propiedades name y dept su objeto prototipico que enlaza en mark.__proto__. Se le asigna un valor local la propiedad projects a través del constructor WorkerBee. De esta forma se heredan propiedades y sus valores en JavaScript. En la sección Property inheritance revisited se discuten algunos detalles de este proceso.

Debido a que estos constructores no permiten especificar valores específicos de instancia, esta información es genérica. Los valores de las propiedades son los valores por omisión, compartidos por todos los objetos nuevos creados a partir de WorkerBee. Por supuesto se pueden cambiar después los valores de estas propiedades. Por ejemplo podríamos dar valores con información específica a mark de la siguiente forma:

mark.name = "Doe, Mark";
mark.dept = "admin";
mark.projects = ["navigator"];

En JavaScript puedes añadir propiedades a los objetos en tiempo de ejecución. No estás limitado a utilizar solo las propiedades que proporciona la función constructora. Para añadir una propiedad que es especifica para un objeto determinado, se le asigna un valor a la propiedad del objeto de la siguiente forma:

mark.bonus = 3000;

Ahora el objeto mark tiene una propiedad bonus, pero ningún otro objeto creado con la función constructor WorkerBee tiene esta propiedad.

Si añades una nueva propiedad a un objeto que se esta utilizando como el prototipo de una función constructor, dicha propiedad se añade a todos los objetos que heredan propiedades de dicho prototipo. Por ejemplo, puedes añadir una propiedad specialty a todos los empleados con la siguientes sentencia:

Employee.prototype.specialty = "none";

Tan pronto JavaScript ejecuta esta sentencia, el objeto mark también tienen la propiedad specialty con el valor "none". La siguiente figura muestra el efecto de añadir esta propiedad al prototipo Employee y después reemplazarlo por el prototipo Engineer.

Figura 8.4: Añadir propiedades

Las funciones constructor que se han mostrado hasta ahora no permiten especificar valores a las propiedades cuando se crea una instancia. Al igual que en Java, se pueden proporcionar argumentos a los constructores para inicializar los valores de las propiedades de las instancias. La siguiente figura muestra una forma de hacerlo.

Figura 8.5: Especificación de propiedades en un construcción, toma 1

La siguiente tabla muestra las definiciones Java y JavaScript para estos objetos.

JavaScript

function Employee (name, dept) {
  this.name = name || "";
  this.dept = dept || "general";
}

Java

public class Employee {
   public String name;
   public String dept;
   public Employee () {
      this("", "general");
   }
   public Employee (String name) {
      this(name, "general");
   }
   public Employee (String name, String dept) {
      this.name = name;
      this.dept = dept;
   }
}

JavaScript

function WorkerBee (projs) {
  this.projects = projs || [];
}
WorkerBee.prototype = new Employee;

Java

public class WorkerBee extends Employee {
   public String[] projects;
   public WorkerBee () {
      this(new String[0]);
   }
   public WorkerBee (String[] projs) {
      projects = projs;
   }
}

JavaScript

function Engineer (mach) {
   this.dept = "engineering";
   this.machine = mach || "";
}
Engineer.prototype = new WorkerBee;

Java

public class Engineer extends WorkerBee {
   public String machine;
   public Engineer () {
      dept = "engineering";
      machine = "";
   }
   public Engineer (String mach) {
      dept = "engineering";
      machine = mach;
   }
}

Estas definiciones JavaScript realizan un uso idiomático especial para asignar valores por defecto:

this.name = name || "";

El operador lógico OR de JavaScript (||) evalúa su primer argumento. Si dicho argumento se convierte a true, el operador lo devuelve. Si no, el operador devuelve el valor del segundo argumento. Por tanto, esta linea de código comprueba si name tiene un valor útil para la propiedad name, en cuyo caso asigna a this.name este valor. En caso contrario asigna a this.name el string vacío. Este capitulo emplea este uso idiomático por abreviación. Sin embargo puede resultar chocante a primera vista.

Con estas definiciones, cuando creas una instancia de un objeto, puedes especificar valores para las propiedades definidas localmente. Tal como se muestra en Figura 8.5, puedes utilizar la siguiente sentencia para crear un nuevo Engineer:

var jane = new Engineer("belau");

Ahora las propiedades de jane son:

jane.name == "";
jane.dept == "engineering";
jane.projects == [];
jane.machine == "belau"

Nota que con estas definiciones no puedes dar un valor inicial a las propiedades heredadas como name. Si quieres especificar un valor inicial para las propiedades heredadas en JavaScript tienes que que añadir más código a la función constructora.

Hasta ahora, la función constructora ha creado un objeto genérico y ha especificado propiedades y valores locales para el nuevo objeto. Puedes hacer que el constructor añada más propiedades llamando directamente a la función constructor de un objeto que esté más arriba en la cadena de prototipos. La siguiente figura muestra estas definiciones.

Figura 8.6 Especificación de propiedades en un constructor, toma 2

Veamos los detalles de una de estas definiciones. Aquí tenemos la nueva definición del constructor Engineer:

function Engineer (name, projs, mach) {
  this.base = WorkerBee;
  this.base(name, "engineering", projs);
  this.machine = mach || "";
}

Supongamos que se crea un nuevo Engineer de esta forma:

var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");

JavaScript sigue los siguientes pasos:

1. El operador new crea un nuevo objeto genérico y le asigna su propiedad __proto__ a Engineer.prototype.
2. El operador new pasa el nuevo objeto al constructor Engineer como el valor de la palabra reservada this.
3. El constructor crea una nueva propiedad llamada base para ese objeto y le asigna el valor del constructor WorkerBee. Esto hace que el constructor WorkerBee pase a ser un método del objeto Engineer. El nombre de esta propiedad (base) no es especial. Puede usarse cualquier nombre de propiedad, si bien base evoca el uso que se le va a dar.
4. El constructor llama al método base, pasándole como argumentos dos de los argumentos que se le han pasado al constructor ("Doe, Jane" y ["navigator", "javascript"]) y también el string "engineering". Usar explícitamente "engineering" en el constructor indica que todos los objetos Engineer tienen el mismo valor para la propiedad heredada dept, y este valor reemplaza el valor heredado de Employee.
5. Como base es un método de Engineer, en la llamada a base, JavaScript liga la palabra this al objeto creado en el paso 1. De esta forma, la función WorkerBee a su vez pasa los argumentos "Doe, Jane" y "engineering" a la función constructor Employee. Cuando retorna la llamada de la función constructor Employee, la función WorkerBee utiliza el resto de argumentos para asignarle un valor a la propiedad projects.
6. Cuando la llamada al método base retorna, el constructor Engineer inicializa la propiedad machine del objeto con el valor"belau".
7. Una vez creado, JavaScript asigna el nuevo objeto a la variable jane.

Podrías pensar que al haber llamado al constructor WorkerBee desde el constructor Engineer ya dejas establecida la herencia para los objetos Engineer. Pero no es así. Al llamar al constructor WorkerBee se garantiza que un objeto Engineer comience con las propiedades especificadas en todas las funciones del constructor que se llaman. Pero si luego se añaden propiedades a los prototipos de Employee o de WorkerBee, estas propiedades no se heredan por los objetos Engineer. Por ejemplo, veamos las siguientes sentencias:

function Engineer (name, projs, mach) {
  this.base = WorkerBee;
  this.base(name, "engineering", projs);
  this.machine = mach || "";
}
var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
Employee.prototype.specialty = "none";

El objeto jane no hereda la propiedad specialty añadida al prototipo de Employee. Sigue siendo necesario dar valor al prototipo de Employee para que la herencia buscada se establezca. Veamos las siguientes sentencias:

function Engineer (name, projs, mach) {
  this.base = WorkerBee;
  this.base(name, "engineering", projs);
  this.machine = mach || "";
}
Engineer.prototype = new WorkerBee;
var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
Employee.prototype.specialty = "none";

Ahora el valor de la propiedad specialty del objeto jane si es "none".

Otra forma de llamar al constructor es mediante el uso de los métodos call() / apply():

JavaScript

function Engineer (name, projs, mach) {
  this.base = WorkerBee;
  this.base(name, "engineering", projs);
  this.machine = mach || "";
}

Java

function Engineer (name, projs, mach) {
  WorkerBee.call(this, name, "engineering", projs);
  this.machine = mach || "";
}

Usar el método Javascript call() da como resultado una implementación más limpia ya que base ya no es necesaria. Mediante call() se llama a la función constructor WorkerBee como un método, pasándole explícitamente this. El efecto es el mismo que el producido al llamar al constructor a través de la propiedad base: en la llamada a WorkerBee, this está ligado al objeto que se está creando en Engineer.

Las secciones precedentes describieron como los constructores y prototipos de JavaScript jerarquías y herencia. En esta sección se discuten algunas sutilezas que no fueron necesariamente evidentes en las discusiones anteriores.

Cuando accedes a una propiedad de un objeto, JavaScript realiza estos pasos, tal como se describió más arriba en este capítulo:

1. Comprueba si el valor existe localmente. Si existe, se devuelve ese valor.
2. Si no existe un valor local, comprueba la cadena de prototipos (usando la propiedad __proto__).
3. Si algún objeto en la cadena de prototipos tiene un valor para la propiedad especificada, devuelve ese valor.
4. Si no encuentra la propiedad en la cadena de prototipos, el objeto no tiene la propiedad.

El resultado de estos pasos depende de cómo se definan las cosas en el camino. El ejemplo original tenía estas definiciones:

function Employee () {
  this.name = "";
  this.dept = "general";
}

function WorkerBee () {
  this.projects = [];
}
WorkerBee.prototype = new Employee;

Con estas definiciones, supongamos que se crea amy como una instancia de WorkerBee con la siguiente sentencia:

var amy = new WorkerBee;

El objeto amy tiene una propiedad local, projects. Los valores de las propiedades name y dept no son locales para amy y por eso se obtienen de la propiedad __proto__ del objeto. Por ello, amy tiene estos valores en sus propiedades:

amy.name == "";
amy.dept == "general";
amy.projects == [];

Ahora supongamos que cambias el valor de la propiedad name en el prototipo asociado a Employee:

Employee.prototype.name = "Unknown"

A primera vista, esperarías que el nuevo valor se propague hacia abajo a todas las instancias de Employee. Pero no es esto lo que ocurre.

Cuando se crea una instancia del objeto Employee, ésta obtiene un valor local para la propiedad name (la cadena vacía). Esto significa que cuando se da valor al prototipo de WorkerBee mediante la creación de un nuevo objeto Employee, WorkerBee.prototype tiene un valor local para la propiedad name. Por tanto, cuando JavaScript busca la propiedad name del objeto amy (una instancia de WorkerBee), JavaScript encuentra el valor local de esa propiedad en WorkerBee.prototype. Por tanto no busca más arriba en la cadena hasta Employee.prototype.

Si quieres cambiar el valor de una propiedad de un objeto en tiempo de ejecución y conseguir que el nuevo valor sea heredado por todos los descendientes del objeto, no puedes definir la propiedad en la función constructor del objeto. En su lugar, la tienes que añadir al prototipo asociado al constructor. Por ejemplo, supongamos que cambiamos el código anterior por este otro:

function Employee () {
  this.dept = "general";
}
Employee.prototype.name = "";

function WorkerBee () {
  this.projects = [];
}
WorkerBee.prototype = new Employee;

var amy = new WorkerBee;

Employee.prototype.name = "Unknown";

En este caso, la propiedad name de amy si pasa a ser "Unknown" tras la ultima sentencia.

Tal como muestran estos ejemplos, si quieres tener valores por defecto para propiedades de objetos, y se necesitas cambiar los valores por defecto en tiempo de ejecución, tienes que asignar las propiedades al prototipo del constructor, y no asignarlas dentro de la función constructor.

La búsqueda de propiedades en la cadena de prototipos comienza en las propiedades locales del objeto y si no se encuentran localmente, se busca a través de la propiedad __proto__ del objeto. La búsqueda continúa recursivamente, conociéndose como "búsqueda en la cadena de prototipos".

La propiedad especial __proto__ de un objeto recibe su valor en el momento en el que es creado; se le asigna el valor de la propiedad prototype de la función constructor usada para crear el objeto. Así, la expresión new Foo() crea un objeto con __proto__ == Foo.prototype. Por tanto, los cambios que se realicen en las propiedades de Foo.prototype alteraran la búsqueda de propiedades de todos los objetos que se crearon mediante new Foo().

Todo objeto tiene una propiedad __proto__ (salvo Object); toda función tiene una propiedad prototype. Es así como los objetos pueden relacionarse mediante 'herencia de prototipos' con otros objetos. Puedes comprobar la herencia comparando el valor de la propiedad __proto__ con el valor de prototype de una función constructor. JavaScript proporciona un atajo: el operador instanceof que compara un objeto con una función constructor y devuelve true si el objeto hereda del prototipo de la función. Por ejemplo,

var f = new Foo();
var isTrue = (f instanceof Foo);

Para ver un ejemplo más detallado, supongamos que tenemos el conjunto de definiciones mostrado en heredando propiedades. Creamos un objeto Engineer somo sigue:

var chris = new Engineer("Pigman, Chris", ["jsd"], "fiji");

En este objeto, las siguientes sentencias son todas true:

chris.__proto__ == Engineer.prototype;
chris.__proto__.__proto__ == WorkerBee.prototype;
chris.__proto__.__proto__.__proto__ == Employee.prototype;
chris.__proto__.__proto__.__proto__.__proto__ == Object.prototype;
chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;

Por tanto podría escribirse una función instanceOf así:

function instanceOf(object, constructor) {
   while (object != null) {
      if (object == constructor.prototype)
         return true;
      if (typeof object == 'xml') {
        return constructor.prototype == XML.prototype;
      }
      object = object.__proto__;
   }
   return false;
}

Usando esta función instanceOf estas expresiones son todas true:

instanceOf (chris, Engineer)
instanceOf (chris, WorkerBee)
instanceOf (chris, Employee)
instanceOf (chris, Object)

Pero la siguiente expresión es false:

instanceOf (chris, SalesPerson)

Cuando creas constructores tienes que tener especial cuidado si se asigna información global en el constructor. Por ejemplo, supongamos que quieres tener un ID único que se asigne automáticamente a cada nuevo empleado. Podrías utilizar la siguiente definición para Employee:

var idCounter = 1;

function Employee (name, dept) {
   this.name = name || "";
   this.dept = dept || "general";
   this.id = idCounter++;
}

Con esta definición, cuando cread un nuevo Employee, el constructor le asigna el siguiente ID y luego incrementa el contador global ID. Por tanto, tras ejecutar el siguiente código, victoria.id es 1 y harry.id es 2:

var victoria = new Employee("Pigbert, Victoria", "pubs")
var harry = new Employee("Tschopik, Harry", "sales")

A primera vista puede parecer razonable. Sin embargo, idCounter se incrementa cada vez que se crea un nuevo objeto Employee, cualquiera que sea su propósito. Si creas la jerarquía completa de Employee mostrada en este capítulo, el constructor Employee es llamado cada vez que se asigna valor a un prototipo. Supongamos que tienes el siguiente código:

var idCounter = 1;

function Employee (name, dept) {
   this.name = name || "";
   this.dept = dept || "general";
   this.id = idCounter++;
}

function Manager (name, dept, reports) {...}
Manager.prototype = new Employee;

function WorkerBee (name, dept, projs) {...}
WorkerBee.prototype = new Employee;

function Engineer (name, projs, mach) {...}
Engineer.prototype = new WorkerBee;

function SalesPerson (name, projs, quota) {...}
SalesPerson.prototype = new WorkerBee;

var mac = new Engineer("Wood, Mac");

Supongamos además que las definiciones que se omiten tienen la propiedad base y se llama al constructor que tienen encima en la cadena de prototipos. En este caso, cuando se llega a crear el objeto mac, mac.id es 5.

Dependiendo de la aplicación, puede o no importar que el contador se haya incrementado esas veces extra. En caso de que importe, una solución es utilizar este constructor:

function Employee (name, dept) {
   this.name = name || "";
   this.dept = dept || "general";
   if (name)
      this.id = idCounter++;
}

Cuando se crea una instancia de Employee para usarla como prototipo, no se especifican argumentos para el constructor. Mediante esta definición del constructor, cuando no se proporcionan argumentos, el constructor no asigna un valor al id y no actualiza el contador. Por tanto, para que se asigne a un Employee un id, hay que especificar un name al employee. En este caso mac.id seria 1.

Algunos lenguajes orientados a objetos tienen herencia múltiple. Es decir, un objeto puede heredar las propiedades y valores de varios objetos padre distintos. JavaScript no proporciona herencia múltiple.

La herencia de valores de propiedades se produce en tiempo de ejecución por JavaScript buscando en la cadena de prototipos de un objeto para encontrar un valor. Debido a que un objeto tiene un solo prototipo asociado, JavaScript no puede heredar dinámicamente de más de una cadena de prototipos.

En JavaScript se puede hacer que desde una función constructor llame a una o más funciones constructor. Esto da la ilusión de herencia múltiple. Considera, por ejemplo, las siguientes definiciones:

function Hobbyist (hobby) {
   this.hobby = hobby || "scuba";
}

function Engineer (name, projs, mach, hobby) {
   this.base1 = WorkerBee;
   this.base1(name, "engineering", projs);
   this.base2 = Hobbyist;
   this.base2(hobby);
   this.machine = mach || "";
}
Engineer.prototype = new WorkerBee;

var dennis = new Engineer("Doe, Dennis", ["collabra"], "hugo")

Consideremos, además, la definición de WorkerBee que se usó antes en este capítulo. En este caso, el objeto dennis tiene estas propiedades:

dennis.name == "Doe, Dennis"
dennis.dept == "engineering"
dennis.projects == ["collabra"]
dennis.machine == "hugo"
dennis.hobby == "scuba"

Por tanto dennis obtiene la propiedad hobby del constructor Hobbyist . Sin embargo, si luego añades una propiedad al prototipo del constructor de Hobbyist:

Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"]

El objeto dennis no hereda esta nueva propiedad porque no está en su cadena de prototipos.

• Anterior
• Siguiente