spl_object_id - PHP code example

Using the PHP Function spl_Object_ID

PHP has a number of functions that allow developers to add code to a program. This code is executed by calling the function, which can be done by typing a short sequence of letters and underscores, or by using an argument to specify the function. Functions are powerful, and can be used to do a wide range of things.

Immutable data structures are useful, and they can help you avoid heisenbugs by making it easier to track what's happening to your data. While PHP doesn't provide immutable data out of the box (except for constants), it is possible to approximate this functionality. This article will take a look at how to do that.

Functions

The spl_object_id() function gives you an identifier that uniquely identifies an object for its lifetime, similar to the address of an object in C or the id() function in Python. This can be very helpful, especially if you have an object-relational mapper.

PHP supports a variety of types, from simple scalars like int and string to complex structures like arrays and objects. Each type has a different way that it can be used, and a different set of restrictions on what can be done with it. The type of a variable or expression can be determined by using the function gettype(). This function returns a human readable representation of the data type of an expression, which can be very helpful when debugging or reviewing code. There are also a few functions to check the type of a variable or expression, including is_bool($value), is_float($value), is_array($value), is_iterable($value), and is_resource($value).

spl_object_id example

error_log($formatter($level, $message, $context, false));
        }

        if ($this->debug && $this->requestStack) {
            $this->record($level, $message, $context);
        }
    }

    public function getLogs(Request $request = null): array
    {
        if ($request) {
            return $this->logs[spl_object_id($request)] ?? [];
        }

        return array_merge(...array_values($this->logs));
    }

    public function countErrors(Request $request = null): int
    {
        if ($request) {
            return $this->errorCount[spl_object_id($request)] ?? 0;
        }

        $currentRequestData = [
            'controller' => $request->attributes->get('_controller'),
            'route' => $request->attributes->get('_route'),
        ];

        if ($this->includeParams) {
            $currentRequestData['route_params'] = $request->attributes->get('_route_params');
        }

        $this->routeData[spl_object_id($request)] = $currentRequestData;
    }

    public function removeRouteData(FinishRequestEvent $event): void
    {
        $requestId = spl_object_id($event->getRequest());
        unset($this->routeData[$requestId]);
    }

    public static function getSubscribedEvents(): array
    {
        return [

        // before the constructor is run. If you need to assign fields after         // the constructor is run. See https://www.drupal.org/node/315092.         $this->setFetchMode(\PDO::FETCH_CLASS, $options['fetch']);
      }
      else {
        $this->setFetchMode($options['fetch']);
      }
    }

    if ($this->connection->isEventEnabled(StatementExecutionStartEvent::class)) {
      $startEvent = new StatementExecutionStartEvent(
        spl_object_id($this),
        $this->connection->getKey(),
        $this->connection->getTarget(),
        $this->getQueryString(),
        $args ?? [],
        $this->connection->findCallerFromDebugBacktrace()
      );
      $this->connection->dispatchEvent($startEvent);
    }

    // Prepare the query.     $statement = $this->getStatement($this->queryString, $args);

$new         = clone $this;
        $new->string = $newSqlString;

        return $new;
    }

    /** * Returns unique id for binding key */
    public function getBindingKey(): string
    {
        return 'RawSql' . spl_object_id($this);
    }
}

case \is_array($v):
                        if (!$v) {
                            continue 2;
                        }
                        $stub = $arrayStub;

                        $stub->class = array_is_list($v) ? Stub::ARRAY_INDEXED : Stub::ARRAY_ASSOC;
                        $a = $v;
                        break;

                    case \is_object($v):
                        if (empty($objRefs[$h = spl_object_id($v)])) {
                            $stub = new Stub();
                            $stub->type = Stub::TYPE_OBJECT;
                            $stub->class = $v::class;
                            $stub->value = $v;
                            $stub->handle = $h;
                            $a = $this->castObject($stub, 0 < $i);
                            if ($v !== $stub->value) {
                                if (Stub::TYPE_OBJECT !== $stub->type || null === $stub->value) {
                                    break;
                                }
                                $stub->handle = $h = spl_object_id($stub->value);
                            }

// \PDO::FETCH_PROPS_LATE tells __construct() to run before properties         // are added to the object.         $this->setFetchMode(\PDO::FETCH_CLASS | \PDO::FETCH_PROPS_LATE, $options['fetch']);
      }
      else {
        $this->setFetchMode($options['fetch']);
      }
    }

    if ($this->connection->isEventEnabled(StatementExecutionStartEvent::class)) {
      $startEvent = new StatementExecutionStartEvent(
        spl_object_id($this),
        $this->connection->getKey(),
        $this->connection->getTarget(),
        $this->getQueryString(),
        $args ?? [],
        $this->connection->findCallerFromDebugBacktrace()
      );
      $this->connection->dispatchEvent($startEvent);
    }

    $return = $this->clientStatement->execute($args);
    $this->markResultsetIterable($return);

    public function getResultSetMapping()
    {
        return $this->currentPersisterContext->rsm;
    }

    /** * {@inheritDoc} */
    public function addInsert($entity)
    {
        $this->queuedInserts[spl_object_id($entity)] = $entity;
    }

    /** * {@inheritDoc} */
    public function getInserts()
    {
        return $this->queuedInserts;
    }

    /** * {@inheritDoc} */

if (!function_exists('stream_isatty')) {
    function stream_isatty($stream) { return p\Php72::stream_isatty($stream); }
}
if (!function_exists('utf8_encode')) {
    function utf8_encode($string) { return p\Php72::utf8_encode($string); }
}
if (!function_exists('utf8_decode')) {
    function utf8_decode($string) { return p\Php72::utf8_decode($string); }
}
if (!function_exists('spl_object_id')) {
    function spl_object_id($object) { return p\Php72::spl_object_id($object); }
}
if (!function_exists('mb_ord')) {
    function mb_ord($string, $encoding = null) { return p\Php72::mb_ord($string, $encoding); }
}
if (!function_exists('mb_chr')) {
    function mb_chr($codepoint, $encoding = null) { return p\Php72::mb_chr($codepoint, $encoding); }
}
if (!function_exists('mb_scrub')) {
    function mb_scrub($string, $encoding = null) { $encoding = null === $encoding ? mb_internal_encoding() : $encoding; return mb_convert_encoding($string, $encoding, $encoding); }
}

if (\in_array($rel, $link->getRels())) {
                $links[] = $link;
            }
        }

        return $links;
    }

    public function withLink(LinkInterface $link): static
    {
        $that = clone $this;
        $that->links[spl_object_id($link)] = $link;

        return $that;
    }

    public function withoutLink(LinkInterface $link): static
    {
        $that = clone $this;
        unset($that->links[spl_object_id($link)]);

        return $that;
    }
}

        $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);
        }

        if (isset($this->object_hashes[$hash])) {
            $object->hints[] = 'recursion';

            $this->applyPlugins($var, $object, self::TRIGGER_RECURSION);

            return $object;
        }

        $this->object_hashes[$hash] = $object;

private array $records = [];
    private array $errorCount = [];
    private ?RequestStack $requestStack;

    public function __construct(RequestStack $requestStack = null)
    {
        $this->requestStack = $requestStack;
    }

    private function doInvoke(array|LogRecord $record): array|LogRecord
    {
        $key = $this->requestStack && ($request = $this->requestStack->getCurrentRequest()) ? spl_object_id($request) : '';

        $timestampRfc3339 = false;
        if ($record['datetime'] instanceof \DateTimeInterface) {
            $timestamp = $record['datetime']->getTimestamp();
            $timestampRfc3339 = $record['datetime']->format(\DateTimeInterface::RFC3339_EXTENDED);
        } elseif (false !== $timestamp = strtotime($record['datetime'])) {
            $timestampRfc3339 = (new \DateTimeImmutable($record['datetime']))->format(\DateTimeInterface::RFC3339_EXTENDED);
        }

        $this->records[$key][] = [
            'timestamp' => $timestamp,

    protected function getConstraints(Field $field): array
    {
        return [];
    }

    /** * @return Constraint[] */
    protected function getCachedConstraints(Field $field): array
    {
        $key = $field->getPropertyName() . spl_object_id($field);

        if (\array_key_exists($key, $this->cachedConstraints)) {
            return $this->cachedConstraints[$key];
        }

        return $this->cachedConstraints[$key] = $this->getConstraints($field);
    }

    protected function sanitize(HtmlSanitizer $sanitizer, KeyValuePair $data, Field $field, EntityExistence $existence): ?string
    {
        if ($data->getValue() === null) {