Componente Registro

Resumen
Phalcon\Registry es un vector orientado a objeto. Extiende Phalcon\Collection pero no puede ser extendido a sí mismo, ya que todos sus métodos están declarados como final
. Ofrece velocidad, así como implementaciones de varias interfaces PHP. Estas son:
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
Constructor
Puede construir el objeto como cualquier otro objeto en PHP. Sin embargo, el constructor acepta un parámetro opcional array
, que rellenará el objeto por usted.
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
Reutilización
También puede reutilizar el componente, volviéndolo a rellenar. Phalcon\Registry expone los métodos clear()
y init()
, que limpiarán y rellenarán el vector interno respectivamente,
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
echo $collection->count(); // 2
$data = [
'year' => 1776,
];
$collection->clear();
$collection->init($data);
echo $collection->count(); // 1
Obtener
Como se ha mencionado antes, Phalcon\Registry implementa varios interfaces, para hacer al componente lo más flexible posible. Recuperar datos almacenados en un elemento se puede hacer usando:
- Propiedad
__get()
- acceso como vector (
$collection[$element]
)
offsetGet()
get()
La manera más rápida es usando la sintaxis de propiedad:
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
echo $collection->year; // 1776
Puede usar __get($element)
pero no es recomendable ya que es mucho más lenta que la sintaxis de propiedad. Lo mismo se aplica a offsetGet
echo $collection->__get('year'); // 1776
echo $collection['year']; // 1776
echo $collection->offsetGet('year'); // 1776
echo $collection->get('year', 1776, true); // 1776
public function get(
string $element,
mixed $defaultValue = null,
string $cast = null
): mixed
Usar get()
ofrece tres parámetros extra. Cuando se define $defaultValue
en la llamada y el elemento no se encuentra, se devolverá $defaultValue
. El parámetro cast
acepta una cadena que define a qué tipo será convertido el valor devuelto. Los valores disponibles son:
array
bool
boolean
double
float
int
integer
null
object
string
Tiene
Para comprobar si un elemento existe o no en la colección, puede usar lo siguiente:
isset()
en la propiedad
__isset()
- isset basado en vector (
isset($collection[$element])
)
offsetExists()
has()
La manera más rápida es usando la sintaxis de propiedad:
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
echo isset($collection->year); // true
Puede usar __isset(element)
pero no es recomendable porque es mucho más lento que la sintaxis de propiedad. Lo mismo se aplica a offsetExists
echo $collection->__isset('year'); // true
echo isset($collection['year']); // true
echo $collection->offsetExists('year'); // true
echo $collection->has('year', true); // true
public function has(string $element): bool
Establecer
Para establecer un elemento en la colección, puede utilizar lo siguiente:
- asignar el valor a la propiedad
__set()
- asignación basado en vector
offsetSet()
set()
La manera más rápida es usando la sintaxis de propiedad:
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
];
$collection = new Registry($data);
$collection->year = 1776;
Puedes usar __set($element, $value)
pero no es recomendable ya que es mucho más lento que la sintaxis de propiedades. Lo mismo se aplica a offsetSet
$collection->__set('year', 1776);
$collection['year'] = 1776;
$collection->offsetSet('year', 1776);
$collection->set('year', 1776);
Eliminar
Para eliminar un elemento en la colección, puede utilizar lo siguiente:
- desestablecer la propiedad
__unset()
- desestablecer basado en vector
offsetUnset()
remove()
La manera más rápida es usando la sintaxis de propiedad:
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
];
$collection = new Registry($data);
unset($collection->year);
Puedes usar __unset($element)
pero no es recomendable ya que es mucho más lento que la sintaxis de propiedades. Lo mismo se aplica a offsetUnset
$collection->__unset('year');
unset($collection['year']);
$collection->offsetUnset('year');
$collection->remove('year');
public function remove(string $element): void
Iteración
Dado que el objeto de colección implementa \IteratorAggregate
, puedes iterar con facilidad a través del objeto. El método getIterator()
devuelve un objeto ArrayIterator()
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
foreach ($collection as $key => $value) {
echo $key . ' - ' . $value . PHP_EOL;
}
Contar
La implementación de la interfaz \Countable
expone el método count()
, que almacena el número de elementos en la colección.
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
echo $collection->count(); // 2
Serialización
Las interfaces \Serializable
y \JsonSerializable
exponen métodos que le permiten serializar y deserializar un objeto. serialize()
y unserialize()
utilizan las funciones serialize
y unserialize
de PHP. jsonSerialize()
devuelve un vector que puede ser usado con json_encode()
para serializar el objeto.
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
echo $collection->serialize(); // a:2:{s:6:"colors";a:3:{i:0;s:3:"red";i:1;s:5:"white";i:2;s:4:"blue";}s:4:"year";i:1776;}
$serialized = 'a:2:{s:6:"colors";a:3:{i:0;s:3:"red";i:1;s:5:"white";i:2;s:4:"blue";}s:4:"year";i:1776;}';
$collection->unserialize($serialized);
echo $collection->jsonSerialize(); // $data
Phalcon\Registry también expone dos métodos de transformación: toArray()
y toJson(int $options)
. toArray()
devuelve el objeto transformado como un vector. Este método devuelve el mismo vector que jsonSerialize()
.
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
echo $collection->toArray(); // $data
toJson(int $options)
devuelve una representación JSON del objeto. Utiliza json_encode()
internamente y acepta un parámetro, que representa las banderas que json_encode
acepta. Por defecto, las opciones se configuran con el valor 74
, (RFC4327) que se traduce a:
JSON_HEX_TAG
JSON_HEX_APOS
JSON_HEX_AMP
JSON_HEX_QUOT
JSON_UNESCAPED_SLASHES
Puede pasar cualquier bandera válida al método según sus necesidades.
<?php
use Phalcon\Registry;
$data = [
'colors' => [
'red',
'white',
'blue',
],
'year' => 1776,
];
$collection = new Registry($data);
echo $collection->toJson(); // ["red","white","blue"],"year":1776}
echo $collection->toJson(74 + JSON_PRETTY_PRINT);
/**
{
"colors": [
"red",
"white",
"blue"
],
"year": 1776
}
*/