design-nation.blog/es

Las tropas del Profesor Dispar están bien entrenadas. Saben que, en caso de ser capturadas, sólo deben decir su nombre, compañía, y número de serie. Nada más. Así que podríamos abstraer un soldado como algo parecido a esto:


class Soldier
{
private var name : String;
private var id : String;
private var company : String;
private var weapons : Object;

function Soldier( initInfo: Object )
{
this.name = initInfo.name;
this.id = initInfo.id;
this.company= initInfo.company;
}

public function getPublicInfo( )
{
return { name: this.name, id: this.id, company: this.company };
}

//Other methods

public function toString( ): String
{
return "soldier{ name: " + this.name + ", id: " + this.id + ", company: " + this.company + " }";
}
}


Lo que define, pues, a un soldado es su nombre, su compañía, y su número de serie, y esa es la única información que proporcionarán cuando se les pregunte.

Imagina que el Profesor Dispar le pide al Mariscal que prepare un desfile con los soldados de la compañía B. El Mariscal, entre cuyas responsabilidades están jugar al golf y mantener en forma a sus soldados, tendrá que ir preguntando a los soldados a qué compañía pertenecen, y seleccionará, por tanto sólo a aquellos que sirvan en la compañía B. Pero ahora, imagina que el Profesor quiere que desfilen sólo los soldados en cuyo nombre haya una letra "P". Entonces, el código del Mariscal será algo así:


class Marshal
{
public static var CONTAINS_LETTER: String = "Letter";
public static var COMPANY : String = "Company";

private var soldiersList: Array;

function Marshal( )
{
this.soldiersList = new Array( );
}

public function recruitSoldier( newSoldier: Soldier )
{
this.soldiersList.push( newSoldier );
}

public function getFilteredCollection( filterType: String, filterValue: String ): Array
{
var returnVal: Array = new Array( );
var numSoldiers: Number = this.soldiersList.length;

var actualSoldierInfo: Object;

for( var k: Number = 0; k< numSoldiers; k++ )
{
actualSoldierInfo = this.soldiersList[ k ].getPublicInfo( );

switch( filterType )
{
case Marshal.CONTAINS_LETTER:
if( actualSoldierInfo.name.indexOf( filterValue ) != -1 )
{
returnVal.push( this.soldiersList[ k ] );
}

break;

case Marshal.COMPANY:
if( actualSoldierInfo.company == filterValue )
{
returnVal.push( this.soldiersList[ k ] );
}

break;

default:
trace( "Filter not created" );
}
}
return returnVal;
}
}


Y el Profesor hará algo como esto:


class Professor
{
function Professor( )
{

}

public static function initApp( )
{
var professor : Professor = new Professor( );
var marshal : Marshal = new Marshal( );

marshal.recruitSoldier( new Soldier( { name: "Peter", id: "0001", company: "B" } ) );

marshal.recruitSoldier( new Soldier( { name: "Paul", id: "0002", company: "B" } ) );
marshal.recruitSoldier( new Soldier( { name: "Cesar", id: "0003", company: "A" } ) );
marshal.recruitSoldier( new Soldier( { name: "Javier", id: "0004", company: "B" } ) );

var companyB: Array = marshal.getFilteredCollection( Marshal.COMPANY, "B" );
trace( companyB );

var companyA: Array = marshal.getFilteredCollection( Marshal.COMPANY, "A" );
trace( companyA );

var nameWithP: Array = marshal.getFilteredCollection( Marshal.CONTAINS_LETTER, "P" );
trace( nameWithP );

var nameWithe: Array = marshal.getFilteredCollection( Marshal.CONTAINS_LETTER, "e" );
trace( nameWithe );

}
}


Pero ¿qué pasa si ahora el Profesor quiere un desfile con los soldados cuyo número de serie sea menor que 10.000?. Habría que cambiar el código del Mariscal. ¿Y si ahora el Profesor quiere...? (ya sabes, al final siempre pasa lo mismo, los genios del mal no hacen más que pedir y pedir). El código del Mariscal, tal y como está no es muy escalable. No es facil añadir nuevas condiciones de filtrado. Pero ése no es el único problema. Con cada iteración del bucle, hay que chequear todas las posibles condiciones, lo cual es, por decirlo suavemente, poco elegante. Y el Profesor Dispar puede estar loco, pero desde luego no es idiota, y quiere que su código sea claro, compacto, fácil de mantener y elegante.

Así pues, el Profesor hace memoria, y recuerda (aquí es donde van los truenos y relámpagos) sus tiempos de estudiante, cuando aprendió el patrón (no, lo siento, el nombre lo tienes que adivinar tú).

Si encontrara una forma de darle al Mariscal un paquete que contuviera la condición a chequear, de forma que el Mariscal no necesitara conocer lo que está chequeando, el problema estaría resuelto. El Mariscal delegaría el chequeo de esa condición en lo que le entregue el Profesor, y se podrían añadir nuevas condiciones sin cambiar el código del Mariscal. Veamos cómo.

El Profesor le va a entregar, por tanto, al Mariscal una clase que será la responsable de realizar el filtro. Pero puede haber muchas condiciones, por lo tanto, todas las clases que se le puedan dar al Mariscal deberán implementar un interfaz común para que el Mariscal las pueda manejar de forma anónima.

Ese interfaz puede ser:

This interface could be:

Por tanto, uno de los filtros podría escribirse así:


class NameContainsLetterFilter implements ICompare
{
private var refValue: String;

function NameContainsLetterFilter( ref: String )
{
this.refValue = ref;
}

public function matches( checkValues: Object ): Boolean
{
return ( checkValues.name.indexOf( this.refValue ) != -1 );
}
}


Y el código del Mariscal pasaría a ser:


class Marshal
{
private var soldiersList: Array;

function Marshal( )
{
this.soldiersList = new Array( );
}

public function recruitSoldier( newSoldier: Soldier )
{
this.soldiersList.push( newSoldier );
}

public function getFilteredCollection( filter: ICompare ): Array
{
var returnVal: Array = new Array( );
var numSoldiers: Number = this.soldiersList.length;

var actualSoldierInfo: Object;

for( var k: Number = 0; k< numSoldiers; k++ )
{
actualSoldierInfo = this.soldiersList[ k ].getPublicInfo( );

if( filter.matches( actualSoldierInfo ) )
{
returnVal.push( this.soldiersList[ k ] );
}
}
return returnVal;
}
}


Y el Profesor Dispar:


class Professor
{
function Professor( )
{

}

public static function initApp( )
{
var professor : Professor = new Professor( );
var marshal : Marshal = new Marshal( );

marshal.recruitSoldier( new Soldier( { name: "Peter", id: "0001", company: "B" } ) );

marshal.recruitSoldier( new Soldier( { name: "Paul", id: "0002", company: "B" } ) );
marshal.recruitSoldier( new Soldier( { name: "Cesar", id: "0003", company: "A" } ) );
marshal.recruitSoldier( new Soldier( { name: "Javier", id: "0004", company: "B" } ) );

var nameWithP: Array = marshal.getFilteredCollection( new NameContainsLetterFilter( "P" ) );
trace( nameWithP );

var nameWithe: Array = marshal.getFilteredCollection( new NameContainsLetterFilter( "e" ) );
trace( nameWithe );

}
}


Añadir nuevos filtros será sencillo. Por ejemplo, para añadir un filtro utilizando el nombre de la compañía, el Profesor Dispar lo podría encapsular en una clase:


class CompanyFilter implements ICompare
{
var refValue: String;

public function CompanyFilter( ref: String )
{
this.refValue = ref;
}

public function matches( checkValues: Object ): Boolean
{
return ( checkValues.company == this.refValue );
}
}


Otro filtro más:


class IDLowerFilter implements ICompare
{
private var refValue: String

function IDLowerFilter( ref: String )
{
this.refValue = ref;
}

public function matches( checkValues: Object ): Boolean
{
var ref : Number = parseInt( this.refValue, 10 );
var check : Number = parseInt( checkValues.id, 10 );

return ( check<= ref );
}
}


Y para utilizar esos filtros:


class Professor
{
function Professor( )
{

}

public static function initApp( )
{
var professor : Professor = new Professor( );
var marshal : Marshal = new Marshal( );

marshal.recruitSoldier( new Soldier( { name: "Peter", id: "0001", company: "B" } ) );

marshal.recruitSoldier( new Soldier( { name: "Paul", id: "0002", company: "B" } ) );
marshal.recruitSoldier( new Soldier( { name: "Cesar", id: "0003", company: "A" } ) );
marshal.recruitSoldier( new Soldier( { name: "Javier", id: "0004", company: "B" } ) );

var nameWithP: Array = marshal.getFilteredCollection( new NameContainsLetterFilter( "P" ) );
trace( nameWithP );

var nameWithe: Array = marshal.getFilteredCollection( new NameContainsLetterFilter( "e" ) );
trace( nameWithe );

var idLessThan2: Array = marshal.getFilteredCollection( new IDLowerFilter( "0002" ) );
trace( idLessThan2 );

var idLessThan3: Array = marshal.getFilteredCollection( new IDLowerFilter( "0003" ) );
trace( idLessThan3 );
}
}


De esta forma, el Profesor ha sido capaz de cambiar los filtros sin cambiar el código del Mariscal.

Pero hay que hacer algunas consideraciones. Todos los filtros implementan un interfaz. Se podría discutir sobre si deberían extender de una clase base o no, pero el hacerlos extender de una misma clase base les haría perder flexibilidad. Por ejemplo, imagina que hay que realizar un filtro basado en cálculos numéricos... Por eso, aunque en este ejemplo podría ser válido el usar una clase base, el polimorfismo se basará en la implementación de un interfaz común.

Resumiendo, ¿qué ha conseguido el Profesor?. En primer lugar, ha seguido el Open-closed principle. El Mariscal está abierto a extensiones, pero cerrado a modificaciones. Dicho de otra forma, se puede extender su funcionalidad sin cambiar su código.

En segundo lugar, se ha delegado la construcción de los filtros en una entidad totalmente distinta a la que los ejecuta, es decir, se ha desacoplado totalmente la creación de esos filtros.

El profesor ríe histéricamente mientras la imagen se funde a negro... Pero ríe no sólo por la resolución de su aventura de hoy, sino porque sabe que este patrón se puede mejorar, por ejemplo, utilizando filtros que sean la composición de otros filtros... (continuará...)

Ahora te toca a tí. ¿Cómo se llama el patrón? (pista: el Profesor ha desacoplado un algoritmo de su receptor, encapsulándolo en una clase separada)

Descarga el código fuente. (si te apetece, claro)