யூஎல்ஐடி உருவாக்கி

ULID உருவாக்கி

அறிமுகம்

ULID (உலகளாவிய தனித்துவமான வரிசைப்படுத்தக்கூடிய அடையாளம்) என்பது ஒரு தனித்துவமான அடையாளமாகும், இது ஒரு காலமோடு மற்றும் சீரற்ற தரவோடு இணைந்து 26-அகர எழுத்து வரிசையை உருவாக்குகிறது. ULIDs, வரிசைப்படுத்தக்கூடியதாகவும், அதிக அளவிலான தனித்துவம் மற்றும் சீரற்ற தன்மையை பராமரிக்கவும் வடிவமைக்கப்பட்டுள்ளது.

ULID-ன் கட்டமைப்பு

ULID இரண்டு முக்கிய பகுதிகளை கொண்டுள்ளது:

1. காலம் (10 எழுத்துகள்): முதல் 10 எழுத்துகள் யூனிக்ஸ் எபொச் (1970-01-01) க்கு பிறகு மில்லி விநாடிகளில் உள்ள நேரத்தை பிரதிநிதித்துவப்படுத்துகின்றன.
2. சீரற்ற தன்மை (16 எழுத்துகள்): மீதமுள்ள 16 எழுத்துகள் குறியாக்கமாகவும், பாதுகாப்பான சீரற்ற தரவுகளை உருவாக்குவதற்காக உருவாக்கப்படுகின்றன.

முடிவில் கிடைக்கும் 26-அகர எழுத்து வரிசை குரோக்க்ஃபோர்டின் அடிப்படையில் 32 அகரவரிசையை (0-9 மற்றும் A-Z, I, L, O மற்றும் U-வை தவிர்த்து) பயன்படுத்தி குறியாக்கப்படுகிறது.

சூத்திரம்

ULID உருவாக்குவதற்கான படிகள்:

1. 48-பிட் காலத்தை (யூனிக்ஸ் எபொச் க்கு மில்லி விநாடிகள்) உருவாக்கவும்.
2. 80 பிட் பாதுகாப்பான சீரற்ற தரவை உருவாக்கவும்.
3. குரோக்க்ஃபோர்டின் அடிப்படையில் 32 குறியாக்கத்தைப் பயன்படுத்தி 128 பிட் ஒன்றிணைக்கவும்.

கணக்கீடு

ULID உருவாக்கி கீழ்காணும் படிகளை மேற்கொள்கிறது:

1. தற்போதைய நேரத்தை மில்லி விநாடிகளில் பெறவும்.
2. ஒரு பாதுகாப்பான சீரற்ற எண் உருவாக்கி 10 சீரற்ற பைட்டுகளை (80 பிட்கள்) உருவாக்கவும்.
3. காலம் மற்றும் சீரற்ற தரவை 128-பிட் முழு எண்ணாக இணைக்கவும்.
4. 128-பிட் முழு எண்ணை குரோக்க்ஃபோர்டின் அடிப்படையில் 32 குறியாக்கத்தில் குறியாக்கிக்கவும்.

பயன்பாட்டு வழிகள்

ULIDs பல்வேறு சூழ்நிலைகளில் பயனுள்ளதாக உள்ளன, அவை:

1. தரவுத்தள விசைகள்: ULIDs, தரவுத்தள பதிவுகளுக்கான தனித்துவமான அடையாளங்களாக பயன்படுத்தப்படலாம், தனித்துவம் மற்றும் வரிசைப்படுத்துதல்களை உறுதிப்படுத்துகிறது.
2. பரவலான அமைப்புகள்: பரவலான சூழ்நிலைகளில், ULIDs, மையமில்லாமல் உருவாக்கப்படலாம்.
3. பதிவு மற்றும் தடயங்கள்: ULIDs, பதிவு பதிவுகளை அல்லது நிகழ்வுகளை அடையாளம் காண பயன்படுத்தப்படலாம், வரிசைப்படுத்தக்கூடிய மற்றும் தனித்துவமான அடையாளத்தை வழங்குகிறது.
4. URL-க்கு நட்பு அடையாளங்கள்: ULIDs URL-க்கு பாதுகாப்பானவை மற்றும் இணைய பயன்பாடுகளில் URL-க்களில் அடையாளங்களாகப் பயன்படுத்தப்படலாம்.

மாற்றுகள்

ULIDs பல்வேறு பயன்பாடுகளுக்கு ஏற்றதாக இருந்தாலும், பரிசீலிக்கவேண்டிய பிற தனித்துவமான அடையாள அமைப்புகள் உள்ளன:

1. UUID (உலகளாவிய தனித்துவமான அடையாளம்): காலம் கூறுகளை உள்ளடக்காத 128-பிட் அடையாளம்.
2. KSUID (K-வரிசைப்படுத்தக்கூடிய தனித்துவமான அடையாளம்): ULID-க்கு ஒத்ததாக இருப்பினும், வேறு காலம் குறியாக்கம்.
3. ஸ்னோஃப்ளேக் அடையாளம்: ட்விட்டரின் பரவலான தனித்துவமான அடையாள உருவாக்கும் அமைப்பு, இது காலம் மற்றும் வேலைக்காரர் அடையாளத்தை உள்ளடக்குகிறது.

வரலாறு

ULIDs 2016-ல் அலிசைன் ஃபீரஸ்டா மூலம் UUID-க்களுக்கு மாற்றமாக அறிமுகப்படுத்தப்பட்டது. அவை, UUID-க்களின் சில வரம்புகளை, குறிப்பாக வரிசைப்படுத்துதலும், வாசிக்கவும், முகாமை செய்யவும் வடிவமைக்கப்பட்டன. ULID விவரக்குறிப்பு அதன் அறிமுகத்திலிருந்து நிலையானதாகவே உள்ளது, பல்வேறு நிரலாக்க மொழிகளில் பல்வேறு செயலாக்கங்கள் கிடைக்கின்றன.

எடுத்துக்காட்டுகள்

கீழே உள்ள நிரல் எடுத்துக்காட்டுகள், பல்வேறு நிரலாக்க மொழிகளில் ULIDs உருவாக்குவதற்கான உதாரணங்களை வழங்குகின்றன:

// ஜாவாஸ்கிரிப்ட் செயலாக்கம்
function generateULID() {
  const timestamp = Date.now().toString(36).padStart(10, '0');
  const randomness = crypto.getRandomValues(new Uint8Array(16))
    .reduce((acc, byte) => acc + byte.toString(36).padStart(2, '0'), '');
  return (timestamp + randomness).toUpperCase();
}

console.log(generateULID());

## பைதான் செயலாக்கம்
import time
import secrets
import base64

def generate_ulid():
    timestamp = int(time.time() * 1000).to_bytes(6, byteorder="big")
    randomness = secrets.token_bytes(10)
    return base64.b32encode(timestamp + randomness).decode("ascii").lower()

print(generate_ulid())

// ஜாவா செயலாக்கம்
import java.security.SecureRandom;
import java.time.Instant;

public class ULIDGenerator {
    private static final SecureRandom random = new SecureRandom();
    private static final char[] ENCODING_CHARS = "0123456789ABCDEFGHJKMNPQRSTVWXYZ".toCharArray();

    public static String generateULID() {
        long timestamp = Instant.now().toEpochMilli();
        byte[] randomness = new byte[10];
        random.nextBytes(randomness);

        StringBuilder result = new StringBuilder();
        // காலத்தை குறியாக்கவும்
        for (int i = 9; i >= 0; i--) {
            result.append(ENCODING_CHARS[(int) (timestamp % 32)]);
            timestamp /= 32;
        }
        // சீரற்ற தன்மையை குறியாக்கவும்
        for (byte b : randomness) {
            result.append(ENCODING_CHARS[b & 31]);
        }
        return result.toString();
    }

    public static void main(String[] args) {
        System.out.println(generateULID());
    }
}

இந்த எடுத்துக்காட்டுகள், ஜாவாஸ்கிரிப்ட், பைதான் மற்றும் ஜாவாவில் ULIDs உருவாக்குவதற்கான முறைகளை விளக்குகின்றன. நீங்கள் இந்த செயல்பாடுகளை உங்கள் குறிப்பிட்ட தேவைகளுக்கு ஏற்றவாறு மாற்றலாம் அல்லது தனித்துவமான அடையாளங்களை தேவைப்படும் பெரிய அமைப்புகளில் ஒருங்கிணைக்கலாம்.

மேற்கோள்கள்

1. "ULID விவரக்குறிப்பு." GitHub, https://github.com/ulid/spec. அணுகப்பட்டது 2 ஆக. 2024.
2. "குரோக்க்ஃபோர்டின் அடிப்படையில் 32 குறியாக்கம்." அடிப்படையில் 32 குறியாக்கம், http://www.crockford.com/base32.html. அணுகப்பட்டது 2 ஆக. 2024.
3. "UUID vs ULID." Stack Overflow, https://stackoverflow.com/questions/54222235/uuid-vs-ulid. அணுகப்பட்டது 2 ஆக. 2024.