El paso de parámetros por valor, se utiliza en programación para realizar una copia del valor del objeto cuando es pasado a través de la invocación de un método. Es decir, al llamar a un método de una clase que requiere un objeto, realizo una copia de dicho objeto. Si dentro de la clase, modifico ese objeto, los cambios no son propagados fuera de la clase.

El paso de parámetros por referencia, pasa “un puntero del objeto”, es decir, de alguna manera estamos pasando el objeto, y si dicho objeto es modificado dentro de la propia clase, sus cambios serán propagados fuera de la misma.

Hay lenguajes que permiten definir el método de paso de variables (referencia o valor), como es el caso de C++. En Actionscript, de momento no podemos pasar por valor de manera nativa, aunque nuestro método siempre puede hacer una copia internamente del argumento recibido para no modificar el original. En Actionscript 3, el paso de parámetros, siempre se realiza de la misma manera:

• Las instancias de clases son pasadas por referencia
• Los tipos primitivos se pasan por valor

Si estás aprendiendo Actionscript 3 y has llegado hasta aquí, te recomiendo que analices a fondo este código, puesto que puede resultarte muy esclarecedor para entender este concepto tan básico como fundamental sobre la orientación a objetos.

Primero, definimos dos Clases, ClaseA y ClaseB. ClaseB está compuesta por un atributo, atributoB que es de tipo Number.

package
{
	public class ClaseB
	{
		public var atributoB:Number;	
		public function ClaseB()
		{
		}
	}
}

ClaseA tiene otro atributo de tipo ClaseB. Estamos hablando por tanto, de una relación de composición entre las dos clases.

package
{
	public class ClaseA
	{
		public var atributoA:ClaseB;
		public function ClaseA(atributo:ClaseB){
			atributoA = atributo;
		}
	}
}

Ahora nuestra clase principal. Nótese cómo atributoB devuelve el mismo valor independientemente del lugar desde donde es modificado (es el mismo objeto) y cómo esto no sucede con tipos primitivos. En este caso paso un parámetro al constructor de la clase ClaseA (nuestro objeto de tipo ClaseB), para posteriormente modificarlo desde diferentes ámbitos y trazar los resultados.

package {
	import flash.display.Sprite;
 
	public class ReferenciaValorTest extends Sprite
	{
		/**
		 * @autor Alejandro Sánchez
		 * http://www.electroduendes.com/blog/
		 * */
		public function ReferenciaValorTest()
		{
			var b:ClaseB = new ClaseB();
			b.atributoB = 10;
			trace(b.atributoB) // OUTPUT: 10
 
			var a:ClaseA = new ClaseA(b);
			trace(a.atributoA.atributoB) // OUTPUT: 10
 
			a.atributoA.atributoB = 5;
			trace(a.atributoA.atributoB) // OUTPUT: 5
			trace(b.atributoB) // OUTPUT: 5
 
			b.atributoB = 10;
			trace(a.atributoA.atributoB) // OUTPUT: 10
			trace(b.atributoB) // OUTPUT: 10
 
			var c:Number = 20;
			a.atributoA.atributoB = c			
			trace(a.atributoA.atributoB); // OUTPUT: 20
			trace(b.atributoB); // OUTPUT: 20
			trace(c); // OUTPUT 20
 
			c = 30;
			trace(a.atributoA.atributoB); // OUTPUT: 20
			trace(b.atributoB); // OUTPUT: 20
			trace(c); // OUTPUT 30
 
		}
	}
}

He visto gente que codifica muy bien, pero que todavía tiene que tocar su código genérico para adaptarlo a sus proyectos. Sobre todo, el problema suele estar en los eventos. Cuando hay que notificar a alguna funcion que un conjunto de cargas está completa, que un formulario está chequeado, o que un combo está seleccionado, ya empiezan los problemas. Para ellos, este post puede ser interesante. Sobre todo si no han trabajado nunca con EventDispatcher. Y para los que han trabajado y piensen que EventDispatcher, a veces se queda corta, puede que también.

Gskinner sacó (gracias Carlos ) hace tiempo una utilidad que mejoraba notablemente la clase EventDispatcher. Por si alguien no sabe de que hablo, EventDispatcher, y su mejora, GDispatcher es la navaja suiza que te permite descorchar la botella del vino con la que celebrarás o celebraste tu completo dominio de la encapsulación de tus clases, sobre todo las que llevan eventos. Esa manera tan estupenda de trabajar con listeners, que es tan “clara” en los UI Components y en la clase MovieClipLoader, se puede utilizar como un patrón de diseño para los mensajes que se envían tus clases (eventos).

¡Por fin podrás decir a tu jefe, - eh! estoy reutilizando! - y el te dirá… - eh, estupendo, en vez de para mañana, lo quiero para hoy! -

GDispatcher

Cuando desarrollé mi primer gran proyecto en Actionscript 2.0 con clases, la mayor parte de ellas contenían atributos estáticos “referencia” , o pasaba referencias como propiedad. Parecía que todo en Flash perdía la referencia: asignaba funciones a los onLoad de los parsers, y perdía la referencia, en los onClick de los botones perdía la referencia, los setInterval, venga a pasar referencias… parecía todos los eventos se habían aliado contra mí, y eso que ya tenía callo con problemas de referencias.

Pero con Flash 7.2, apareció la clase Delegate.

Éste es un ejemplo de mis frustraciones: un típico parser que simplemente visualiza un XML en un TextField en el que las referencias son todo problemas.

/**
 * @author Alejanadro Sánchez Marcos
 * @usage tutorial de uso de delegate en los parsers.
 * la clase emula un parser básico y su uso común.
 */
class ParserTradicional {
	public var xml:XML;
	public var textoResultado:TextField;
	// ouch!
	public static var ruta:ParserTradicional;
	public function ParserTradicional(URL:String, textoResultado:TextField) {
		xml = new XML();
		// off!
		ruta = this;
		this.textoResultado = textoResultado;
		xml.load(URL);
		// empiezan los problemas...
		// xml.ruta = this; // ay!           
		xml.onLoad = parse;
	}
	public function parse() {
		// no tengo ruta.. mmm meto un atributo estático con la ruta
		// buff!
		trace(ruta.xml);
		ruta.mostrarXML();
	}
	public function mostrarXML() {
		textoResultado.text = xml.toString();
	}
}

y exactamente la misma clase, pero usando delegate.

import mx.utils.Delegate;
/**
* @author Alex Sanchez
* @usage tutorial de uso de delegate en los parsers.
* la clase emula un parser básico y su uso común.
*/
class ParserDelegate {
	public var xml:XML;
	public var textoResultado:TextField;
	public function ParserDelegate(URL:String, textoResultado:TextField) {
		this.textoResultado = textoResultado;
		xml = new XML();
		xml.load(URL);
		// yeeeha!
		xml.onLoad = Delegate.create(this, parse);
	}
	public function parse(success:Boolean) {
		if (success) {
			mostrarXML();
		}
	}
	public function mostrarXML() {
		textoResultado.text = xml.toString();
	}
}

# Delegates are now built into the language, making event dispatching easier.
In ActionScript 2.0, routing an event to a method required use of the mx.utils.Delegate class or other workarounds:

import mx.utils.Delegate;
myButton.addEventListener(“click”, Delegate.create(this, onClick));

In ActionScript 3.0, a reference to a method automatically remembers the object instance it was extracted from; in essence, it is an automatic delegate. So, the code can simply be written as:

myButton.addEventListener(“click”, onClick);

Si no trabajas todavía con sistemas basados en eventos… no sufras más,

Y el mejor argumento para persuadirte es: ¿a que se trabaja bien con los listeners de los componentes? Pues bien, a lo sumo 10 líneas más en vuestras clases pueden aumentar al máximo vuestro código reutilizable.

A lo largo de estos días iré colocando código útil en base a mi periplo con los mismos para todos aquellos que empecéis de 0 con ellos.

 
//var mapa = _root.obj.contenidos.lista[i].elemento[j].mapa;
// Bug: ya había un mc que se llama mapa!
 
var sMapa:String = _root.obj.contenidos.lista[i].elemento[j].mapa;
 
/* 
Alejandro Sánchez:
la notación húngara y el strict data typing sirven para depurar 
errores como este.
ejemplo:
comentario:String = "llevo una hora intentando resolver este bug"
*/

El problema era que ya había otro objeto que se llamaba mapa, y no se trataba de una cadena de texto. Al no estar tipado, me costó bastante depurar el error.
Para el que no conozca la notación húngara y se pregunte para qué sirve el strict data typing, el código que me he encontrado, son un gran ejemplo de que los tipados de datos proporcionan ventajas a la hora de depurar, ya que en tiempo real las asignaciones que no son alojadas en los tipos de datos adecuados, lanzan un error.

• Enlace sobre la notación húngara en Wikipedia
• Enlace sobre Strict Data Typing en la documentación de Macromedia