Generátor CUID

Úvod

CUID (Collision-resistant Unique IDentifier) je unikátní identifikátor navržený tak, aby byl odolný vůči kolizím, horizontálně škálovatelný a sekvenčně tříděný. CUIDy jsou obzvlášť užitečné v distribuovaných systémech, kde je potřeba generovat unikátní identifikátory bez koordinace mezi uzly.

Struktura CUIDů

CUID obvykle sestává z následujících komponent:

1. Časová značka: Reprezentace aktuálního času
2. Čítač: Sekvenční čítač zajišťující unikátnost v rámci stejné milisekundy
3. Otisk klienta: Unikátní identifikátor pro stroj nebo proces generující CUID
4. Náhodná složka: Další náhodná data pro další snížení pravděpodobnosti kolize

Přesná struktura se může lišit v závislosti na implementaci CUID, ale tyto komponenty spolupracují na vytvoření unikátního a tříděného identifikátoru.

Zde je vizuální reprezentace typické struktury CUID:

Jak se CUIDy generují

CUIDy se generují pomocí kombinace časových a náhodných komponent. Proces obvykle zahrnuje:

1. Získání aktuální časové značky
2. Inkrementaci čítače (který se periodicky resetuje)
3. Generování otisku klienta (obvykle prováděno jednou na sezení nebo při spuštění aplikace)
4. Přidání náhodných dat
5. Kombinaci těchto prvků do specifického formátu

Výsledný CUID je obvykle reprezentován jako řetězec písmen a čísel.

Výhody a případy použití

CUIDy nabízejí několik výhod oproti jiným systémům unikátních identifikátorů:

1. Odolnost vůči kolizím: Kombinace časové značky, čítače a náhodných dat činí kolize extrémně nepravděpodobnými, i v distribuovaných systémech.
2. Horizontální škálovatelnost: CUIDy mohou být generovány nezávisle na více strojích bez koordinace.
3. Sekvenční třídění: Komponenta časové značky umožňuje chronologické třídění CUIDů.
4. URL-přátelské: CUIDy se obvykle skládají z znaků bezpečných pro URL.

Běžné případy použití CUIDů zahrnují:

• Primární klíče databáze
• Distribuované systémy, kde je potřeba generovat unikátní ID napříč více uzly
• ID sezení v webových aplikacích
• Sledování událostí v analytických systémech
• Pojmenovávání souborů nebo prostředků v cloudových úložištích

Příklady kódu

Zde jsou příklady generování CUIDů v různých programovacích jazycích:

1// JavaScript (používající knihovnu 'cuid')
2const cuid = require('cuid');
3const id = cuid();
4console.log(id);
5

1## Python (používající knihovnu 'cuid')
2import cuid
3id = cuid.cuid()
4print(id)
5

1## Ruby (používající gem 'cuid')
2require 'cuid'
3id = Cuid::generate
4puts id
5

1// Java (používající knihovnu 'com.github.f4b6a3.cuid')
2import com.github.f4b6a3.cuid.Cuid;
3
4public class CuidExample {
5    public static void main(String[] args) {
6        String id = Cuid.createCuid();
7        System.out.println(id);
8    }
9}
10

1// C# (používající balíček NuGet 'Cuid.Net')
2using Cuid;
3
4class Program
5{
6    static void Main(string[] args)
7    {
8        string id = CuidGenerator.Generate();
9        Console.WriteLine(id);
10    }
11}
12

1// PHP (používající balíček 'endyjasmi/cuid')
2<?php
3require 'vendor/autoload.php';
4use Endyjasmi\Cuid\Cuid;
5
6$id = Cuid::make();
7echo $id;
8

1// Go (používající balíček 'github.com/lucsky/cuid')
2package main
3
4import (
5    "fmt"
6    "github.com/lucsky/cuid"
7)
8
9func main() {
10    id := cuid.New()
11    fmt.Println(id)
12}
13

1// Swift (používající balíček 'CUID')
2import CUID
3
4let id = CUID()
5print(id)
6

1// C++ (používající vlastní implementaci)
2#include <iostream>
3#include <chrono>
4#include <random>
5#include <sstream>
6#include <iomanip>
7
8std::string generateCUID() {
9    auto now = std::chrono::system_clock::now();
10    auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
11    auto value = now_ms.time_since_epoch();
12    long duration = value.count();
13
14    std::random_device rd;
15    std::mt19937 gen(rd());
16    std::uniform_int_distribution<> dis(0, 35);
17
18    std::stringstream ss;
19    ss << 'c';
20    ss << std::hex << std::setfill('0') << std::setw(8) << duration;
21    for (int i = 0; i < 8; i++) {
22        int r = dis(gen);
23        ss << (char)(r < 10 ? '0' + r : 'a' + r - 10);
24    }
25    return ss.str();
26}
27
28int main() {
29    std::string id = generateCUID();
30    std::cout << id << std::endl;
31    return 0;
32}
33

1% MATLAB (používající vlastní implementaci)
2function id = generateCUID()
3    timestamp = dec2hex(round(posixtime(datetime('now'))*1000), 8);
4    random = '';
5    for i = 1:8
6        random = [random char(randi([48 57 97 122]))];
7    end
8    id = ['c' timestamp random];
9end
10
11% Použití
12id = generateCUID();
13disp(id);
14

1## R (používající vlastní implementaci)
2library(lubridate)
3
4generate_cuid <- function() {
5  timestamp <- format(as.numeric(now()) * 1000, scientific = FALSE)
6  timestamp <- substr(timestamp, 1, 8)
7  random <- paste0(sample(c(0:9, letters[1:6]), 8, replace = TRUE), collapse = "")
8  paste0("c", timestamp, random)
9}
10
11## Použití
12id <- generate_cuid()
13print(id)
14

1' Excel VBA (používající vlastní implementaci)
2Function GenerateCUID() As String
3    Dim timestamp As String
4    Dim random As String
5    Dim i As Integer
6    
7    timestamp = Right("00000000" & Hex(CLng(CDbl(Now()) * 86400000)), 8)
8    
9    For i = 1 To 8
10        random = random & Mid("0123456789abcdef", Int(Rnd() * 16) + 1, 1)
11    Next i
12    
13    GenerateCUID = "c" & timestamp & random
14End Function
15
16' Použití v buňce
17'=GenerateCUID()
18

Historie a vývoj

CUIDy byly původně vyvinuty Ericem Elliottem v roce 2012 jako řešení problému generování unikátních identifikátorů v distribuovaných systémech. Koncept byl inspirován systémem ID Snowflake společnosti Twitter, ale navržen tak, aby byl snadněji implementovatelný a použitelný napříč různými platformami.

Vývoj CUIDů byl řízen potřebou jednoduchého, odolného ID systému, který by mohl fungovat napříč různými programovacími jazyky a prostředími. Elliottovým cílem bylo vytvořit systém, který by byl snadno implementovatelný, nevyžadoval centrální koordinaci a mohl by horizontálně škálovat.

Od svého vzniku prošly CUIDy několika iteracemi a vylepšeními:

1. Původní implementace CUID se zaměřila na jednoduchost a snadnost použití.
2. Jak rostla adopce, komunita přispěla implementacemi v různých programovacích jazycích.
3. V roce 2021 byla představena CUID2, aby se vyřešily některé omezení původního CUID a poskytly ještě lepší výkon a odolnost vůči kolizím.
4. CUID2 vylepšil původní systém použitím bezpečnějšího generátoru náhodných čísel a zvýšením celkové délky identifikátoru.

Evoluce CUIDů odráží měnící se potřeby distribuovaných systémů a neustálé úsilí o vyvážení jednoduchosti, bezpečnosti a výkonu při generování unikátních identifikátorů.

Odkazy

1. Oficiální GitHub repozitář CUID
2. Specifikace CUID2
3. Elliott, Eric. "Generování unikátních ID v distribuovaném prostředí." Medium, 2015.
4. "ID odolná vůči kolizím pro distribuované systémy." DZone, 2018.

Tento nástroj generátor CUID vám umožňuje rychle generovat CUIDy pro vaše projekty. Jednoduše klikněte na tlačítko "Generovat", abyste vytvořili nový CUID, a použijte tlačítko "Kopírovat", abyste ho zkopírovali do schránky pro snadné použití ve vašich aplikacích.