Bueno muchachos, que alegría que me da y como me halaga que para hacer demostraciones de accessors en PHP para objetos, utilicen las funciones que hice hace ya un par de años ( en realidad, casi 3 ) para la clase Paginado.
Ahora, quería comentarles un par de asuntos, al menos respecto a lo que hago yo con los accessors, para ver si logramos que el tema quede un poco más claro para el que no comprende aún como funciona este "estilo" de funciones:
Una sola variable por Atributo
Este es el caso más común y el explicado por jpinedo. Es el método que espera una y solo una variable para asignarse al atributo. No importa realmente el tipo del atributo, ya sea string, integer, boolean, un arreglo y otro objeto (aqui deberiamos pensar en asignaciones por referencia).
Entonces, el código queda como fue marcado antes:
Código PHP:
function Atributo1(){
switch (func_num_args()){// según la cantidad de parámetros que se hayan pasado
case 1:
// si se pasó un parámetro se asigna valor (escribir)
$this->atributo1 = func_get_arg(0);
default:
// Si no se pasó ningún parámetro se lee el valor.
return $this->atributo;
}
}
Por favor noten el detalle que entre 'case 1' y 'default' (aqui he corregido esto, porque no es "case 0", sino que una buena política es que si no tiene la cantidad de argumentos que esperamos, que se comporte como un get), les decía, noten que entre estas dos opciones del switch, no hay un "break". ESto es para que este método se comporte como una asignación de variable normal en PHP, donde luego de la asignación, también se devuelve el valor asignado. Es por eso que podemos hacer cosas como :
Código PHP:
echo $variable = 'valor';
Con este método es lo mismo. Se puede hacer normalmente:
Código PHP:
echo $objeto->atributo('valor');
Más de una variable en un Accesor.
Aqui no estoy tan seguro de llamar esto un Accessor, porque no es directamente un atributo lo que estamos moficando, sino varios atributos. Si podría llamarse asi si el atributo se compone luego de todos los parámetros de la función. Eso debería verlo cada uno en su implementación o requerimiento particular.
Lo que si, aqui hay que tener en cuenta que es importantísimo que un método de este tipo, requiere SI o SI, X cantidad de argumentos. Ya sean 2, 3, 4 o 1000, el caso es que si se reciben un número inadecuado de parámetros, entonces no hay que hacer nada o actuar como un getter (esto aqui es decisión de cada uno). Por ejemplo:
Código PHP:
function figura()
switch (func_num_args()){
case 3: // un círculo
$this->radio = func_get_arg(2);
case 2: // un punto
$this->coordX = func_get_arg(0);
$this->coordY = func_get_arg(1);
return true;
break;
default:
// si se pasa otra cantidad de parámetros, entonces es una llamada inválida.
return false;
}
}
Aqui vemos como dependiendo de la cantidad de parámetros, se hace una u otra cosa. Si son solo 2 parámetros, se guardan como Coordenadas de un punto, si en cambio son 3 parámetros, aparte se guarda el radio del círculo, si se pasan 1 o más de 3 parámetros, no se hace nada y la aplicación continúa sin problema. Se podría lanzar un mensaje de error o un null para distinguir entre una asignación correcta o no.
Una cantidad no predeterminada de parámetros
Este es el último caso de los que se habló aquí, y es cuando un método es tan flexible que recibe una lista de parámetros que se desconoce previamente. Esto se resuelve con otra de las funciones de PHP que permite trabajar con parámetros. Tan solo tenemos que recorrer el arreglo de parámetros que nos devuelve la función
func_get_args(), y ya luego guardarlos en un atributo. Supongamos que tenemos el código del primer ejemplo, que acepta 1 solo parámetro, y a este, le agregamos otro método que reciba la lista variable de atributos. Entonces, nos quedaría algo asi:
Código PHP:
function Atributo1(){
switch (func_num_args()){// según la cantidad de parámetros que se hayan pasado
case 1:
// si se pasó un parámetro se asigna valor (escribir)
$this->atributo1 = func_get_arg(0);
default:
// Si no se pasó ningún parámetro se lee el valor.
return $this->atributo;
}
}
function propagar()
{
$this->Atributo1(func_get_args());
}
$obj =& new Objeto();
$obj->propagar('aqui', 'ponemos', 'una', 'lista', 'de', 'parámetros');
print_r($obj->Atributo1()):
De esta manera, veremos como el método
Atributo1 nos devuelve un Arreglo con 6 valores, siendo cada uno de ellos los que pasamos al método propagar. Aqui he reutilizado otro método, pero pueden hacer todo el trabajo solo en "
propagar" si quieren.
Bueno, eso cubre más o menos mi manera de trabajar con accessors hace ya varios años, y que sigo utilizando hasta en la actualidad en objetos simples. Ya luego si quieren un nivel mayor de complejidad, pueden hacer un Objeto llamado AdministradorAtributos, que contenga una colección de Objetos Atributo y que cada clase que necesiten, extienda o esté compuesta por uno de estas clases. Pero eso ya es otro cantar.
Posiblemente en estos días, les deje un comentario sobre el tema original del tema, que es el de una capa de abstracción de base de datos, la que hice para utilizar, y por qué me parece cómoda, al menos a mi.
Suerte.
Este tema le ha gustado a 1 personas (incluyéndote)