Generator CUID

Introducere

Un CUID (Identificator Unic Rezistent la Coliziune) este un identificator unic conceput pentru a fi rezistent la coliziuni, scalabil pe orizontală și sortabil secvențial. CUID-urile sunt deosebit de utile în sistemele distribuite unde identificatorii unici trebuie generați fără coordonare între noduri.

Structura CUID-urilor

Un CUID constă de obicei din următoarele componente:

1. Timestamp: O reprezentare a timpului curent
2. Counter: Un contor secvențial pentru a asigura unicitatea în aceeași milisecundă
3. Amprenta clientului: Un identificator unic pentru mașina sau procesul care generează CUID-ul
4. Componenta aleatoare: Date suplimentare aleatoare pentru a reduce și mai mult probabilitatea coliziunilor

Structura exactă poate varia în funcție de implementarea CUID, dar aceste componente lucrează împreună pentru a crea un identificator unic și sortabil.

Iată o reprezentare vizuală a unei structuri tipice CUID:

Cum sunt generate CUID-urile

CUID-urile sunt generate folosind o combinație de componente bazate pe timp și aleatorii. Procesul implică de obicei:

1. Obținerea timestamp-ului curent
2. Incrementarea unui contor (care se resetează periodic)
3. Generarea unei amprente a clientului (de obicei realizată o dată pe sesiune sau la pornirea aplicației)
4. Adăugarea de date aleatoare
5. Combinarea acestor elemente într-un format specific

CUID-ul rezultat este de obicei reprezentat ca un șir de litere și cifre.

Avantaje și cazuri de utilizare

CUID-urile oferă mai multe avantaje față de alte sisteme de identificatori unici:

1. Rezistență la coliziuni: Combinația de timestamp, contor și date aleatoare face ca coliziunile să fie extrem de puțin probabile, chiar și în sistemele distribuite.
2. Scalabilitate pe orizontală: CUID-urile pot fi generate independent pe mai multe mașini fără coordonare.
3. Sortare secvențială: Componenta timestamp permite sortarea cronologică a CUID-urilor.
4. Prietenoase cu URL-urile: CUID-urile sunt de obicei compuse din caractere sigure pentru URL.

Cazuri comune de utilizare pentru CUID-uri includ:

• Chei primare în baze de date
• Sisteme distribuite în care ID-uri unice trebuie generate pe mai multe noduri
• ID-uri de sesiune în aplicații web
• Urmărirea evenimentelor în sistemele de analiză
• Denumirea fișierelor sau resurselor în sistemele de stocare în cloud

Exemple de cod

Iată exemple de generare a CUID-urilor în diferite limbaje de programare:

1// JavaScript (folosind biblioteca 'cuid')
2const cuid = require('cuid');
3const id = cuid();
4console.log(id);
5

1## Python (folosind biblioteca 'cuid')
2import cuid
3id = cuid.cuid()
4print(id)
5

1## Ruby (folosind gem-ul 'cuid')
2require 'cuid'
3id = Cuid::generate
4puts id
5

1// Java (folosind biblioteca '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# (folosind pachetul 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 (folosind pachetul 'endyjasmi/cuid')
2<?php
3require 'vendor/autoload.php';
4use Endyjasmi\Cuid\Cuid;
5
6$id = Cuid::make();
7echo $id;
8

1// Go (folosind pachetul '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 (folosind pachetul 'CUID')
2import CUID
3
4let id = CUID()
5print(id)
6

1// C++ (folosind o implementare personalizată)
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 (folosind o implementare personalizată)
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% Utilizare
12id = generateCUID();
13disp(id);
14

1## R (folosind o implementare personalizată)
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## Utilizare
12id <- generate_cuid()
13print(id)
14

1' Excel VBA (folosind o implementare personalizată)
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' Utilizare într-o celulă
17'=GenerateCUID()
18

Istoric și dezvoltare

CUID-urile au fost dezvoltate inițial de Eric Elliott în 2012 ca o soluție la problema generării identificatorilor unici în sistemele distribuite. Conceptul a fost inspirat de sistemul de ID-uri Snowflake de la Twitter, dar conceput pentru a fi mai ușor de implementat și utilizat pe diferite platforme.

Dezvoltarea CUID-urilor a fost determinată de nevoia de a avea un sistem simplu, rezistent la coliziuni, care să funcționeze pe diferite limbaje de programare și medii. Scopul lui Elliott a fost să creeze un sistem care să fie ușor de implementat, să nu necesite coordonare centrală și să poată scala pe orizontală.

De la înființarea sa, CUID a trecut prin mai multe iterații și îmbunătățiri:

1. Implementarea originală CUID s-a concentrat pe simplitate și ușurință în utilizare.
2. Pe măsură ce adoptarea a crescut, comunitatea a contribuit cu implementări în diferite limbaje de programare.
3. În 2021, CUID2 a fost introdus pentru a aborda unele limitări ale CUID-ului original și pentru a oferi o performanță și o rezistență la coliziuni și mai bune.
4. CUID2 a îmbunătățit originalul prin utilizarea unui generator de numere aleatoare mai sigur și prin creșterea lungimii totale a identificatorului.

Evoluția CUID-urilor reflectă nevoile în schimbare ale sistemelor distribuite și eforturile continue de a echilibra simplitatea, securitatea și performanța în generarea identificatorilor unici.

Referințe

1. Repository-ul oficial CUID pe GitHub
2. Specificația CUID2
3. Elliott, Eric. "Generarea ID-urilor unice într-un mediu distribuit." Medium, 2015.
4. "ID-uri rezistente la coliziuni pentru sisteme distribuite." DZone, 2018.

Acest instrument generator CUID vă permite să generați rapid CUID-uri pentru proiectele dumneavoastră. Faceți clic pe butonul "Generați" pentru a crea un nou CUID și folosiți butonul "Copiați" pentru a-l copia în clipboard pentru utilizare ușoară în aplicațiile dumneavoastră.