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:

1// JavaScript (ved hjelp av 'cuid'-biblioteket)
2const cuid = require('cuid');
3const id = cuid();
4console.log(id);
5

1## Python (ved hjelp av 'cuid'-biblioteket)
2import cuid
3id = cuid.cuid()
4print(id)
5

1## Ruby (ved hjelp av 'cuid'-gem)
2require 'cuid'
3id = Cuid::generate
4puts id
5

1// Java (ved hjelp av 'com.github.f4b6a3.cuid'-biblioteket)
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# (ved hjelp av 'Cuid.Net'-NuGet-pakken)
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 (ved hjelp av 'endyjasmi/cuid'-pakken)
2<?php
3require 'vendor/autoload.php';
4use Endyjasmi\Cuid\Cuid;
5
6$id = Cuid::make();
7echo $id;
8

1// Go (ved hjelp av 'github.com/lucsky/cuid'-pakken)
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 (ved hjelp av 'CUID'-pakken)
2import CUID
3
4let id = CUID()
5print(id)
6

1// C++ (ved hjelp av en tilpasset implementering)
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 (ved hjelp av en tilpasset implementering)
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% Bruk
12id = generateCUID();
13disp(id);
14

1## R (ved hjelp av en tilpasset implementering)
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## Bruk
12id <- generate_cuid()
13print(id)
14

1' Excel VBA (ved hjelp av en tilpasset implementering)
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' Bruk i en celle
17'=GenerateCUID()
18

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.