Generator CUID

Wprowadzenie

CUID (Collision-resistant Unique IDentifier) to unikalny identyfikator zaprojektowany tak, aby był odporny na kolizje, poziomo skalowalny i sortowalny sekwencyjnie. CUID-y są szczególnie przydatne w systemach rozproszonych, gdzie unikalne identyfikatory muszą być generowane bez koordynacji między węzłami.

Struktura CUID-ów

CUID zazwyczaj składa się z następujących komponentów:

1. Znacznik czasu: Reprezentacja aktualnego czasu
2. Licznik: Sekwencyjny licznik zapewniający unikalność w tej samej milisekundzie
3. Odcisk klienta: Unikalny identyfikator maszyny lub procesu generującego CUID
4. Komponent losowy: Dodatkowe losowe dane, aby jeszcze bardziej zredukować prawdopodobieństwo kolizji

Dokładna struktura może się różnić w zależności od implementacji CUID, ale te komponenty współpracują ze sobą, aby stworzyć unikalny i sortowalny identyfikator.

Oto wizualna reprezentacja typowej struktury CUID:

Jak generowane są CUID-y

CUID-y są generowane przy użyciu kombinacji komponentów opartych na czasie i losowych. Proces zazwyczaj obejmuje:

1. Uzyskanie aktualnego znacznika czasu
2. Inkrementacja licznika (który resetuje się okresowo)
3. Generowanie odcisku klienta (zwykle wykonywane raz na sesję lub przy uruchomieniu aplikacji)
4. Dodawanie danych losowych
5. Łączenie tych elementów w określonym formacie

Wynikowy CUID zazwyczaj reprezentowany jest jako ciąg liter i cyfr.

Zalety i zastosowania

CUID-y oferują kilka zalet w porównaniu do innych systemów unikalnych identyfikatorów:

1. Odporność na kolizje: Kombinacja znacznika czasu, licznika i danych losowych sprawia, że kolizje są niezwykle mało prawdopodobne, nawet w systemach rozproszonych.
2. Pozioma skalowalność: CUID-y mogą być generowane niezależnie na wielu maszynach bez koordynacji.
3. Sortowanie sekwencyjne: Komponent znacznika czasu umożliwia chronologiczne sortowanie CUID-ów.
4. Przyjazne dla URL: CUID-y zazwyczaj składają się z bezpiecznych dla URL znaków.

Typowe zastosowania CUID-ów obejmują:

• Klucze główne w bazach danych
• Systemy rozproszone, w których unikalne ID muszą być generowane na wielu węzłach
• Identyfikatory sesji w aplikacjach internetowych
• Śledzenie zdarzeń w systemach analitycznych
• Nazewnictwo plików lub zasobów w systemach przechowywania w chmurze

Przykłady kodu

Oto przykłady generowania CUID-ów w różnych językach programowania:

1// JavaScript (z użyciem biblioteki 'cuid')
2const cuid = require('cuid');
3const id = cuid();
4console.log(id);
5

1## Python (z użyciem biblioteki 'cuid')
2import cuid
3id = cuid.cuid()
4print(id)
5

1## Ruby (z użyciem gema 'cuid')
2require 'cuid'
3id = Cuid::generate
4puts id
5

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

1// Go (z użyciem pakietu '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 (z użyciem pakietu 'CUID')
2import CUID
3
4let id = CUID()
5print(id)
6

1// C++ (z użyciem własnej implementacji)
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 (z użyciem własnej implementacji)
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% Użycie
12id = generateCUID();
13disp(id);
14

1## R (z użyciem własnej implementacji)
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## Użycie
12id <- generate_cuid()
13print(id)
14

1' Excel VBA (z użyciem własnej implementacji)
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' Użycie w komórce
17'=GenerateCUID()
18

Historia i rozwój

CUID-y zostały pierwotnie opracowane przez Erica Elliotta w 2012 roku jako rozwiązanie problemu generowania unikalnych identyfikatorów w systemach rozproszonych. Koncepcja została zainspirowana systemem identyfikatorów Snowflake Twittera, ale zaprojektowana tak, aby była łatwiejsza do zaimplementowania i używania w różnych platformach.

Rozwój CUID-ów był napędzany potrzebą prostego, odpornego na kolizje systemu ID, który mógłby działać w różnych językach programowania i środowiskach. Celem Elliotta było stworzenie systemu, który byłby łatwy do zaimplementowania, nie wymagał centralnej koordynacji i mógłby skalować się poziomo.

Od momentu powstania, CUID przeszedł kilka iteracji i ulepszeń:

1. Oryginalna implementacja CUID koncentrowała się na prostocie i łatwości użycia.
2. W miarę wzrostu adopcji, społeczność przyczyniła się do implementacji w różnych językach programowania.
3. W 2021 roku wprowadzono CUID2, aby rozwiązać niektóre ograniczenia oryginalnego CUID i zapewnić jeszcze lepszą wydajność oraz odporność na kolizje.
4. CUID2 poprawił oryginał, wykorzystując bardziej bezpieczny generator liczb losowych i zwiększając ogólną długość identyfikatora.

Ewolucja CUID-ów odzwierciedla zmieniające się potrzeby systemów rozproszonych oraz ciągłe wysiłki na rzecz zrównoważenia prostoty, bezpieczeństwa i wydajności w generowaniu unikalnych identyfikatorów.

Odnośniki

1. Oficjalne repozytorium CUID na GitHubie
2. Specyfikacja CUID2
3. Elliott, Eric. "Generowanie unikalnych identyfikatorów w rozproszonym środowisku." Medium, 2015.
4. "Identyfikatory odporne na kolizje dla systemów rozproszonych." DZone, 2018.

To narzędzie do generowania CUID-ów pozwala szybko generować CUID-y do Twoich projektów. Po prostu kliknij przycisk "Generuj", aby stworzyć nowy CUID, a następnie użyj przycisku "Kopiuj", aby skopiować go do schowka w celu łatwego użycia w Twoich aplikacjach.