Генераторы уникальных ID

<?php

declare(strict_types=1);

use Ramsey\Uuid\Uuid;

$id = Uuid::uuid7()->toString();
// 018efab2-2d1a-7b0e-9b7f-1234567890ab
//    ^timestamp^

// Custom time:
$id = Uuid::uuid7(new \DateTimeImmutable('2025-01-01'));

package main

import "github.com/google/uuid"

func main() {
	id, err := uuid.NewV7()
	if err != nil {
		panic(err)
	}
	_ = id.String()
}

// .NET 9+ has UUID v7 built in -- no package needed
var id = Guid.CreateVersion7().ToString();
// 018efab2-2d1a-7b0e-9b7f-1234567890ab
//    ^timestamp^

// Custom time:
var backdated = Guid.CreateVersion7(new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero));

// On .NET 8 and earlier use the UUIDNext package: Uuid.NewSequential()

from datetime import datetime, timezone

from uuid_utils import uuid7  # pip install uuid-utils

id_ = str(uuid7())
# 018efab2-2d1a-7b0e-9b7f-1234567890ab
#    ^timestamp^

# Custom time: the constructor takes whole seconds plus optional nanoseconds
ts = int(datetime(2025, 1, 1, tzinfo=timezone.utc).timestamp())
backdated = str(uuid7(timestamp=ts))

# stdlib uuid has no v7 generator as of 3.13 -- only UUID(int=...) parsing

<?php

declare(strict_types=1);

namespace App\Ids;

/**
 * Twitter Snowflake: 41 bit timestamp | 10 bit machine | 12 bit sequence.
 *
 * Not safe across forks -- keep one instance per process.
 * NTP must be enabled; clock rollback triggers an exception.
 */
final class Snowflake
{
    private const EPOCH = 1_704_067_200_000; // 2024-01-01 UTC in ms
    private const MACHINE_BITS = 10;
    private const SEQUENCE_BITS = 12;
    private const MAX_MACHINE = (1 << self::MACHINE_BITS) - 1;
    private const MAX_SEQUENCE = (1 << self::SEQUENCE_BITS) - 1;

    private int $lastTimestamp = -1;
    private int $sequence = 0;

    public function __construct(private readonly int $machineId)
    {
        if ($machineId < 0 || $machineId > self::MAX_MACHINE) {
            throw new \InvalidArgumentException("machine_id out of range");
        }
    }

    public function next(): int
    {
        $ts = $this->currentMs();

        if ($ts < $this->lastTimestamp) {
            // Clock moved backward. Either wait or throw.
            throw new \RuntimeException(
                "clock moved backward: last=$this->lastTimestamp, now=$ts",
            );
        }

        if ($ts === $this->lastTimestamp) {
            $this->sequence = ($this->sequence + 1) & self::MAX_SEQUENCE;
            if ($this->sequence === 0) {
                // Sequence overflow -- wait for next ms
                $ts = $this->waitNextMs($this->lastTimestamp);
            }
        } else {
            $this->sequence = 0;
        }

        $this->lastTimestamp = $ts;

        return (($ts - self::EPOCH) << (self::MACHINE_BITS + self::SEQUENCE_BITS))
             | ($this->machineId << self::SEQUENCE_BITS)
             | $this->sequence;
    }

    public static function extractTimestampMs(int $id): int
    {
        return (int) ($id >> (self::MACHINE_BITS + self::SEQUENCE_BITS)) + self::EPOCH;
    }

    public static function extractMachineId(int $id): int
    {
        return ($id >> self::SEQUENCE_BITS) & self::MAX_MACHINE;
    }

    private function currentMs(): int
    {
        return (int) (microtime(true) * 1000);
    }

    private function waitNextMs(int $last): int
    {
        $ts = $this->currentMs();
        while ($ts <= $last) {
            usleep(100);
            $ts = $this->currentMs();
        }
        return $ts;
    }
}

// Usage:
// $gen = new Snowflake(machineId: 7);
// $id = $gen->next();
// echo $id, "\n";

package ids

import (
	"errors"
	"fmt"
	"sync"
	"time"
)

const (
	epoch         int64 = 1_704_067_200_000 // 2024-01-01
	machineBits         = 10
	sequenceBits        = 12
	maxMachine    int64 = (1 << machineBits) - 1
	maxSequence   int64 = (1 << sequenceBits) - 1
	timestampShift      = machineBits + sequenceBits
)

type Snowflake struct {
	mu            sync.Mutex
	machineID     int64
	lastTimestamp int64
	sequence      int64
}

func NewSnowflake(machineID int64) (*Snowflake, error) {
	if machineID < 0 || machineID > maxMachine {
		return nil, fmt.Errorf("machine_id out of range: %d", machineID)
	}
	return &Snowflake{machineID: machineID, lastTimestamp: -1}, nil
}

// Next returns a new monotonic ID; safe for concurrent use.
func (s *Snowflake) Next() (int64, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	ts := time.Now().UnixMilli()

	if ts < s.lastTimestamp {
		return 0, errors.New("clock moved backward")
	}

	if ts == s.lastTimestamp {
		s.sequence = (s.sequence + 1) & maxSequence
		if s.sequence == 0 {
			ts = s.waitNextMs(s.lastTimestamp)
		}
	} else {
		s.sequence = 0
	}
	s.lastTimestamp = ts

	id := ((ts - epoch) << timestampShift) | (s.machineID << sequenceBits) | s.sequence
	return id, nil
}

func (s *Snowflake) waitNextMs(last int64) int64 {
	for {
		ts := time.Now().UnixMilli()
		if ts > last {
			return ts
		}
	}
}

func ExtractTimestamp(id int64) time.Time {
	ms := (id >> timestampShift) + epoch
	return time.UnixMilli(ms)
}

func ExtractMachine(id int64) int64 {
	return (id >> sequenceBits) & maxMachine
}

using System.Diagnostics;

namespace App.Ids;

/// Twitter Snowflake: 41 bit timestamp | 10 bit machine | 12 bit sequence.
///
/// Thread-safe via a lock -- unlike PHP, a single instance is shared across threads.
/// NTP must be enabled; a clock rollback throws.
public sealed class Snowflake
{
    private const long Epoch = 1_704_067_200_000L; // 2024-01-01 UTC in ms
    private const int MachineBits = 10;
    private const int SequenceBits = 12;
    private const long MaxMachine = (1L << MachineBits) - 1;
    private const long MaxSequence = (1L << SequenceBits) - 1;
    private const int TimestampShift = MachineBits + SequenceBits;

    // .NET 9 has a dedicated Lock type; object keeps this valid on C# 12
    private readonly object _gate = new();
    private readonly long _machineId;
    private long _lastTimestamp = -1;
    private long _sequence;

    public Snowflake(long machineId)
    {
        if (machineId is < 0 or > MaxMachine)
        {
            throw new ArgumentOutOfRangeException(nameof(machineId), "machine_id out of range");
        }

        _machineId = machineId;
    }

    public long Next()
    {
        lock (_gate)
        {
            var ts = CurrentMs();

            if (ts < _lastTimestamp)
            {
                // Clock moved backward. Either wait or throw.
                throw new InvalidOperationException(
                    $"clock moved backward: last={_lastTimestamp}, now={ts}");
            }

            if (ts == _lastTimestamp)
            {
                _sequence = (_sequence + 1) & MaxSequence;
                if (_sequence == 0)
                {
                    // Sequence overflow -- wait for the next ms
                    ts = WaitNextMs(_lastTimestamp);
                }
            }
            else
            {
                _sequence = 0;
            }

            _lastTimestamp = ts;

            return ((ts - Epoch) << TimestampShift)
                 | (_machineId << SequenceBits)
                 | _sequence;
        }
    }

    public static DateTimeOffset ExtractTimestamp(long id) =>
        DateTimeOffset.FromUnixTimeMilliseconds((id >> TimestampShift) + Epoch);

    public static long ExtractMachineId(long id) => (id >> SequenceBits) & MaxMachine;

    private static long CurrentMs() => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

    private static long WaitNextMs(long last)
    {
        var spinner = new SpinWait();
        long ts;
        while ((ts = CurrentMs()) <= last)
        {
            spinner.SpinOnce();
        }

        return ts;
    }
}

// Usage:
// var gen = new Snowflake(machineId: 7);
// long id = gen.Next();

import threading
import time

EPOCH_MS = 1_704_067_200_000  # 2024-01-01 UTC in ms
MACHINE_BITS = 10
SEQUENCE_BITS = 12
MAX_MACHINE = (1 << MACHINE_BITS) - 1
MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1
TIMESTAMP_SHIFT = MACHINE_BITS + SEQUENCE_BITS

class ClockRollbackError(RuntimeError):
    """System clock moved backwards; generating IDs would risk collisions."""

class Snowflake:
    """41 bit timestamp | 10 bit machine | 12 bit sequence.

    The lock is still required even under the GIL: the read-modify-write of
    (last_timestamp, sequence) spans several bytecodes and can be preempted.
    NTP must be enabled; a clock rollback raises.
    """

    __slots__ = ("_machine_id", "_last_timestamp", "_sequence", "_lock")

    def __init__(self, machine_id: int) -> None:
        if not 0 <= machine_id <= MAX_MACHINE:
            raise ValueError("machine_id out of range")
        self._machine_id = machine_id
        self._last_timestamp = -1
        self._sequence = 0
        self._lock = threading.Lock()

    def next(self) -> int:
        with self._lock:
            ts = self._current_ms()

            if ts < self._last_timestamp:
                raise ClockRollbackError(
                    f"clock moved backward: last={self._last_timestamp}, now={ts}"
                )

            if ts == self._last_timestamp:
                self._sequence = (self._sequence + 1) & MAX_SEQUENCE
                if self._sequence == 0:
                    # Sequence overflow -- wait for the next ms
                    ts = self._wait_next_ms(self._last_timestamp)
            else:
                self._sequence = 0

            self._last_timestamp = ts

            return (
                ((ts - EPOCH_MS) << TIMESTAMP_SHIFT)
                | (self._machine_id << SEQUENCE_BITS)
                | self._sequence
            )

    @staticmethod
    def extract_timestamp_ms(id_: int) -> int:
        return (id_ >> TIMESTAMP_SHIFT) + EPOCH_MS

    @staticmethod
    def extract_machine_id(id_: int) -> int:
        return (id_ >> SEQUENCE_BITS) & MAX_MACHINE

    @staticmethod
    def _current_ms() -> int:
        return time.time_ns() // 1_000_000

    @classmethod
    def _wait_next_ms(cls, last: int) -> int:
        ts = cls._current_ms()
        while ts <= last:
            time.sleep(0.0001)
            ts = cls._current_ms()
        return ts

# Usage:
# gen = Snowflake(machine_id=7)
# print(gen.next())

// composer require robinvdvleuten/ulid
use Ulid\Ulid;
$id = (string) Ulid::generate();

import "github.com/oklog/ulid/v2"

id := ulid.Make().String()

// composer require hidehalo/nanoid-php
$id = (new \Hidehalo\Nanoid\Client())->generateId();

import "github.com/matoous/go-nanoid/v2"
id, _ := gonanoid.New()