Zend_Dojo_Data: Envolturas de dojo.data
Dojo proporciona abstracciones de datos para los widgets de datos
habilitados a través de su
componente dojo.data. Este componente
proporciona la capacidad de adjuntar un datastore,
ofrecer algunos
metadatos relativos al campo identidad, opcionalmente una etiqueta de
campo, y
una
API
para efectuar consultas,
clasificación, recuperación de archivos y conjuntos de registros del
datastore.
dojo.data se utiliza a menudo con XmlHttpRequest para traer
dinámicamente datos desde el
servidor. El principal mecanismo para esto
es extender el QueryReadStore para que apunte a
una
URL
y especificar la
información a consultar. El lado del servidor después devuelve los datos
con
el siguiente formato
JSON
:
',
',>
items: [
{ name: '...', label: '...', someKey: '...' },
...
]
}
]]>
Zend_Dojo_Data
ofrece una interfaz simple para la
construcción de estas estructuras programáticamente,
interactuando con
ellos, y serializándolos a un array o a
JSON
.
Uso de Zend_Dojo_Data
En su forma más simple, dojo.data requiere que se proporcione el
nombre del campo
identificador en cada item, y un conjunto de items
(datos). Puede pasarlos tanto via el
constructor, o via mutators:
Inicialización de Zend_Dojo_Data via constructor
Inicialización de Zend_Dojo_Data via mutators
setIdentifier('id')
->addItems($items);
]]>
También puede añadir un solo item a la vez, o agregar items
utilizando
addItem()
y
addItems()
.
Agregando datos a
Zend_Dojo_Data
addItem($someItem);
$data->addItems($someMoreItems);
]]>
Siempre use un identificador!
Cada datastore de dojo.data requiere que la columna
identificadora se proporcione
como metadatos, incluyendo
Zend_Dojo_Data
. De hecho, si intenta
añadir items sin un identificador, se generará una excepción.
Los items individuales pueden ser uno de los siguientes:
Arrays asociativos
Objectos implementando un método
toArray()
Cualquiera de los otros objetos (se serializarán via
get_object_vars())
Puede adjuntar colecciones de los items anteriores via
addItems()
o
setItems()
(sobreescribe todos los
items previamente establecidos); cuando lo haga, puede pasar un
solo
argumento:
Arrays
Objectos implementando la interfaz
Traversable
, que incluye las
interfaces
Iterator
y
ArrayAccess
.
Si quiere especificar un campo que actuará como una etiqueta para
el item, llame a
setLabel()
:
Especificando la etiqueta de un campo en
Zend_Dojo_Data
setLabel('name');
]]>
Por último, también puede cargar un item
Zend_Dojo_Data
de un array
JSON
dojo.data, utilizando el método
fromJson()
.
Alimentando Zend_Dojo_Data desde
JSON
fromJson($json);
]]>
Agregando metadatos a sus contenedores
Algunos componentes de Dojo requieren metadatos adicionales junto
al conjunto de datos de
dojo.data. Como ejemplo,
dojox.grid.Grid
puede tirar datos
dinámicamente desde un
dojox.data.QueryReadStore
. Para que la
paginación funcione correctamente, cada conjunto de datos de regreso
debería contener una clave
numRows
con el
número total de filas que podrían ser devueltas por la consulta. Con
estos datos,
la plantilla sabe cuando seguir haciendo pequeños
pedidos de subconjuntos de datos al
servidor y cuando dejar de hacer
más peticiones (es decir, ha llegado a la última página
de datos).
Esta técnica es útil para despachar grandes conjuntos de datos en
sus
plantillas sin cargar todo el conjunto de una sola vez.
Zend_Dojo_Data
permite asignar propiedades a
los metadatos como al objeto. Lo siguiente ilustra su uso:
setMetadata('numRows', 100);
// Establece varios items a la vez:
$data->setMetadata(array(
'numRows' => 100,
'sort' => 'name',
));
// Inspecciona un único valor de metadatos:
$numRows = $data->getMetadata('numRows');
// Inspecciona todos los metadatos:
$metadata = $data->getMetadata();
// Elimina un item de metadatos:
$data->clearMetadata('numRows');
// Elimina todos los metadatos:
$data->clearMetadata();
]]>
Casos Avanzados de Uso
Además de actuar como un contenedor de datos serializable,
Zend_Dojo_Data
también ofrece la
posibilidad de manipular y recorrer los datos en una variedad de
formas.
Zend_Dojo_Data
implementa las interfaces
ArrayAccess
,
Iterator
, y
Countable
. Por lo tanto, puede usar la
recopilación de datos casi como si fuera un array.
Todos los items son referenciados por el identificador de campo.
Dado que los
identificadores deben ser únicos, puede usar los
valores de este campo para sacar los
registros individuales. Hay dos
maneras de hacer esto: con el método
getItem()
, o via notación de array.
getItem('foo');
// O usando notación de array:
$item = $data['foo'];
]]>
Si conoce el identificador, puede utilizarlo para recuperar un
item, actualizarlo,
borrarlo, crearlo, o probarlo:
'Foo', 'email' => 'foo@foo.com');
// Borrar un item:
unset($data['foo']);
// Efectuar una prueba para un item:
if (isset($data[foo])) {
}
]]>
También puede hacer un loop sobre todos los items. Internamente,
todos los items se
almacenan como arrays.
O inclusive contar para ver cuántos ítems tiene:
Por último, como la clase implementa
__toString()
, también puede convertirlo
a
JSON
simplemente con "echo" de
PHP
o
convertirlo a string:
Métodos Disponibles
Además de los métodos necesarios para aplicar las interfaces
enumeradas
anteriormente, están disponibles los siguientes
métodos.
setItems($items)
: establece
varios items a la vez, sobrescribiendo cualquier item
que figurase
anteriormente en el objeto.
$items
debe ser un array o
un objeto
Traversable
.
setItem($item, $id = null)
:
establece un item individual, opcionalmente puede pasar
un identificador
explícito. Sobreescribe el item si ya
existe en la colección. Los items
válidos incluyen a
arrays asociativos, objetos implementando
toArray()
, o cualquier
objeto con propiedades públicas.
addItem($item, $id = null)
:
añade un item individual, opcionalmente puede pasar un
identificador
explícito. Generará una excepción si el
item ya existe en la colección. Los
items válidos
incluyen a arrays asociativos, objetos implementando
toArray()
, o cualquier
objeto con propiedades públicas.
addItems($items)
: agrega
múltiples items a la vez, añadiendolos a cualquiera de
los items
actuales. Generará una excepción si alguno de
los nuevos items tiene un
identificador concordante a un
identificador ya existente en la colección.
$items
debe ser un array o
un objeto
Traversable
.
getItems()
: recupera todos los
items como un array de arrays.
hasItem($id)
: determina si un
item con el identificador dado existe en la colección.
getItem($id)
: recupera un item
con el identificador dado de la colección; el item
retornado será un array asociativo. Si ningún item
coincide, se devolverá un
valor null.
removeItem($id)
: elimina de la
colección un item con el identificador dado.
clearItems()
: elimina todos los
items de la colección.
setIdentifier($identifier)
:
establece el nombre del campo que representa el
identificador único para
cada item en la colección.
getIdentifier()
: recupera el
nombre del campo identificador.
setLabel($label)
: establece el
nombre de un campo para ser utilizado como la etiqueta a
mostrar para un item.
getLabel()
: recupera la
etiqueta del nombre del campo.
toArray()
: enviar el objeto a
un array. Como mínimo, el array contendrá las claves
'identifier', 'items', y 'label' si una etiqueta de
campo ha sido establecida
en el objeto.
toJson()
: enviar el objeto a
una representación
JSON
.