serialize - PHP code example

The php Function Serialize

The php function serialize is used to convert any value into its storable representation in string format. This is useful for storing and passing around PHP values without losing their type and structure. To turn the string back into the original PHP value, use unserialize().

Objects and arrays in PHP are complex data structures that aren’t really designed to be transported outside of a running script. To enable them to be moved between different systems, they must be made serializable. Serialization is the process of turning a data structure into a string of byte-streams that can be read and processed by other programs.

The PHP serialize() function turns an array, object, or any other complex data structure into a string that can be stored in a database, passed to another script, or sent as part of an HTTP request. It also allows for circular references within an object to be saved as they are serialized.

This is very useful for moving complex data between different systems, as the data can be transferred as a single string. In order to make it work, however, the data must be properly encapsulated in an object.

Fortunately, PHP has two hooks that can be called during the serialization and unserialization processes. The _ _sleep() and _ _wakeup() methods provide a way to make an object aware of the fact that it’s going to be serialized. If an object doesn’t have these methods, it won’t get notified and will lose its shape during the serialization process.

serialize example

foreach (($dbConfig['session'] ?? []) as $sessionKey => $sessionValue) {
                if (\is_int($sessionValue)) {
                    $conn->exec(sprintf('SET @@session.`%s` = %d;', $sessionKey, $sessionValue));
                } elseif (\is_float($sessionValue)) {
                    $conn->exec(sprintf('SET @@session.`%s` = %f;', $sessionKey, $sessionValue));
                } elseif (\is_string($sessionValue)) {
                    $conn->exec(sprintf('SET @@session.`%s` = %s;', $sessionKey, $conn->quote($sessionValue)));
                } elseif ($sessionValue === null) {
                    $conn->exec(sprintf('SET @@session.`%s` = NULL;', $sessionKey));
                } else {
                    throw new InvalidArgumentException(
                        sprintf('Unexpected database session value for %s: %s', $sessionKey, serialize($sessionValue))
                    );
                }
            }
        } catch (PDOException $e) {
            $message = str_replace(
                [
                    $dbConfig['username'],
                    $dbConfig['password'],
                ],
                '******',
                $e->getMessage()
            );

    /** * Tests that an empty container works properly. * * @covers ::dump * @covers ::getArray * @covers ::supportsMachineFormat */
    public function testDumpForEmptyContainer() {
      $serialized_definition = $this->dumper->dump();
      $this->assertEquals(serialize($this->containerDefinition), $serialized_definition);
    }

    /** * Tests that alias processing works properly. * * @covers ::getAliases * * @dataProvider getAliasesDataProvider */
    public function testGetAliases($aliases, $definition_aliases) {
      $this->containerDefinition['aliases'] = $definition_aliases;

$instance, $method] = $this->determineClass($library);

        $class = is_object($instance)
            ? get_class($instance)
            : null;

        $params = $this->prepareParams($params);

        // Is the output cached?         $cacheName = ! empty($cacheName)
            ? $cacheName
            : str_replace(['\\', '/'], '', $class) . $method . md5(serialize($params));

        if (! empty($this->cache) && $output = $this->cache->get($cacheName)) {
            return $output;
        }

        if (method_exists($instance, 'initController')) {
            $instance->initController(Services::request(), Services::response(), Services::logger());
        }

        if (! method_exists($instance, $method)) {
            throw ViewException::forInvalidCellMethod($class, $method);
        }

'email' => $email]
            );
        } else {
            // Check if mail address is already subscribed, return             if ($this->db->fetchOne('SELECT id FROM s_campaigns_mailaddresses WHERE email = ?', [$email])) {
                return false;
            }

            $optInNewsletter = $this->config->get('optinnewsletter');
            if ($optInNewsletter) {
                $hash = Random::getAlphanumericString(32);
                $data = serialize(['newsletter' => $email, 'subscribeToNewsletter' => true]);

                $link = $this->front->ensureRouter()->assemble([
                    'sViewport' => 'newsletter',
                    'action' => 'index',
                    'sConfirmation' => $hash,
                    'module' => 'frontend',
                ]);

                $this->sendMail($email, 'sOPTINNEWSLETTER', $link);

                $this->db->insert(

return $response;
    }

    /** * @param Request $request * * @return string */
    protected function getScript(object $request)
    {
        $kernel = var_export(serialize($this->kernel), true);
        $request = var_export(serialize($request), true);

        $errorReporting = error_reporting();

        $requires = '';
        foreach (get_declared_classes() as $class) {
            if (str_starts_with($class, 'ComposerAutoloaderInit')) {
                $r = new \ReflectionClass($class);
                $file = \dirname($r->getFileName(), 2).'/autoload.php';
                if (file_exists($file)) {
                    $requires .= 'require_once '.var_export($file, true).";\n";
                }

$mode = 0666;
        $umask = umask();
        $filesystem = new Filesystem();
        $filesystem->dumpFile($this->file, $content);
        try {
            $filesystem->chmod($this->file, $mode, $umask);
        } catch (IOException) {
            // discard chmod failure (some filesystem may not support it)         }

        if (null !== $metadata) {
            $filesystem->dumpFile($this->getMetaFile(), serialize($metadata));
            try {
                $filesystem->chmod($this->getMetaFile(), $mode, $umask);
            } catch (IOException) {
                // discard chmod failure (some filesystem may not support it)             }
        }

        if (\function_exists('opcache_invalidate') && filter_var(\ini_get('opcache.enable'), \FILTER_VALIDATE_BOOL)) {
            @opcache_invalidate($this->file, true);
        }
    }

$this->text = $text;
    }

    /** * String-ified version * * @return string */
    public function __toString()
    {
        // There is no $this->data here         return md5(serialize($this));
    }

    /** * Get the end time * * @return string|null Time in the format 'hh:mm:ss.SSS' */
    public function get_endtime()
    {
        if ($this->endTime !== null)
        {

private function loadConfigCacheMetadataFor(MappedAsset $mappedAsset): array
    {
        $cachedPath = $this->getConfigCachePath($mappedAsset).'.meta';

        return unserialize(file_get_contents($cachedPath));
    }

    private function saveConfigCache(MappedAsset $mappedAsset): void
    {
        $configCache = new ConfigCache($this->getConfigCachePath($mappedAsset), true);
        $configCache->write(serialize($mappedAsset), [new FileResource($mappedAsset->sourcePath)]);
    }

    private function getConfigCachePath(MappedAsset $mappedAsset): string
    {
        return $this->cacheDir.'/'.hash('xxh128', $mappedAsset->logicalPath.':'.$mappedAsset->sourcePath).'.php';
    }
}

$salutation = [
            'id' => Uuid::randomHex(),
            'salutationKey' => 'mrs',
            'translations' => [
                Defaults::LANGUAGE_SYSTEM => [
                    'displayName' => 'Mrs.',
                    'letterName' => 'Dear Mrs.',
                ],
            ],
        ];

        $serialized = iterator_to_array($this->serializer->serialize($config, $this->salutationRepository->getDefinition(), $salutation));

        $deserialized = iterator_to_array($this->serializer->deserialize($config, $this->salutationRepository->getDefinition(), $serialized));

        $expectedTranslations = $salutation['translations'][Defaults::LANGUAGE_SYSTEM];
        $actualTranslations = $deserialized['translations'][Defaults::LANGUAGE_SYSTEM];
        unset($salutation['translations'], $deserialized['translations']);

        static::assertEquals($salutation, $deserialized);
        static::assertEquals($expectedTranslations, $actualTranslations);
    }

'type_name' => 'story',
        'widget_active' => TRUE,
        'field_name' => 'field_test_filefield',
        'type' => 'filefield',
        'module' => 'filefield',
        'weight' => '8',
        'widget_type' => 'filefield_widget',
      ],
    ];

    // The source data.     $empty_array = serialize([]);
    $tests[0]['source_data']['content_node_field'] = [
      [
        'field_name' => 'field_test_filefield',
        'type' => 'filefield',
        'global_settings' => $empty_array,
        'required' => '0',
        'multiple' => '0',
        'db_storage' => '1',
        'module' => 'filefield',
        'db_columns' => $empty_array,
        'active' => '1',

namespace Symfony\Component\ExpressionLanguage\Tests;

use PHPUnit\Framework\TestCase;
use Symfony\Component\ExpressionLanguage\Expression;

class ExpressionTest extends TestCase
{
    public function testSerialization()
    {
        $expression = new Expression('kernel.boot()');

        $serializedExpression = serialize($expression);
        $unserializedExpression = unserialize($serializedExpression);

        $this->assertEquals($expression, $unserializedExpression);
    }
}

    // Store the selection settings in the key/value store and pass a hashed key     // in the route parameters.     $selection_settings = $element['#selection_settings'] ?? [];
    // Don't serialize the entity, it will be added explicitly afterwards.     if (isset($selection_settings['entity']) && ($selection_settings['entity'] instanceof EntityInterface)) {
      $element['#autocomplete_query_parameters']['entity_type'] = $selection_settings['entity']->getEntityTypeId();
      $element['#autocomplete_query_parameters']['entity_id'] = $selection_settings['entity']->id();
      unset($selection_settings['entity']);
    }
    $data = serialize($selection_settings) . $element['#target_type'] . $element['#selection_handler'];
    $selection_settings_key = Crypt::hmacBase64($data, Settings::getHashSalt());

    $key_value_storage = \Drupal::keyValue('entity_autocomplete');
    if (!$key_value_storage->has($selection_settings_key)) {
      $key_value_storage->set($selection_settings_key, $selection_settings);
    }

    $element['#autocomplete_route_name'] = 'system.entity_autocomplete';
    $element['#autocomplete_route_parameters'] = [
      'target_type' => $element['#target_type'],
      'selection_handler' => $element['#selection_handler'],

public function testSerialize()
    {
        $attributeMetadata = new AttributeMetadata('attribute');
        $attributeMetadata->addGroup('a');
        $attributeMetadata->addGroup('b');
        $attributeMetadata->setMaxDepth(3);
        $attributeMetadata->setSerializedName('serialized_name');
        $serializedPath = new PropertyPath('[serialized][path]');
        $attributeMetadata->setSerializedPath($serializedPath);

        $serialized = serialize($attributeMetadata);
        $this->assertEquals($attributeMetadata, unserialize($serialized));
    }
}

EOD;
        $this->addSql($sql);

        // Create Captcha Option in Password Reset         $sql = <<<'EOD' INSERT IGNORE s_core_config_elements (`form_id`, `name`, `value`, `label`, `description`, `type`, `required`, `position`, `scope`, `options`) VALUE (LAST_INSERT_ID(), 'passwordResetCaptcha', '%s', 'Captcha für das Zurücksetzen des Passworts', 'Wenn diese Option aktiv ist, wird das Formular zum Zurücksetzen des Passworts mit einem Captcha geschützt.', 'combo', 1, 0, 1, 'a:5:{s:8:"editable";b:0;s:10:"valueField";s:2:"id";s:12:"displayField";s:11:"displayname";s:13:"triggerAction";s:3:"all";s:5:"store";s:12:"base.Captcha";}'); EOD;
        $this->addSql(sprintf($sql, serialize('nocaptcha')));

        // Translation         $sql = <<<'EOD' SET @elementId = (SELECT id FROM `s_core_config_elements` WHERE `name` LIKE 'passwordResetCaptcha' LIMIT 1); EOD;
        $this->addSql($sql);

        $sql = <<<'EOD' INSERT IGNORE INTO `s_core_config_element_translations` (`element_id`, `locale_id`, `label`, `description`) VALUES (@elementId, '2', 'Use captcha for the password reset form', 'If this option is active, a captcha is used to protect the Password reset form.');

// object exists and is current                 return 'HIT';
        } else {
            // object does not exist             return 'MISS';
        }
    }

/*=======================================================================*\ Function: serialize \*=======================================================================*/
    function serialize ( $rss ) {
        return serialize( $rss );
    }

/*=======================================================================*\ Function: unserialize \*=======================================================================*/
    function unserialize ( $data ) {
        return unserialize( $data );
    }

/*=======================================================================*\ Function: file_name Purpose: map url to location in cache Input: url from which the rss file was fetched Output: a file name \*=======================================================================*/