સામગ્રી પર જાઓ
🛠️
Whiz Tools

ULID જનરેટર - ઓનલાઇન ફ્રી યુનિક સૉર્ટેબલ ID બનાવો

ફ્રી ULID જનરેટર ટૂલ તતક્ષણ યુનિક, સૉર્ટેબલ ઓળખકર્તાઓ બનાવે છે. ડેટાબેઝ, API & વિતરિત સિસ્ટમ્સ માટે ક્રિપ્ટોગ્રાફિક રીતે સુરક્ષિત ULIDsને ઓનલાઇન જનરેટ કરો.

ULID જનરેટર

પરિણામો જોવા માટે મૂલ્ય દાખલ કરો
લોડિંગ કેલ્ક્યુલેટર...
📚

દસ્તાવેજીકરણ

ULID શું છે?

ULID (Universally Unique Lexicographically Sortable Identifier) એ ડેટાબેઝમાં રેકોર્ડ અથવા વિતરિત સિસ્ટમમાં બનેલી ઘટનાને ઓળખવા માટે વપરાતો 26-અક્ષરનો કોડ છે. તેમાં વર્તમાન સમય સાથે રેન્ડમ ડેટા જોડવામાં આવે છે, તેથી અક્ષરક્રમ પ્રમાણે ગોઠવેલી ULIDની યાદી દરેક ULID બન્યાના સમયક્રમ પ્રમાણે પણ ગોઠવાય છે. ULID જનરેટર આ કોડ બનાવતું સાધન છે.

ULIDની રચના

ULIDના બે ભાગ હોય છે, જે કોઈ વિભાજક વિના એક પછી એક લખાય છે:

  • ટાઇમસ્ટેમ્પ (10 અક્ષરો): 1 જાન્યુઆરી, 1970થી (Unix epoch) અત્યાર સુધીની મિલિસેકન્ડની સંખ્યા, જે વધુમાં વધુ 48 બિટ્સ આવરી લે છે.
  • રેન્ડમનેસ (16 અક્ષરો): 80 બિટ્સનો રેન્ડમ ડેટા, જેથી એક જ મિલિસેકન્ડમાં બનેલી બે ULID લગભગ નિશ્ચિતપણે અલગ રહે.

બંને ભાગો Crockfordના Base32 અક્ષરસમૂહથી લખાય છે: 0–9 અંકો અને A-Z અક્ષરોમાંથી I, L, O અને U કાઢી નાખવામાં આવે છે. આ ચાર અક્ષરોને બાકાત રાખવામાં આવે છે, કારણ કે તેઓ 0 અને 1 અંકો અથવા એકબીજા સાથે ભુલાઈ શકે છે. પરિણામે મળતી સ્ટ્રિંગ ટૂંકી, ઉચ્ચારવામાં સરળ અને સીધી URLમાં મૂકવા માટે સુરક્ષિત હોય છે.

ULIDની ગણતરી કેવી રીતે કરવી

ULID જનરેટર ત્રણ પગલાંમાં ઓળખકર્તા બનાવે છે.

  1. વર્તમાન સમય વાંચો અને તેને Unix epochથી અત્યાર સુધીની મિલિસેકન્ડમાં દર્શાવો. આ 48-બિટની સંખ્યા છે.
  2. 80 બિટ્સનો રેન્ડમ ડેટા બનાવો, સામાન્ય રીતે ક્રિપ્ટોગ્રાફિક રીતે સુરક્ષિત રેન્ડમ નંબર જનરેટરમાંથી, જેથી 10 રેન્ડમ બાઇટ્સ મળે.
  3. બંને ભાગોને અલગ-અલગ એન્કોડ કરો અને Crockfordના Base32 અક્ષરસમૂહનો ઉપયોગ કરો: 48-બિટનો ટાઇમસ્ટેમ્પ 10 અક્ષરો બને છે અને 80-બિટનું રેન્ડમ મૂલ્ય 16 અક્ષરો બને છે. અંતિમ 26-અક્ષરની ULID બનાવવા માટે બંને એન્કોડ કરેલી સ્ટ્રિંગ જોડવામાં આવે છે.

એન્કોડિંગમાં સંખ્યા એક સમયે 5 બિટ્સ વાંચીને આગળ વધે છે, કારણ કે દરેક Base32 અક્ષર 32 સંભવિત મૂલ્યોમાંથી એક દર્શાવે છે (2^5 = 32). દસ અક્ષરોમાં વધુમાં વધુ 50 બિટ્સ સમાઈ શકે છે, જે 48-બિટના ટાઇમસ્ટેમ્પ માટે પૂરતું છે. સોળ અક્ષરોમાં ચોક્કસ 80 બિટ્સ સમાય છે, જે રેન્ડમનેસના ભાગ સાથે સંપૂર્ણ રીતે મેળ ખાય છે.

ઉદાહરણ સાથે ગણતરી

માનો કે ULID જનરેટર ટાઇમસ્ટેમ્પ 1712345678901 (epochથી મિલિસેકન્ડમાં) પર ચાલે છે અને રેન્ડમ બાઇટ્સ [12, 240, 88, 3, 199, 45, 6, 231, 128, 17] મેળવે છે.

પગલું 1 – ટાઇમસ્ટેમ્પ એન્કોડ કરો. 1712345678901ને વારંવાર 32 વડે ભાગો, દર વખતે શેષ લો અને અંકોને છેલ્લેથી પહેલો વાંચો (આ પ્રમાણભૂત બેઝ રૂપાંતરણ છે). પરિણામે 10-અક્ષરની સ્ટ્રિંગ 01HTQW311N મળે છે.

પગલું 2 – રેન્ડમનેસ એન્કોડ કરો. 10 રેન્ડમ બાઇટ્સને 80 બિટ્સની સ્ટ્રીમમાં ગોઠવો, પછી એક સમયે 5 બિટ્સ વાંચો અને દરેક 5-બિટના ખંડને Base32 અક્ષરમાં ફેરવો. પરિણામે 16-અક્ષરની સ્ટ્રિંગ 1KR5G0Y75M3EF00H મળે છે.

પગલું 3 – ભાગોને જોડો. અંતિમ ULID છે:

101HTQW311N 1KR5G0Y75M3EF00H
2

જગ્યા વિના લખીએ તો: 01HTQW311N1KR5G0Y75M3EF00H, કુલ 26 અક્ષરો.

આ જનરેટરનો ઉપયોગ

જનરેટર બ્રાઉઝરમાં ચાલે છે. દરેક ULID બ્રાઉઝરની ઘડિયાળ અને બ્રાઉઝરના ક્રિપ્ટોગ્રાફિક રેન્ડમ નંબર જનરેટરમાંથી લેવાયેલા 80 નવા રેન્ડમ બિટ્સથી બને છે, તેથી કોઈ ઓળખકર્તર સર્વરને મોકલાતો કે સર્વરમાંથી મેળવાતો નથી.

  • ULIDની સંખ્યા 1થી 50 સુધીની પૂર્ણ સંખ્યા સ્વીકારે છે. મૂળભૂત મૂલ્ય 1 છે.
  • ULID બનાવો નવી બેચ બનાવે છે. સંખ્યા બદલવાથી પણ નવી બેચ બને છે.
  • પરિણામમાં કૉપી કરો તે એક ULIDની નકલ કરે છે. એકથી વધુ ULID દેખાય ત્યારે બધું કૉપી કરો આખી યાદીની નકલ કરે છે, દરેક લાઇનમાં એક ULID સાથે.
  • રીસેટ સંખ્યાને પાછી 1 પર મૂકે છે અને એક નવી ULID બનાવે છે.

પરિણામોની નીચેનું ULID Structure પેનલ બેચની પ્રથમ ULIDને તેના બે ભાગોમાં વહેંચે છે: પ્રથમ 10 અક્ષરો (ટાઇમસ્ટેમ્પ) અને છેલ્લા 16 અક્ષરો (રેન્ડમનેસ).

ULID અને UUIDની સરખામણી

વિશેષતાULIDUUID (આવૃત્તિ 4)
લંબાઈ26 અક્ષરો36 અક્ષરો (હાઇફન સાથે)
બનાવવાના સમય પ્રમાણે ગોઠવી શકાયહાના
એન્કોડિંગCrockford Base32હેક્સાડેસિમલ
ટાઇમસ્ટેમ્પ ધરાવે છેહા (48 બિટ્સ)ના
એસ્કેપિંગ વિના URL માટે સુરક્ષિતહાહા

બંને ફોર્મેટ કોઈ કેન્દ્રીય સત્તા દ્વારા સંખ્યાઓ ફાળવ્યા વિના વિવિધ સિસ્ટમોમાં અનન્ય ઓળખકર્તા બનાવવાનો હેતુ ધરાવે છે. વ્યવહારુ મુખ્ય તફાવત ગોઠવણીનો છે: ULIDની શરૂઆત ટાઇમસ્ટેમ્પથી થતી હોવાથી, ULIDને સાદા લખાણ તરીકે ગોઠવવાથી તે સમયક્રમ પ્રમાણે પણ ગોઠવાય છે. રેન્ડમ UUIDમાં આ ગુણધર્મ નથી, કારણ કે તેનો દરેક ભાગ રેન્ડમ હોય છે.

સામાન્ય ઉપયોગો

  • ડેટાબેઝની પ્રાથમિક કીઓ: ULID ડેટાબેઝને નવી પંક્તિઓ દાખલ થયેલા અંદાજિત ક્રમમાં ઇન્ડેક્સ કરવાની મંજૂરી આપે છે, જેને ઘણા ડેટાબેઝ એન્જિન સંપૂર્ણપણે રેન્ડમ કીઓ કરતાં વધુ કાર્યક્ષમ રીતે સંભાળે છે.
  • વિતરિત સિસ્ટમો: અલગ સર્વરો કેન્દ્રીય કાઉન્ટર સાથે સંકલન કર્યા વિના સ્વતંત્ર રીતે ULID બનાવી શકે છે, અને પરિણામો હજુ પણ લગભગ નિશ્ચિતપણે અનન્ય રહે છે.
  • ઘટના લૉગ્સ: ULID સમય પ્રમાણે ગોઠવાય છે, તેથી ઘટના IDની યાદી અંદાજિત સમયરેખા તરીકે પણ કામ કરી શકે છે.
  • API અને ફાઇલ ઓળખકર્તા: નિશ્ચિત 26-અક્ષરનું, URL માટે સુરક્ષિત ફોર્મેટ વેબ સરનામાં અને ફાઇલ નામોમાં સરળતાથી કામ કરે છે.

સંબંધિત ઓળખકર્તા ફોર્મેટમાં KSUIDનો સમાવેશ થાય છે, જે ગોઠવણી માટે ટાઇમસ્ટેમ્પને પણ એન્કોડ કરે છે, તેમજ Snowflake IDનો, જે Twitter અને અન્ય સંસ્થાઓ દ્વારા વપરાય છે અને ટાઇમસ્ટેમ્પ, મશીન ઓળખકર્તા તથા કાઉન્ટરને જોડે છે.

કોડનાં ઉદાહરણો

નીચેના દરેક ઉદાહરણમાં ULID સ્પષ્ટીકરણમાં વર્ણવેલી સમાન રીતથી ULID બનાવવામાં આવે છે: 48-બિટના ટાઇમસ્ટેમ્પને 10 Crockford Base32 અક્ષરો તરીકે એન્કોડ કરો, 80 બિટ્સની રેન્ડમનેસને વધુ 16 અક્ષરો તરીકે એન્કોડ કરો અને બંનેને જોડો.

JavaScript

1const ENCODING_CHARS = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
2
3function encodeULID(time, randomBytes) {
4  // Timestamp: 48 bits -> 10 characters
5  let timestampStr = '';
6  let t = time;
7  for (let i = 0; i < 10; i++) {
8    timestampStr = ENCODING_CHARS[t % 32] + timestampStr;
9    t = Math.floor(t / 32);
10  }
11
12  // Randomness: 80 bits -> 16 characters
13  let result = timestampStr;
14  let bits = 0;
15  let bitCount = 0;
16  for (let i = 0; i < 10; i++) {
17    bits = (bits << 8) | randomBytes[i];
18    bitCount += 8;
19    while (bitCount >= 5) {
20      bitCount -= 5;
21      result += ENCODING_CHARS[(bits >> bitCount) & 0x1f];
22    }
23  }
24  return result;
25}
26
27function generateULID() {
28  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
29  return encodeULID(Date.now(), randomBytes);
30}
31
32console.log(generateULID());
33

Python

1import os
2import time
3
4ENCODING_CHARS = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
5
6def encode_ulid(time_ms, random_bytes):
7    # Timestamp: 48 bits -> 10 characters
8    chars = []
9    t = time_ms
10    for _ in range(10):
11        chars.append(ENCODING_CHARS[t % 32])
12        t //= 32
13    timestamp_part = "".join(reversed(chars))
14
15    # Randomness: 80 bits -> 16 characters
16    bits = 0
17    bit_count = 0
18    random_part = []
19    for byte in random_bytes:
20        bits = (bits << 8) | byte
21        bit_count += 8
22        while bit_count >= 5:
23            bit_count -= 5
24            random_part.append(ENCODING_CHARS[(bits >> bit_count) & 0x1F])
25
26    return timestamp_part + "".join(random_part)
27
28def generate_ulid():
29    return encode_ulid(int(time.time() * 1000), os.urandom(10))
30
31print(generate_ulid())
32

Java

1import java.security.SecureRandom;
2import java.time.Instant;
3
4public class ULIDGenerator {
5    private static final SecureRandom random = new SecureRandom();
6    private static final char[] ENCODING_CHARS =
7        "0123456789ABCDEFGHJKMNPQRSTVWXYZ".toCharArray();
8
9    public static String generateULID() {
10        long timestamp = Instant.now().toEpochMilli();
11        byte[] randomBytes = new byte[10];
12        random.nextBytes(randomBytes);
13
14        // Timestamp: 48 bits -> 10 characters
15        char[] timestampChars = new char[10];
16        long t = timestamp;
17        for (int i = 9; i >= 0; i--) {
18            timestampChars[i] = ENCODING_CHARS[(int) (t % 32)];
19            t /= 32;
20        }
21
22        // Randomness: 80 bits -> 16 characters
23        StringBuilder result = new StringBuilder(new String(timestampChars));
24        long bits = 0;
25        int bitCount = 0;
26        for (byte b : randomBytes) {
27            bits = (bits << 8) | (b & 0xFF);
28            bitCount += 8;
29            while (bitCount >= 5) {
30                bitCount -= 5;
31                result.append(ENCODING_CHARS[(int) ((bits >> bitCount) & 0x1F)]);
32            }
33        }
34        return result.toString();
35    }
36
37    public static void main(String[] args) {
38        System.out.println(generateULID());
39    }
40}
41

વારંવાર પૂછાતા પ્રશ્નો

ULIDનો ઉપયોગ શા માટે થાય છે? ULIDનો ઉપયોગ ડેટાબેઝની પંક્તિ, API સંસાધન અથવા લૉગ થયેલી ઘટનાના અનન્ય ઓળખકર્તા તરીકે થાય છે, ખાસ કરીને ત્યારે જ્યારે બનાવવાના સમય પ્રમાણે ગોઠવણી પણ ઉપયોગી હોય.

ULID કેટલો લાંબો હોય છે? ULID હંમેશાં 26 અક્ષરો લાંબી હોય છે: ટાઇમસ્ટેમ્પ માટે 10 અક્ષરો અને રેન્ડમ ભાગ માટે 16 અક્ષરો.

ULID કયા એન્કોડિંગનો ઉપયોગ કરે છે? ULID Crockfordના Base32 અક્ષરસમૂહનો ઉપયોગ કરે છે, જેમાં 0–9 અંકો અને I, L, O તથા U દૂર કરેલા A-Z અક્ષરોનો સમાવેશ થાય છે, જેથી અન્ય અક્ષરો સાથેની ગૂંચવણ ટાળી શકાય.

ULID UUIDથી કેવી રીતે અલગ છે? ULID બનાવવાના સમય પ્રમાણે ગોઠવાય છે અને 26 અક્ષરો લાંબી હોય છે. રેન્ડમ (આવૃત્તિ 4) UUID સમય પ્રમાણે ગોઠવાતી નથી અને હાઇફન સહિત 36 અક્ષરો લાંબી હોય છે.

બે ULID વચ્ચે અથડામણની સંભાવના કેટલી છે? 80 બિટ્સની રેન્ડમનેસ અથડામણને અત્યંત અસંભવિત બનાવે છે. કોઈપણ બે ULID સરખી થવાની 50% સંભાવના સુધી પહોંચવા માટે એક જ મિલિસેકન્ડમાં અંદાજે 1.3 ટ્રિલિયન ULID બનાવવી પડે.

શું ઇન્ટરનેટ કનેક્શન વિના ULID બનાવી શકાય? હા. ULID માટે માત્ર સ્થાનિક ઘડિયાળ અને રેન્ડમ નંબર જનરેટરની જરૂર પડે છે, તેથી તે સંપૂર્ણપણે ઑફલાઇન બનાવી શકાય છે.

સંદર્ભો

  1. "ULID Specification." GitHub, https://github.com/ulid/spec.
  2. "Crockford's Base32 Encoding." http://www.crockford.com/base32.html.