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ó:

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

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

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

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

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

1// C++ (usant una implementació personalitzada)
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 (usant una implementació personalitzada)
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% Ús
12id = generateCUID();
13disp(id);
14

1## R (usant una implementació personalitzada)
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## Ús
12id <- generate_cuid()
13print(id)
14

1' Excel VBA (usant una implementació personalitzada)
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' Ús en una cel·la
17'=GenerateCUID()
18

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.