不同AI生成的PHP版雪花算法

OpenAI

<?php
/*** Snowflake 雪花算法生成器* 生成的 64 位 ID 结构：*  1 位    保留位（始终为0，防止负数）*  41 位   时间戳（毫秒级，当前时间减去自定义纪元）*  5 位    数据中心ID*  5 位    机器ID*  12 位   序列号（同一毫秒内生成多个 ID）*/
class Snowflake
{// 自定义纪元（起始时间戳），可根据实际情况调整private $twepoch = 1288834974657;// 各部分占用的位数private $workerIdBits     = 5;   // 机器ID位数private $datacenterIdBits = 5;   // 数据中心ID位数private $sequenceBits     = 12;  // 序列号位数// 各部分的最大数值（通过位运算计算）private $maxWorkerId;private $maxDatacenterId;private $sequenceMask;// 各部分左移位数private $workerIdShift;private $datacenterIdShift;private $timestampLeftShift;// 工作机器ID和数据中心ID（取值范围 0 ~ 最大值）private $workerId;private $datacenterId;// 序列号，记录同一毫秒内生成的ID序号private $sequence = 0;// 上一次生成ID的时间戳，初始化为 -1private $lastTimestamp = -1;/*** 构造函数** @param int $workerId      机器ID（0 ~ 31）* @param int $datacenterId  数据中心ID（0 ~ 31）*/public function __construct($workerId, $datacenterId){// 计算各部分最大值：如 -1 << 5 得到 0b11111 (31)$this->maxWorkerId     = -1 ^ (-1 << $this->workerIdBits);$this->maxDatacenterId = -1 ^ (-1 << $this->datacenterIdBits);// 序列号最大值（4095：12位全1）$this->sequenceMask    = -1 ^ (-1 << $this->sequenceBits);// 检查传入的机器ID和数据中心ID是否合法if ($workerId > $this->maxWorkerId || $workerId < 0) {throw new Exception("机器ID必须在 0 到 " . $this->maxWorkerId . " 之间");}if ($datacenterId > $this->maxDatacenterId || $datacenterId < 0) {throw new Exception("数据中心ID必须在 0 到 " . $this->maxDatacenterId . " 之间");}$this->workerId     = $workerId;$this->datacenterId = $datacenterId;// 计算各部分需要左移的位数// 序列号占用 12 位，因此机器ID需要左移 12 位$this->workerIdShift     = $this->sequenceBits;// 数据中心ID需要左移 12 + 5 = 17 位$this->datacenterIdShift = $this->sequenceBits + $this->workerIdBits;// 时间戳需要左移 12 + 5 + 5 = 22 位$this->timestampLeftShift = $this->sequenceBits + $this->workerIdBits + $this->datacenterIdBits;}/*** 生成下一个唯一ID** @return int 64位的唯一ID*/public function nextId(){// 获取当前毫秒级时间戳$timestamp = $this->timeGen();// 如果当前时间小于上一次生成ID的时间戳，则说明系统时钟回拨，无法生成IDif ($timestamp < $this->lastTimestamp) {throw new Exception("时钟回拨异常，拒绝生成ID. 差值: " . ($this->lastTimestamp - $timestamp) . " 毫秒");}// 如果当前时间与上次生成ID时间相同，表示同一毫秒内生成多个IDif ($timestamp == $this->lastTimestamp) {// 序列号自增，并通过位运算确保在 12 位内（最大值为 4095）$this->sequence = ($this->sequence + 1) & $this->sequenceMask;// 如果序列号达到最大值，则等待下一毫秒if ($this->sequence == 0) {$timestamp = $this->tilNextMillis($this->lastTimestamp);}} else {// 不同毫秒内，序列号重置为 0$this->sequence = 0;}// 更新上一次生成ID的时间戳$this->lastTimestamp = $timestamp;/*** 拼接各部分生成最终ID：* 1. (当前时间戳 - 自定义纪元) 左移 TIMESTAMP_LEFT_SHIFT 位* 2. 数据中心ID左移 DATACENTER_ID_SHIFT 位* 3. 机器ID左移 WORKER_ID_SHIFT 位* 4. 序列号（低12位）* 最终通过按位或（|）运算组合成一个 64 位的整数*/$id = (($timestamp - $this->twepoch) << $this->timestampLeftShift)| ($this->datacenterId << $this->datacenterIdShift)| ($this->workerId << $this->workerIdShift)| $this->sequence;return $id;}/*** 等待直到下一毫秒** @param int $lastTimestamp 上次生成ID的时间戳* @return int 下一毫秒的时间戳*/private function tilNextMillis($lastTimestamp){$timestamp = $this->timeGen();// 循环等待直到时间戳发生变化（进入下一毫秒）while ($timestamp <= $lastTimestamp) {$timestamp = $this->timeGen();}return $timestamp;}/*** 获取当前时间戳（毫秒级）** @return int 当前毫秒级时间戳*/private function timeGen(){// microtime(true) 返回秒为单位的小数，将其乘以 1000 转换为毫秒return (int) (microtime(true) * 1000);}
}// ------------------------- 测试示例 ------------------------- //// 创建一个 Snowflake 实例，指定机器ID和数据中心ID
try {$snowflake = new Snowflake(1, 1);// 生成 10 个唯一ID，并输出for ($i = 0; $i < 10; $i++) {echo "生成的ID " . ($i + 1) . " : " . $snowflake->nextId() . "\n";}
} catch (Exception $e) {echo "异常：" . $e->getMessage();
}
?>

DeepSeek

<?php/*** 雪花算法分布式ID生成器* 结构：0 | 时间戳(41位) | 数据中心ID(5位) | 机器ID(5位) | 序列号(12位)*/
class Snowflake
{// 起始时间戳（2024-01-01 00:00:00 UTC）const EPOCH = 1704067200000;// 位数分配const SEQUENCE_BITS = 12;   // 序列号位数const MACHINE_BITS = 5;     // 机器标识位数const DATACENTER_BITS = 5;  // 数据中心位数// 最大值计算（位运算优化）const MAX_SEQUENCE = -1 ^ (-1 << self::SEQUENCE_BITS);const MAX_MACHINE = -1 ^ (-1 << self::MACHINE_BITS);const MAX_DATACENTER = -1 ^ (-1 << self::DATACENTER_BITS);// 移位偏移量计算const TIMESTAMP_SHIFT = self::SEQUENCE_BITS + self::MACHINE_BITS + self::DATACENTER_BITS;const DATACENTER_SHIFT = self::SEQUENCE_BITS + self::MACHINE_BITS;const MACHINE_SHIFT = self::SEQUENCE_BITS;private $machineId;      // 机器标识IDprivate $datacenterId;   // 数据中心IDprivate $sequence = 0;   // 序列号private $lastTimestamp = -1; // 上次生成时间戳/*** 构造函数* @param int $machineId    机器ID (0~31)* @param int $datacenterId 数据中心ID (0~31)*/public function __construct($machineId, $datacenterId){// 参数校验if ($machineId > self::MAX_MACHINE || $machineId < 0) {throw new InvalidArgumentException("机器ID值超出范围（0～".self::MAX_MACHINE."）");}if ($datacenterId > self::MAX_DATACENTER || $datacenterId < 0) {throw new InvalidArgumentException("数据中心ID值超出范围（0～".self::MAX_DATACENTER."）");}$this->machineId = $machineId;$this->datacenterId = $datacenterId;}/*** 生成下一个分布式ID* @return int 64位整型ID（PHP中实际返回字符串类型以保证精度）*/public function generateId(){$timestamp = $this->getCurrentTimestamp();// 时钟回拨检查if ($timestamp < $this->lastTimestamp) {$diff = $this->lastTimestamp - $timestamp;throw new RuntimeException("系统时钟回拨 {$diff} 毫秒");}// 同一毫秒内生成if ($this->lastTimestamp == $timestamp) {$this->sequence = ($this->sequence + 1) & self::MAX_SEQUENCE;// 序列号耗尽，等待下一毫秒if ($this->sequence == 0) {$timestamp = $this->waitNextMillis($this->lastTimestamp);}} else {// 新时间戳重置序列号$this->sequence = 0;}$this->lastTimestamp = $timestamp;// 组合各部分数据$id = (($timestamp) << self::TIMESTAMP_SHIFT)| ($this->datacenterId << self::DATACENTER_SHIFT)| ($this->machineId << self::MACHINE_SHIFT)| $this->sequence;// 返回字符串类型以避免32位系统精度丢失return (string)$id;}/*** 阻塞到下一毫秒* @param int $lastTimestamp 上次生成时间戳* @return int 当前时间戳*/private function waitNextMillis($lastTimestamp){$timestamp = $this->getCurrentTimestamp();while ($timestamp <= $lastTimestamp) {usleep(1000); // 休眠1毫秒$timestamp = $this->getCurrentTimestamp();}return $timestamp;}/*** 获取当前时间戳（毫秒）* @return int 毫秒时间戳*/private function getCurrentTimestamp(){return round(microtime(true) * 1000) - self::EPOCH;}
}/* 使用示例 */
try {$snowflake = new Snowflake(1, 1); // 机器ID=1，数据中心ID=1// 生成10个IDfor ($i = 0; $i < 10; $i++) {echo $snowflake->generateId() . PHP_EOL;}
} catch (Exception $e) {echo $e->getMessage();
}

Kimi

<?php/*** 雪花算法生成唯一ID* 基于Twitter的Snowflake算法，生成一个64位的唯一ID*/
class Snowflake
{// 以下是各个部分所占的位数const SIGN_BIT = 1; // 符号位，始终为0const TIMESTAMP_BIT = 41; // 时间戳位数const DATA_CENTER_ID_BIT = 5; // 数据中心ID位数const WORKER_ID_BIT = 5; // 机器节点ID位数const SEQUENCE_BIT = 12; // 序列号位数// 最大值const MAX_DATA_CENTER_ID = -1 ^ (-1 << self::DATA_CENTER_ID_BIT); // 31const MAX_WORKER_ID = -1 ^ (-1 << self::WORKER_ID_BIT); // 31const MAX_SEQUENCE = -1 ^ (-1 << self::SEQUENCE_BIT); // 4095// 每一部分的偏移量const DATA_CENTER_ID_SHIFT = self::SEQUENCE_BIT;const WORKER_ID_SHIFT = self::SEQUENCE_BIT + self::DATA_CENTER_ID_BIT;const TIMESTAMP_SHIFT = self::SEQUENCE_BIT + self::DATA_CENTER_ID_BIT + self::WORKER_ID_BIT;// 开始时间戳（2023-01-01 00:00:00的毫秒数）const EPOCH = 1672502400000;// 数据中心ID和机器节点IDprivate $dataCenterId;private $workerId;// 序列号private $sequence = 0;// 上一次的时间戳private $lastTimestamp = -1;/*** 构造函数* @param int $dataCenterId 数据中心ID* @param int $workerId 机器节点ID*/public function __construct($dataCenterId = 0, $workerId = 0){if ($dataCenterId > self::MAX_DATA_CENTER_ID || $dataCenterId < 0) {throw new \InvalidArgumentException("dataCenterId不能大于" . self::MAX_DATA_CENTER_ID . "或小于0");}if ($workerId > self::MAX_WORKER_ID || $workerId < 0) {throw new \InvalidArgumentException("workerId不能大于" . self::MAX_WORKER_ID . "或小于0");}$this->dataCenterId = $dataCenterId;$this->workerId = $workerId;}/*** 生成唯一ID* @return int 唯一ID*/public function generateId(){$currentTimestamp = $this->getCurrentTimestamp();if ($currentTimestamp < $this->lastTimestamp) {throw new \RuntimeException("时间戳回退，拒绝生成ID");}if ($currentTimestamp == $this->lastTimestamp) {$this->sequence = ($this->sequence + 1) & self::MAX_SEQUENCE;if ($this->sequence == 0) {$currentTimestamp = $this->tilNextMillis($this->lastTimestamp);}} else {$this->sequence = 0;}$this->lastTimestamp = $currentTimestamp;// ID拼接$id = (($currentTimestamp - self::EPOCH) << self::TIMESTAMP_SHIFT)| ($this->dataCenterId << self::DATA_CENTER_ID_SHIFT)| ($this->workerId << self::WORKER_ID_SHIFT)| $this->sequence;return $id;}/*** 等待下一毫秒* @param int $lastTimestamp 上一次的时间戳* @return int 当前时间戳*/private function tilNextMillis($lastTimestamp){$timestamp = $this->getCurrentTimestamp();while ($timestamp <= $lastTimestamp) {$timestamp = $this->getCurrentTimestamp();}return $timestamp;}/*** 获取当前时间戳（毫秒）* @return int 当前时间戳*/private function getCurrentTimestamp(){return round(microtime(true) * 1000);}
}// 使用示例
$snowflake = new Snowflake(1, 2); // 数据中心ID为1，机器节点ID为2
$id = $snowflake->generateId();
echo $id;

智谱清言

<?php/*** Snowflake ID生成类，基于Twitter的Snowflake算法*/
class Snowflake {// 雪花算法常量定义const EPOCH = 1288834974657; // 起始时间戳，单位毫秒const DATA_CENTER_ID_BITS = 5; // 数据中心ID所占的位数const MACHINE_ID_BITS = 5; // 机器ID所占的位数const SEQUENCE_BITS = 12; // 序列号所占的位数const MAX_DATA_CENTER_ID = (1 << self::DATA_CENTER_ID_BITS) - 1; // 最大的数据中心IDconst MAX_MACHINE_ID = (1 << self::MACHINE_ID_BITS) - 1; // 最大的机器IDconst MAX_SEQUENCE = (1 << self::SEQUENCE_BITS) - 1; // 最大的序列号const MACHINE_ID_SHIFT = self::SEQUENCE_BITS; // 机器ID的偏移量const DATA_CENTER_ID_SHIFT = self::MACHINE_ID_SHIFT + self::MACHINE_ID_BITS; // 数据中心ID的偏移量const TIMESTAMP_SHIFT = self::DATA_CENTER_ID_SHIFT + self::DATA_CENTER_ID_BITS; // 时间戳的偏移量private $dataCenterId; // 数据中心IDprivate $machineId; // 机器IDprivate $sequence = 0; // 序列号private $lastTimestamp = -1; // 上一次生成ID的时间戳/*** 构造函数* @param int $dataCenterId 数据中心ID，范围0到31* @param int $machineId 机器ID，范围0到31*/public function __construct($dataCenterId,$machineId) {if ($dataCenterId < 0 ||$dataCenterId > self::MAX_DATA_CENTER_ID) {throw new InvalidArgumentException("数据中心ID必须在0和" . self::MAX_DATA_CENTER_ID . "之间");}if ($machineId < 0 ||$machineId > self::MAX_MACHINE_ID) {throw new InvalidArgumentException("机器ID必须在0和" . self::MAX_MACHINE_ID . "之间");}$this->dataCenterId =$dataCenterId;$this->machineId =$machineId;}/*** 生成下一个ID* @return string 生成的ID字符串*/public function nextId() {$timestamp =$this->timeGen();// 如果当前时间戳小于上一次的时间戳，说明时钟回拨if ($timestamp <$this->lastTimestamp) {throw new RuntimeException("时钟回拨，拒绝生成ID");}// 如果当前时间戳与上一次的时间戳相同，同一毫秒内生成多个IDif ($timestamp ==$this->lastTimestamp) {$this->sequence = ($this->sequence + 1) & self::MAX_SEQUENCE;// 如果序列号达到最大值，等待下一毫秒if ($this->sequence == 0) {$timestamp =$this->tilNextMillis($this->lastTimestamp);}} else {// 如果进入新的毫秒，序列号重置为0$this->sequence = 0;}// 更新上一次的时间戳$this->lastTimestamp =$timestamp;// 生成ID$id = (($timestamp - self::EPOCH) << self::TIMESTAMP_SHIFT) |($this->dataCenterId << self::DATA_CENTER_ID_SHIFT) |($this->machineId << self::MACHINE_ID_SHIFT) |$this->sequence;return strval($id);}/*** 获取当前时间戳，单位毫秒* @return int*/private function timeGen() {return floor(microtime(true) * 1000);}/*** 等待下一毫秒，直到时间戳增加* @param int $lastTimestamp 上一次的时间戳* @return int 当前时间戳*/private function tilNextMillis($lastTimestamp) {$timestamp =$this->timeGen();while ($timestamp <=$lastTimestamp) {$timestamp =$this->timeGen();}return $timestamp;}
}// 使用示例
try {// 创建Snowflake实例，数据中心ID为1，机器ID为1$snowflake = new Snowflake(1, 1);// 生成并输出10个唯一IDfor ($i = 0;$i < 10; $i++) {$id =$snowflake->nextId();echo $id . "\n";}// 创建另一个Snowflake实例，数据中心ID为1，机器ID为2$snowflake2 = new Snowflake(1, 2);// 生成并输出10个唯一IDfor ($i = 0;$i < 10; $i++) {$id =$snowflake2->nextId();echo $id . "\n";}// 创建另一个Snowflake实例，数据中心ID为2，机器ID为1$snowflake3 = new Snowflake(2, 1);// 生成并输出10个唯一IDfor ($i = 0;$i < 10; $i++) {$id =$snowflake3->nextId();echo $id . "\n";}
} catch (Exception $e) {echo "错误: " . $e->getMessage() . "\n";
}

Claude

<?php/*** 雪花算法（Snowflake）PHP实现* * 雪花算法是由Twitter开发的分布式ID生成算法，能够在分布式系统中产生唯一的ID* 该算法生成的ID结构为64位长整型，由以下部分组成：* 1. 1位符号位，固定为0（表示正数）* 2. 41位时间戳（毫秒级），可使用约69年* 3. 10位工作机器ID，包括5位数据中心ID和5位机器ID，最多支持32个数据中心和每个中心下32台机器* 4. 12位序列号，1毫秒内最多生成4096个ID*/
class Snowflake {/*** 开始时间戳（2020-01-01）* 这是算法的基准时间，用于计算相对时间戳*/const START_TIMESTAMP = 1577808000000; // 2020-01-01 00:00:00 GMT/*** 各部分占用的位数*/const SEQUENCE_BITS = 12;       // 序列号占用的位数const MACHINE_ID_BITS = 5;      // 机器ID占用的位数const DATACENTER_ID_BITS = 5;   // 数据中心ID占用的位数/*** 各部分的最大值*/const MAX_SEQUENCE = -1 ^ (-1 << self::SEQUENCE_BITS);          // 序列号最大值 4095const MAX_MACHINE_ID = -1 ^ (-1 << self::MACHINE_ID_BITS);      // 机器ID最大值 31const MAX_DATACENTER_ID = -1 ^ (-1 << self::DATACENTER_ID_BITS);// 数据中心ID最大值 31/*** 各部分向左的位移*/const MACHINE_ID_SHIFT = self::SEQUENCE_BITS;                                   // 机器ID向左移12位const DATACENTER_ID_SHIFT = self::SEQUENCE_BITS + self::MACHINE_ID_BITS;        // 数据中心ID向左移17位const TIMESTAMP_SHIFT = self::SEQUENCE_BITS + self::MACHINE_ID_BITS + self::DATACENTER_ID_BITS; // 时间戳向左移22位/*** 数据中心ID* @var int*/private $datacenterId;/*** 机器ID* @var int*/private $machineId;/*** 毫秒内序列号* @var int*/private $sequence = 0;/*** 上次生成ID的时间戳* @var int*/private $lastTimestamp = -1;/*** 构造函数* * @param int $datacenterId 数据中心ID (0~31)* @param int $machineId 机器ID (0~31)* @throws Exception 当数据中心ID或机器ID超出范围时抛出异常*/public function __construct($datacenterId, $machineId) {// 参数校验if ($datacenterId > self::MAX_DATACENTER_ID || $datacenterId < 0) {throw new Exception("数据中心ID不能大于".self::MAX_DATACENTER_ID."或小于0");}if ($machineId > self::MAX_MACHINE_ID || $machineId < 0) {throw new Exception("机器ID不能大于".self::MAX_MACHINE_ID."或小于0");}$this->datacenterId = $datacenterId;$this->machineId = $machineId;}/*** 获取当前时间戳（毫秒）* * @return int 当前时间戳（毫秒）*/private function getCurrentTimestamp() {// 获取当前时间戳，单位为毫秒return floor(microtime(true) * 1000);}/*** 阻塞到下一个毫秒，直到获得新的时间戳* * @param int $lastTimestamp 上次生成ID的时间戳* @return int 新的时间戳*/private function waitNextMillis($lastTimestamp) {$timestamp = $this->getCurrentTimestamp();while ($timestamp <= $lastTimestamp) {$timestamp = $this->getCurrentTimestamp();}return $timestamp;}/*** 生成ID* * @return string 返回生成的ID（字符串形式，因为PHP整数范围有限）* @throws Exception 当时钟回拨时抛出异常*/public function nextId() {// 获取当前时间戳$timestamp = $this->getCurrentTimestamp();// 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过，抛出异常if ($timestamp < $this->lastTimestamp) {throw new Exception("时钟向后移动，拒绝生成ID，时间差: " . ($this->lastTimestamp - $timestamp) . " 毫秒");}// 如果是同一时间生成的，则进行毫秒内序列号递增if ($timestamp == $this->lastTimestamp) {// 序列号递增$this->sequence = ($this->sequence + 1) & self::MAX_SEQUENCE;// 同一毫秒内序列号已经达到最大值，阻塞到下一个毫秒if ($this->sequence == 0) {$timestamp = $this->waitNextMillis($this->lastTimestamp);}} else {// 时间戳改变，毫秒内序列号重置为0$this->sequence = 0;}// 记录上次生成ID的时间戳$this->lastTimestamp = $timestamp;// 计算相对时间戳（与起始时间的差值）$relativeTimestamp = $timestamp - self::START_TIMESTAMP;// 组装ID并返回// 使用字符串拼接，避免PHP整数溢出问题$id = (($relativeTimestamp << self::TIMESTAMP_SHIFT) |($this->datacenterId << self::DATACENTER_ID_SHIFT) |($this->machineId << self::MACHINE_ID_SHIFT) |$this->sequence);// 转换为字符串，避免潜在的整数溢出问题return (string)$id;}
}// 使用示例
try {// 创建一个雪花算法实例，参数为数据中心ID和机器ID$snowflake = new Snowflake(1, 1);// 生成ID$id = $snowflake->nextId();echo "生成的ID: " . $id . PHP_EOL;// 批量生成多个IDecho "批量生成5个ID:" . PHP_EOL;for ($i = 0; $i < 5; $i++) {echo $snowflake->nextId() . PHP_EOL;}
} catch (Exception $e) {echo "错误: " . $e->getMessage() . PHP_EOL;
}
?>

豆包

<?phpclass Snowflake {// 起始时间戳，一般设置为项目开始的时间，单位：毫秒const EPOCH = 1609459200000; // 数据中心 ID 所占的位数const DATA_CENTER_ID_BITS = 5; // 机器 ID 所占的位数const WORKER_ID_BITS = 5; // 序列号所占的位数const SEQUENCE_BITS = 12; // 数据中心 ID 最大值const MAX_DATA_CENTER_ID = -1 ^ (-1 << self::DATA_CENTER_ID_BITS); // 机器 ID 最大值const MAX_WORKER_ID = -1 ^ (-1 << self::WORKER_ID_BITS); // 序列号最大值const MAX_SEQUENCE = -1 ^ (-1 << self::SEQUENCE_BITS); // 机器 ID 向左移位数const WORKER_ID_SHIFT = self::SEQUENCE_BITS; // 数据中心 ID 向左移位数const DATA_CENTER_ID_SHIFT = self::SEQUENCE_BITS + self::WORKER_ID_BITS; // 时间戳向左移位数const TIMESTAMP_LEFT_SHIFT = self::SEQUENCE_BITS + self::WORKER_ID_BITS + self::DATA_CENTER_ID_BITS; // 数据中心 IDprivate $dataCenterId; // 机器 IDprivate $workerId; // 序列号private $sequence = 0; // 上一次生成 ID 的时间戳private $lastTimestamp = -1; /*** 构造函数，初始化数据中心 ID 和机器 ID** @param int $dataCenterId 数据中心 ID* @param int $workerId 机器 ID* @throws Exception 如果数据中心 ID 或机器 ID 超出范围，抛出异常*/public function __construct($dataCenterId, $workerId) {// 检查数据中心 ID 是否在合法范围内if ($dataCenterId > self::MAX_DATA_CENTER_ID || $dataCenterId < 0) {throw new Exception("Data center ID must be between 0 and " . self::MAX_DATA_CENTER_ID);}// 检查机器 ID 是否在合法范围内if ($workerId > self::MAX_WORKER_ID || $workerId < 0) {throw new Exception("Worker ID must be between 0 and " . self::MAX_WORKER_ID);}$this->dataCenterId = $dataCenterId;$this->workerId = $workerId;}/*** 生成下一个唯一的 ID** @return int 生成的唯一 ID* @throws Exception 如果系统时钟回拨，抛出异常*/public function nextId() {// 获取当前时间戳，单位：毫秒$timestamp = $this->getCurrentTimestamp();// 处理时钟回拨问题if ($timestamp < $this->lastTimestamp) {throw new Exception("Clock moved backwards. Refusing to generate id for " . ($this->lastTimestamp - $timestamp) . " milliseconds");}if ($timestamp == $this->lastTimestamp) {// 如果在同一毫秒内，序列号递增$this->sequence = ($this->sequence + 1) & self::MAX_SEQUENCE;if ($this->sequence == 0) {// 序列号达到最大值，等待下一毫秒$timestamp = $this->waitNextMillis($this->lastTimestamp);}} else {// 时间戳改变，重置序列号$this->sequence = 0;}// 更新上一次生成 ID 的时间戳$this->lastTimestamp = $timestamp;// 生成最终的 IDreturn (($timestamp - self::EPOCH) << self::TIMESTAMP_LEFT_SHIFT) |($this->dataCenterId << self::DATA_CENTER_ID_SHIFT) |($this->workerId << self::WORKER_ID_SHIFT) |$this->sequence;}/*** 获取当前时间戳，单位：毫秒** @return int 当前时间戳*/private function getCurrentTimestamp() {return floor(microtime(true) * 1000);}/*** 等待下一毫秒** @param int $lastTimestamp 上一次生成 ID 的时间戳* @return int 下一毫秒的时间戳*/private function waitNextMillis($lastTimestamp) {$timestamp = $this->getCurrentTimestamp();while ($timestamp <= $lastTimestamp) {$timestamp = $this->getCurrentTimestamp();}return $timestamp;}
}// 使用示例
try {// 创建 Snowflake 实例，指定数据中心 ID 和机器 ID$snowflake = new Snowflake(1, 1);// 生成唯一 ID$id = $snowflake->nextId();echo "Generated ID: " . $id;
} catch (Exception $e) {echo "Error: " . $e->getMessage();
}

腾讯元宝

<?php
class Snowflake
{// 数据中心ID所占位数（5位，支持32个数据中心）const DATA_CENTER_ID_BITS = 5;// 机器ID所占位数（5位，支持32台机器）const MACHINE_ID_BITS = 5;// 序列号所占位数（12位，每毫秒支持4096个ID）const SEQUENCE_BITS = 12;// 最大数据中心ID（2^5 - 1）const MAX_DATA_CENTER_ID = -1 ^ (-1 << self::DATA_CENTER_ID_BITS);// 最大机器ID（2^5 - 1）const MAX_MACHINE_ID = -1 ^ (-1 << self::MACHINE_ID_BITS);// 时间戳左移位数（41+5+5=51位）const TIMESTAMP_LEFT_SHIFT = self::SEQUENCE_BITS + self::MACHINE_ID_BITS + self::DATA_CENTER_ID_BITS;// 机器ID左移位数（41+5=46位）const SEQUENCE_LEFT_SHIFT = self::MACHINE_ID_BITS + self::DATA_CENTER_ID_BITS;// 起始时间戳（2021-01-01 00:00:00，可自定义）private $epoch = 1609430400000;// 实例属性private int $datacenterId;    // 数据中心IDprivate int $machineId;       // 机器IDprivate int $sequence = 0;     // 序列号private int $lastTimestamp = -1; // 上次生成ID的时间戳/*** 构造函数，初始化ID生成器* @param int $datacenterId 数据中心ID（0-31）* @param int $machineId 机器ID（0-31）* @throws Exception 如果ID超出范围*/public function __construct(int $datacenterId, int $machineId){// 验证数据中心ID范围if ($datacenterId < 0 || $datacenterId > self::MAX_DATA_CENTER_ID) {throw new Exception("数据中心ID超出范围");}// 验证机器ID范围if ($machineId < 0 || $machineId > self::MAX_MACHINE_ID) {throw new Exception("机器ID超出范围");}$this->datacenterId = $datacenterId;$this->machineId = $machineId;}/*** 生成唯一ID* @return int 64位唯一ID* @throws Exception 如果时钟发生回拨*/public function nextId(): int{$timestamp = $this->currentTimeMillis();// 检测时钟回拨if ($timestamp < $this->lastTimestamp) {throw new Exception("错误：系统时钟发生回拨");}// 同一毫秒内处理序列号递增if ($this->lastTimestamp === $timestamp) {$this->sequence = ($this->sequence + 1) & ((1 << self::SEQUENCE_BITS) - 1);// 序列号溢出，等待下一毫秒if ($this->sequence === 0) {$timestamp = $this->waitNextMillis($timestamp);}} else {// 新的一毫秒，重置序列号$this->sequence = 0;}// 更新上次时间戳$this->lastTimestamp = $timestamp;// 组合ID：(时间戳 << 22) | (数据中心ID << 17) | (机器ID << 12) | 序列号return (($timestamp - $this->epoch) << self::TIMESTAMP_LEFT_SHIFT) |($this->datacenterId << self::SEQUENCE_LEFT_SHIFT) |($this->machineId << self::SEQUENCE_BITS) |$this->sequence;}/*** 等待下一毫秒* @param int $lastTimestamp 上次时间戳* @return int 下一毫秒时间戳*/private function waitNextMillis(int $lastTimestamp): int{$timestamp = $this->currentTimeMillis();while ($timestamp <= $lastTimestamp) {$timestamp = $this->currentTimeMillis();}return $timestamp;}/*** 获取当前时间戳（毫秒级）* @return int*/private function currentTimeMillis(): int{return (int)(microtime(true) * 1000);}
}// 使用示例
$datacenterId = 1;    // 数据中心ID（0-31）
$machineId = 1;       // 机器ID（0-31）
$snowflake = new Snowflake($datacenterId, $machineId);for ($i = 0; $i < 10; $i++) {$userId = $snowflake->nextId();echo "生成的用户ID: {$userId}<br/>";
}

Vercel

<?php/*** 雪花算法（Snowflake）PHP实现* * 雪花算法是由Twitter开发的分布式唯一ID生成算法，结构如下：* 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000* * 第1位：符号位，始终为0* 第2-42位：41位时间戳（毫秒级），可以使用69年* 第43-43位：1位数据中心ID* 第44-48位：5位机器ID* 第49-53位：5位数据中心内机器ID* 第54-64位：12位序列号，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒产生4096个ID序号*/
class Snowflake {/*** 开始时间戳（2020-01-01）* 这是一个自定义的起始时间，用于计算相对时间戳*/const START_TIMESTAMP = 1577808000000; // 2020-01-01 00:00:00 GMT/*** 各部分占用的位数*/const SEQUENCE_BITS = 12;       // 序列号占用的位数const MACHINE_ID_BITS = 5;      // 机器ID占用的位数const DATACENTER_ID_BITS = 5;   // 数据中心ID占用的位数/*** 各部分的最大值*/const MAX_SEQUENCE = -1 ^ (-1 << self::SEQUENCE_BITS);           // 序列号最大值 4095const MAX_MACHINE_ID = -1 ^ (-1 << self::MACHINE_ID_BITS);       // 机器ID最大值 31const MAX_DATACENTER_ID = -1 ^ (-1 << self::DATACENTER_ID_BITS); // 数据中心ID最大值 31/*** 各部分向左的位移*/const MACHINE_ID_SHIFT = self::SEQUENCE_BITS;                                     // 机器ID向左移12位const DATACENTER_ID_SHIFT = self::SEQUENCE_BITS + self::MACHINE_ID_BITS;          // 数据中心ID向左移17位const TIMESTAMP_SHIFT = self::SEQUENCE_BITS + self::MACHINE_ID_BITS + self::DATACENTER_ID_BITS; // 时间戳向左移22位/*** @var int 数据中心ID*/private $datacenterId;/*** @var int 机器ID*/private $machineId;/*** @var int 毫秒内序列号*/private $sequence = 0;/*** @var int 上次生成ID的时间戳*/private $lastTimestamp = -1;/*** 构造函数** @param int $datacenterId 数据中心ID (0~31)* @param int $machineId 机器ID (0~31)* @throws Exception 当数据中心ID或机器ID超出范围时抛出异常*/public function __construct($datacenterId = 0, $machineId = 0) {// 检查数据中心ID和机器ID是否在有效范围内if ($datacenterId > self::MAX_DATACENTER_ID || $datacenterId < 0) {throw new Exception("数据中心ID超出范围: 应为0~" . self::MAX_DATACENTER_ID);}if ($machineId > self::MAX_MACHINE_ID || $machineId < 0) {throw new Exception("机器ID超出范围: 应为0~" . self::MAX_MACHINE_ID);}$this->datacenterId = $datacenterId;$this->machineId = $machineId;}/*** 获取下一个ID** @return string 生成的ID（返回字符串是因为PHP的整数范围可能不足以存储64位ID）* @throws Exception 当时钟回拨时抛出异常*/public function nextId() {// 获取当前时间戳（毫秒）$timestamp = $this->getCurrentTimestamp();// 检查时钟回拨if ($timestamp < $this->lastTimestamp) {throw new Exception("时钟回拨，拒绝生成ID，上次时间: " . $this->lastTimestamp . ", 当前时间: " . $timestamp);}// 如果是同一毫秒内，则增加序列号if ($timestamp == $this->lastTimestamp) {// 序列号递增$this->sequence = ($this->sequence + 1) & self::MAX_SEQUENCE;// 如果序列号溢出，则等待下一毫秒if ($this->sequence == 0) {$timestamp = $this->waitNextMillis($this->lastTimestamp);}} else {// 不同毫秒内，序列号重置为0$this->sequence = 0;}// 更新上次生成ID的时间戳$this->lastTimestamp = $timestamp;// 计算相对时间戳（相对于开始时间）$timestampDiff = $timestamp - self::START_TIMESTAMP;// 组合各部分生成ID// 注意：PHP的整数范围可能不足以存储64位ID，所以使用字符串或GMP扩展处理大整数$id = (($timestampDiff << self::TIMESTAMP_SHIFT) |($this->datacenterId << self::DATACENTER_ID_SHIFT) |($this->machineId << self::MACHINE_ID_SHIFT) |$this->sequence);return (string)$id;}/*** 获取当前时间戳（毫秒）** @return int 当前时间戳（毫秒）*/private function getCurrentTimestamp() {// 获取微秒级时间戳并转换为毫秒return (int)floor(microtime(true) * 1000);}/*** 等待下一毫秒** @param int $lastTimestamp 上次生成ID的时间戳* @return int 新的时间戳（毫秒）*/private function waitNextMillis($lastTimestamp) {$timestamp = $this->getCurrentTimestamp();// 循环等待，直到获得新的时间戳while ($timestamp <= $lastTimestamp) {$timestamp = $this->getCurrentTimestamp();}return $timestamp;}
}// 使用示例
try {// 创建雪花算法实例，参数为数据中心ID和机器ID$snowflake = new Snowflake(1, 1);// 生成10个IDecho "生成的ID示例：\n";for ($i = 0; $i < 10; $i++) {echo $snowflake->nextId() . "\n";}
} catch (Exception $e) {echo "错误: " . $e->getMessage();
}
?>

文心一言

<?phpclass Snowflake {// 定义雪花ID的各部分位数private const TIMESTAMP_BITS = 41; // 时间戳位数private const NODE_ID_BITS = 10;  // 节点ID位数private const SEQUENCE_BITS = 12; // 序列号位数// 定义起始时间戳（这里以2020-01-01为例）private const EPOCH = 1577836800000;// 定义最大取值范围private const MAX_NODE_ID = (1 << self::NODE_ID_BITS) - 1;private const MAX_SEQUENCE = (1 << self::SEQUENCE_BITS) - 1;// 定义偏移量private const TIMESTAMP_SHIFT = self::NODE_ID_BITS + self::SEQUENCE_BITS;private const NODE_ID_SHIFT = self::SEQUENCE_BITS;private $nodeId;           // 节点IDprivate $lastTimestamp = -1; // 上次生成ID的时间戳private $sequence = 0;     // 序列号/*** 构造函数，用于初始化节点ID** @param int $nodeId 节点ID* @throws InvalidArgumentException 如果节点ID超出范围*/public function __construct($nodeId) {if ($nodeId < 0 || $nodeId > self::MAX_NODE_ID) {throw new InvalidArgumentException("Invalid node ID, must be between 0 and " . self::MAX_NODE_ID);}$this->nodeId = $nodeId;}/*** 生成下一个唯一的ID** @return int 生成的唯一ID* @throws RuntimeException 如果系统时钟回拨*/public function generateId() {$currentTimestamp = $this->timestamp();// 检查时钟回拨if ($currentTimestamp < $this->lastTimestamp) {throw new RuntimeException("Clock moved backwards");}// 如果当前时间戳与上次相同，则递增序列号if ($currentTimestamp == $this->lastTimestamp) {$this->sequence = ($this->sequence + 1) & self::MAX_SEQUENCE;// 如果序列号溢出，则等待下一毫秒if ($this->sequence == 0) {$currentTimestamp = $this->untilNextMillis($this->lastTimestamp);}} else {// 如果时间戳不同，则重置序列号$this->sequence = 0;}// 更新上次生成ID的时间戳$this->lastTimestamp = $currentTimestamp;// 组合时间戳、节点ID和序列号生成唯一的IDreturn (($currentTimestamp - self::EPOCH) << self::TIMESTAMP_SHIFT) |($this->nodeId << self::NODE_ID_SHIFT) |$this->sequence;}/*** 获取当前时间戳（毫秒）** @return int 当前时间戳*/private function timestamp() {return round(microtime(true) * 1000);}/*** 等待下一毫秒** @param int $lastTimestamp 上次生成ID的时间戳* @return int 下一毫秒的时间戳*/private function untilNextMillis($lastTimestamp) {$currentTimestamp = $this->timestamp();while ($currentTimestamp <= $lastTimestamp) {$currentTimestamp = $this->timestamp();}return $currentTimestamp;}
}// 示例使用
$nodeId = 1; // 设置节点ID
$snowflake = new Snowflake($nodeId);// 生成10个唯一ID
for ($i = 0; $i < 10; $i++) {$id = $snowflake->generateId();echo "Generated ID: $id\n";
}

讯飞星火

讯飞星火在生成代码的过程中居然出现了BUG, 代码在生成过程中, 开头生成的代码莫名消失, 最后生成的代码如下

 self::MAX_DATA_CENTER_ID || $dataCenterId < 0) {throw new Exception("Data Center ID can't be greater than " . self::MAX_DATA_CENTER_ID . " or less than 0");}if ($machineId > self::MAX_MACHINE_ID || $machineId < 0) {throw new Exception("Machine ID can't be greater than " . self::MAX_MACHINE_ID . " or less than 0");}$this->dataCenterId = $dataCenterId;$this->machineId = $machineId;}public function nextId() {$timestamp = $this->timeGen();if ($timestamp < $this->lastTimestamp) {throw new Exception("Clock moved backwards. Refusing to generate id for " . ($this->lastTimestamp - $timestamp) . " milliseconds");}if ($this->lastTimestamp == $timestamp) {$this->sequence = ($this->sequence + 1) &amp; self::MAX_SEQUENCE;if ($this->sequence == 0) {$timestamp = $this->tilNextMillis($this->lastTimestamp);}} else {$this->sequence = 0;}$this->lastTimestamp = $timestamp;return (($timestamp - self::EPOCH) << self::TIMESTAMP_SHIFT) |($this->dataCenterId << self::DATA_CENTER_ID_SHIFT) |($this->machineId << self::MACHINE_ID_SHIFT) |$this->sequence;}protected function tilNextMillis($lastTimestamp) {$timestamp = $this->timeGen();while ($timestamp <= $lastTimestamp) {$timestamp = $this->timeGen();}return $timestamp;}protected function timeGen() {return round(microtime(true) * 1000); // 获取当前时间的毫秒级时间戳}
}// 使用示例
try {$snowflake = new Snowflake(1, 1); // 数据中心ID和机器ID都设置为1echo $snowflake->nextId(); // 生成一个唯一的ID
} catch (Exception $e) {echo 'Error: ' . $e->getMessage();
}
?>