CUID Generator

CUID-generator

Introduktion

En CUID (Collision-resistant Unique IDentifier) är en unik identifierare som är utformad för att vara kollision-resistent, horisontellt skalbar och sekventiellt sorterad. CUID:er är särskilt användbara i distribuerade system där unika identifierare behöver genereras utan samordning mellan noder.

Struktur av CUID:er

En CUID består typiskt av följande komponenter:

1. Tidsstämpel: En representation av den aktuella tiden
2. Räknare: En sekventiell räknare för att säkerställa unikhet inom samma millisekund
3. Klientfingeravtryck: En unik identifierare för maskinen eller processen som genererar CUID:en
4. Slumptal: Ytterligare slumpmässiga data för att ytterligare minska kollisionens sannolikhet

Den exakta strukturen kan variera beroende på CUID-implementeringen, men dessa komponenter arbetar tillsammans för att skapa en unik och sorteringsbar identifierare.

Här är en visuell representation av en typisk CUID-struktur:

Hur CUID:er genereras

CUID:er genereras med en kombination av tidsbaserade och slumpmässiga komponenter. Processen involverar vanligtvis:

1. Hämta den aktuella tidsstämpeln
2. Inkrementera en räknare (som återställs periodiskt)
3. Generera ett klientfingeravtryck (vanligtvis gjort en gång per session eller applikationsstart)
4. Lägga till slumpmässiga data
5. Kombinera dessa element i ett specifikt format

Den resulterande CUID:en representeras vanligtvis som en sträng av bokstäver och siffror.

Fördelar och användningsområden

CUID:er erbjuder flera fördelar jämfört med andra system för unika identifierare:

1. Kollisionresistens: Kombinationen av tidsstämpel, räknare och slumpmässiga data gör kollisioner extremt osannolika, även i distribuerade system.
2. Horisontell skalbarhet: CUID:er kan genereras oberoende på flera maskiner utan samordning.
3. Sekventiell sortering: Tidsstämpelkomponenten möjliggör kronologisk sortering av CUID:er.
4. URL-vänlig: CUID:er består vanligtvis av URL-säkra tecken.

Vanliga användningsområden för CUID:er inkluderar:

• Databas primära nycklar
• Distribuerade system där unika ID:n behöver genereras över flera noder
• Sessions-ID:n i webbapplikationer
• Spåra händelser i analysystem
• Fil- eller resursnamn i molnlagringssystem

Kodexempel

Här är exempel på hur man genererar CUID:er i olika programmeringsspråk:

// JavaScript (använder 'cuid'-biblioteket)
const cuid = require('cuid');
const id = cuid();
console.log(id);

## Python (använder 'cuid'-biblioteket)
import cuid
id = cuid.cuid()
print(id)

## Ruby (använder 'cuid'-gem)
require 'cuid'
id = Cuid::generate
puts id

// Java (använder '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# (använder 'Cuid.Net'-NuGet-paketet)
using Cuid;

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

// PHP (använder 'endyjasmi/cuid'-paketet)
<?php
require 'vendor/autoload.php';
use Endyjasmi\Cuid\Cuid;

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

// Go (använder 'github.com/lucsky/cuid'-paketet)
package main

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

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

// Swift (använder 'CUID'-paketet)
import CUID

let id = CUID()
print(id)

// C++ (använder en egen implementation)
#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 (använder en egen implementation)
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

% Användning
id = generateCUID();
disp(id);

## R (använder en egen implementation)
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)
}

## Användning
id <- generate_cuid()
print(id)

' Excel VBA (använder en egen implementation)
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

' Användning i en cell
'=GenerateCUID()

Historia och utveckling

CUID:er utvecklades ursprungligen av Eric Elliott 2012 som en lösning på problemet med att generera unika identifierare i distribuerade system. Konceptet inspirerades av Twitters Snowflake-ID-system men utformades för att vara enklare att implementera och använda över olika plattformar.

Utvecklingen av CUID:er drevs av behovet av ett enkelt, kollision-resistent ID-system som kunde fungera över olika programmeringsspråk och miljöer. Elliotts mål var att skapa ett system som var enkelt att implementera, inte krävde central samordning och kunde skalas horisontellt.

Sedan dess har CUID:er genomgått flera iterationer och förbättringar:

1. Den ursprungliga CUID-implementeringen fokuserade på enkelhet och användarvänlighet.
2. När antalet användare växte bidrog gemenskapen med implementeringar i olika programmeringsspråk.
3. År 2021 introducerades CUID2 för att åtgärda vissa begränsningar i den ursprungliga CUID och ge ännu bättre prestanda och kollisionresistens.
4. CUID2 förbättrade den ursprungliga genom att använda en mer säker slumptalsgenerator och öka den totala längden på identifieraren.

Utvecklingen av CUID:er speglar de föränderliga behoven hos distribuerade system och de pågående ansträngningarna för att balansera enkelhet, säkerhet och prestanda i genereringen av unika identifierare.

Referenser

1. Officiell CUID GitHub-repo
2. CUID2-specifikation
3. Elliott, Eric. "Generating Unique IDs in a Distributed Environment." Medium, 2015.
4. "Collision-resistant IDs for Distributed Systems." DZone, 2018.

Detta CUID-generatorverktyg låter dig snabbt generera CUID:er för dina projekt. Klicka helt enkelt på "Generera"-knappen för att skapa en ny CUID, och använd "Kopiera"-knappen för att kopiera den till ditt urklipp för enkel användning i dina applikationer.