| Artículos | 01 NOV 2004

Javascript avanzado: programación orientada a objetos

Tags: Histórico
Adolfo Aladro.
El lenguaje Javascript está normalmente vinculado a la idea de pequeños frAgmentos de código que sirven para “enriquecer” las páginas Web. Sin embargo, con las versiones que implementan actualmente los navegadores, las tareas que pueden llevarse a cabo empleando este lenguaje son de mucha mayor envergadura y complejidad. Quizás una de las más interesantes estriba en la posibilidad que tiene el programador de crear sus propios objetos, a imagen y semejanza de otros objetos definidos por el estándar, como son Date, Array, etc. Esto reprensenta un avance considerable a la hora de afrontar el desarrollo de sitios Web complejos (HTML, DHTML, XML, XSL, etc.) y cambia por concepto la idea habitual de que Javascript es un lenguaje tan sencillo como limitado.

El lenguaje JavaScript se utiliza normalmente para crear pequeños bloques de código dentro de las páginas web. Con ellos es posible controlar los eventos originados por la interacción de los usuarios, comprobar los formularios y en general, llevar a cabo todo un sinfín de pequeñas tareas rutinarias y simples. Ahora bien, a medida que las páginas se complican y ofrecen más posibilidades a los usuarios, los scripts también crecen, en tamaño y complejidad. En estos casos el código resultante suele ser bastante confuso, ineficiente y poco reutilizable, debido principalmente a la falta de conocimientos serios acerca de este lenguaje de programación, así como al hecho de que normalmente no se le concede demasiada importancia a este tipo de desarrollos. Sin embargo el lenguaje JavaScript dispone de los recursos necesarios para trabajar con orientación a objetos, que si no se ajusta por completo a la metodología ortodoxa, sí permite al menos organizar el código dando lugar a scripts más reducidos, eficientes y reutilizables.

Creación de objetos:el constructor, las propiedades y los métodos
El lenguaje JavaScript cuenta con varios objetos predefinidos. Por ejemplo: window, document, form, etc. Todos ellos tienen una serie de métodos y propiedades. De manera equivalente el programador tiene la facultad de definir los objetos que considere necesarios. Un objeto queda definido por su constructor. En JavaScript, éste no es más que una función que se define de manera especial. El siguiente fragmento de código muestra un ejemplo:

function MyDate(year, month, date)
{
this.year = year;
this.month = month;
this.date = date;
return this;
}

El objeto MyDate representa una fecha. Cuenta con tres propiedades, year, month y date, que se corresponden respectivamente con el año, el mes y el día de la fecha. La palabra reservada this se emplea para hacer referencia al propio objeto. El siguiente ejemplo muestra cómo se puede crear una instancia de este objeto:

var mydate = new MyDate(2001, 11, 11);
alert(mydate.year);
...

Las propiedades de un objeto se referencian escribiendo su nombre a continuación del nombre del objeto seguido de un punto. Así por ejemplo se puede actualizar el valor de la propiedad year haciendo simplemente:

mydate.year = 2002;

Los métodos se definen de manera similar a lo visto para los objetos. Así por ejemplo, a continuación se puede observar cómo se modifica la definición del objeto MyDate y cómo se define el método show recién definido:

function MyDate(year, month, date)
{
this.year = year;
this.month = month;
this.date = date;
this.show = show;
return this;
}
function show()
{
var months = new Array(“enero”, “febrero”, “marzo”, “abril”, “mayo”, “junio”, “julio”, “agosto”, “septiembre”, “octubre”, “noviembre”, “diciembre”);
var s = “”;
s += this.date;
s += “ de “;
s += months[this.month - 1];
s += “ de “;
s += this.year;
alert(s);
}
var mydate = new MyDate(2001, 11, 11);
mydate.show();

El código fuente del método show utiliza las propiedades del objeto gracias a la palabra reservada this. Observando el código fuente del constructor se puede apreciar que no existe ninguna diferencia entre definir un método y una propiedad. Posteriormente, cuando se ejecuta el método de un objeto, sí que es preciso utilizar los paréntesis.

Objetos como propiedades
Hasta el momento el ejemplo que se ha mostrado ilustra un caso muy sencillo. Los objetos pueden llegar a ser tan complicados como sea necesario y en estos casos las propiedades pueden llegar a ser también objetos a su vez. Por ejemplo, para implementar la dualidad número/nombre del mes de la fecha se puede crear el siguiente objeto:

var months = new Array(“enero”, “febrero”, “marzo”, “abril”, “mayo”, “junio”, “julio”, “agosto”, “septiembre”, “octubre”, “noviembre”, “diciembre”);

function MyMonth(month)
{
this.number = month;
this.name = months[month - 1];
return this;
}

El objeto MyMonth cuenta con dos propiedades, number y name, que representan respectivamente el número y el nombre de un mes. La declaración del array months se ha sacado fuera de cualquier método para que no se cree esa estructura de más que una vez al cargarse la página que contiene este script. El objeto MyDate puede utilizar una instancia del objeto MyMonth simplemente modificando el código de su constructor, tal y como se muestra seguidamente:

function MyDate(year, month, date)
{
this.year = year;
this.month = new MyMonth(month);
this.date = date;
this.show = show;
return this;
}

De esta forma la propiedad month se convierte a su vez en otro objeto y el método show debe adaptarse a este nuevo cambio, con lo que resulta:

function show()
{
var s = “”;
s += this.date;
s += “ de “;
s += this.month.name;
s += “ de “;
s += this.year;
alert(s);
}

Cuando existen varias referencias, como en el ejemplo que se muestra, simplemente se suceden los nombres de las propiedades/objetos seguidos del carácter punto “.” hasta llegar al valor que se desea escribir y/o leer.
En resumen, cualquier tipo de objeto, ya sea los que ofrece el propio lenguaje o los definidos por el usuario, puede convertirse en propiedad de otro objeto. Este esquema puede complicarse añadiendo tantos niveles de indirección como sea necesario.

Constructores con un número variable de parámetros
Los lenguajes orientados a objetos permiten tener varios constructores para un mismo objeto. Si bien Javascript no puede equipararse a uno de estos lenguajes, y por lo tanto carece de dicha facultad, sí que es posible ejecutar el constructor de un objeto con un número distinto de parámetros al establecido en la definición, y controlar desde el propio código del constructor lo que sucede en estos casos. El siguiente ejemplo muestra el código fuente del constructor del objeto MyDate transformado para aceptar los valores correspondientes a la hora como parte de la fecha.

function MyDate(year, month, date, hour, minute, second)
{
this.year = year;
this.month = new MyMonth(month);
this.date = date;
this.show = show;
this.hour = 0;
this.minute = 0;
this.second = 0;
if (arguments.length == 4) {
this.ho

Contenidos recomendados...

Comentar
Para comentar, es necesario iniciar sesión
Se muestran 0 comentarios
X

Uso de cookies

Esta web utiliza cookies técnicas, de personalización y análisis, propias y de terceros, para facilitarle la navegación de forma anónima y analizar estadísticas del uso de la web. Consideramos que si continúa navegando, acepta su uso. Obtener más información