വിവിധ ആപ്ലിക്കേഷനുകൾക്കായി സർവദേശീയമായി വ്യത്യസ്തമായ തിരിച്ചറിയലുകൾ (UUIDs) സൃഷ്ടിക്കുക. വിതരണം ചെയ്ത സിസ്റ്റങ്ങൾ, ഡാറ്റാബേസുകൾ എന്നിവയിൽ ഉപയോഗിക്കുന്നതിനായി പതിപ്പ് 1 (സമയം അടിസ്ഥാനമാക്കിയ)യും പതിപ്പ് 4 (അവസാന) UUIDs ഉം സൃഷ്ടിക്കുക.
ഒരു യൂണിവേഴ്സലി യുണിക് ഐഡന്റിഫയർ (UUID) 128-ബിറ്റ് നമ്പർ ആണ്, ഇത് കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങളിൽ വിവരങ്ങൾ തിരിച്ചറിയാൻ ഉപയോഗിക്കുന്നു. UUIDകൾ ഓപ്പൺ സോഫ്റ്റ്വെയർ ഫൗണ്ടേഷൻ (OSF) വഴി വിതരണ കമ്പ്യൂട്ടിംഗ് പരിസ്ഥിതിയുടെ (DCE) ഭാഗമായും സ്റ്റാൻഡേർഡ് ചെയ്യപ്പെട്ടവയാണ്. ഈ ഐഡന്റിഫയർസ് സ്ഥലം കൂടാതെ സമയത്തും യുണിക് ആയിരിക്കാനായി രൂപകൽപ്പന ചെയ്തതാണ്, അതിനാൽ ഇത് വിതരണ സിസ്റ്റങ്ങൾക്കും അതിനപ്പുറം വിവിധ അപേക്ഷകൾക്കായി അനുയോജ്യമാണ്.
ഈ UUID ജനറേറ്റർ ഉപകരണം പതിപ്പ് 1 (സമയ അടിസ്ഥാനമാക്കിയ) കൂടാതെ പതിപ്പ് 4 (രണ്ടാമത്തെ) UUIDകൾ സൃഷ്ടിക്കാൻ നിങ്ങൾക്ക് അനുവദിക്കുന്നു. ഈ ഐഡന്റിഫയർസ് യുണിക് തിരിച്ചറിയൽ ആവശ്യമുള്ള വിവിധ സാഹചര്യങ്ങളിൽ ഉപകാരപ്രദമാണ്, ഉദാഹരണത്തിന് ഡാറ്റാബേസ് കീകൾ, വിതരണ സിസ്റ്റങ്ങൾ, നെറ്റ്‌വർക്കിന്റെ പ്രോട്ടോകോളുകൾ എന്നിവയിൽ.
ഒരു UUID സാധാരണയായി 32 ഹെക്സാഡെസിമൽ അക്കങ്ങൾ ആയി പ്രതിനിധീകരിക്കപ്പെടുന്നു, അഞ്ച് ഗ്രൂപ്പുകൾ ഹൈഫൻമാർക്കുകൾ കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു, 8-4-4-4-12 എന്ന രൂപത്തിൽ 36 അക്ഷരങ്ങൾ (32 അക്ഷരങ്ങൾ കൂടാതെ 4 ഹൈഫൻ) ഉള്ളത്. ഉദാഹരണത്തിന്:
1550e8400-e29b-41d4-a716-446655440000
2UUIDയുടെ 128 ബിറ്റുകൾ പ്രത്യേക ഫീൽഡുകളിൽ വിഭജിക്കപ്പെട്ടിരിക്കുന്നു, UUID പതിപ്പിന്റെ അടിസ്ഥാനത്തിൽ ഓരോന്നിലും വ്യത്യസ്തമായ വിവരങ്ങൾ ഉണ്ട്:
UUID ഘടനയെ വിശദീകരിക്കുന്ന ഒരു രൂപരേഖ ഇവിടെ കാണാം:
UUIDകളുടെ വിവിധ പതിപ്പുകൾ ഉണ്ട്, ഓരോന്നും തങ്ങളുടെ സ്വന്തം നിർമ്മാണ രീതിയുണ്ടാണ്:
ഈ ഉപകരണം പതിപ്പ് 1 കൂടാതെ പതിപ്പ് 4 UUIDകൾ സൃഷ്ടിക്കുന്നതിൽ കേന്ദ്രീകരിക്കുന്നു.
പതിപ്പ് 1 UUIDകൾ നിർമ്മിക്കാൻ താഴെപ്പറയുന്ന ഘടകങ്ങൾ ഉപയോഗിക്കുന്നു:
ഒരു പതിപ്പ് 1 UUID സൃഷ്ടിക്കുന്നതിനുള്ള ഫോർമുല ഇങ്ങനെ രേഖപ്പെടുത്താം:
1UUID = (timestamp * 2^64) + (clock_sequence * 2^48) + node
2പതിപ്പ് 4 UUIDകൾ ക്രിപ്റ്റോഗ്രാഫിക്കായി ശക്തമായ യാദൃച്ഛിക നമ്പർ ജനറേറ്റർ ഉപയോഗിച്ച് നിർമ്മിക്കുന്നു. ഫോർമുല വളരെ ലളിതമാണ്:
1UUID = random_128_bit_number
2നിശ്ചിത ബിറ്റുകൾ പതിപ്പ് (4) കൂടാതെ വേരിയന്റ് സൂചിപ്പിക്കാൻ സെറ്റ് ചെയ്യുന്നു.
UUIDകൾ കമ്പ്യൂട്ടർ ശാസ്ത്രം, സോഫ്റ്റ്വെയർ എഞ്ചിനീയറിംഗ് എന്നിവയിലെ വിവിധ മേഖലകളിൽ അനേകം അപേക്ഷകൾ ഉണ്ട്:
ഡാറ്റാബേസ് കീകൾ: UUIDകൾ പലപ്പോഴും ഡാറ്റാബേസുകളിൽ പ്രാഥമിക കീകളായി ഉപയോഗിക്കുന്നു, പ്രത്യേകിച്ച് നിരവധി നോഡുകൾ ഒരേ സമയം രേഖകൾ സൃഷ്ടിക്കുമ്പോൾ.
വിതരണ സിസ്റ്റങ്ങൾ: വലിയ തോതിലുള്ള വിതരണ സിസ്റ്റങ്ങളിൽ, UUIDകൾ നിരവധി നോഡുകൾ അല്ലെങ്കിൽ ഡാറ്റാ സെന്ററുകൾക്കിടയിൽ വിഭവങ്ങൾ, ഇടപാടുകൾ, അല്ലെങ്കിൽ സംഭവങ്ങൾ യുണിക് ആയി തിരിച്ചറിയാൻ സഹായിക്കുന്നു.
ഉള്ളടക്കം വിലാസനം: UUIDകൾ ഉള്ളടക്കത്തിന്റെ യുണിക് ഐഡന്റിഫയർസുകൾ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കാം.
സെഷൻ മാനേജ്മെന്റ്: വെബ് ആപ്ലിക്കേഷനുകൾ പലപ്പോഴും UUIDകൾ ഉപയോഗിച്ച് ഉപയോക്തൃ സെഷനുകൾ കൈകാര്യം ചെയ്യുന്നു, ഓരോ സെഷനും യുണിക് ഐഡന്റിഫയർ ഉണ്ടാക്കുന്നു.
IoT ഉപകരണം തിരിച്ചറിയൽ: ഇന്റർനെറ്റ് ഓഫ് തിംഗ്സ് (IoT) അപേക്ഷകളിൽ, UUIDകൾ ഒരു നെറ്റ്‌വർക്കിൽ വ്യക്തിഗത ഉപകരണങ്ങളെ യുണിക് ആയി തിരിച്ചറിയാൻ ഉപയോഗിക്കാം.
UUIDകൾ വ്യാപകമായി ഉപയോഗിക്കുമ്പോൾ, യുണിക് ഐഡന്റിഫയർസുകൾ സൃഷ്ടിക്കാൻ മറ്റ് സമീപനങ്ങൾ ഉണ്ട്:
ഓട്ടോ-ഇൻക്രിമെന്റിംഗ് ഐഡികൾ: ഏകദേശം സിംപിൾ, ഒറ്റ ഡാറ്റാബേസ് സിസ്റ്റങ്ങളിൽ സാധാരണയായി ഉപയോഗിക്കപ്പെടുന്നു, എന്നാൽ വിതരണ പരിസ്ഥിതികൾക്കായി അനുയോജ്യമായില്ല.
ടൈംസ്റ്റാമ്പ് അടിസ്ഥാനമാക്കിയ ഐഡികൾ: സമയക്രമത്തിൽ ഡാറ്റയ്ക്ക് ഉപകാരപ്രദമായേക്കാം, എന്നാൽ ഉയർന്ന-കൺക്കറൻസി സാഹചര്യങ്ങളിൽ കൂട്ടിയിടിച്ച പ്രശ്നങ്ങൾ നേരിടേണ്ടി വരാം.
സ്നോഫ്ലേക്ക് ഐഡുകൾ: ട്വിറ്റർ വികസിപ്പിച്ച, ഈ ഐഡുകൾ ടൈംസ്റ്റാമ്പും തൊഴിലാളി നമ്പറും സംയോജിപ്പിച്ച് വിതരണ സിസ്റ്റങ്ങളിൽ യുണിക് ഐഡികൾ സൃഷ്ടിക്കുന്നു.
ULID (യൂണിവേഴ്സലി യുണിക് ലെക്സിക്കോഗ്രാഫിക്കായി ക്രമീകരിക്കാവുന്ന ഐഡന്റിഫയർ): UUIDകളെക്കാൾ കൂടുതൽ മനുഷ്യ സൗഹൃദവും ക്രമീകരിക്കാവുന്നവയും ആകാൻ ലക്ഷ്യമിട്ട പുതിയ ഒരു മാറ്റം.
UUIDകളുടെ ആശയം ആദ്യം അപ്പോളോ നെറ്റ്വർക്ക് കമ്പ്യൂട്ടിംഗ് സിസ്റ്റത്തിൽ അവതരിപ്പിക്കപ്പെട്ടു, പിന്നീട് 1990കളിൽ ഓപ്പൺ സോഫ്റ്റ്വെയർ ഫൗണ്ടേഷൻ (OSF) വഴി സ്റ്റാൻഡേർഡ് ചെയ്യപ്പെട്ടു. ആദ്യത്തെ സ്പെസിഫിക്കേഷൻ 1997-ൽ ISO/IEC 11578:1996 എന്ന പേരിൽ പ്രസിദ്ധീകരിക്കുകയും പിന്നീട് 2005-ൽ ISO/IEC 9834-8:2005 എന്ന ഭാഗമായും പുനഃപരിശോധിക്കപ്പെടുകയും ചെയ്തു.
UUID ചരിത്രത്തിലെ പ്രധാന സംഭവങ്ങൾ:
കാലക്രമേണ, UUIDകൾ വിതരണ സിസ്റ്റങ്ങൾക്കും ഡാറ്റാബേസ് ഡിസൈനിനും അനിവാര്യമായ ഒരു ഉപകരണമാകുകയും, വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളും പ്ലാറ്റ്ഫോമുകളും തമ്മിൽ വിവിധ നടപ്പിലാക്കലുകളും അനുസൃതമാക്കുകയും ചെയ്തു.
വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ UUIDകൾ സൃഷ്ടിക്കുന്നതിന് ഉദാഹരണങ്ങൾ ഇവിടെ നൽകുന്നു:
1import uuid
2
3## പതിപ്പ് 4 (രണ്ടാമത്തെ) UUID സൃഷ്ടിക്കുക
4random_uuid = uuid.uuid4()
5print(f"പതിപ്പ് 4 UUID: {random_uuid}")
6
7## പതിപ്പ് 1 (സമയ അടിസ്ഥാനമാക്കിയ) UUID സൃഷ്ടിക്കുക
8time_based_uuid = uuid.uuid1()
9print(f"പതിപ്പ് 1 UUID: {time_based_uuid}")
101const { v1: uuidv1, v4: uuidv4 } = require('uuid');
2
3// പതിപ്പ് 4 (രണ്ടാമത്തെ) UUID സൃഷ്ടിക്കുക
4const randomUuid = uuidv4();
5console.log(`പതിപ്പ് 4 UUID: ${randomUuid}`);
6
7// പതിപ്പ് 1 (സമയ അടിസ്ഥാനമാക്കിയ) UUID സൃഷ്ടിക്കുക
8const timeBasedUuid = uuidv1();
9console.log(`പതിപ്പ് 1 UUID: ${timeBasedUuid}`);
101import java.util.UUID;
2
3public class UuidGenerator {
4 public static void main(String[] args) {
5 // പതിപ്പ് 4 (രണ്ടാമത്തെ) UUID സൃഷ്ടിക്കുക
6 UUID randomUuid = UUID.randomUUID();
7 System.out.println("പതിപ്പ് 4 UUID: " + randomUuid);
8
9 // പതിപ്പ് 1 (സമയ അടിസ്ഥാനമാക്കിയ) UUID സൃഷ്ടിക്കുക
10 UUID timeBasedUuid = UUID.fromString(new com.eaio.uuid.UUID().toString());
11 System.out.println("പതിപ്പ് 1 UUID: " + timeBasedUuid);
12 }
13}
141require 'securerandom'
2
3## പതിപ്പ് 4 (രണ്ടാമത്തെ) UUID സൃഷ്ടിക്കുക
4random_uuid = SecureRandom.uuid
5puts "പതിപ്പ് 4 UUID: #{random_uuid}"
6
7## Ruby-യിൽ പതിപ്പ് 1 UUIDകൾക്കുള്ള ഒരു ബിൽറ്റ് ഇൻ രീതിയില്ല
8## അതിനായി 'uuidtools' പോലുള്ള ഒരു ജെം ഉപയോഗിക്കേണ്ടതുണ്ട്
91<?php
2// പതിപ്പ് 4 (രണ്ടാമത്തെ) UUID സൃഷ്ടിക്കുക
3$randomUuid = sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
4 mt_rand(0, 0xffff), mt_rand(0, 0xffff),
5 mt_rand(0, 0xffff),
6 mt_rand(0, 0x0fff) | 0x4000,
7 mt_rand(0, 0x3fff) | 0x8000,
8 mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
9);
10echo "പതിപ്പ് 4 UUID: " . $randomUuid . "\n";
11
12// PHP-യിൽ പതിപ്പ് 1 UUIDകൾക്കുള്ള ഒരു ബിൽറ്റ് ഇൻ രീതിയില്ല
13// അതിനായി 'ramsey/uuid' പോലുള്ള ഒരു ലൈബ്രറി ഉപയോഗിക്കേണ്ടതുണ്ട്
14?>
15നിങ്ങളുടെ പ്രവർത്തനത്തിന് ഉപയോഗപ്പെടുന്ന കൂടുതൽ ഉപകരണങ്ങൾ കണ്ടെത്തുക.