1{
2  "ULID Generator": "યુએલઆઇડી જનરેટર",
3  "Introduction": "પરિચય",
4  "A ULID (Universally Unique Lexicographically Sortable Identifier) is a unique identifier that combines a timestamp with random data to create a 26-character string. ULIDs are designed to be lexicographically sortable while maintaining a high degree of uniqueness and randomness.": "યુએલઆઇડી (યુનિવર્સલ યુનિક લેક્સિકોગ્રાફિકલી સોર્ટેબલ આઇડેન્ટિફાયર) એ એક અનન્ય ઓળખપત્ર છે જે ટાઇમસ્ટેમ્પને રેન્ડમ ડેટા સાથે જોડે છે અને 26 અક્ષરોની સ્ટ્રિંગ બનાવે છે. યુએલઆઇડીઓ lexicographically સોર્ટેબલ હોવા માટે ડિઝાઇન કરવામાં આવ્યા છે જ્યારે અનન્યતા અને રેન્ડમને ઉચ્ચ ડિગ્રી જાળવી રાખે છે.",
5  "Structure of a ULID": "યુએલઆઇડીની રચના",
6  "A ULID consists of two main parts:": "યુએલઆઇડી બે મુખ્ય ભાગોમાં વહેંચાય છે:",
7  "Timestamp (10 characters): The first 10 characters represent the time in milliseconds since the Unix Epoch (1970-01-01).": "ટાઇમસ્ટેમ્પ (10 અક્ષરો): પ્રથમ 10 અક્ષરો યુનિક્સ એપોક (1970-01-01) પછીના મિલિસેકન્ડમાં સમયને દર્શાવે છે.",
8  "Randomness (16 characters): The remaining 16 characters are generated using cryptographically secure random data.": "રેન્ડમનેસ (16 અક્ષરો): બાકી 16 અક્ષરો ક્રિપ્ટોગ્રાફિકલી સુરક્ષિત રેન્ડમ ડેટાનો ઉપયોગ કરીને જનરેટ કરવામાં આવે છે.",
9  "The resulting 26-character string is encoded using Crockford's base32 alphabet (0-9 and A-Z, excluding I, L, O, and U).": "પરિણામે મળતી 26 અક્ષરોની સ્ટ્રિંગ ક્રોકફોર્ડના બેઝ32 અલ્ફાબેટ (0-9 અને A-Z, I, L, O, અને Uને બહાર પાડીને) નો ઉપયોગ કરીને એન્કોડ કરવામાં આવે છે.",
10  "Formula": "સૂત્ર",
11  "The ULID is generated using the following steps:": "યુએલઆઇડી નીચેના પગલાંઓનો ઉપયોગ કરીને જનરેટ કરવામાં આવે છે:",
12  "1. Generate a 48-bit timestamp (milliseconds since Unix Epoch).": "1. 48-બિટ ટાઇમસ્ટેમ્પ (યુનિક્સ એપોક પછીના મિલિસેકન્ડ) જનરેટ કરો.",
13  "2. Generate 80 bits of cryptographically secure random data.": "2. 80 બિટના ક્રિપ્ટોગ્રાફિકલી સુરક્ષિત રેન્ડમ ડેટા જનરેટ કરો.",
14  "3. Encode the combined 128 bits using Crockford's base32 encoding.": "3. ક્રોકફોર્ડના બેઝ32 એન્કોડિંગનો ઉપયોગ કરીને સંયુક્ત 128 બિટને એન્કોડ કરો.",
15  "Calculation": "ગણનાકીય",
16  "The ULID generator performs the following steps:": "યુએલઆઇડી જનરેટર નીચેના પગલાંઓને અમલમાં લાવે છે:",
17  "1. Get the current timestamp in milliseconds.": "1. મિલિસેકન્ડમાં વર્તમાન ટાઇમસ્ટેમ્પ મેળવો.",
18  "2. Generate 10 random bytes (80 bits) using a cryptographically secure random number generator.": "2. ક્રિપ્ટોગ્રાફિકલી સુરક્ષિત રેન્ડમ નંબર જનરેટરનો ઉપયોગ કરીને 10 રેન્ડમ બાઇટ્સ (80 બિટ) જનરેટ કરો.",
19  "3. Combine the timestamp and random data into a 128-bit integer.": "3. ટાઇમસ્ટેમ્પ અને રેન્ડમ ડેટાને 128-બિટ પૂર્ણાંકમાં જોડો.",
20  "4. Encode the 128-bit integer using Crockford's base32 encoding.": "4. ક્રોકફોર્ડના બેઝ32 એન્કોડિંગનો ઉપયોગ કરીને 128-બિટ પૂર્ણાંકને એન્કોડ કરો.",
21  "Use Cases": "ઉપયોગ કેસ",
22  "ULIDs are useful in various scenarios, including:": "યુએલઆઇડી વિવિધ પરિસ્થિતિઓમાં ઉપયોગી છે, જેમાં શામેલ છે:",
23  "1. Database keys: ULIDs can be used as unique identifiers for database records, ensuring uniqueness and sortability.": "1. ડેટાબેઝ કી: યુએલઆઇડીને ડેટાબેઝ રેકોર્ડ માટે અનન્ય ઓળખપત્ર તરીકે ઉપયોગ કરી શકાય છે, જે અનન્યતા અને સોર્ટેબલને સુનિશ્ચિત કરે છે.",
24  "2. Distributed systems: In distributed environments, ULIDs can be generated without coordination between nodes.": "2. વિતરણિત સિસ્ટમો: વિતરણિત પર્યાવરણમાં, યુએલઆઇડીને નોડ્સ વચ્ચેની સમન્વય વિના જનરેટ કરી શકાય છે.",
25  "3. Logging and tracing: ULIDs can be used to tag log entries or trace events, providing a sortable and unique identifier.": "3. લોગિંગ અને ટ્રેસિંગ: યુએલઆઇડીને લોગ એન્ટ્રીઓને ટૅગ કરવા અથવા ઇવેન્ટ્સને ટ્રેસ કરવા માટે ઉપયોગમાં લેવાઈ શકે છે, જે સોર્ટેબલ અને અનન્ય ઓળખપત્ર પ્રદાન કરે છે.",
26  "4. URL-friendly IDs: ULIDs are URL-safe and can be used in web applications as identifiers in URLs.": "4. URL-ફ્રેન્ડલી આઈડીઓ: યુએલઆઇડી URL-સુરક્ષિત છે અને વેબ એપ્લિકેશનોમાં URLsમાં ઓળખપત્રો તરીકે ઉપયોગ કરી શકાય છે.",
27  "Alternatives": "વિકલ્પો",
28  "While ULIDs are versatile, there are other unique identifier systems to consider:": "જ્યારે યુએલઆઇડી વિશિષ્ટ છે, ત્યારે વિચારવા માટે અન્ય અનન્ય ઓળખપત્ર સિસ્ટમો છે:",
29  "1. UUID (Universally Unique Identifier): A 128-bit identifier that doesn't include a timestamp component.": "1. UUID (યુનિવર્સલ યુનિક આઇડેન્ટિફાયર): 128-બિટ ઓળખપત્ર જે ટાઇમસ્ટેમ્પ ઘટકને સમાવેશ કરતું નથી.",
30  "2. KSUID (K-Sortable Unique IDentifier): Similar to ULID but with a different timestamp encoding.": "2. KSUID (K-સોર્ટેબલ યુનિક આઇડેન્ટિફાયર): યુએલઆઇડી સમાન પરંતુ અલગ ટાઇમસ્ટેમ્પ એન્કોડિંગ સાથે.",
31  "3. Snowflake ID: Twitter's distributed unique ID generation system, which includes a timestamp and worker ID.": "3. સ્નોફ્લેક આઈડી: ટ્વિટરનું વિતરિત અનન્ય આઈડી જનરેશન સિસ્ટમ, જેમાં ટાઇમસ્ટેમ્પ અને વર્કર આઈડી શામેલ છે.",
32  "History": "ઇતિહાસ",
33  "ULIDs were introduced in 2016 by Alizain Feerasta as an alternative to UUIDs. They were designed to address some limitations of UUIDs, particularly in terms of sortability and readability. The ULID specification has remained stable since its introduction, with various implementations available in different programming languages.": "યુએલઆઇડી 2016માં અલિઝાઇન ફીરસ્તા દ્વારા UUIDના વિકલ્પ તરીકે રજૂ કરવામાં આવ્યા હતા. તેઓ UUIDની કેટલીક મર્યાદાઓને ઉકેલવા માટે ડિઝાઇન કરવામાં આવ્યા હતા, ખાસ કરીને સોર્ટેબલ અને વાંચનક્ષમતા સંબંધિત. યુએલઆઇડી સ્પષ્ટીકરણ તેની રજૂઆતથી સ્થિર રહ્યું છે, વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં વિવિધ અમલ ઉપલબ્ધ છે.",
34  "Examples": "ઉદાહરણો",
35  "Here are some code examples to generate ULIDs in different programming languages:": "અહીં વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં યુએલઆઇડી જનરેટ કરવા માટેના કેટલાક કોડ ઉદાહરણો છે:",
36  "// JavaScript implementation": "// જાવાસ્ક્રિપ્ટ અમલ",
37  "function generateULID() {": "ફંક્શન generateULID() {",
38  "const timestamp = Date.now().toString(36).padStart(10, '0');": "const timestamp = Date.now().toString(36).padStart(10, '0');",
39  "const randomness = crypto.getRandomValues(new Uint8Array(16))": "const randomness = crypto.getRandomValues(new Uint8Array(16))",
40  ".reduce((acc, byte) => acc + byte.toString(36).padStart(2, '0'), '');": ".reduce((acc, byte) => acc + byte.toString(36).padStart(2, '0'), '');",
41  "return (timestamp + randomness).toUpperCase();": "return (timestamp + randomness).toUpperCase();",
42  "}": "}",
43  "console.log(generateULID());": "console.log(generateULID());",
44  "# Python implementation": "# પાયથન અમલ",
45  "import time": "ઇમ્પોર્ટ સમય",
46  "import secrets": "ઇમ્પોર્ટ સિક્રેટ્સ",
47  "import base64": "ઇમ્પોર્ટ બેઝ64",
48  "def generate_ulid():": "def generate_ulid():",
49  "timestamp = int(time.time() * 1000).to_bytes(6, byteorder=\"big\")": "timestamp = int(time.time() * 1000).to_bytes(6, byteorder=\"big\")",
50  "randomness = secrets.token_bytes(10)": "randomness = secrets.token_bytes(10)",
51  "return base64.b32encode(timestamp + randomness).decode(\"ascii\").lower()": "return base64.b32encode(timestamp + randomness).decode(\"ascii\").lower()",
52  "print(generate_ulid())": "પ્રિન્ટ(generate_ulid())",
53  "// Java implementation": "// જાવા અમલ",
54  "import java.security.SecureRandom;": "ઇમ્પોર્ટ java.security.SecureRandom;",
55  "import java.time.Instant;": "ઇમ્પોર્ટ java.time.Instant;",
56  "public class ULIDGenerator {": "પબ્લિક ક્લાસ ULIDGenerator {",
57  "private static final SecureRandom random = new SecureRandom();": "પ્રાઇવેટ સ્ટેટિક ફાઇનલ SecureRandom random = new SecureRandom();",
58  "private static final char[] ENCODING_CHARS = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\".toCharArray();": "પ્રાઇવેટ સ્ટેટિક ફાઇનલ char[] ENCODING_CHARS = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\".toCharArray();",
59  "public static String generateULID() {": "પબ્લિક સ્ટેટિક સ્ટ્રિંગ generateULID() {",
60  "long timestamp = Instant.now().toEpochMilli();": "લાંબો ટાઇમસ્ટેમ્પ = Instant.now().toEpochMilli();",
61  "byte[] randomness = new byte[10];": "બાઇટ[] randomness = નવા બાઇટ[10];",
62  "random.nextBytes(randomness);": "random.nextBytes(randomness);",
63  "StringBuilder result = new StringBuilder();": "StringBuilder પરિણામ = નવી StringBuilder();",
64  "// Encode timestamp": "// ટાઇમસ્ટેમ્પને એન્કોડ કરો",
65  "for (int i = 9; i >= 0; i--) {": "ફોર (int i = 9; i >= 0; i--) {",
66  "result.append(ENCODING_CHARS[(int) (timestamp % 32)]);": "result.append(ENCODING_CHARS[(int) (timestamp % 32)]);",
67  "timestamp /= 32;": "timestamp /= 32;",
68  "}": "}",
69  "// Encode randomness": "// રેન્ડમનેસને એન્કોડ કરો",
70  "for (byte b : randomness) {": "ફોર (બાઇટ b : randomness) {",
71  "result.append(ENCODING_CHARS[b & 31]);": "result.append(ENCODING_CHARS[b & 31]);",
72  "}": "}",
73  "return result.toString();": "return result.toString();",
74  "}": "}",
75  "public static void main(String[] args) {": "પબ્લિક સ્ટેટિક વોઇડ મુખ્ય(String[] args) {",
76  "System.out.println(generateULID());": "System.out.println(generateULID());",
77  "}": "}",
78  "These examples demonstrate how to generate ULIDs in JavaScript, Python, and Java. You can adapt these functions to your specific needs or integrate them into larger systems requiring unique identifiers.": "આ ઉદાહરણો બતાવે છે કે જાવાસ્ક્રિપ્ટ, પાયથન અને જાવામાં યુએલઆઇડી કેવી રીતે જનરેટ કરવી. તમે આ ફંક્શન્સને તમારી વિશિષ્ટ જરૂરિયાતોને અનુકૂળ બનાવી શકો છો અથવા અનન્ય ઓળખપત્રો આવશ્યકતા ધરાવતા મોટા સિસ્ટમોમાં સમાવી શકો છો.",
79  "References": "સંદર્ભો",
80  "1. \"ULID Specification.\" GitHub, https://github.com/ulid/spec. Accessed 2 Aug. 2024.": "1. \"યુએલઆઇડી સ્પષ્ટીકરણ.\" Gitહબ, https://github.com/ulid/spec. 2 ઓગસ્ટ 2024ને ઍક્સેસ કર્યું.",
81  "2. \"Crockford's Base32 Encoding.\" Base32 Encoding, http://www.crockford.com/base32.html. Accessed 2 Aug. 2024.": "2. \"ક્રોકફોર્ડની બેઝ32 એન્કોડિંગ.\" બેઝ32 એન્કોડિંગ, http://www.crockford.com/base32.html. 2 ઓગસ્ટ 2024ને ઍક્સેસ કર્યું.",
82  "3. \"UUID vs ULID.\" Stack Overflow, https://stackoverflow.com/questions/54222235/uuid-vs-ulid. Accessed 2 Aug. 2024.": "3. \"UUID vs યુએલઆઇડી.\" સ્ટેક ઓવરફ્લો, https://stackoverflow.com/questions/54222235/uuid-vs-ulid. 2 ઓગસ્ટ 2024ને ઍક્સેસ કર્યું."
83}
84