UUID what?
UUID (Universally Unique Identifier) એ 128-બિટ મૂલ્ય છે જે 550e8400-e29b-41d4-a716-446655440000 જેવી 36-અક્ષરની સ્ટ્રિંગ તરીકે રજૂ થાય છે. ફોર્મેટ અને વર્ઝન-સિમેન્ટિક્સ v1 થી v5 માટે RFC 4122 દ્વારા, અને નવા v6, v7 તથા v8 માટે RFC 9562 દ્વારા વ્યાખ્યાયિત છે. આ સાધન v4 (સંપૂર્ણપણે રેન્ડમ), v1 (ટાઇમસ્ટેમ્પ વત્તા રેન્ડમ નોડ ID), અને v7 (Unix-મિલિસેકન્ડ ટાઇમસ્ટેમ્પ ઉપસર્ગ વત્તા રેન્ડમ સફિક્સ, જનરેશન સમય પ્રમાણે ક્રમ માં ગોઠવી શકાય તેવું) ઉત્પન્ન કરે છે — બધું જ તમારા બ્રાઉઝરમાં, પ્લેટફોર્મની Web Crypto API નો ઉપયોગ કરીને. કોઈ ડેટા સર્વર પર મોકલવામાં આવતો નથી.
UUID જનરેશન કેવી રીતે કામ કરે છે?
દરેક વર્ઝન નિર્ધારણ-નિશ્ચિતતા (determinism), ક્રમબદ્ધતા અને એન્ટ્રોપી વચ્ચે અલગ-અલગ સંતુલન રાખે છે. સાધન તમારી પસંદગીના આધારે યોગ્ય એલ્ગોરિધમ પસંદ કરે છે:
- v4 (રેન્ડમ) બ્રાઉઝરના
crypto.randomUUID()ને કૉલ કરે છે, જે 122 બિટ ક્રિપ્ટોગ્રાફિક રેન્ડમનેસ પાછા આપે છે, જેમાં 6 નિશ્ચિત બિટ (વર્ઝન0100અને10વેરિઅન્ટ) સાચા સ્થાનો પર સેટ કરેલા હોય છે. ટકરાવ (collision) ની સંભાવના ખગોળીય રીતે નહિવત્ છે — 50% સંભાવના સાથે એક પણ ડુપ્લિકેટ મેળવવા માટે તમારે આશરે 2.71 ક્વિન્ટિલિયન v4 UUID ઉત્પન્ન કરવા પડે. - v1 (ટાઇમસ્ટેમ્પ + નોડ) 60-બિટ ગ્રેગોરિયન ટાઇમસ્ટેમ્પ (1582-10-15 થી 100-નેનોસેકન્ડ ટિક) ને
time_low/time_mid/time_hi_and_versionમાં પેક કરે છે, વર્ઝન નિબલ ને0001પર સેટ કરે છે, વેરિઅન્ટ બિટ્સ સાથે 14-બિટ ક્લોક ક્રમ પસંદ કરે છે, અને 48-બિટ રેન્ડમ નોડ ID નો ઉપયોગ કરે છે જેમાં મલ્ટિકાસ્ટ બિટ ફરજિયાત ચાલુ કરેલ હોય છે (RFC 4122 §4.5 સ્પષ્ટપણે પરવાનગી આપે છે કે જ્યારે કોઈ હાર્ડવેર MAC ઉપલબ્ધ ન હોય ત્યારે રેન્ડમ નોડ ID વાપરી શકાય — મલ્ટિકાસ્ટ બિટ તેને બિન-MAC તરીકે ચિહ્નિત કરે છે). - v7 (ક્રમબદ્ધ ટાઇમસ્ટેમ્પ), RFC 9562 §5.7 અનુસાર, 48-બિટ big-endian Unix-મિલિસેકન્ડ ટાઇમસ્ટેમ્પ ગોઠવે છે, પછી 4-બિટ વર્ઝન
0111, પછી 12 રેન્ડમ બિટ્સ, પછી 2-બિટ વેરિઅન્ટ10, પછી વધુ 62 રેન્ડમ બિટ્સ. ટાઇમસ્ટેમ્પ સૌથી મહત્વના બિટ્સમાં હોવાથી, v7 UUID જનરેશન ક્રમમાં લેક્સિકોગ્રાફિક રીતે ગોઠવાય છે — એવી વિશેષતા જે અન્ય કોઈ UUID વર્ઝન વધારાના એન્કોડિંગ વિના આપતું નથી. - બધી રેન્ડમનેસ
crypto.getRandomValues()માંથી આવે છે, એટલે કે બ્રાઉઝરનું ક્રિપ્ટોગ્રાફિક રીતે સુરક્ષિત RNG. v1 અને v7 બંનેમાં intra-tick monotonic ગાર્ડ સામેલ છે, જેથી એક જ ક્લોક ટિક ની અંદર બે સળંગ કૉલ માં બીજો કૉલ પહેલા કરતાં ઉપર જ ગોઠવાય — મિલિસેકન્ડ ઘડિયાળ સાથે હરીફાઈ કરતી બલ્ક જનરેશન માટે આ મહત્વનું છે. - ફોર્મેટ પાઇપલાઇન જનરેશન પછી ચાલે છે. તમે હાઇફન દૂર કરી શકો છો, મોટા અક્ષરોમાં ફેરવી શકો છો, મૂલ્યને બ્રેસેસમાં લપેટી શકો છો (
{…}— Microsoft GUID પરંપરા), અથવા કાચા 16 બાઇટ્સને base64 તરીકે રજૂ કરી શકો છો (22-અક્ષર આઉટપુટ, કોઈ પેડિંગ વગર). base64 મોડ અન્ય ફોર્મેટ વિકલ્પોને ઓવરરાઇડ કરે છે કારણ કે base64 પોતે જ એક અલગ રજૂઆત છે.
આ UUID જનરેટરનો ઉપયોગ શા માટે કરવો?
- કંઈ પણ તમારા બ્રાઉઝરની બહાર જતું નથી. Web Crypto API સ્થાનિક રીતે ચાલે છે; પ્રારંભિક દસ્તાવેજ લોડ થયા પછી પેજ શૂન્ય નેટવર્ક વિનંતી કરે છે. DevTools ખોલો, Generate ક્લિક કરો, અને Network પેનલ શાંત જ રહેશે.
- RFC-અનુરૂપ આઉટપુટ. v4 એ RFC 4122 §4.4 ને અનુસરે છે, v1 એ §4.2 અને §4.5 ને, અને v7 એ RFC 9562 §5.7 ને. વર્ઝન નિબલ અને વેરિઅન્ટ બિટ્સ ત્યાં જ મુકાય છે જ્યાં ધોરણો કહે છે — દરેક UUID કેનોનિકલ વર્ઝન regex સામે માન્ય ઠરે છે.
- ડેટાબેઝ કીઓ માટે ક્રમબદ્ધ v7. Postgres, MySQL કે SQL Server માં ક્લસ્ટર્ડ પ્રાઇમરી કી તરીકે વપરાયેલ v7 UUID ઇન્ડેક્સ પર ઇન્સર્ટને append-only રાખે છે — કોઈ પેજ સ્પ્લિટ નહીં, કોઈ રેન્ડમ I/O નહીં — અને છતાં વૈશ્વિક રીતે અનન્ય રહે છે. v4 આ કરી શકતું નથી કારણ કે તેના બિટ્સ રેન્ડમ છે.
- રેટ-મર્યાદા વગર બલ્ક જનરેશન. એક સાથે 1, 10, 100 કે 1,000 UUID ઉત્પન્ન કરો. કોઈ ક્વોટા નથી અને કોઈ સાઇન-અપ નથી — સાધન તમારા ટેબમાં ચાલે છે, તેથી મર્યાદા તમારી CPU છે, કોઈ વિક્રેતાનું API ટિયર નહીં.
UUIDs ના સામાન્ય ઉપયોગો કયા છે?
UUIDs કેન્દ્રીય પ્રાધિકરણ સાથે સમન્વય કર્યા વિના વૈશ્વિક અદ્વિતીય ઓળખ-ચિહ્ન જ્યાં જરૂર ત્યાં આવે છે:
- ડેટાબેઝ પ્રાઇમરી કીઓ. ઓટો-ઇન્ક્રિમેન્ટ થતા પૂર્ણાંકો પંક્તિ-ગણતરી ઉઘાડી પાડે છે અને શાર્ડિંગ તોડી નાખે છે. UUID શાર્ડ્સ વચ્ચે સ્થિર છે, પ્રદેશો વચ્ચે મર્જ કરવા સલામત છે, અને (v7 સાથે) પેજ સ્પ્લિટ વગર B-tree ઇન્સર્ટ્સને ગરમ રાખે છે. એક સામાન્ય એપ્લિકેશન UUID ને ક્લાયન્ટ-સાઇડ પર બનાવે છે, તેને ઇન્સર્ટમાં મોકલે છે, અને કી માટે ક્યારેય સર્વર સાથે રાઉન્ડ-ટ્રિપ કરવો પડતો નથી.
- વિનંતી correlation ID. HTTP મિડલવેર દરેક આવનારી વિનંતી સાથે એક v4 UUID જોડે છે, દરેક span પર તેને લૉગ કરે છે, અને તેને ડાઉનસ્ટ્રીમ (ઘણીવાર
X-Request-Idહેડર તરીકે) પ્રસારિત કરે છે. જ્યારે ગ્રાહક કોઈ બગ ની જાણ કરે, ત્યારે સપોર્ટ ઇજનેર એ ID પેસ્ટ કરે છે અને આખી વિનંતી ટ્રેસ — સેવાઓ અને ટાઇમ ઝોન ની આરપાર — કોઈ સંદિગ્ધતા વગર સામે આવી જાય છે. - Idempotency કીઓ. ચૂકવણી API (Stripe, Adyen, Square) એક
Idempotency-Keyહેડર સ્વીકારે છે જેથી ફરી પ્રયાસ કરાયેલી વિનંતી ગ્રાહક પાસેથી ક્યારેય બે વાર ચાર્જ ન કરે. ક્લાયન્ટ-જનરેટેડ UUID ખાતરી આપે છે કે કી દરેક તાર્કિક ઑપરેશન દીઠ અનન્ય છે, જે ઠીક એ જ કરાર છે જેની આ API માગ કરે છે.
UUID example?
Node.js માં અથવા આધુનિક બ્રાઉઝરમાં, એક-લીટીની crypto.randomUUID() એક નવો v4 UUID પાછો આપે છે — ઉદાહરણ તરીકે 3f50b5a8-2c54-4b9c-9c1f-3e5c7e2b8d12. તેને વિનંતી ID કે idempotency કી માટે વાપરો. જ્યારે UUID એવા ડેટાબેઝ કૉલમમાં જઈ રહ્યો હોય જે ક્લસ્ટર્ડ પ્રાઇમરી કી હશે, ત્યારે તેને બદલે v7 ઉત્પન્ન કરો: એક મિલિસેકન્ડના અંતરે બનેલા બે v7 મૂલ્ય, જેમ કે 0190a3b0-7d4f-7c9e-8b21-a4d6f0bd9c11 અને 0190a3b0-7d50-7f15-9c4e-72b3e0c1d8a4, જનરેશન ક્રમમાં લેક્સિકોગ્રાફિક રીતે ગોઠવાય છે. Postgres નો uuid પ્રકાર બંને વર્ઝનને એકસરખી રીતે સંગ્રહે છે — તફાવત ઇન્ડેક્સ-રાઇટ સમયે દેખાય છે, જ્યાં v7 ઇન્સર્ટ્સ B-tree ની જમણી બાજુએ append થાય છે જ્યારે v4 ઇન્સર્ટ્સ વિખેરાઈ જાય છે અને રેન્ડમ I/O ને ફરજ પાડે છે.
આ UUID Generator માત્ર એક જ કામ કરે છે: એક ક્લિકને એક અથવા અનેક RFC-અનુરૂપ ઓળખકર્તાઓમાં ફેરવી દેવી, તમને જોઈએ તે ફોર્મેટમાં, તમારી વિનંતી સર્વર પર મોકલ્યા વગર. એક વર્ઝન પસંદ કરો, એક સંખ્યા પસંદ કરો, એક ફોર્મેટ પસંદ કરો — ઉત્પન્ન કરો, કૉપી કરો, આગળ વધો.