CUID Generator

Generate collision-resistant unique IDs (CUID v1)

Antal

Genererade CUIDs

Klicka på Generera för att skapa CUIDs

CUID v1 är ett legacy-format. Använd CUID2 för nya projekt.

Vad är CUID?

CUID (Collision-resistant Unique IDentifier) är ett globalt unikt ID utformat för horisontellt skalbara applikationer.

Börjar alltid med bokstaven c, följt av en tidsstämpel, räknare, värdavtryck och ett slumpmässigt segment — allt kodat i base36.

ID:n är URL-säkra, kompakta och läsbara, lämpliga för databas-ID:n, URL:er och sessionsgenerering.

CUID-struktur

Varje CUID består av fem olika sektioner som säkerställer unikhet över maskiner, processer och tid:

Exempel:: clrc4gkwz001ag2hs3k7f9m2q
cPrefixDet konstanta tecknet 'c' som typmarkör
lrc4gkwzTidsstämpelUnix-tid i millisekunder, kodad i base36
001aRäknareSekventiell räknare för att förhindra kollisioner vid samma millisekund
g2hsFingeravtryckUnikt värdfingeravtryck från PID och värdnamn
3k7f9m2qSlumpmässigSlumpmässigt segment för ytterligare unikhet

Denna hierarkiska design säkerställer att ID:n är kronologiskt ordnade samtidigt som tillräcklig slumpentropi bibehålls för distribuerade system.

Kollisionsresistens

CUID kombinerar flera mekanismer för att garantera unikhet:

Tidsprecision
Millisekundsprecision innebär att ID:n som skapas i olika exekveringstrådar vanligtvis börjar med olika värden.
Sekventiell räknare
Även om två ID:n skapas under samma millisekund, ökar räknaren för att garantera unikhet inom en enskild process.
Värdfingeravtryck
Fingeravtrycket härrört från PID och värdnamn skiljer ID:n utfärdade från olika servrar.
Slumpentropi
Det slumpmässiga segmentet lägger till ett extra försvarslager mot återstående kollisioner.

CUID vs UUID

Både CUID och UUID löser uniktetsproblemet men med olika tillvägagångssätt:

FunktionCUID v1UUID v4
FormatAlfanumeriska gemenerHex med bindestreck
SorterbarDelvis (tidsstämpel först)Nej (v4 slumpmässig)
URL-säkerJaJa (med bindestreck)
KollisionsresistensHög (strukturell)Hög (statistisk)
FörutsägbarhetLåg (synlig tidsstämpel)Mycket låg
Längd25 tecken36 tecken
Kräver koordineringNejNej

CUID är bättre för synliga databas-ID:n och URL:er; UUID är mer vitt antagen och har bredare stöd.

CUID v1 vs CUID v2

CUID v2 är en komplett algoritmomskrivning som åtgärdar säkerhetsproblem i CUID v1:

EgenskapCUID v1CUID v2
AlgoritmAnpassadSHA3 + CSPRNG
KryptografiskNej (förutsägbar)Ja (kryptografiskt säker)
TidsstämpelTydligt synligDold i hash
FormatBörjar alltid med 'c'Anpassningsbart prefix
npm-paketcuid@paralleldrive/cuid2
LängdFast 25 teckenAnpassningsbar (standard 24)

För nya projekt rekommenderas CUID v2 som ger starkare säkerhetsgarantier med bibehållen användarvänlighet.

Vanliga användningsfall

Databas-ID:n
Idealisk som primärnycklar — läsbar, kompakt, URL-säker utan kodning.
Sessionshantering
Generera unika sessions-ID:n för webbapplikationer med resistens mot gissning.
Begäran-ID:n
Spåra förfrågningar i distribuerade system med ett unikt ID som kan loggas och spåras.
Fil-ID:n
Generera unika filnamn för uppladdat innehåll eller temporära filer.
Datasynkronisering
Synkronisera data över flera enheter eller distribuerade databaser med förtroende för unikhet.
URL-identifierare
Skapa kortlänkar eller video-ID:n med garanterad minimal kollision.

Kodexempel

Installation och grundläggande användning:

JavaScript / TypeScript
// npm install @paralleldrive/cuid2  (recommended — CUID v2)
import { createId } from '@paralleldrive/cuid2'

const id = createId()
// → 'tz4a98xxat96iws9zmbrgj3a'

// Custom length
import { init } from '@paralleldrive/cuid2'
const createShortId = init({ length: 10 })
createShortId() // → 'zxp1l6mf4c'

Node.js och vanlig databasintegration:

Node.js (no dependencies)
// Pure Node.js — CUID v1 style (no dependencies)
let counter = 0

function pad(str, size) {
  return str.padStart(size, '0').slice(-size)
}

function fingerprint() {
  const os = require('os')
  const source = [process.pid, os.hostname().length].join('')
  let hash = 0
  for (const c of source) {
    hash = ((hash << 5) - hash) + c.charCodeAt(0)
    hash |= 0
  }
  return pad(Math.abs(hash).toString(36), 4)
}

function cuid() {
  const timestamp = Date.now().toString(36)
  const cnt       = pad((counter++ & 0xffff).toString(36), 4)
  const fp        = fingerprint()
  const rnd       = pad(Math.floor(Math.random() * 0xffffffff).toString(36), 4)
              + pad(Math.floor(Math.random() * 0xffffffff).toString(36), 4)
  return 'c' + timestamp + cnt + fp + rnd
}

console.log(cuid()) // → 'clrc4gkwz001ag2hs3k7f9m2q'

Användning av databasbegränsning:

Prisma / SQL
-- Use CUID as a primary key in PostgreSQL
CREATE TABLE users (
  id   TEXT        PRIMARY KEY DEFAULT gen_cuid(),
  name TEXT        NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Prisma schema (auto-generates CUID by default)
model User {
  id        String   @id @default(cuid())
  name      String
  createdAt DateTime @default(now())
}

Vanliga frågor

Är CUID verkligen unikt över olika servrar?
Ja — fingeravtrycksmekanismen (PID + värdnamn) säkerställer att ID:n utfärdade från olika servrar varierar i fingeravtrycksdelen. Den tidsbaserade räknaren och det slumpmässiga segmentet ger ytterligare skydd.
Kan CUID användas i webbläsaren?
Ja — CUID-biblioteket är kompatibelt med både webbläsare och Node.js. I webbläsarmiljö använder fingeravtrycket navigatorinformation och annan data istället för processdata.
Hur stor är CUID jämfört med alternativ?
CUID v1 har en fast längd på 25 tecken. UUID v4 har 36 tecken med bindestreck. NanoID är anpassningsbart, vanligtvis 21 tecken. CUID v2 är anpassningsbart, standard 24 tecken.
Är CUID kryptografiskt säker?
CUID v1 är inte kryptografiskt säker — tidsstämpeln är synlig och vissa komponenter är förutsägbara. CUID v2 använder SHA3 och CSPRNG, vilket gör den lämplig för säkerhetskänsliga fall.
Vad är den huvudsakliga skillnaden mellan CUID och NanoID?
NanoID fokuserar på liten storlek och kryptografisk säkerhet med fullt anpassningsbara storlekar. CUID prioriterar partiell kronologisk sorterbarhet och visuell distinktivitet. CUID v2 kombinerar säkerhet med igenkännbar identitet.
Hur hanterar CUID kollisioner?
Kollisioner är teoretiskt möjliga men statistiskt mycket osannolika. Räknaren förhindrar kollisioner inom en enskild process; fingeravtrycket separerar olika maskiner; det slumpmässiga segmentet hanterar kantfall. Algoritmen är utformad för verkliga produktionssystem.