Bloques estáticos en AS3

Los bloques estáticos son bloques de código pertenecientes a una clase que se ejecutan una única vez cuando la clase en cuestión es cargada por primera vez en la AVM.
Dentro de un bloque estático se puede ejecutar cualquier tipo de expresión y referenciar a otras clases pero se debe tener en cuenta que desde el bloque, al estar dentro del ámbito de la clase (no de la instancia, de ahí que se llamen bloques estáticos), solo se pueden referenciar las propiedades y métodos estáticos de la clase.
Un bloque estático es equiparable a un constructor pero dentro del ámbito de clase (no de instancia).

El siguiente código muestra el uso de un bloque estático a modo de inyección de dependencias dinámico:

PLAIN TEXT

Actionscript:

/* Archivo.as */
package com.joangarnet.persistencia {
import flash.system.Capabilities;
public class Archivo implements IArchivo{
static private var archivoImpl:IArchivo;
/* bloque estático */
{
if( Capabilities.playerType == "Desktop" ){
// guarda en el sistema de archivos del O.S.
archivoImpl = new ArchivoAIR();
}else{
// guarda en web
archivoImpl = new ArchivoFlex();
}
trace( Capabilities.playerType );
}
/*
* implementacion de IArchivo
*/
public function guardar():void{
archivoImpl.guardar();
}
public function borrar():void{
archivoImpl.borrar();
}
}
}
/* IArchivo.as */
package com.joangarnet.persistencia{
public interface IArchivo{
function guardar():void;
function borrar():void;
}
}
/* ArchivoAIR.as */
package com.joangarnet.persistencia{
public class ArchivoAIR implements IArchivo{
public function guardar():void{
trace("guardar() en el sistema de archivos local")
}
public function borrar():void{
trace("borrar() en el sistema de archivos local")
}
}
}
/* ArchivoFlex.as */
package com.joangarnet.persistencia{
public class ArchivoFlex implements IArchivo{
public function guardar():void{
trace("guardar() vía web")
}
public function borrar():void{
trace("borrar() vía web")
}
}
}

TestBloqueEstatico.mxml

PLAIN TEXT

XML:

<?xml version = "1.0" encoding = "utf-8"?>
<mx:Application xmlns:mx = "http://www.adobe.com/2006/mxml" layout = "absolute">
<mx:Script>
<![CDATA[
import com.joangarnet.persistencia.Archivo;
private var f:Archivo = new Archivo();
]]>
</mx:Script>
<mx:Button click = "f.borrar()" label="borrar" />
<mx:Button click = "f.guardar()" label="guardar" />
</mx:Application>

Si se ejecuta en el contexto de una aplicación AIR y clicamos en los dos botones borrar y guardar respectivamente se mostrará en la consola:

borrar() en el sistema de archivos local
guardar() en el sistema de archivos local

Si de lo contrario se hace desde el navegador se mostrará:

borrar() vía web
guardar() vía web

August 10, 2009 | Filed Under AS3 freaks | 4 Comments

Utilizando namespaces

¿Qué es?

Un namespace (espacio de nombres) es un contenedor abstracto que nos permite controlar la visibilidad de propiedades y métodos. Es algo parecido al concepto de package.
Por defecto disponemos de cuatro namespaces: private, protected, public e internal. Estos espacios de nombre tiene un comportamiento especial que permite restringir el acceso a miembros teniendo en cuenta una serie de reglas con respecto a la herencia o al package al que pertenecen.
Aparte de éstos cuatro nosotros podemos definir nuestros propios namespaces.

Un ejemplo

Definimos un namespace:

PLAIN TEXT

Actionscript:

package com.joangarnet.namespaces{
public namespace jg_internal = "http://www.joangarnet.com/namespaces/jg_internal";
}

Aplicamos el namespace a un miembro de una clase:

PLAIN TEXT

Actionscript:

package com.joangarnet.controls{
public class Window{
import com.joangarnet.namespaces.jg_internal;
private var propiedad:String = "No soy accesible";
jg_internal var propiedad:String = "Si soy accesible";
}
}

Vemos que tenemos dos propiedades "propiedad" con el mismo identificador, lo cual puede parecer erróneo. Lo que sucede al compilar es que al tener visibilidades diferentes, estan en espacios de nombres diferentes, los identificadores no colisionan.
Yo personalmente he utilizado raramente esta característica del lenguaje, pero se me ocurren algunas [pseudo]situaciones interesantes dónde puede ser útil:

Miembros pseudo privados

Hace un par de posts me quejaba del hecho que, en algún caso puntual algunas clases del SDK de Flex lo ponían dificil a la hora de proporcionar extendibilidad. La causa de ésto era la definición de miembros privados en algunas clases que entorpecían y, alguna vez incluso imposibilitaban el poder extenderlas. En un par de ocasiones he tenido que recurrir a una técnica llamada monkey patching para poder extender una clase determinada.
Una posible forma de eviar esto pasaría por definir un espacio de nombres semánticamente parecido a private (¿os suena mx_internal?) que nos permitiera extender los miembros de la clase de forma responsable, siendo conscientes de que estamos utilizando un namespace especial y que tenemos que andar con especial ojo en lo que hacemos.

Pseudo sobrecarga de métodos

El hecho que podamos definir un mismo método en diferentes espacios de nombres dentro de una misma clase nos hace recordar a la sobrecarga de métodos disponible en otros lenguajes como Java. Se puede obtener una funcionalidad parecida utilizando namespaces:

PLAIN TEXT

Actionscript:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" creationComplete="inicio()">
<mx:Script>
<![CDATA[
namespace air;
namespace flex;
private var runtime:Namespace;
private function inicio():void{
if( Capabilities.playerType == "Desktop" ) {
runtime = air;
}else{
runtime = flex
}
runtime::guardar();
}
air function guardar():void {
trace( "Guardar en filesystem" )
}
flex function guardar():void {
trace( "Guardar en el server" )
}
]]>
</mx:Script>
</mx:Application>

Esto ejecutado en un navegador y ejecutado en una aplicación AIR muestra dos resultados diferentes.

Ejecución pseudo condicional

La compilación condicional disponible en Flex Builder es una funcionalidad muy útil (de la que hablaré en un futuro post en madeinflex) que permite definir bloques que se ejecutan dependiendo si se ha asignado un valor determinado desde los parámetros de compilación. Esto permite por ejemplo tener rutinas de debug que solo se compilan durante el desarrollo y que en el momento de salir a producción con un simple cambio en un valor desaparecen por completo.
Con namespaces y siguiendo exactamente el mismo sistema que en el ejemplo anterior podemos hacer algo parecido como se ve en el siguiente ejemplo:

PLAIN TEXT

XML:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" creationComplete="inicio()">
<mx:Script>
<![CDATA[
namespace desarrollo;
namespace produccion;
public static var entorno:Namespace;
private function inicio():void{
entorno = produccion;
entorno::guardar();
}
desarrollo function guardar():void {
trace( "Estoy en desarrollo" )
}
produccion function guardar():void {
trace( "Estoy en producción" )
}
]]>
</mx:Script>
</mx:Application>