Vad är CUID?
CUID (Collision-Resistant Unique Identifier) är en öppen algoritm för att generera unika ID:n som fungerar väl i distribuerade system utan en central koordinator. Till skillnad från ett enkelt UUID är CUID utformat för att vara horisontellt skalbart — flera servrar eller webbläsarflikar kan generera ID:n oberoende av varandra med minimal kollisionsrisk.
Varje CUID börjar med den gemena bokstaven c, vilket gör formatet omedelbart igenkännbart. Återstående tecken är gemena alfanumeriska (base36), vilket innebär att ett CUID är URL-säkert och kan användas direkt som URL-sökvägssegment eller databasprimärnyckel utan extra kodning.
Den ursprungliga CUID-specifikationen (v1) skapades av Eric Elliott och populariserades via npm-paketet cuid. Den har nu ersatts av CUID v2, som erbjuder kryptografisk säkerhet. Denna sida — och generatorn ovan — producerar CUID v1-ID:n, det klassiska formatet som fortfarande är vanligt i produktionskodbaserna.
CUID-struktur
Ett CUID v1 är ungefär 25 tecken långt och består av fem sammansatta segment, där varje segment bär en annan typ av entropi:
Segmenten är helt enkelt sammansatta — det finns inga avskiljare. Den totala längden varierar något beroende på det aktuella tidsstämpelvärdet men håller sig på ungefär 25 tecken.
Hur CUID förhindrar kollisioner
Kollisionsresistens uppnås genom att kombinera oberoende entropikällor, så att även i värsta fall (tusentals ID:n genererade per millisekund över många maskiner) förblir sannolikheten för två identiska ID:n försvinnande liten.
CUID vs UUID v4
Både CUID och UUID v4 hanterar ID-generering på klientsidan utan en central server, men de gör olika avvägningar:
| Funktion | CUID v1 | UUID v4 |
|---|---|---|
| Format | c + base36 (~25 tecken) | hexgrupper (36 tecken med bindestreck) |
| Sorterbar | Ungefär (tidsstämpelprefix) | Nej |
| URL-säker | Ja (endast alfanumeriska) | Mestadels (bindestreck är ok i URL:er) |
| Kollisionsresistens | Hög — tidsstämpel + räknare + fingeravtryck + slump | Hög — 122 bitar slump |
| Förutsägbarhet | Delvis (tidsstämpel synlig) | Ingen (ren slump) |
| Längd | ~25 tecken | 36 tecken |
| Kräver koordinering | Nej | Nej |
UUID v4 är det säkrare valet för säkerhetskänsliga scenarion eftersom det inte avslöjar någon tidinformation. CUID har fördelen när du vill ha ID:n som är ungefär sorterbara, kortare och saknar bindestreck — praktiskt i URL:er, filnamn eller loggar där du snabbt vill identifiera när en post skapades.
CUID v1 vs CUID2
CUID-specifikationen har reviderats betydligt. Så här jämför de två versionerna:
| Egenskap | CUID v1 | CUID v2 |
|---|---|---|
| Algoritm | Deterministiska komponenter | SHA-3-baserad, helt ogenomskinlig |
| Kryptografisk | Nej | Ja |
| Tidsstämpel synlig | Ja | Nej |
| Format | Börjar med "c" | Börjar med "c" (konfigurerbar) |
| npm-paket | @paralleldrive/cuid (avvecklad) | @paralleldrive/cuid2 |
| Längd | ~25 tecken | 24 tecken (standard, konfigurerbar) |
För nya projekt är CUID v2 det rekommenderade valet. Dess SHA-3-baserade konstruktion innebär att utdata är ogenomskinliga — ingen tidsstämpel, räknare eller fingeravtryck kan bakåtkonstrueras från ID:t. Använd CUID v1 bara när du behöver bakåtkompatibilitet med en befintlig datamängd eller vill ha en beroendefri implementation.
Användningsfall
@id på String-primärnycklar via @default(cuid()), vilket gör det till ett av de mest spridda ID-formaten i JavaScript-ekosystemet.Kodexempel
Installera det officiella CUID v2-paketet (rekommenderat) eller skriv en minimal v1-implementation utan beroenden:
// 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'Om du föredrar en beroendefri Node.js-implementation av v1-algoritmen:
// 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ända CUID som databasprimärnyckel med Prisma och PostgreSQL:
-- 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())
}