ఎవరైనా వేరే వ్యక్తులు సృష్టించిన దానితో ఎప్పుడూ ఘర్షణ పడని, మీరు ఎప్పుడూ వినని ఒక యంత్రంపై రూపొందించబడిన, మరియు ఎవరి అనుమతి కోసం అడగాల్సిన అవసరం లేని ఒక ఐడెంటిఫైయర్ మీకు అవసరమా? ఆ పనినే ఒక UUID చేస్తుంది. ఇది ఒక 128-బిట్ సంఖ్య, పరిచయం ఉన్న 8-4-4-4-12 అమరికలో 36 అక్షరాలుగా రాయబడుతుంది, మరియు ఎవరికి ఏది అందుతుందో దేనిచే సమన్వయం చేయబడకపోయినప్పటికీ, వాటిలో ఏ రెండూ ఒకేలా ఉండవన్నదే దీని పూర్తి రూపకల్పన ఉద్దేశం. ఈ ఉచిత జనరేటర్ వాటిని మీ బ్రౌజర్‌లోనే తయారుచేస్తుంది: 'వెర్షన్' లో ఒక వెర్షన్‌ని ఎంచుకోండి, 'ఎంపికల సంఖ్య' లో మీకు ఎన్ని కావాలో చెప్పండి, ఆపై 'సృష్టించు' నొక్కండి. ఈ పేజీ ఒకే v4 తో తెరుచుకుంటుంది, ఇదే ఎక్కువ ప్రాజెక్ట్‌లు కోరుకునే వెర్షన్, కాబట్టి మీ మొదటి ఐడెంటిఫైయర్ కేవలం ఒక క్లిక్ దూరంలో ఉంటుంది.
ప్రతి ఐడెంటిఫైయర్ Web Crypto API ద్వారా మీ బ్రౌజర్ చేత నిర్మించబడుతుంది. వెర్షన్ 4 బ్రౌజర్ అందించే చోట crypto.randomUUID() ని మరియు ఇతర చోట్ల crypto.getRandomValues() ని ఉపయోగిస్తుంది — ఇది Math.random() వంటి జావాస్క్రిప్ట్ నకిలీ-రాండమ్ ఫంక్షన్‌కి బదులుగా, క్రిప్టోగ్రాఫికల్‌గా బలమైన రాండమ్‌నెస్ మూలం. వెర్షన్ 7 ముందు భాగంలో ఒక 48-బిట్ మిల్లీసెకండ్ టైమ్‌స్టాంప్‌ని ఉంచుతుంది, ఆపై అదే మిల్లీసెకండ్‌లో పెరిగే ఒక 12-బిట్ కౌంటర్‌ను, ఆపై 62 రాండమ్ బిట్‌లను ఉంచుతుంది, ఇది RFC 9562 లో వివరించబడిన క్రమబద్ధీకరణ పద్ధతి; ఆ కౌంటర్ కారణంగానే వెయ్యి వాల్యూస్‌ ఉన్న ఒక బ్యాచ్ కలగలుపుగా కాకుండా ఒక క్రమంలో వస్తుంది. వెర్షన్ 1 టైమ్‌స్టాంప్‌ని మల్టీకాస్ట్ బిట్ సెట్ చేయబడిన ఒక రాండమ్ నోడ్ ఐడెంటిఫైయర్‌తో కలుపుతుంది, కాబట్టి 1990 ల నాటి అసలైన ఇంప్లిమెంటేషన్‌ల వలె ఇది మీ నెట్‌వర్క్ కార్డ్ అడ్రస్‌ను ఎప్పటికీ తీసుకువెళ్ళదు. వెర్షన్లు 3 మరియు 5 ఏమాత్రం రాండమ్ కావు: అవి MD5 మరియు SHA-1 లను ఉపయోగించి ఒక నేమ్‌స్పేస్‌ను మరియు ఒక పేరును కలిపి హ్యాష్ చేస్తాయి, మరియు ఆ హ్యాషింగ్ కూడా మీ పరికరంలోనే జరుగుతుంది. సర్వర్‌కు ఏమీ పంపబడదు, ఏదీ లాగ్ చేయబడదు, మరియు ఒకసారి పేజీ లోడ్ అయిన తర్వాత ఇంటర్నెట్ కనెక్షన్ లేకపోయినా ఇది పనిచేస్తూనే ఉంటుంది.
మిగతా వాటన్నింటినీ నిర్ణయించే ఫీల్డ్ 'వెర్షన్'. వెర్షన్ 4 అనేది 122 రాండమ్ బిట్‌లు మరియు ఎలాంటి నిర్మాణం లేనిది — ఇది డిఫాల్ట్, మరియు ఒక ఐడెంటిఫైయర్ కేవలం ప్రత్యేకంగా (unique) ఉండాల్సినప్పుడు సరైన సమాధానం. వెర్షన్ 7 కి 62 రాండమ్ బిట్‌లు ఉంటాయి కానీ అది సృష్టించబడిన సమయంతో మొదలవుతుంది, కాబట్టి వాటి సమితి (set) అవి తయారు చేయబడిన క్రమంలో పేర్చబడుతుంది; ఐడెంటిఫైయర్ ఒక డేటాబేస్ కీ గా మారబోతున్నప్పుడు దానిని ఎంచుకోవడానికి కారణం అదే. వెర్షన్ 1 అనేది అసలైన సమయం-ఆధారిత స్కీమ్, ఇది ఇప్పటికీ అడిగే సిస్టమ్‌ల కోసం ఇక్కడ ఉంచబడింది. వెర్షన్లు 3 మరియు 5 ఒక భిన్నమైన జంట: అవి డిటర్మినిస్టిక్ అనగా నిర్ణయాత్మకమైనవి, అంటే ఒకే ఇన్‌పుట్‌లు ఎప్పుడూ ఒకే ఐడెంటిఫైయర్‌ను ఉత్పత్తి చేస్తాయి, మరియు అవి రెండు అదనపు ఫీల్డ్‌లను తీసుకుంటాయి — ప్రామాణిక ప్రదేశాలైన DNS, URL, OID మరియు X.500 లేదా మీ స్వంత ఒక 'అనుకూల' ప్రదేశం అయిన 'నేమ్‌స్పేస్', మరియు గుర్తించబడుతున్న స్ట్రింగ్ అయిన 'పేరు'. v5 కి URL నేమ్‌స్పేస్ మరియు https://example.com/a ని ఇస్తే, మీకు ఈరోజూ, రేపూ మరియు వేరొకరి మెషీన్‌లోనూ ఒకే UUID వస్తుంది. ఆ కారణంగా, v3 లేదా v5 ఎంపిక చేయబడినప్పుడు 'ఎంపికల సంఖ్య' అదృశ్యమవుతుంది: ఒకే నిర్ణయాత్మక విలువకు చెందిన వెయ్యి కాపీలు కేవలం ఒకే నిర్ణయాత్మక విలువ యొక్క వెయ్యి కాపీలు మాత్రమే అవుతాయి. మిగతా ప్రతి వెర్షన్‌కూ 'ఎంపికల సంఖ్య' 1 నుండి 1000 వరకు నడుస్తుంది.
నాలుగు స్విచ్‌లు అడుగున ఉన్న 128 బిట్‌లను మార్చకుండా ఔట్‌పుట్ ఆకారాన్ని మారుస్తాయి. 'పెద్ద అక్షరాలు' హెక్సాడెసిమల్ అంకెలను పెద్ద అక్షరాలుగా ముద్రిస్తుంది, 'అడ్డుగీతలు లేకుండా' అనేది కొన్ని నిలువు వరుసలు మరియు ఫైల్ పేర్లు కోరుకునే కుదించబడిన 32-అక్షరాల రూపాన్ని ఇస్తుంది, మరియు 'వంకర కుండలీకరణాలు' విలువను { } లోపల ఉంచుతుంది — ఈ ఆకారాన్నే Windows మరియు .NET ప్రపంచం GUID అని పిలుస్తుంది. 'అధునాతన ఎంపికలు' కింద, urn:uuid: అనేది దీనిని ఒక అధికారిక URN గా మార్చే ప్రిఫిక్స్‌ను జోడిస్తుంది; ఇది ఆన్‌లో ఉన్నప్పుడు 'వంకర కుండలీకరణాలు' మరియు 'అడ్డుగీతలు లేకుండా' ఆప్షన్లను ఆఫ్ చేస్తుంది, ఎందుకంటే ప్రమాణం (standard) సరిగ్గా ఒకే ఒక URN రూపాన్ని మాత్రమే అనుమతిస్తుంది మరియు అది అడ్డుగీతలు ఉన్న కానానికల్ రూపం. మీరు ఒక బ్యాచ్‌ను తీసుకున్నప్పుడు అది ఎలా కలుపబడుతుందో 'కాపీ ఫార్మాట్' నిర్ణయిస్తుంది: ఒక్కో లైన్‌కు ఒకటిగా, కామాలచే వేరు చేయబడి, లేదా ప్రతి విలువా కొటేషన్లలో ఒక కామాతో కలిపి, ఇది నేరుగా కోడ్‌లోని ఒక ఎరేలో (array) పేస్ట్ అవుతుంది. ఫలితం కింద బిట్‌లలో రాండమ్‌నెస్‌ను నివేదించే ఒక లైన్ ఉంటుంది — v4 కి 122, v7 కి 62 — మరియు, v7 కి సంబంధించి, బ్యాచ్‌లోని మొదటి ఐడెంటిఫైయర్‌లో ఎన్‌కోడ్ చేయబడిన టైమ్‌స్టాంప్, తద్వారా విలువ లోపలి సమయం సూచనప్రాయంగా కాకుండా స్పష్టంగా కనిపిస్తుంది. 'అన్నీ కాపీ చేయండి' మరియు 'ఫైల్‌కు సేవ్ చేయండి' రెండూ 'కాపీ ఫార్మాట్' ను గౌరవిస్తాయి. 'చరిత్ర' మీ గత 10 బ్యాచ్‌లను మీ స్వంత బ్రౌజర్‌లోనే ఉంచుతుంది: ఒక దాన్ని తిరిగి తీసుకురావడానికి క్లిక్ చేయండి, ఒకే ఎంట్రీని కాపీ చేయండి లేదా తొలగించండి, లేదా మొత్తాన్ని క్లియర్ చేయండి. 'క్లియర్ చేయండి' మీ సెట్టింగ్‌లను అలాగే ఉంచి ఫలితాన్ని ఖాళీ చేస్తుంది, మరియు 50 ఐడెంటిఫైయర్‌ల తర్వాత జాబితా యాభై వరుసలకు బదులుగా స్క్రోల్ చేయగల ఒకే బ్లాక్‌గా మారుతుంది.
ఈ పేజీలో అత్యంత పర్యవసానమైన విషయం ఏమిటంటే ఒక ప్రైమరీ కీ గా v4 మరియు v7 ల మధ్య ఉన్న వ్యత్యాసం, మరియు ఇది కేవలం ఇష్టానికి సంబంధించిన విషయం కాదు. డేటాబేస్ ఇండెక్స్‌లు క్రమబద్ధమైన (sorted) ఆర్డర్‌లో ఉంచబడిన చెట్లు (B-trees), మరియు ఆ క్రమంలో ఒక కొత్త కీ ఎక్కడ ల్యాండ్ అవుతుందనేది ఇన్సర్ట్ ఆపరేషన్‌కి ఎంత పని అవుతుందనేది నిర్ణయిస్తుంది. ఒక v4 కీ రాండమ్‌గా ఉంటుంది, కాబట్టి వరుస ఇన్సర్ట్‌లు ఇండెక్స్‌లోని సంబంధం లేని మూలల్లో ల్యాండ్ అవుతాయి: నిండిపోయిన పేజీలు చీలిపోతాయి, డేటాబేస్ మెమరీలో ఉంచుకున్న చెట్టు విభాగాలు తదుపరి ఇన్సర్ట్‌కు అవసరమైన విభాగాలుగా ఉండటం అరుదు, మరియు ఇండెక్స్ అది సూచించే వరుసలు సమర్థించే దానికంటే పెద్దదిగా మరియు మరింత విచ్ఛిన్నంగా (fragmented) మారుతుంది. ఒక v7 కీ ప్రస్తుత మిల్లీసెకండ్‌తో మొదలవుతుంది, కాబట్టి వరుస ఇన్సర్ట్‌లు చెట్టు యొక్క కుడివైపు అంచున ఒకదాని పక్కన ఒకటి ల్యాండ్ అవుతాయి, ఆటో-ఇంక్రిమెంట్ అయ్యే ఒక ఇంటీజర్ (integer) ఉత్పత్తి చేసే నమూనా ఇదే మరియు ఇండెక్స్ స్ట్రక్చర్‌లు దేని చుట్టూ నిర్మించబడ్డాయో ఆ నమూనా కూడా ఇదే. ఈ మొత్తం రాజీ ఇదే: సర్వర్‌ని అడగకుండా ఎవరైనా ఐడెంటిఫైయర్‌ను సృష్టించవచ్చు అనే ప్రాథమిక లక్షణాన్ని (దీనివల్లే మీరు అసలు UUID లను ఎంచుకున్నారు) అట్టిపెట్టుకుంటూనే, ఒక సీక్వెన్షియల్ కీ యొక్క ఇన్సర్ట్ ప్రవర్తనను v7 మీకు ఇస్తుంది. ఇది అడిగే మూల్యం ఏమిటంటే ఐడెంటిఫైయర్ లోపల సృష్టించిన సమయం చదవగలిగేలా ఉంటుంది, అది పట్టింపు అంశమా కాదా అనేది మీ డేటా గురించిన ప్రశ్న, ఫార్మాట్ గురించి కాదు.
ఏదీ కూడా ఒక UUID యొక్క ప్రత్యేకతను (uniqueness) ఎప్పుడూ తనిఖీ చేయదు; దాని పరిమాణమే దానికి గ్యారెంటీ. రిజిస్ట్రీ లేదు, సర్వర్‌కు వెళ్లొచ్చే రౌండ్-ట్రిప్ లేదు, వెతకటం (lookup) లేదు — జనరేటర్ ఒక సంఖ్యను ఉత్పత్తి చేసి దాన్ని అప్పగిస్తుంది, మరియు వాటిలో ఏ రెండూ ఒకదానితో ఒకటి ఢీకొనకపోవడానికి (collide) కారణం కేవలం v4 కి సంబంధించి 2^122 సాధ్యమైన విలువలు ఉండటమే, ఇది సుమారు 5.3 అన్‌డెసిలియన్ (5.3 × 10^36). బర్త్‌డే ప్రాబ్లమ్ అనేది దాని పరిమాణాన్ని అంచనా వేయడానికి ఒక నిజాయితీ పద్ధతి: వాటిలో ఏవైనా రెండు సరిపోలడానికి 50% అవకాశం ఉండాలంటే మీకు సుమారు 2.7 క్వింటిలియన్ (2.7 × 10^18) ఐడెంటిఫైయర్‌లు కావాలి, అనగా 86 సంవత్సరాల పాటు ప్రతి సెకనుకు ఒక బిలియన్ కొత్త UUID లు. ఇది ఏ హామీ ఇస్తుంది మరియు ఏమి ఇవ్వదు అనే విషయాల్లో కచ్చితంగా ఉండటం విలువైంది. ఇది ఒక స్టాటిస్టికల్ హామీ, అంకగణిత (arithmetic) హామీ కాదు, మరియు అడుగున ఉన్న రాండమ్‌నెస్ నిజమైనదిగా ఉన్నంత వరకే ఇది వర్తిస్తుంది — తప్పుగా సీడ్ చేయబడిన (seeded) ఒక జనరేటర్, లేదా దాని ఎంట్రోపీ పూల్‌తో సహా క్లోన్ (clone) చేయబడిన ఒక వర్చువల్ మెషీన్, దీన్ని ఫార్మాట్ పసిగట్టలేని రీతిలో విచ్ఛిన్నం చేస్తుంది. వెర్షన్ 7 ఈ ప్రశ్నను మరింత కుదిస్తుంది: ఒకే మిల్లీసెకండ్ లోపల ఒక జనరేటర్ తనను తాను పునరావృతం చేసుకోనే లేదు, ఎందుకంటే డైస్ వేసినట్టు కాకుండా కౌంటర్ ఒక్కొక్కటీ పెరుగుతుంది (increments), మరియు స్వతంత్ర జనరేటర్‌ల మధ్య 62 రాండమ్ బిట్‌లు ఆ పని చేస్తాయి.
ఒక UUID అనేది ఒక ఐడెంటిఫైయర్, పాస్‌వర్డ్ కాదు. వెర్షన్ 4 అనూహ్యమైనది, మరియు అది మనుషులను దీన్ని ఒక రహస్యం వలె పరిగణించేలా ఊరిస్తుంది — ఒక పాస్‌వర్డ్-రీసెట్ లింక్, ఊహించలేని URL, సెషన్ టోకెన్, ఒక API కీ లాగా. అనూహ్యత అనేది నిజమే, కానీ రహస్యం అనేది ఒక విలువను ఎలా నిర్వహిస్తారనే దానికి సంబంధించిన లక్షణం, మరియు ఐడెంటిఫైయర్‌లు కావాలనే అజాగ్రత్తగా నిర్వహించబడతాయి: అవి బ్రౌజర్ హిస్టరీ, సర్వర్ లాగ్స్, రెఫరర్ హెడర్‌లు మరియు అనలిటిక్స్‌లో చేరే URL లలో కూర్చుంటాయి, మరియు చాట్ మెసేజ్‌లలో పేస్ట్ చేయబడతాయి. మిగతా వెర్షన్లు ఇంకా చెడ్డ ఎంపికలు. వెర్షన్ 1 మరియు వెర్షన్ 7 రెండూ సృష్టించబడిన క్షణాన్ని ఎన్‌కోడ్ చేస్తాయి, కాబట్టి ఒక దాన్ని పట్టుకున్న ఎవరికైనా అది ఎప్పుడు తయారు చేయబడిందో స్థూలంగా తెలుస్తుంది మరియు దానితో పాటు తయారైన వాటన్నింటి కదలికల పరిధిని ఇరుకు చేయవచ్చు. వెర్షన్లు 3 మరియు 5 ఉద్దేశపూర్వకంగానే నిర్ణయాత్మకమైనవి (deterministic): ఇమెయిల్ అడ్రస్‌కి చెందిన v5 UUID ఒక హ్యాష్ చేయబడిన రహస్యం కాదు, అది అదే అడ్రస్ ఉన్న ఎవరైనా ఒక సెకనులో లెక్కించగల విలువ. ఒక వస్తువుకు పేరు పెట్టడానికి UUID ని వాడండి. విలువ ఎవరికీ తెలియకుండా ఉండాల్సినప్పుడు, పాస్‌వర్డ్ జనరేటర్ లేదా రహస్యాల కోసం నిర్మించిన లైబ్రరీ నుండి ఒక టోకెన్‌ను వాడండి.
ఈ UUID జనరేటర్‌ను ఎందుకు ఎంచుకోవాలి?
- బ్రౌజర్‌లో మాత్రమే సృష్టి: ఐడెంటిఫైయర్‌లు మీ పరికరంలో తయారవుతాయి మరియు ఎక్కడికీ పంపబడవు
- Web Crypto API రాండమ్‌నెస్: క్రిప్టోగ్రాఫికల్‌గా సురక్షితమైనది, Math.random() కాదు
- ఐదు వెర్షన్లు ఒకే చోట: టూల్స్ మార్చుకోకుండానే v1, v3, v4, v5 మరియు v7
- నిజంగా క్రమబద్ధీకరించబడిన v7: RFC 9562 వివరించినట్లుగా మిల్లీసెకండ్ లోపల ఒక కౌంటర్
- ప్రామాణికమైన నాలుగు నేమ్‌స్పేస్‌లతో లేదా మీ స్వంత దానితో నిర్ణయాత్మకమైన v3 మరియు v5
- ఒకేసారి 1000 వరకు, యాభై దాటితే స్క్రోల్ చేయగల ఒక కాంపాక్ట్ జాబితాతో
- ప్రతి సాధారణ ఆకారం: అడ్డుగీతతో, వట్టిగా, పెద్ద అక్షరాలు, కుండలీకరణాలు లేదా ఒక urn:uuid: URN
- లైన్‌లుగా, కామాలతో లేదా నేరుగా కోడ్‌లో పేస్ట్ చేయడానికి కొటేషన్ విలువలుగా కాపీ చేయవచ్చు
- అపరిమితం మరియు ఉచితం: సైన్-అప్ లేదు, వినియోగ పరిమితులు లేవు, మా సర్వర్‌లలో ఏమీ ఉండదు
పేరు ఖాళీగా ఉందని ఏదైనా నిర్ధారించడానికి ముందు ఏదైనా వస్తువుకు పేరు పెట్టాల్సిన ప్రతి చోటా UUID లు కనిపిస్తాయి. అప్లికేషన్ కోడ్ ఇప్పుడే ఇన్సర్ట్ చేయబోతున్న వరుసల (rows) కోసం వీటిని ముద్రిస్తుంది, కాబట్టి ఆ ఆబ్జెక్ట్ డేటాబేస్‌ను చేరుకోకముందే దానికి ఒక గుర్తింపు ఉంటుంది మరియు రాసే ప్రక్రియ ఇంకా కొనసాగుతుండగానే క్లయింట్ దాన్ని రిఫరెన్స్ చేయవచ్చు. డిస్ట్రిబ్యూటెడ్ సిస్టమ్‌లు వీటిపై ఇంకా ఎక్కువగా ఆధారపడతాయి: ఒకే టేబుల్‌లోకి రాసే పలు సర్వీస్‌లు, విమానంలో ఉన్నప్పుడు ఆఫ్‌లైన్‌లో రికార్డులను సృష్టిస్తున్న మొబైల్ క్లయింట్, తాను ఇప్పటికే ప్రాసెస్ చేసిన సందేశాన్ని గుర్తించాల్సిన క్యూ — వీటిలో ఏవీ షేర్ చేయబడిన కౌంటర్ కోసం తమ వంతు వచ్చే దాకా వేచి ఉండలేవు. వెర్షన్ 5 వేరొక అవసరాన్ని తీరుస్తుంది, అదేంటంటే మీ వద్ద అప్పటికే ఉన్న దాని నుండి సేకరించిన ఒక స్థిరమైన ఐడెంటిఫైయర్: ఒకే డాక్యుమెంట్, ఒకే URL లేదా ఒకే అకౌంట్ ఎప్పుడూ ఒకే UUID కి మ్యాప్ అవుతుంది, తద్వారా దేనినీ డూప్లికేట్ చేయకుండా ఒక ఇంపోర్ట్‌ను రెండుసార్లు నడపవచ్చు. ఇతర చోట్ల అవి కేవలం ఒక సిస్టమ్ డిమాండ్ చేసే ఫార్మాట్ — లాగ్‌లు మరియు ట్రేస్‌ల ద్వారా చేరే కోరిలేషన్ ఐడెంటిఫైయర్, వెయ్యి మంది వినియోగదారుల అప్‌లోడ్‌లు ఒకే బకెట్‌లో పడినప్పుడు ఢీకొనని ఫైల్ పేరు, ఒక Windows రిజిస్ట్రీ కీ, అసలైన డేటా లాగా కనిపించాల్సిన టెస్ట్ ఫిక్స్‌చర్ (test fixture).
కొన్ని నిజాయితీ గల పరిమితులు తెలుసుకోవడం విలువైంది. ఒక బ్యాచ్ అనగా ఒక వెర్షన్: 'వెర్షన్' లో ఉన్న విలువ దానిలోని ప్రతిదానికీ వర్తిస్తుంది, కాబట్టి v4 ల రన్ మరియు v7 ల రన్ అనేవి రెండు బ్యాచ్‌లు. ఇది ఒక జనరేటర్, ఇన్‌స్పెక్టర్ కాదు — ఒక UUID ని అందులో పేస్ట్ చేసి దాని వెర్షన్ లేదా టైమ్‌స్టాంప్‌ను తిరిగి చదవడం అనేది ఈ పేజీ చేసే పని కాదు. 'ఫైల్‌కు సేవ్ చేయండి' అనేది CSV లేదా JSON కు బదులుగా ఒక ప్లెయిన్ టెక్స్ట్ ఫైల్‌ను రాస్తుంది. వెర్షన్ 7 అది ఎప్పుడు సృష్టించబడిందో మిల్లీసెకండ్ వరకు ఓపెన్‌గా వెల్లడిస్తుంది, ఇది ఒక నిజమైన రాజీ మాత్రమే తప్ప లోపం కాదు, మరియు వెర్షన్ 1 కూడా అదే విధంగా సమయాన్ని లీక్ చేస్తుంది; అది మీ డేటాకి సమస్య అయితే, ఎవరికీ ఏమీ చెప్పని వెర్షన్ వెర్షన్ 4 మాత్రమే. ప్రమాణం నుండి వచ్చిన రెండు ప్రత్యేక విలువలు వెర్షన్లు కావు కాబట్టి అవి 'వెర్షన్' లో ఎంపికలుగా లేవు, కానీ మీరు వాటిని ఇక్కడ నుండి కాపీ చేయవచ్చు: nil UUID, 00000000-0000-0000-0000-000000000000, మరియు max UUID, ffffffff-ffff-ffff-ffff-ffffffffffff. ఈ పేజీలోని ప్రతిదీ 2024 లో RFC 4122 స్థానంలో వచ్చిన స్పెసిఫికేషన్ అయిన RFC 9562 ని అనుసరిస్తుంది, కాబట్టి ఔట్‌పుట్ అనేది UUID లను హ్యాండిల్ చేసే ఏ లైబ్రరీ, డేటాబేస్ లేదా API చేతనైనా అంగీకరించబడుతుంది. ఆ పరిమితుల లోపల దీని హామీ ఒక బలమైనది: ప్రతి ఐడెంటిఫైయర్ ప్రమాణానికి అనుగుణంగా, క్రిప్టోగ్రాఫికల్‌గా సురక్షితమైన రాండమ్‌నెస్ నుండి, మీ స్వంత మెషీన్‌లో నిర్మించబడుతుంది, మరియు దాన్ని మరెవరూ ఎప్పటికీ చూడరు.