CUID Generator

CUID Generator

Introduktion

En CUID (Collision-resistant Unique IDentifier) er en unik identifikator designet til at være kollisionsresistent, horisontalt skalerbar og sekventielt sorterbar. CUID'er er særligt nyttige i distribuerede systemer, hvor unikke identifikatorer skal genereres uden koordinering mellem noder.

Struktur af CUID'er

En CUID består typisk af følgende komponenter:

1. Tidsstempel: En repræsentation af den nuværende tid
2. Tæller: En sekventiel tæller for at sikre unikhed inden for den samme millisekund
3. Klientfingeraftryk: En unik identifikator for den maskine eller proces, der genererer CUID'en
4. Tilfældig komponent: Yderligere tilfældige data for yderligere at reducere kollisionssandsynligheden

Den præcise struktur kan variere afhængigt af CUID-implementeringen, men disse komponenter arbejder sammen for at skabe en unik og sorterbar identifikator.

Her er en visuel repræsentation af en typisk CUID-struktur:

Hvordan CUID'er genereres

CUID'er genereres ved hjælp af en kombination af tidsbaserede og tilfældige komponenter. Processen involverer typisk:

1. At få det nuværende tidsstempel
2. At inkrementere en tæller (som nulstilles periodisk)
3. At generere et klientfingeraftryk (normalt gjort én gang pr. session eller applikationsstart)
4. At tilføje tilfældige data
5. At kombinere disse elementer i et specifikt format

Den resulterende CUID repræsenteres typisk som en streng af bogstaver og tal.

Fordele og anvendelsesområder

CUID'er tilbyder flere fordele i forhold til andre systemer til unikke identifikatorer:

1. Kollisionsresistens: Kombinationen af tidsstempel, tæller og tilfældige data gør kollisionssandsynligheden ekstremt lav, selv i distribuerede systemer.
2. Horisontal skalerbarhed: CUID'er kan genereres uafhængigt på flere maskiner uden koordinering.
3. Sekventiel sortering: Tidsstempelkomponenten muliggør kronologisk sortering af CUID'er.
4. URL-venlig: CUID'er består typisk af URL-sikre tegn.

Almindelige anvendelsesområder for CUID'er inkluderer:

• Primære nøgler i databaser
• Distribuerede systemer, hvor unikke ID'er skal genereres på tværs af flere noder
• Session ID'er i webapplikationer
• Sporingsbegivenheder i analysetjenester
• Fil- eller ressource-navngivning i cloud-lagringssystemer

Kodeeksempler

Her er eksempler på generering af CUID'er i forskellige programmeringssprog:

// JavaScript (ved hjælp af 'cuid' biblioteket)
const cuid = require('cuid');
const id = cuid();
console.log(id);

## Python (ved hjælp af 'cuid' biblioteket)
import cuid
id = cuid.cuid()
print(id)

## Ruby (ved hjælp af 'cuid' gem)
require 'cuid'
id = Cuid::generate
puts id

// Java (ved hjælp af 'com.github.f4b6a3.cuid' biblioteket)
import com.github.f4b6a3.cuid.Cuid;

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

// C# (ved hjælp af 'Cuid.Net' NuGet-pakken)
using Cuid;

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

// PHP (ved hjælp af 'endyjasmi/cuid' pakken)
<?php
require 'vendor/autoload.php';
use Endyjasmi\Cuid\Cuid;

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

// Go (ved hjælp af 'github.com/lucsky/cuid' pakken)
package main

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

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

// Swift (ved hjælp af 'CUID' pakken)
import CUID

let id = CUID()
print(id)

// C++ (ved hjælp af en brugerdefineret implementering)
#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 (ved hjælp af en brugerdefineret implementering)
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

% Brug
id = generateCUID();
disp(id);

## R (ved hjælp af en brugerdefineret implementering)
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)
}

## Brug
id <- generate_cuid()
print(id)

' Excel VBA (ved hjælp af en brugerdefineret implementering)
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

' Brug i en celle
'=GenerateCUID()

Historie og udvikling

CUID'er blev oprindeligt udviklet af Eric Elliott i 2012 som en løsning på problemet med at generere unikke identifikatorer i distribuerede systemer. Konceptet blev inspireret af Twitters Snowflake ID-system, men designet til at være lettere at implementere og bruge på tværs af forskellige platforme.

Udviklingen af CUID'er blev drevet af behovet for et simpelt, kollisionsresistent ID-system, der kunne fungere på tværs af forskellige programmeringssprog og miljøer. Elliotts mål var at skabe et system, der var nemt at implementere, ikke krævede central koordinering og kunne skaleres horisontalt.

Siden sin opstart er CUID gået gennem flere iterationer og forbedringer:

1. Den oprindelige CUID-implementering fokuserede på enkelhed og brugervenlighed.
2. Efterhånden som adoptionen voksede, bidrog fællesskabet med implementeringer i forskellige programmeringssprog.
3. I 2021 blev CUID2 introduceret for at adressere nogle af begrænsningerne ved den oprindelige CUID og give endnu bedre ydeevne og kollisionsresistens.
4. CUID2 forbedrede den oprindelige ved at bruge en mere sikker tilfældig talgenerator og øge den samlede længde af identifikatoren.

Udviklingen af CUID'er afspejler de skiftende behov i distribuerede systemer og de løbende bestræbelser på at balancere enkelhed, sikkerhed og ydeevne i genereringen af unikke identifikatorer.

Referencer

1. Officiel CUID GitHub Repository
2. CUID2-specifikation
3. Elliott, Eric. "Generering af unikke ID'er i et distribueret miljø." Medium, 2015.
4. "Kollisionsresistente ID'er til distribuerede systemer." DZone, 2018.

Dette CUID-generatorværktøj giver dig mulighed for hurtigt at generere CUID'er til dine projekter. Klik blot på "Generer"-knappen for at oprette en ny CUID, og brug "Kopier"-knappen for at kopiere den til din udklipsholder for nem brug i dine applikationer.