> For the complete documentation index, see [llms.txt](https://senens-organization.gitbook.io/senenhermida.docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://senens-organization.gitbook.io/senenhermida.docs/symfony/serializer.md).

# Serializer

## Serializer

## Serializer - deserialize update object

*The Serializer component is meant to be used to turn objects into a specific format (XML, JSON, YAML, ...) and the other way around.*

Normalizers (object < = > array)

Encoders (format(json, xml, csv, yaml…) < = > array)

**Core Components**:

* **Normalizers**: Transform objects to and from arrays. Different normalizers are available for handling various types of objects.
* **Encoders**: Convert arrays into specific formats (like JSON, XML, CSV) and decode these formats back into arrays.
* **Context**: Provides additional settings or parameters to influence the serialization and deserialization processes.
* Serialize (object ⇒ format)

```php
use App\Model\Person;

$person = new Person();
$person->setName('foo');
$person->setAge(99);
$person->setSportsperson(false);

$jsonContent = $serializer->serialize($person, 'json');

// $jsonContent contains {"name":"foo","age":99,"sportsperson":false,"createdAt":null}
```

* deserialize (format ⇒ object)

```php
use App\Model\Person;

$data = <<<EOF
<person>
    <name>foo</name>
    <age>99</age>
    <sportsperson>false</sportsperson>
</person>
EOF;

$person = $serializer->deserialize($data, Person::class, 'xml');
```

* deserialize can be used to update the object to

```php
// ...
$person = new Person();
$person->setName('bar');
$person->setAge(99);
$person->setSportsperson(true);

$data = <<<EOF
<person>
    <name>foo</name>
    <age>69</age>
</person>
EOF;

$serializer->deserialize
							(
								$data, 
							  Person::class, 
								'xml', 
								[AbstractNormalizer::OBJECT_TO_POPULATE => $person]
);
// $person = App\Model\Person(name: 'foo', age: '69', sportsperson: true)
```

This is a common need when working with an ORM.

The `AbstractNormalizer::OBJECT_TO_POPULATE` is only used for the top level object

If that object is the root of a tree structure, all child elements that exist in the normalized data will be re-created with new instances.

When the `AbstractObjectNormalizer::DEEP_OBJECT_TO_POPULATE` option is set to true, existing children of the root `OBJECT_TO_POPULATE` are updated from the normalized data, instead of the denormalizer re-creating them. Note that `DEEP_OBJECT_TO_POPULATE` only works for single child objects, but not for arrays of objects. Those will still be replaced when present in the normalized data.

#### Context

Context refers to additional settings to pass to the serializer/deserializer

You can pass the context as follows:

```php
$serializer->deserialize($someJson, Something::class, 'json', [
    DateTimeNormalizer::FORMAT_KEY => 'Y-m-d H:i:s',
]);
```

or

```php
# config/packages/framework.yaml
framework:
    # ...
    serializer:
        default_context:
            enable_max_depth: true
            yaml_indentation: 2
```

or

```php
#[Context([DateTimeNormalizer::FORMAT_KEY => 'Y-m-d'])]
public \DateTimeInterface $createdAt;
```

#### Features

* attributes groups

to normalize/denormalize different attributes

```php
class MyObj
{
    #[Groups(['group1', 'group2'])]
    public string $foo;
```

* selecting specific attributes

```php
$data = $serializer->normalize($user, null, [AbstractNormalizer::ATTRIBUTES => ['familyName', 'company' => ['name']]]);
```

* ignoring attributes

```php
$serializer->serialize($person, 'json', [AbstractNormalizer::IGNORED_ATTRIBUTES => ['age']]); // Output: {"name":"foo"}
```

* Converting property names: custom, camelCase to snake\_case
* booleans: it works for has, get and can (App\Model\Person::isSportsperson())
* callbacks: When serializing, you can set a callback to format a specific object property.

#### Normalizer

Normalizers in Symfony's Serializer are responsible for converting data between object and array (or scalar values) formats.

Object < = > array

object, getSet, property, datetime…

Always make sure to load the `DateTimeNormalizer` when serializing the `DateTime` or `DateTimeImmutable` classes to avoid excessive memory usage and exposing internal details.

#### Encoders

Encoders are components that handle the final stage of serialization — converting normalized data (arrays or scalar values) into a specific format (like JSON or XML) and vice versa.

array < = > formats

json, xml, csv, yaml

**Circular Reference Handling**:

* The Serializer can handle circular references to prevent infinite loops during serialization, which is crucial in object graphs with bidirectional relationships.