Behöver du en identifierare som inte krockar med någon som en annan person har skapat, på en maskin du aldrig har hört talas om, utan att be någon om lov? Det är precis vad ett UUID gör. Det är ett 128-bitars tal, skrivet som 36 tecken i det bekanta mönstret 8-4-4-4-12, och hela dess design bygger på att två av dem aldrig kommer att vara likadana, även om inget system samordnar vem som får vad. Den här gratis generatorn skapar dem direkt i din webbläsare: välj en version under "Version", ange hur många du behöver under "Antal", och tryck på "Generera". Sidan öppnas med ett enda v4, den version som de flesta projekt vill ha, så din första identifierare är bara ett klick bort.
Varje identifierare byggs av din webbläsare via Web Crypto API. Version 4 använder crypto.randomUUID() där webbläsaren stöder det och annars crypto.getRandomValues() — en kryptografiskt stark källa till slumpmässighet i stället för en pseudoslumpmässig JavaScript-funktion som Math.random(). Version 7 placerar en 48-bitars tidsstämpel i millisekunder i början, därefter en 12-bitars räknare som tickar uppåt inom samma millisekund, och sedan 62 slumpmässiga bitar, vilket är den ordningsmetod som beskrivs i RFC 9562; den räknaren är anledningen till att en grupp på tusen genereras i rätt ordning i stället för blandat. Version 1 kombinerar en tidsstämpel med en slumpmässig nodidentifierare där multicast-biten är satt, så den innehåller aldrig adressen till ditt nätverkskort som de ursprungliga implementationerna från 1990-talet gjorde. Version 3 och 5 är inte slumpmässiga alls: de hashar en namnrymd tillsammans med ett namn, med hjälp av MD5 respektive SHA-1, och den beräkningen sker också på din enhet. Inget skickas till en server, inget loggas, och när sidan väl har laddats fortsätter den att fungera även om du stänger av uppkopplingen.
"Version" är det fält som avgör allt annat. Version 4 är 122 slumpmässiga bitar helt utan struktur — standardvalet och rätt svar när en identifierare enbart behöver vara unik. Version 7 behåller 62 slumpmässiga bitar men inleds med tidpunkten då den skapades, så att en uppsättning av dem sorteras i den ordning de gjordes; detta är den version du ska välja när identifieraren kommer att bli en databasnyckel. Version 1 är det ursprungliga tidsbaserade formatet, som finns kvar här för de system som fortfarande kräver det. Version 3 och 5 är ett udda par: de är deterministiska, vilket innebär att samma indata alltid ger samma identifierare, och de kräver två extra fält — "Namnrymd", som är en av standardrymderna DNS, URL, OID och X.500 eller din egen "Anpassad namnrymd (UUID)", samt "Namn", strängen som ska identifieras. Mata in namnrymden URL och https://example.com/a i v5, så får du samma UUID i dag, i morgon och på någon annans dator. På grund av detta försvinner "Antal" när v3 eller v5 väljs: tusen kopior av en deterministisk värde skulle bara vara tusen kopior av exakt samma värde. För alla andra versioner går "Antal" från 1 till 1000.
Fyra reglage ändrar formen på utdatan utan att påverka de underliggande 128 bitarna. "Versaler" skriver ut de hexadecimala siffrorna som stora bokstäver, "Utan bindestreck" ger det kompakta formatet med 32 tecken som en del kolumner och filnamn föredrar, och "Klammerparenteser" omsluter värdet i { } — det format som Windows och .NET-världen kallar GUID. Under "Avancerade alternativ" lägger urn:uuid: till det prefix som gör det till ett formellt URN; det inaktiverar "Klammerparenteser" och "Utan bindestreck" så länge det är aktiverat, eftersom standarden enbart tillåter exakt ett URN-format, och det är det kanoniska formatet med bindestreck. "Kopieringsformat" avgör hur en grupp slås samman när du hämtar den: en per rad, separerade med kommatecken, eller varje värde inom citattecken med ett avslutande kommatecken, vilket kan klistras in direkt i en array i din kod. Under resultatet finns en rad som rapporterar slumpmässigheten i bitar — 122 för v4, 62 för v7 — samt, för v7, den tidsstämpel som är kodad i seriens första identifierare, så att tiden inuti värdet är synlig snarare än underförstådd. Både "Kopiera alla" och "Spara till fil" respekterar det valda kopieringsformatet. "Historik" sparar dina senaste 10 grupper direkt i din webbläsare: klicka på en för att hämta tillbaka den, kopiera eller ta bort en enskild post, eller rensa hela listan. "Rensa" tömmer resultatet men låter dina inställningar vara, och vid fler än 50 identifierare förvandlas listan till ett enda rullbart block i stället för femtio rader.
Den mest avgörande detaljen på den här sidan är skillnaden mellan v4 och v7 när de används som en primärnyckel (primary key) i en databas, och det handlar inte om tycke och smak. Databasindex är trädstrukturer som lagras i sorterad ordning, och var en ny nyckel landar i den ordningen avgör hur mycket arbete insättningen kommer att kosta. En v4-nyckel är slumpmässig, vilket innebär att på varandra följande insättningar hamnar i helt orelaterade hörn av indexet: sidor (page split) som var fulla delas upp, de delar av trädet som databasen håller i minnet är sällan de delar som nästa insättning behöver, och indexet blir i slutändan mycket större och mer fragmenterat än vad de rader det pekar på motiverar. En v7-nyckel börjar med den aktuella millisekunden, vilket innebär att på varandra följande insättningar landar intill varandra vid trädets högra kant, vilket är precis det mönster som ett automatiskt uppräknande heltal ger och det mönster som indexstrukturerna byggdes för. Det är hela avvägningen: v7 ger dig insättningsbeteendet hos en sekventiell nyckel samtidigt som du behåller den egenskap som fick dig att välja UUID från första början, nämligen att vem som helst kan skapa en utan att fråga en central server. Priset för detta är att skapelsetiden nu är läsbar inuti identifieraren, och huruvida det spelar någon roll är en fråga om din data, inte om formatet.
Ingenting kontrollerar någonsin ett UUID för att se om det är unikt; dess storlek är garantin. Det finns inget register, inga anrop till en server, ingen sökning — en generator producerar ett nummer och överlämnar det, och anledningen till att två av dem inte krockar är helt enkelt att det finns 2^122 möjliga värden för v4, vilket är ungefär 5,3 sextiljoner. Födelsedagsparadoxen (birthday problem) är det ärliga sättet att sätta dimension på detta: du skulle behöva uppemot 2,7 triljoner identifierare innan det överhuvudtaget fanns en jämn chans att två av dem var likadana, vilket motsvarar en miljard nya UUID:n varje sekund i 86 år. Det är värt att vara exakt om vad detta lovar och inte lovar. Det är en statistisk garanti, ingen aritmetisk sådan, och den håller bara så länge slumpmässigheten i botten är äkta — en generator med en dålig startpunkt (seed), eller en virtuell maskin som klonats tillsammans med sin entropipool, bryter löftet på ett sätt som formatet inte kan upptäcka. Version 7 begränsar den frågan ytterligare: under en enskild millisekund kan en generator inte upprepa sig alls, eftersom räknaren stegar upp i stället för att slå tärning, och mellan oberoende generatorer gör de 62 slumpmässiga bitarna jobbet.
Ett UUID är en identifierare, inte ett lösenord. Version 4 är oförutsägbar, och detta frestar ofta människor att behandla den som en hemlighet — en länk för att återställa lösenord, en URL som inte går att gissa sig till, en sessionstoken, en API-nyckel. Oförutsägbarheten är förvisso verklig, men sekretess är en egenskap hos hur ett värde hanteras, och identifierare hanteras avsiktligt vårdslöst: de hamnar i URL:er, som lagras i webbläsarhistorik, serverloggar, referrer-rubriker och analysverktyg, och klistras ofta in i chattmeddelanden. De andra versionerna är ännu sämre kandidater. Både version 1 och version 7 kodar tidpunkten för skapandet, så alla som har en vet ungefär när den gjordes och kan därmed ringa in hela omgivningen av allt annat som skapades samtidigt. Version 3 och 5 är avsiktligt deterministiska: ett v5 UUID för en e-postadress är inte en hemlig, hashad sträng, det är ett värde som alla med samma adress kan räkna ut på en sekund. Använd ett UUID för att namnge en sak. Använd en lösenordsgenerator, eller en token från ett bibliotek skapat just för hemligheter, när värdet måste förbli okänt.
Varför välja den här UUID-generatorn?
- Generering endast i webbläsaren: identifierare skapas på din enhet och skickas aldrig iväg
- Slumpmässighet via Web Crypto API: kryptografiskt säkert, inte Math.random()
- Fem versioner på ett ställe: v1, v3, v4, v5 och v7, utan att byta verktyg
- Genuint sorterad v7: en räknare inuti millisekunden, som RFC 9562 beskriver
- Deterministiska v3 och v5 med de fyra standardnamnrymderna eller din egen
- Upp till 1000 åt gången, med en kompakt rullbar lista efter femtio
- Alla vanliga format: med bindestreck, utan, versaler, inom klamrar eller som urn:uuid: URN
- Kopiera som rader, med kommatecken eller inom citattecken för direkt inklistring i kod
- Obegränsat och gratis: ingen inloggning, inga användningsgränser, ingenting på våra servrar
UUID:n dyker upp överallt där något måste få ett namn innan något annat kan bekräfta att namnet är ledigt. Applikationskoden skapar dem för rader den precis ska till att sätta in, så att objektet har en identitet innan det ens har nått databasen och en klient kan referera till det medan skrivningen fortfarande pågår. Distribuerade system förlitar sig ännu hårdare på dem: flera tjänster som skriver till en och samma tabell, en mobil klient offline som skapar poster på ett flygplan, en kö som måste känna igen det meddelande den redan har bearbetat — inget av dessa system kan vänta på sin tur vid en gemensam räknare. Version 5 fyller ett annat behov, vilket är en stabil identifierare som härleds från något du redan har: samma dokument, samma URL eller samma konto mappas alltid till exakt samma UUID, så en import kan köras två gånger utan att någonting dupliceras. Någon annanstans är de helt enkelt det format som ett system kräver — en korrelationsidentifierare som träs genom loggar och spårningar, ett filnamn som inte krockar när uppladdningar från tusen användare hamnar i samma mapp, en registernyckel i Windows, en uppsättning testdata som måste se ut som riktig data.
Några ärliga begränsningar är värda att känna till. En grupp är en version: värdet i "Version" gäller för allt i den, så en körning med v4 och en körning med v7 är två helt separata grupper. Det här är en generator, inte en inspektör — att klistra in ett UUID för att läsa av dess version eller tidsstämpel är inte något som den här sidan gör. "Spara till fil" skriver en vanlig textfil, inte en export till CSV eller JSON. Version 7 avslöjar helt öppet när den skapades, ner till på millisekunden, vilket är en verklig avvägning snarare än en brist, och version 1 läcker tid på samma sätt; om det utgör ett problem för din data är det version 4 du ska använda, då den inte avslöjar något för någon. Två specialvärden från standarden är inte egentliga versioner och finns därför inte som alternativ under "Version", men du kan kopiera dem härifrån: nil UUID, 00000000-0000-0000-0000-000000000000, och max UUID, ffffffff-ffff-ffff-ffff-ffffffffffff. Allting på den här sidan följer RFC 9562, den specifikation som år 2024 ersatte RFC 4122, vilket gör att utdatan utan problem accepteras av varje bibliotek, databas eller API som överhuvudtaget kan hantera UUID:n. Inom dessa ramar är garantin urstark: varje identifierare byggs enligt standarden, från kryptografiskt säker slumpmässighet, lokalt på din egen maskin, och ingen annan ser den någonsin.