Generatore di CUID

Introduzione

Un CUID (Collision-resistant Unique IDentifier) è un identificatore unico progettato per essere resistente alle collisioni, orizzontalmente scalabile e ordinabile in modo sequenziale. I CUID sono particolarmente utili nei sistemi distribuiti in cui è necessario generare identificatori unici senza coordinazione tra i nodi.

Struttura dei CUID

Un CUID tipicamente consiste nei seguenti componenti:

1. Timestamp: Una rappresentazione dell'ora attuale
2. Contatore: Un contatore sequenziale per garantire l'unicità all'interno della stessa millisecondo
3. Impronta del client: Un identificatore unico per la macchina o il processo che genera il CUID
4. Componente casuale: Dati casuali aggiuntivi per ridurre ulteriormente la probabilità di collisione

La struttura esatta può variare a seconda dell'implementazione del CUID, ma questi componenti lavorano insieme per creare un identificatore unico e ordinabile.

Ecco una rappresentazione visiva di una tipica struttura CUID:

Come vengono generati i CUID

I CUID vengono generati utilizzando una combinazione di componenti basati sul tempo e casuali. Il processo tipicamente prevede:

1. Ottenere il timestamp attuale
2. Incrementare un contatore (che si resetta periodicamente)
3. Generare un'impronta del client (di solito eseguita una sola volta per sessione o avvio dell'applicazione)
4. Aggiungere dati casuali
5. Combinare questi elementi in un formato specifico

Il CUID risultante è tipicamente rappresentato come una stringa di lettere e numeri.

Vantaggi e casi d'uso

I CUID offrono diversi vantaggi rispetto ad altri sistemi di identificazione unici:

1. Resistenza alle collisioni: La combinazione di timestamp, contatore e dati casuali rende estremamente improbabili le collisioni, anche nei sistemi distribuiti.
2. Scalabilità orizzontale: I CUID possono essere generati in modo indipendente su più macchine senza coordinazione.
3. Ordinamento sequenziale: Il componente timestamp consente l'ordinamento cronologico dei CUID.
4. Sicurezza in URL: I CUID sono tipicamente composti da caratteri sicuri per gli URL.

I casi d'uso comuni per i CUID includono:

• Chiavi primarie nei database
• Sistemi distribuiti in cui è necessario generare ID unici su più nodi
• ID di sessione nelle applicazioni web
• Tracciamento degli eventi nei sistemi di analisi
• Nominativi di file o risorse nei sistemi di archiviazione cloud

Esempi di codice

Ecco esempi di generazione di CUID in vari linguaggi di programmazione:

1// JavaScript (utilizzando la libreria 'cuid')
2const cuid = require('cuid');
3const id = cuid();
4console.log(id);
5

1## Python (utilizzando la libreria 'cuid')
2import cuid
3id = cuid.cuid()
4print(id)
5

1## Ruby (utilizzando il gem 'cuid')
2require 'cuid'
3id = Cuid::generate
4puts id
5

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

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

1// C++ (utilizzando un'implementazione personalizzata)
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 (utilizzando un'implementazione personalizzata)
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% Utilizzo
12id = generateCUID();
13disp(id);
14

1## R (utilizzando un'implementazione personalizzata)
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## Utilizzo
12id <- generate_cuid()
13print(id)
14

1' Excel VBA (utilizzando un'implementazione personalizzata)
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' Utilizzo in una cella
17'=GenerateCUID()
18

Storia e sviluppo

I CUID sono stati originariamente sviluppati da Eric Elliott nel 2012 come soluzione al problema della generazione di identificatori unici nei sistemi distribuiti. Il concetto è stato ispirato dal sistema di ID Snowflake di Twitter, ma progettato per essere più facilmente implementato e utilizzato su varie piattaforme.

Lo sviluppo dei CUID è stato guidato dalla necessità di un sistema di ID semplice e resistente alle collisioni che potesse funzionare su diversi linguaggi di programmazione e ambienti. L'obiettivo di Elliott era creare un sistema che fosse facile da implementare, non richiedesse coordinazione centrale e potesse scalare orizzontalmente.

Dalla sua nascita, i CUID hanno subito diverse iterazioni e miglioramenti:

1. L'implementazione originale del CUID si concentrava sulla semplicità e facilità d'uso.
2. Con la crescita dell'adozione, la comunità ha contribuito con implementazioni in vari linguaggi di programmazione.
3. Nel 2021, è stato introdotto il CUID2 per affrontare alcune limitazioni del CUID originale e fornire prestazioni e resistenza alle collisioni migliori.
4. Il CUID2 ha migliorato l'originale utilizzando un generatore di numeri casuali più sicuro e aumentando la lunghezza complessiva dell'identificatore.

L'evoluzione dei CUID riflette le esigenze in cambiamento dei sistemi distribuiti e gli sforzi continui per bilanciare semplicità, sicurezza e prestazioni nella generazione di identificatori unici.

Riferimenti

1. Repository ufficiale di CUID su GitHub
2. Specifiche di CUID2
3. Elliott, Eric. "Generazione di ID unici in un ambiente distribuito." Medium, 2015.
4. "ID resistenti alle collisioni per sistemi distribuiti." DZone, 2018.

Questo strumento generatore di CUID ti consente di generare rapidamente CUID per i tuoi progetti. Basta fare clic sul pulsante "Genera" per creare un nuovo CUID e utilizzare il pulsante "Copia" per copiarlo negli appunti per un facile utilizzo nelle tue applicazioni.