spl_object_hash - PHP code example

The php Function spl_Object_Hash()

The php function spl_object_hash() takes an object and gives it a unique identifier. This can then be used as a key in an array or other data structure. It works in the same way as an address in C or an id in Python.

A hash is not equals or contains; it algorithmically reduces data to a scalar value. So a hash does not guarantee that two identical inputs will provide the same output. However, an object's hash can be used as a key to a data structure, and that means it is possible for the same object to appear twice in an array.

This is what makes spl_object_hash() useful. This function can take a string and return a lowercase hex number. It is a great way to make a key for an array.

It is also useful when serializing objects and unserializing them. Since the hex numbers are unique, the object can still be identified after it is recreated. This can be especially helpful in situations where multiple copies of an object must exist (like a response cache).

The function spl_object_id() does a similar job but it is older and it doesn't really provide any more information than spl_object_hash. The newer spl_object_hash() is more useful and it's probably worth migrating if you're using this function.

It is also important to note that this function is only useful if the objects are stored in the same order. Performing a containment check before calling attach() will not change the order of the object set. In fact, doing so will probably be redundant and expensive.

spl_object_hash example

  public static function generateServiceIdHash($object) {
    @trigger_error(__METHOD__ . "() is deprecated in drupal:9.5.1 and is removed from drupal:11.0.0. Use the 'Drupal\Component\DependencyInjection\ReverseContainer' service instead. See https://www.drupal.org/node/3327942", E_USER_DEPRECATED);
    // Include class name as an additional namespace for the hash since     // spl_object_hash's return can be recycled. This still is not a 100%     // guarantee to be unique but makes collisions incredibly difficult and even     // then the interface would be preserved.     // @see https://php.net/spl_object_hash#refsect1-function.spl-object-hash-notes     return hash('sha256', get_class($object) . spl_object_hash($object));
  }

  /** * {@inheritdoc} */
  public function getServiceIdMapping() {
    @trigger_error(__METHOD__ . "() is deprecated in drupal:9.5.1 and is removed from drupal:11.0.0. Use the 'Drupal\Component\DependencyInjection\ReverseContainer' service instead. See https://www.drupal.org/node/3327942", E_USER_DEPRECATED);
    $this->collectServiceIdMapping();
    return $this->serviceIdMapping;
  }

$entity = EntityTestMul::create([
      'name' => 'test',
      'langcode' => $default_langcode,
    ]);
    $entity->save();
    $entity->addTranslation($translation_langcode)->save();

    // Test that the default translation object is put into the translation     // object cache when a new translation object is initialized.     $entity = \Drupal::entityTypeManager()->getStorage($entity->getEntityTypeId())->loadUnchanged($entity->id());
    $default_translation_spl_object_hash = spl_object_hash($entity);
    $this->assertEquals($default_translation_spl_object_hash, spl_object_hash($entity->getTranslation($translation_langcode)->getTranslation($default_langcode)));

    // Test that non-default translations are always served from the translation     // object cache.     $entity = \Drupal::entityTypeManager()->getStorage($entity->getEntityTypeId())->loadUnchanged($entity->id());
    $this->assertEquals(spl_object_hash($entity->getTranslation($translation_langcode)), spl_object_hash($entity->getTranslation($translation_langcode)));
    $this->assertEquals(spl_object_hash($entity->getTranslation($translation_langcode)), spl_object_hash($entity->getTranslation($translation_langcode)->getTranslation($default_langcode)->getTranslation($translation_langcode)));
  }

}

$scheme, $rest] = explode(':', $dsn, 2);
        $driver = strtok($scheme, '+');
        if (!\in_array($driver, ['pgsql', 'postgres', 'postgresql'])) {
            throw new InvalidArgumentException(sprintf('The adapter "%s" does not support the "%s" driver.', __CLASS__, $driver));
        }

        return sprintf('%s:%s', $driver, $rest);
    }

    private function getInternalStore(): SharedLockStoreInterface
    {
        $namespace = spl_object_hash($this->conn);

        return self::$storeRegistry[$namespace] ??= new InMemoryStore();
    }
}

'has_children_error' => false,
             'children' => [
                 'child' => $childFormData,
             ],
         ];

        $this->assertEquals([
            'forms' => [
                'name' => $formData,
            ],
            'forms_by_hash' => [
                spl_object_hash($this->form) => $formData,
                spl_object_hash($this->childForm) => $childFormData,
            ],
            'nb_errors' => 0,
         ], $this->dataCollector->getData());
    }

    public function testBuildMultiplePreliminaryFormTrees()
    {
        $form1 = $this->createForm('form1');
        $form2 = $this->createForm('form2');

return $array;
    }

    /** * Parses an object into a Kint InstanceValue structure. * * @param object &$var The input variable * @param Value $o The base object */
    private function parseObject(&$var, Value $o): Value
    {
        $hash = \spl_object_hash($var);
        $values = (array) $var;

        $object = new InstanceValue();
        $object->transplant($o);
        $object->classname = \get_class($var);
        $object->spl_object_hash = $hash;
        $object->size = \count($values);

        if (KINT_PHP72) {
            $object->spl_object_id = \spl_object_id($var);
        }

$container->loadFromExtension('framework', $config);

        $container->loadFromExtension('web_profiler', [
            'toolbar' => true,
            'intercept_redirects' => false,
        ]);
    }

    public function getCacheDir(): string
    {
        return sys_get_temp_dir().'/cache-'.spl_object_hash($this);
    }

    public function getLogDir(): string
    {
        return sys_get_temp_dir().'/log-'.spl_object_hash($this);
    }

    protected function build(ContainerBuilder $container): void
    {
        $container->register('data_collector.dump', DumpDataCollector::class);
        $container->register('logger', NullLogger::class);
    }

public function isObjectInitialized(string $cacheKey): bool
    {
        return isset($this->initializedObjects[$cacheKey]);
    }

    /** * @internal */
    public function generateCacheKey(object $object): string
    {
        if (!isset($this->cachedObjectsRefs[$object])) {
            $this->cachedObjectsRefs[$object] = spl_object_hash($object);
        }

        return $this->cachedObjectsRefs[$object];
    }

    public function __clone()
    {
        $this->violations = clone $this->violations;
    }
}

->setParameter('{{ type }}', $e->getExpectedType())
                    ->addViolation();
            }
        }
    }

    private function generateCacheKey(object $object, bool $dependsOnPropertyPath = false): string
    {
        if ($this->context instanceof ExecutionContext) {
            $cacheKey = $this->context->generateCacheKey($object);
        } else {
            $cacheKey = spl_object_hash($object);
        }

        if ($dependsOnPropertyPath) {
            $cacheKey .= $this->context->getPropertyPath();
        }

        return $cacheKey;
    }
}

/** * @author Fabien Potencier <fabien@symfony.com> */
final class CallbackTrigger implements TriggerInterface
{
    private \Closure $callback;
    private string $description;

    public function __construct(callable $callback, string $description = null)
    {
        $this->callback = $callback(...);
        $this->description = $description ?? spl_object_hash($this->callback);
    }

    public function __toString(): string
    {
        return $this->description;
    }

    public function getNextRunDate(\DateTimeImmutable $run): ?\DateTimeImmutable
    {
        return ($this->callback)($run);
    }
}

/** * @internal */
class KernelTestBehaviourTest extends TestCase
{
    use KernelTestBehaviour;

    private string $kernelId;

    protected function setUp(): void
    {
        $this->kernelId = spl_object_hash($this->getKernel());
    }

    protected function tearDown(): void
    {
        if (!$this->kernelId === spl_object_hash($this->getKernel())) {
            throw new \RuntimeException('Kernel has changed');
        }
    }

    public function testTheKernelIsEqual(): void
    {

public function hasListeners(string $eventName = null): bool
    {
        return $this->dispatcher->hasListeners($eventName);
    }

    public function dispatch(object $event, string $eventName = null): object
    {
        $eventName ??= $event::class;

        $this->callStack ??= new \SplObjectStorage();

        $currentRequestHash = $this->currentRequestHash = $this->requestStack && ($request = $this->requestStack->getCurrentRequest()) ? spl_object_hash($request) : '';

        if (null !== $this->logger && $event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
            $this->logger->debug(sprintf('The "%s" event is already stopped. No listeners have been called.', $eventName));
        }

        $this->preProcess($eventName);
        try {
            $this->beforeDispatch($eventName, $event);
            try {
                $e = $this->stopwatch->start($eventName, 'section');
                try {

private function createRepository(EntityManagerInterface $entityManager, string $entityName): ObjectRepository
    {
        $metadata = $entityManager->getClassMetadata($entityName);
        $repositoryClassName = $metadata->customRepositoryClassName ?: $entityManager->getConfiguration()->getDefaultRepositoryClassName();

        return new $repositoryClassName($entityManager, $metadata);
    }

    private function getRepositoryHash(EntityManagerInterface $entityManager, string $entityName): string
    {
        return $entityManager->getClassMetadata($entityName)->getName().spl_object_hash($entityManager);
    }
}

    if ( is_object( $callback ) ) {
        // Closures are currently implemented as objects.         $callback = array( $callback, '' );
    } else {
        $callback = (array) $callback;
    }

    if ( is_object( $callback[0] ) ) {
        // Object class calling.         return spl_object_hash( $callback[0] ) . $callback[1];
    } elseif ( is_string( $callback[0] ) ) {
        // Static calling.         return $callback[0] . '::' . $callback[1];
    }
}

'SunOS' => 'Solaris',
        ];

        return $map[\PHP_OS] ?? 'Unknown';
    }

    public static function spl_object_id($object)
    {
        if (null === self::$hashMask) {
            self::initHashMask();
        }
        if (null === $hash = spl_object_hash($object)) {
            return;
        }

        // On 32-bit systems, PHP_INT_SIZE is 4,         return self::$hashMask ^ hexdec(substr($hash, 16 - (\PHP_INT_SIZE * 2 - 1), \PHP_INT_SIZE * 2 - 1));
    }

    public static function sapi_windows_vt100_support($stream, $enable = null)
    {
        if (!\is_resource($stream)) {
            trigger_error('sapi_windows_vt100_support() expects parameter 1 to be resource, '.\gettype($stream).' given', \E_USER_WARNING);