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 ਬਣਾਉਣ ਲਈ "Generate KSUID" ਬਟਨ 'ਤੇ ਕਲਿਕ ਕਰੋ।
3. ਜਨਰੇਟ ਕੀਤਾ ਗਿਆ KSUID ਨਿਕਾਸ ਖੇਤਰ ਵਿੱਚ ਦਰਸਾਇਆ ਜਾਵੇਗਾ।
4. ਤੁਸੀਂ ਕਈ KSUIDs ਜਨਰੇਟ ਕਰਨ ਲਈ ਕਦਮ 1-3 ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਰਹਿ ਸਕਦੇ ਹੋ।
5. ਹਰ KSUID ਦੇ ਨਾਲ "Copy" ਬਟਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਆਪਣੇ ਕਲਿੱਪਬੋਰਡ 'ਤੇ ਕਾਪੀ ਕਰੋ।
6. ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ, ਜਨਰੇਟ ਕੀਤੇ KSUIDs ਦੀ ਸੂਚੀ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ "Export" ਫੀਚਰ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਯਾਦ ਰੱਖੋ ਕਿ ਹਰ KSUID ਵਿਲੱਖਣ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਿਰਫ ਇੱਕ ਵਾਰ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ। ਜਦੋਂ ਵੀ ਤੁਹਾਨੂੰ ਇੱਕ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਦੀ ਲੋੜ ਹੋਵੇ, ਨਵਾਂ KSUID ਜਨਰੇਟ ਕਰੋ।

ਕੋਡ ਉਦਾਹਰਣ

ਇੱਥੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ KSUIDs ਜਨਰੇਟ ਕਰਨ ਦੇ ਉਦਾਹਰਣ ਹਨ:

1## ਪਾਇਥਨ
2import ksuid
3
4new_id = ksuid.ksuid()
5print(f"Generated KSUID: {new_id}")
6

1// ਜਾਵਾਸਕ੍ਰਿਪਟ
2const { ksuid } = require('ksuid')
3
4const newId = ksuid()
5console.log(`Generated 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("Generated 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 << "Generated KSUID: " << newId.string() << std::endl;
8    return 0;
9}
10

1## ਰੂਬੀ
2require 'ksuid'
3
4new_id = KSUID.new
5puts "Generated 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 "Generated 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("Generated KSUID: %s\n", newId.String())
12}
13

1// ਸਵਿਫਟ
2import KSUID
3
4let newId = KSUID()
5print("Generated KSUID: \(newId)")
6

ਹਵਾਲੇ

1. ਸੈਗਮੈਂਟ ਦਾ KSUID ਗਿਟਹੱਬ ਰਿਪੋਜ਼ਿਟਰੀ: https://github.com/segmentio/ksuid
2. "Generating good unique identifiers" ਪੀਟਰ ਬੌਰਗਨ ਦੁਆਰਾ: https://peter.bourgon.org/blog/2019/05/20/generating-good-unique-ids.html
3. KSUID ਵਿਸ਼ੇਸ਼ਤਾ: https://github.com/segmentio/ksuid/blob/master/README.md