KSUID જનરેટર

પરિચય

KSUID (K-Sortable Unique IDentifier) એ એક અનન્ય ઓળખપત્ર ફોર્મેટ છે જે પરંપરાગત UUID (Universally Unique Identifier) અને અન્ય ઓળખપત્ર સિસ્ટમ્સની તુલનામાં અનેક લાભો આપે છે. આ સાધન તમને KSUIDs ઝડપથી અને સરળતાથી જનરેટ કરવાની મંજૂરી આપે છે.

KSUID શું છે?

KSUID એ 20-બાઇટનું સોર્ટેબલ ઓળખપત્ર છે જેમાં સામેલ છે:

1. 32-બિટનું ટાઈમસ્ટેમ્પ (4 બાઇટ)
2. 16 બાઇટની રેન્ડમનેસ

જ્યારે તેને સ્ટ્રિંગ તરીકે રજૂ કરવામાં આવે છે, KSUIDને બેઝ62માં એન્કોડ કરવામાં આવે છે અને તે 27 અક્ષરો લાંબું છે.

KSUIDની રચના

KSUIDની રચનાને નીચે મુજબ વિભાજિત કરી શકાય છે:

1. ટાઈમસ્ટેમ્પ (4 બાઇટ): આ યુનિક્સ ઇપોચ (1 જાન્યુઆરી 1970, 00:00 UTC) પછીના સેકન્ડની સંખ્યા દર્શાવે છે. ટાઈમસ્ટેમ્પ KSUIDsને જનરેશન સમય દ્વારા લગભગ સોર્ટેબલ બનાવે છે.

2. રેન્ડમ ઘટક (16 બાઇટ): આ એક ક્રિપ્ટોગ્રાફિક રીતે સુરક્ષિત રેન્ડમ નંબર છે જે સુનિશ્ચિત કરે છે કે એક જ સેકન્ડમાં અનેક KSUIDs જનરેટ કરવામાં આવે ત્યારે પણ અનન્યતા રહે છે.

3. બેઝ62 એન્કોડિંગ: સંયુક્ત 20 બાઇટ (ટાઈમસ્ટેમ્પ + રેન્ડમ) પછી બેઝ62 (A-Z, a-z, 0-9) નો ઉપયોગ કરીને એન્કોડ કરવામાં આવે છે જેથી અંતિમ 27-અક્ષરનું સ્ટ્રિંગ બને.

KSUID ફોર્મ્યુલા

KSUIDને ગણિતીય રીતે નીચે મુજબ રજૂ કરી શકાય છે:

$KSUID = Base62(T || R)$

જ્યાં:

• $T$ 32-બિટનું ટાઈમસ્ટેમ્પ છે
• $R$ 128-બિટનું રેન્ડમ ઘટક છે
• $||$ જોડાણ દર્શાવે છે

ટાઈમસ્ટેમ્પ $T$ ની ગણતરી આ રીતે થાય છે:

T = \text{floor}(\text{current_time} - \text{KSUID_epoch})

જ્યાં KSUID_epoch 1400000000 (2014-05-13T16:53:20Z) છે.

KSUIDની રચના આકૃતિ

KSUIDs માટેના ઉપયોગ કેસ

KSUIDs ખાસ કરીને નીચેના દ્રષ્ટિકોણોમાં ઉપયોગી છે:

1. વિતરિત સિસ્ટમો: જ્યારે તમને અનેક સર્વરો અથવા સેવાઓમાં અનન્ય ઓળખપત્રોની જરૂર હોય છે જે કોઈ સમન્વય વિના હોય.

2. સમય-સોર્ટેબલ ડેટા: જ્યારે તમે ડેટાને સર્જન સમય દ્વારા સોર્ટ કરવા માંગતા હોવ છો, જ્યારે અલગ ટાઈમસ્ટેમ્પ સંગ્રહવાની જરૂર નથી.

3. ડેટાબેસ કી: ડેટાબેસમાં પ્રાથમિક કી તરીકે, ખાસ કરીને વિતરિત ડેટાબેસમાં જ્યાં ઓટો-ઇન્ક્રિમેન્ટિંગ પૂર્ણાંક યોગ્ય નથી.

4. URL-સુરક્ષિત ઓળખપત્રો: વેબ એપ્લિકેશન્સમાં સ્રોતો માટે ટૂંકા, અનન્ય, URL-સુરક્ષિત ઓળખપત્રો બનાવવા માટે.

5. લોગ સંકલન: માઇક્રોસર્વિસ આર્કિટેક્ચરમાં વિવિધ સેવાઓમાં લોગ એન્ટ્રીઓને સંકલિત કરવા માટે.

KSUIDsના લાભો

KSUIDs અન્ય ઓળખપત્ર સિસ્ટમ્સની તુલનામાં અનેક લાભો આપે છે:

1. સોર્ટેબલ: UUIDsની તુલનામાં, KSUIDs ક્રોનોલોજીકલ રીતે સોર્ટ કરી શકાય છે, જે ડેટાબેસ ઈન્ડેક્સિંગ અને લોગ વિશ્લેષણ માટે ઉપયોગી છે.

2. કોઈ સમન્વયની જરૂર નથી: ઓટો-ઇન્ક્રિમેન્ટિંગ IDની તુલનામાં, KSUIDs વિભિન્ન સર્વરો દ્વારા સ્વતંત્ર રીતે જનરેટ કરી શકાય છે, જે ટકરાવના જોખમ વિના.

3. સંકુચિત પ્રતિનિધિત્વ: 27 અક્ષરોમાં KSUIDsને સ્ટ્રિંગ તરીકે રજૂ કરવાથી UUIDsની તુલનામાં વધુ સંકુચિત છે.

4. ટાઈમસ્ટેમ્પ એમ્બેડેડ: એમ્બેડેડ ટાઈમસ્ટેમ્પ સમય આધારિત સોર્ટિંગ અને ફિલ્ટરિંગ માટેની જરૂરિયાત વિના ઉપયોગી છે.

5. URL-સુરક્ષિત: બેઝ62 એન્કોડિંગ KSUIDsને URLsમાં ઉપયોગ માટે સુરક્ષિત બનાવે છે કોઈ વધારાની એન્કોડિંગ વિના.

6. ટકરાવની સંભાવના ઘટાડવી: 16-બાઇટની રેન્ડમ ઘટક ટકરાવની શક્યતાઓને અત્યંત ઓછું કરે છે, ભલે જ ઉચ્ચ જનરેશન દર હોય.

આ જનરેટરનો ઉપયોગ કેવી રીતે કરવો

1. જો જરૂરી હોય તો કોઈ વધારાના પેરામીટર્સ દાખલ કરો (ઉદાહરણ તરીકે, કસ્ટમ ટાઈમસ્ટેમ્પ).
2. નવા KSUID બનાવવા માટે "KSUID જનરેટ કરો" બટન પર ક્લિક કરો.
3. જનરેટ થયેલ KSUID આઉટપુટ ફીલ્ડમાં દર્શાવવામાં આવશે.
4. તમે પગલાં 1-3 પુનરાવર્તિત કરીને અનેક KSUIDs જનરેટ કરી શકો છો.
5. દરેક KSUIDને ક્લિપબોર્ડમાં નકલ કરવા માટે "કોપી" બટનનો ઉપયોગ કરો.
6. વૈકલ્પિક રીતે, જનરેટ થયેલ KSUIDsની યાદી ડાઉનલોડ કરવા માટે "નિકાસ" સુવિધાનો ઉપયોગ કરો.

યાદ રાખો કે દરેક KSUID અનન્ય છે અને તેને માત્ર એક જ વાર ઉપયોગમાં લેવો જોઈએ. જ્યારે પણ તમને અનન્ય ઓળખપત્રની જરૂર હોય ત્યારે નવા KSUIDને જનરેટ કરો.

કોડ ઉદાહરણો

અહીં વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં KSUIDs જનરેટ કરવાની ઉદાહરણો છે:

1## પાયથન
2import ksuid
3
4new_id = ksuid.ksuid()
5print(f"જનરેટ થયેલ KSUID: {new_id}")
6

1// જાવાસ્ક્રિપ્ટ
2const { ksuid } = require('ksuid')
3
4const newId = ksuid()
5console.log(`જનરેટ થયેલ KSUID: ${newId}`)
6

1// જાવા
2import com.github.ksuid.KsuidGenerator;
3
4public class KsuidExample {
5    public static void main(String[] args) {
6        String newId = KsuidGenerator.generate();
7        System.out.println("જનરેટ થયેલ KSUID: " + newId);
8    }
9}
10

1// C++
2#include <iostream>
3#include <ksuid/ksuid.hpp>
4
5int main() {
6    ksuid::Ksuid newId = ksuid::Ksuid::generate();
7    std::cout << "જનરેટ થયેલ KSUID: " << newId.string() << std::endl;
8    return 0;
9}
10

1## રૂબી
2require 'ksuid'
3
4new_id = KSUID.new
5puts "જનરેટ થયેલ KSUID: #{new_id}"
6

1// PHP
2<?php
3require_once 'vendor/autoload.php';
4
5use Tuupola\KsuidFactory;
6
7$factory = new KsuidFactory();
8$newId = $factory->create();
9echo "જનરેટ થયેલ KSUID: " . $newId . "\n";
10?>
11

1// ગો
2package main
3
4import (
5    "fmt"
6    "github.com/segmentio/ksuid"
7)
8
9func main() {
10    newId := ksuid.New()
11    fmt.Printf("જનરેટ થયેલ KSUID: %s\n", newId.String())
12}
13

1// સ્વિફ્ટ
2import KSUID
3
4let newId = KSUID()
5print("જનરેટ થયેલ KSUID: \(newId)")
6

સંદર્ભો

1. સેગમેન્ટનું KSUID GitHub રિપોઝિટરી: https://github.com/segmentio/ksuid
2. "સારા અનન્ય ઓળખપત્રો જનરેટ કરવું" પીટર બોર્ગોન દ્વારા: https://peter.bourgon.org/blog/2019/05/20/generating-good-unique-ids.html
3. KSUID સ્પષ્ટીકરણ: https://github.com/segmentio/ksuid/blob/master/README.md