Generador de CUID

Generador de CUID

Introducció

Un CUID (Identificador Únic Resistant a Colisions) és un identificador únic dissenyat per ser resistant a colisions, escalable horitzontalment i ordenable de manera seqüencial. Els CUIDs són particularment útils en sistemes distribuïts on cal generar identificadors únics sense coordinació entre nodes.

Estructura dels CUIDs

Un CUID normalment consta dels següents components:

1. Timestamp: Una representació del temps actual
2. Comptador: Un comptador seqüencial per assegurar la unicitat dins del mateix mil·lisegon
3. Empremta del client: Un identificador únic per a la màquina o procés que genera el CUID
4. Component aleatori: Dades aleatòries addicionals per reduir encara més la probabilitat de colisions

L'estructura exacta pot variar depenent de la implementació del CUID, però aquests components treballen junts per crear un identificador únic i ordenable.

Aquí teniu una representació visual d'una estructura típica de CUID:

Com es generen els CUIDs

Els CUIDs es generen mitjançant una combinació de components basats en el temps i aleatoris. El procés normalment implica:

1. Obtenir el timestamp actual
2. Incrementar un comptador (que es reinicia periòdicament)
3. Generar una empremta del client (normalment es fa una vegada per sessió o inici d'aplicació)
4. Afegir dades aleatòries
5. Combinar aquests elements en un format específic

El CUID resultant normalment es representa com una cadena de lletres i números.

Avantatges i casos d'ús

Els CUIDs ofereixen diversos avantatges sobre altres sistemes d'identificadors únics:

1. Resistència a colisions: La combinació de timestamp, comptador i dades aleatòries fa que les colisions siguin extremadament improbables, fins i tot en sistemes distribuïts.
2. Escalabilitat horitzontal: Els CUIDs es poden generar de manera independent en múltiples màquines sense coordinació.
3. Ordenació seqüencial: El component del timestamp permet l'ordenació cronològica dels CUIDs.
4. Amigable amb URL: Els CUIDs normalment estan compostos de caràcters segurs per a URL.

Els casos d'ús comuns per als CUIDs inclouen:

• Clau primària de base de dades
• Sistemes distribuïts on cal generar IDs únics a través de múltiples nodes
• IDs de sessió en aplicacions web
• Seguiment d'esdeveniments en sistemes d'analítica
• Nomenclatura de fitxers o recursos en sistemes d'emmagatzematge al núvol

Exemples de codi

Aquí teniu exemples de generació de CUIDs en diversos llenguatges de programació:

// JavaScript (usant la biblioteca 'cuid')
const cuid = require('cuid');
const id = cuid();
console.log(id);

## Python (usant la biblioteca 'cuid')
import cuid
id = cuid.cuid()
print(id)

## Ruby (usant la gem 'cuid')
require 'cuid'
id = Cuid::generate
puts id

// Java (usant la biblioteca 'com.github.f4b6a3.cuid')
import com.github.f4b6a3.cuid.Cuid;

public class CuidExample {
    public static void main(String[] args) {
        String id = Cuid.createCuid();
        System.out.println(id);
    }
}

// C# (usant el paquet NuGet 'Cuid.Net')
using Cuid;

class Program
{
    static void Main(string[] args)
    {
        string id = CuidGenerator.Generate();
        Console.WriteLine(id);
    }
}

// PHP (usant el paquet 'endyjasmi/cuid')
<?php
require 'vendor/autoload.php';
use Endyjasmi\Cuid\Cuid;

$id = Cuid::make();
echo $id;

// Go (usant el paquet 'github.com/lucsky/cuid')
package main

import (
    "fmt"
    "github.com/lucsky/cuid"
)

func main() {
    id := cuid.New()
    fmt.Println(id)
}

// Swift (usant el paquet 'CUID')
import CUID

let id = CUID()
print(id)

// C++ (usant una implementació personalitzada)
#include <iostream>
#include <chrono>
#include <random>
#include <sstream>
#include <iomanip>

std::string generateCUID() {
    auto now = std::chrono::system_clock::now();
    auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
    auto value = now_ms.time_since_epoch();
    long duration = value.count();

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, 35);

    std::stringstream ss;
    ss << 'c';
    ss << std::hex << std::setfill('0') << std::setw(8) << duration;
    for (int i = 0; i < 8; i++) {
        int r = dis(gen);
        ss << (char)(r < 10 ? '0' + r : 'a' + r - 10);
    }
    return ss.str();
}

int main() {
    std::string id = generateCUID();
    std::cout << id << std::endl;
    return 0;
}

% MATLAB (usant una implementació personalitzada)
function id = generateCUID()
    timestamp = dec2hex(round(posixtime(datetime('now'))*1000), 8);
    random = '';
    for i = 1:8
        random = [random char(randi([48 57 97 122]))];
    end
    id = ['c' timestamp random];
end

% Ús
id = generateCUID();
disp(id);

## R (usant una implementació personalitzada)
library(lubridate)

generate_cuid <- function() {
  timestamp <- format(as.numeric(now()) * 1000, scientific = FALSE)
  timestamp <- substr(timestamp, 1, 8)
  random <- paste0(sample(c(0:9, letters[1:6]), 8, replace = TRUE), collapse = "")
  paste0("c", timestamp, random)
}

## Ús
id <- generate_cuid()
print(id)

' Excel VBA (usant una implementació personalitzada)
Function GenerateCUID() As String
    Dim timestamp As String
    Dim random As String
    Dim i As Integer
    
    timestamp = Right("00000000" & Hex(CLng(CDbl(Now()) * 86400000)), 8)
    
    For i = 1 To 8
        random = random & Mid("0123456789abcdef", Int(Rnd() * 16) + 1, 1)
    Next i
    
    GenerateCUID = "c" & timestamp & random
End Function

' Ús en una cel·la
'=GenerateCUID()

Història i desenvolupament

Els CUIDs van ser desenvolupats originalment per Eric Elliott el 2012 com una solució al problema de generar identificadors únics en sistemes distribuïts. El concepte es va inspirar en el sistema d'ID de Snowflake de Twitter, però dissenyat per ser més fàcil d'implementar i utilitzar a través de diverses plataformes.

El desenvolupament dels CUIDs va ser impulsat per la necessitat d'un sistema d'ID simple i resistant a colisions que pogués funcionar a través de diferents llenguatges de programació i entorns. L'objectiu d'Elliott era crear un sistema que fos fàcil d'implementar, que no requerís coordinació central i que pogués escalar horitzontalment.

Des de la seva creació, els CUIDs han passat per diverses iteracions i millores:

1. La implementació original del CUID es va centrar en la simplicitat i la facilitat d'ús.
2. A mesura que l'adopció va créixer, la comunitat va contribuir amb implementacions en diversos llenguatges de programació.
3. El 2021, es va introduir el CUID2 per abordar algunes limitacions del CUID original i proporcionar un millor rendiment i resistència a colisions.
4. El CUID2 va millorar l'original utilitzant un generador de números aleatoris més segur i augmentant la longitud total de l'identificador.

L'evolució dels CUIDs reflecteix les necessitats canviants dels sistemes distribuïts i els esforços continus per equilibrar la simplicitat, la seguretat i el rendiment en la generació d'identificadors únics.

Referències

1. Repositori oficial de CUID a GitHub
2. Especificació de CUID2
3. Elliott, Eric. "Generant IDs Únics en un Entorn Distribuït." Medium, 2015.
4. "IDs resistents a colisions per a sistemes distribuïts." DZone, 2018.

Aquest eina generadora de CUID us permet generar ràpidament CUIDs per als vostres projectes. Simplement feu clic al botó "Generar" per crear un nou CUID, i utilitzeu el botó "Copiar" per copiar-lo al vostre portapapers per a un ús fàcil a les vostres aplicacions.