CUID-generator

CUID Generator

Introduksjon

En CUID (Collision-resistant Unique IDentifier) er en unik identifikator designet for å være kollisjonsbestandig, horisontalt skalerbar og sekvensielt sortert. CUID-er er spesielt nyttige i distribuerte systemer der unike identifikatorer må genereres uten koordinering mellom noder.

Struktur av CUID-er

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

1. Tidsstempel: En representasjon av den nåværende tiden
2. Teller: En sekvensiell teller for å sikre unikhet innen samme millisekund
3. Klientfingeravtrykk: En unik identifikator for maskinen eller prosessen som genererer CUID-en
4. Tilfeldig komponent: Ekstra tilfeldige data for ytterligere å redusere kollisjonsmuligheten

Den eksakte strukturen kan variere avhengig av CUID-implementeringen, men disse komponentene arbeider sammen for å lage en unik og sortert identifikator.

Her er en visuell representasjon av en typisk CUID-struktur:

Hvordan CUID-er genereres

CUID-er genereres ved hjelp av en kombinasjon av tidsbaserte og tilfeldige komponenter. Prosessen involverer vanligvis:

1. Hente det nåværende tidsstempelet
2. Øke en teller (som tilbakestilles periodisk)
3. Generere et klientfingeravtrykk (vanligvis gjort én gang per økt eller applikasjonsstart)
4. Legge til tilfeldige data
5. Kombinere disse elementene i et spesifikt format

Den resulterende CUID-en representeres vanligvis som en streng med bokstaver og tall.

Fordeler og bruksområder

CUID-er tilbyr flere fordeler sammenlignet med andre systemer for unike identifikatorer:

1. Kollisjonsbestandighet: Kombinasjonen av tidsstempel, teller og tilfeldige data gjør kollisjoner ekstremt usannsynlige, selv i distribuerte systemer.
2. Horisontal skalerbarhet: CUID-er kan genereres uavhengig på flere maskiner uten koordinering.
3. Sekvensiell sortering: Tidsstempelkomponenten tillater kronologisk sortering av CUID-er.
4. URL-vennlig: CUID-er består vanligvis av URL-sikre tegn.

Vanlige bruksområder for CUID-er inkluderer:

• Primærnøkler i databaser
• Distribuerte systemer der unike ID-er må genereres på tvers av flere noder
• Økt-ID-er i webapplikasjoner
• Sporing av hendelser i analyssystemer
• Fil- eller ressursnavn i skytjenester

Kodeeksempler

Her er eksempler på generering av CUID-er i forskjellige programmeringsspråk:

// JavaScript (ved hjelp av 'cuid'-biblioteket)
const cuid = require('cuid');
const id = cuid();
console.log(id);

## Python (ved hjelp av 'cuid'-biblioteket)
import cuid
id = cuid.cuid()
print(id)

## Ruby (ved hjelp av 'cuid'-gem)
require 'cuid'
id = Cuid::generate
puts id

// Java (ved hjelp av '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 hjelp av 'Cuid.Net'-NuGet-pakken)
using Cuid;

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

// PHP (ved hjelp av 'endyjasmi/cuid'-pakken)
<?php
require 'vendor/autoload.php';
use Endyjasmi\Cuid\Cuid;

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

// Go (ved hjelp av 'github.com/lucsky/cuid'-pakken)
package main

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

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

// Swift (ved hjelp av 'CUID'-pakken)
import CUID

let id = CUID()
print(id)

// C++ (ved hjelp av en tilpasset 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 hjelp av en tilpasset 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

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

## R (ved hjelp av en tilpasset 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)
}

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

' Excel VBA (ved hjelp av en tilpasset 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

' Bruk i en celle
'=GenerateCUID()

Historie og utvikling

CUID-er ble opprinnelig utviklet av Eric Elliott i 2012 som en løsning på problemet med å generere unike identifikatorer i distribuerte systemer. Konseptet ble inspirert av Twitters Snowflake ID-system, men designet for å være lettere å implementere og bruke på tvers av forskjellige plattformer.

Utviklingen av CUID-er ble drevet av behovet for et enkelt, kollisjonsbestandig ID-system som kunne fungere på tvers av forskjellige programmeringsspråk og miljøer. Elliotts mål var å lage et system som var enkelt å implementere, ikke krevde sentral koordinering, og kunne skaleres horisontalt.

Siden oppstarten har CUID gått gjennom flere iterasjoner og forbedringer:

1. Den originale CUID-implementeringen fokuserte på enkelhet og brukervennlighet.
2. Etter hvert som adopsjonen vokste, bidro fellesskapet med implementeringer i forskjellige programmeringsspråk.
3. I 2021 ble CUID2 introdusert for å adressere noen begrensninger ved den originale CUID og gi enda bedre ytelse og kollisjonsbestandighet.
4. CUID2 forbedret den originale ved å bruke en sikrere tilfeldig tallgenerator og øke den totale lengden på identifikatoren.

Utviklingen av CUID-er gjenspeiler de skiftende behovene til distribuerte systemer og de pågående innsatsene for å balansere enkelhet, sikkerhet og ytelse i generering av unike identifikatorer.

Referanser

1. Offisiell CUID GitHub-repositorium
2. CUID2-spesifikasjon
3. Elliott, Eric. "Generering av unike ID-er i et distribuert miljø." Medium, 2015.
4. "Kollisjonsbestandige ID-er for distribuerte systemer." DZone, 2018.

Dette CUID-generatorverktøyet lar deg raskt generere CUID-er for prosjektene dine. Klikk ganske enkelt på "Generer"-knappen for å lage en ny CUID, og bruk "Kopier"-knappen for å kopiere den til utklippstavlen for enkel bruk i applikasjonene dine.