uniqid - PHP code example

PHP Function Uniqid - Generate UUIDs in PHP

The php function uniqid is used to create unique IDs based on the microtime (the current time in microseconds). These unique IDs are useful for things like generating session IDs for users or tracking unique visitors to a website. The uniqid() function takes two optional parameters: prefix and more_entropy. The prefix parameter allows you to add a custom string to the beginning of the generated ID, while the more_entropy parameter increases the likelihood that the returned value is unique.

Unlike some other programming languages, PHP does not have built-in support for generating RFC 4122 compliant UUIDs. Fortunately, there are several 3rd-party solutions that allow you to generate UUIDs in PHP.

One of the most popular is random_bytes(), which is a simple and reliable method for generating unique identifiers. This function is not suitable for cryptographic purposes, however, because it only generates a string of bytes and does not provide any guarantees that the sequence will not be repeated. Luckily, there are other functions that can be used to generate UUIDs in PHP, such as bin2hex().

Another option is the mt_rand() function, which is a simple and secure way to generate pseudo-random numbers. This function requires no configuration parameters and is available on most systems, including Windows systems that do not have access to /dev/urandom. It is also possible to use mt_rand() in conjunction with mt_seq_hi_and_reserved(), which provides a more robust and secure alternative to mt_rand() for Windows systems that do not have mt_urandom available.

uniqid example

trait UnserializableTestTrait
{
    /** * @see AbstractStoreTestCase::getStore() */
    abstract protected function getStore(): PersistingStoreInterface;

    public function testUnserializableKey()
    {
        $store = $this->getStore();

        $key = new Key(uniqid(__METHOD__, true));

        $store->save($key);
        $this->assertTrue($store->exists($key));

        $this->expectException(UnserializableKeyException::class);
        serialize($key);
    }
}

'Shopware\Core\Framework\Update\Event\UpdatePostFinishEvent' => 'update',
            ],
            UpdateHtaccess::getSubscribedEvents()
        );
    }

    /** * @dataProvider getCombinations */
    public function testCombination(string $currentEnv, ?string $newEnv, string $expected): void
    {
        $fs = sys_get_temp_dir() . '/' . uniqid(__METHOD__, true) . '/';
        mkdir($fs);

        file_put_contents($fs . '.env', $currentEnv);

        if ($newEnv) {
            file_put_contents($fs . '.env.dist', $newEnv);
        }

        $updater = new UpdateHtaccess($fs . '.env');
        $updater->update();

/** * {@inheritdoc} */
    public function handle(
        CriteriaPartInterface $criteriaPart,
        Criteria $criteria,
        Search $search,
        ShopContextInterface $context
    ) {
        $randomQuery = new FunctionScoreQuery(new MatchAllQuery());
        $randomQuery->addRandomFunction(md5(uniqid('swag', true)));

        $search->addSort(new FieldSort('_score'));
        $search->addQuery($randomQuery);
    }
}

  public function testSkipInvalid($value) {
    $migration_plugin = $this->prophesize(MigrationInterface::class);
    $migration_plugin_manager = $this->prophesize(MigrationPluginManagerInterface::class);

    $configuration = [
      'migration' => 'foo',
    ];
    $migration_plugin->id()->willReturn(uniqid());
    $migration_plugin_manager->createInstances(['foo'])
      ->willReturn(['foo' => $migration_plugin->reveal()]);
    $migration = MigrationLookup::create($this->prepareContainer(), $configuration, '', [], $migration_plugin->reveal());
    $this->expectException(MigrateSkipProcessException::class);
    $migration->transform($value, $this->migrateExecutable, $this->row, 'foo');
  }

  /** * Provides data for the SkipInvalid test. * * @return array * Empty values. */

            $element['componentId'] = $element['component']['xType'];
            $fieldMapping = [];

            foreach ($element['component']['fields'] as $field) {
                $fieldMapping[$field['id']] = $field;
            }

            $element = $this->cleanupElementData($element, $fieldMapping);
            $element['viewports'] = $this->cleanupElementViewports($element['viewports']);
            $element['syncKey'] = uniqid('preset-element-', true);
            unset($element['component']);
        }

        return $elements;
    }

    /** * @return array */
    private function cleanupElementData(array $element, array $fieldMapping)
    {

$foo->dynamicProp = 123;
        $this->assertSame(123, @$foo->dynamicProp);
    }

    public static function getProxyCandidates(): array
    {
        $definitions = [
            [new Definition(__CLASS__), true],
            [new Definition('stdClass'), true],
            [new Definition(DumperInterface::class), true],
            [new Definition(uniqid('foo', true)), false],
            [new Definition(), false],
        ];

        array_map(
            function D$definition) {
                $definition[0]->setLazy(true);
            },
            $definitions
        );

        return $definitions;
    }

class TraceableEventDispatcher extends BaseTraceableEventDispatcher
{
    /** * @return void */
    protected function beforeDispatch(string $eventName, object $event)
    {
        switch ($eventName) {
            case KernelEvents::REQUEST:
                $event->getRequest()->attributes->set('_stopwatch_token', substr(hash('sha256', uniqid(mt_rand(), true)), 0, 6));
                $this->stopwatch->openSection();
                break;
            case KernelEvents::VIEW:
            case KernelEvents::RESPONSE:
                // stop only if a controller has been executed                 if ($this->stopwatch->isStarted('controller')) {
                    $this->stopwatch->stop('controller');
                }
                break;
            case KernelEvents::TERMINATE:
                $sectionId = $event->getRequest()->attributes->get('_stopwatch_token');

<?php use Config\Services;
use CodeIgniter\CodeIgniter;

$errorId = uniqid('error', true);
?> <!doctype html> <html> <head> <meta charset="UTF-8"> <meta name="robots" content="noindex"> <title><?= esc($title) ?></title> <style> <?= preg_replace('#[\r\n\t ]+#', ' ', file_get_contents(__DIR__ . DIRECTORY_SEPARATOR . 'debug.css')) ?> </style> <script>

$title = '-';
        if (isset($context['request'])) {
            $request = $context['request'];
            $controller = "<span class='dumped-tag'>{$this->dumper->dump($request['controller'], true, ['maxDepth' => 0])}</span>";
            $title = sprintf('<code>%s</code> <a href="%s">%s</a>', $request['method'], $uri = $request['uri'], $uri);
            $dedupIdentifier = $request['identifier'];
        } elseif (isset($context['cli'])) {
            $title = '<code>$ </code>'.$context['cli']['command_line'];
            $dedupIdentifier = $context['cli']['identifier'];
        } else {
            $dedupIdentifier = uniqid('', true);
        }

        $sourceDescription = '';
        if (isset($context['source'])) {
            $source = $context['source'];
            $projectDir = $source['project_dir'] ?? null;
            $sourceDescription = sprintf('%s on line %d', $source['name'], $source['line']);
            if (isset($source['file_link'])) {
                $sourceDescription = sprintf('<a href="%s">%s</a>', $source['file_link'], $sourceDescription);
            }
        }

  protected $defaultSchema = 'public';

  /** * A unique identifier for this query object. * * @var string */
  protected $uniqueIdentifier;

  public function __construct($connection) {
    $this->uniqueIdentifier = uniqid('', TRUE);
    $this->connection = $connection;
  }

  /** * Implements the magic __clone function. */
  public function __clone() {
    $this->uniqueIdentifier = uniqid('', TRUE);
  }

  /** * {@inheritdoc} */

foreach ($arguments as $name => $node) {
            if (!\is_int($name)) {
                return true;
            }
        }

        return false;
    }

    private function getVarName(): string
    {
        return sprintf('__internal_%s', hash('sha256', uniqid(mt_rand(), true), false));
    }
}

            $customer->setPassword(
                $this->passwordManager->encodePassword(
                    $customer->getPassword(),
                    $customer->getEncoderName()
                )
            );
        }

        // Account mode validation         if ($customer->getAccountMode() == Customer::ACCOUNT_MODE_FAST_LOGIN) {
            $customer->setPassword(md5(uniqid((string) rand())));
            $customer->setEncoderName('md5');
        }

        if (!$customer->getPaymentId()) {
            $customer->setPaymentId($this->config->get('defaultPayment'));
        }

        $subShop = $this->modelManager->find(ShopModel::class, $shop->getId());
        if (!$subShop instanceof ShopModel) {
            throw new ModelNotFoundException(ShopModel::class, $shop->getId());
        }

    public function add(string $body, array $headers, int $delayInMs = 0): string
    {
        if ($this->autoSetup) {
            $this->setup();
        }
        $redis = $this->getRedis();

        try {
            if ($delayInMs > 0) { // the delay is <= 0 for queued messages                 $id = uniqid('', true);
                $message = json_encode([
                    'body' => $body,
                    'headers' => $headers,
                    // Entry need to be unique in the sorted set else it would only be added once to the delayed messages queue                     'uniqid' => $id,
                ]);

                if (false === $message) {
                    throw new TransportException(json_last_error_msg());
                }

use Symfony\Component\Lock\SharedLockStoreInterface;
use Symfony\Component\Lock\Store\ExpiringStoreTrait;
use Symfony\Component\Lock\Store\InMemoryStore;

/** * @author Jérémy Derussé <jeremy@derusse.com> */
class LockTest extends TestCase
{
    public function testAcquireNoBlocking()
    {
        $key = new Key(uniqid(__METHOD__, true));
        $store = $this->createMock(PersistingStoreInterface::class);
        $lock = new Lock($key, $store);

        $store
            ->expects($this->once())
            ->method('save');
        $store
            ->method('exists')
            ->willReturnOnConsecutiveCalls(true, false);

        $this->assertTrue($lock->acquire(false));
    }

    abstract protected function getRedisConnection(): \Redis|Relay|\RedisArray|\RedisCluster|\Predis\ClientInterface;

    public function getStore(): PersistingStoreInterface
    {
        return new RedisStore($this->getRedisConnection());
    }

    public function testBackwardCompatibility()
    {
        $resource = uniqid(__METHOD__, true);
        $key1 = new Key($resource);
        $key2 = new Key($resource);

        $oldStore = new Symfony51Store($this->getRedisConnection());
        $newStore = $this->getStore();

        $oldStore->save($key1);
        $this->assertTrue($oldStore->exists($key1));

        $this->expectException(LockConflictedException::class);
        $newStore->save($key2);
    }