CUID ਜਨਰੇਟਰ

CUID ਜਨਰੇਟਰ

ਜਾਣ-ਪਛਾਣ

CUID (Collision-resistant Unique IDentifier) ਇੱਕ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਹੈ ਜੋ ਟਕਰਾਅ-ਰੋਧੀ, ਅੱਡੇ-ਪੈਮਾਨੇ ਤੇ, ਅਤੇ ਕ੍ਰਮਬੱਧ ਤੌਰ ਤੇ ਛਾਂਟਣ ਲਈ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਗਿਆ ਹੈ। CUID ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਵੰਡੇ ਗਏ ਸਿਸਟਮਾਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੁੰਦੇ ਹਨ ਜਿੱਥੇ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਬਿਨਾਂ ਨੋਡਾਂ ਦੇ ਵਿਚਕਾਰ ਸਹਿਯੋਗ ਦੇ ਜਨਰੇਟ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

CUID ਦੀ ਸੰਰਚਨਾ

CUID ਆਮ ਤੌਰ 'ਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਗਏ ਘਟਕਾਂ ਦਾ ਸਮਾਵੇਸ਼ ਕਰਦਾ ਹੈ:

1. ਟਾਈਮਸਟੈਂਪ: ਵਰਤਮਾਨ ਸਮੇਂ ਦੀ ਪ੍ਰਤੀਨਿਧੀ
2. ਕਾਊਂਟਰ: ਇੱਕ ਲਗਾਤਾਰ ਕਾਊਂਟਰ ਜੋ ਇੱਕੋ ਮਿਲੀਸੈਕੰਡ ਦੇ ਅੰਦਰ ਵਿਲੱਖਣਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ
3. ਕਲਾਇੰਟ ਫਿੰਗਰਪ੍ਰਿੰਟ: CUID ਜਨਰੇਟ ਕਰਨ ਵਾਲੀ ਮਸ਼ੀਨ ਜਾਂ ਪ੍ਰਕਿਰਿਆ ਲਈ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ
4. ਬੇਰੁਖਾ ਘਟਕ: ਟਕਰਾਅ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਹੋਰ ਘਟਾਉਣ ਲਈ ਵਾਧੂ ਬੇਰੁਖਾ ਡਾਟਾ

ਸਹੀ ਸੰਰਚਨਾ CUID ਦੇ ਕਾਰਜਨਵਿਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰ ਸਕਦੀ ਹੈ, ਪਰ ਇਹ ਘਟਕ ਇਕੱਠੇ ਹੋ ਕੇ ਇੱਕ ਵਿਲੱਖਣ ਅਤੇ ਛਾਂਟਣ ਯੋਗ ਪਛਾਣਕਰਤਾ ਬਣਾਉਂਦੇ ਹਨ।

ਇੱਕ ਆਮ CUID ਸੰਰਚਨਾ ਦਾ ਵਿਜ਼ੂਅਲ ਪ੍ਰਤੀਨਿਧੀ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ:

CUID ਕਿਵੇਂ ਜਨਰੇਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ

CUID ਇੱਕ ਸਮੇਂ-ਅਧਾਰਿਤ ਅਤੇ ਬੇਰੁਖਾ ਘਟਕਾਂ ਦੇ ਸੰਯੋਜਨ ਦੇ ਨਾਲ ਜਨਰੇਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਪ੍ਰਕਿਰਿਆ ਆਮ ਤੌਰ 'ਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਗਏ ਕਦਮਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ:

1. ਵਰਤਮਾਨ ਟਾਈਮਸਟੈਂਪ ਪ੍ਰਾਪਤ ਕਰਨਾ
2. ਇੱਕ ਕਾਊਂਟਰ ਨੂੰ ਵਧਾਉਣਾ (ਜੋ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਰੀਸੈਟ ਹੁੰਦਾ ਹੈ)
3. ਇੱਕ ਕਲਾਇੰਟ ਫਿੰਗਰਪ੍ਰਿੰਟ ਜਨਰੇਟ ਕਰਨਾ (ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਸੈਸ਼ਨ ਜਾਂ ਐਪਲੀਕੇਸ਼ਨ ਸ਼ੁਰੂ ਕਰਨ ਦੇ ਸਮੇਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)
4. ਬੇਰੁਖਾ ਡਾਟਾ ਸ਼ਾਮਲ ਕਰਨਾ
5. ਇਹਨਾਂ ਤੱਤਾਂ ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਫਾਰਮੈਟ ਵਿੱਚ ਜੋੜਨਾ

ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਾਪਤ CUID ਆਮ ਤੌਰ 'ਤੇ ਅੱਖਰਾਂ ਅਤੇ ਨੰਬਰਾਂ ਦੇ ਸਤਰ ਵਜੋਂ ਦਰਸ਼ਾਇਆ ਜਾਂਦਾ ਹੈ।

ਫਾਇਦੇ ਅਤੇ ਵਰਤੋਂ ਦੇ ਕੇਸ

CUID ਹੋਰ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਪ੍ਰਣਾਲੀਆਂ ਦੇ ਮੁਕਾਬਲੇ ਕਈ ਫਾਇਦੇ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ:

1. ਟਕਰਾਅ-ਰੋਧੀ: ਟਾਈਮਸਟੈਂਪ, ਕਾਊਂਟਰ, ਅਤੇ ਬੇਰੁਖਾ ਡਾਟਾ ਦੇ ਸੰਯੋਜਨ ਨਾਲ ਟਕਰਾਅ ਦੀ ਸੰਭਾਵਨਾ ਬਹੁਤ ਹੀ ਘੱਟ ਹੁੰਦੀ ਹੈ, ਭਾਵੇਂ ਵੰਡੇ ਗਏ ਸਿਸਟਮਾਂ ਵਿੱਚ ਵੀ।
2. ਅੱਡੇ-ਪੈਮਾਨੇ ਤੇ: CUID ਬਿਨਾਂ ਸਹਿਯੋਗ ਦੇ ਕਈ ਮਸ਼ੀਨਾਂ 'ਤੇ ਸੁਤੰਤਰਤਾ ਨਾਲ ਜਨਰੇਟ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।
3. ਕ੍ਰਮਬੱਧ ਛਾਂਟਣਾ: ਟਾਈਮਸਟੈਂਪ ਘਟਕ CUID ਦੀਆਂ ਕ੍ਰਮਬੱਧ ਛਾਂਟਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
4. URL-ਮਿੱਤਰ: CUID ਆਮ ਤੌਰ 'ਤੇ URL-ਸੁਰੱਖਿਅਤ ਅੱਖਰਾਂ ਦੇ ਸਮੂਹ ਤੋਂ ਬਣੇ ਹੁੰਦੇ ਹਨ।

CUID ਦੇ ਆਮ ਵਰਤੋਂ ਦੇ ਕੇਸਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ਡੇਟਾਬੇਸ ਪ੍ਰਾਈਮਰੀ ਕੀ
• ਵੰਡੇ ਗਏ ਸਿਸਟਮਾਂ ਜਿੱਥੇ ਵਿਲੱਖਣ ID ਬਹੁਤ ਸਾਰੀਆਂ ਨੋਡਾਂ 'ਤੇ ਜਨਰੇਟ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ
• ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਸੈਸ਼ਨ ID
• ਵਿਸ਼ਲੇਸ਼ਣ ਸਿਸਟਮਾਂ ਵਿੱਚ ਘਟਨਾਵਾਂ ਦੀ ਪਛਾਣ
• ਕਲਾਉਡ ਸਟੋਰੇਜ ਸਿਸਟਮਾਂ ਵਿੱਚ ਫਾਈਲ ਜਾਂ ਸਰੋਤਾਂ ਦੇ ਨਾਮਕਰਨ

ਕੋਡ ਉਦਾਹਰਨਾਂ

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

// ਜਾਵਾਸਕ੍ਰਿਪਟ (cuid ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
const cuid = require('cuid');
const id = cuid();
console.log(id);

## ਪਾਇਥਨ (cuid ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
import cuid
id = cuid.cuid()
print(id)

## ਰੂਬੀ (cuid ਜੇਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
require 'cuid'
id = Cuid::generate
puts id

// ਜਾਵਾ (com.github.f4b6a3.cuid ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
import com.github.f4b6a3.cuid.Cuid;

public class CuidExample {
    public static void main(String[] args) {
        String id = Cuid.createCuid();
        System.out.println(id);
    }
}

// C# (Cuid.Net NuGet ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
using Cuid;

class Program
{
    static void Main(string[] args)
    {
        string id = CuidGenerator.Generate();
        Console.WriteLine(id);
    }
}

// PHP (endyjasmi/cuid ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
<?php
require 'vendor/autoload.php';
use Endyjasmi\Cuid\Cuid;

$id = Cuid::make();
echo $id;

// Go (github.com/lucsky/cuid ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
package main

import (
    "fmt"
    "github.com/lucsky/cuid"
)

func main() {
    id := cuid.New()
    fmt.Println(id)
}

// ਸਵਿਫਟ (CUID ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
import CUID

let id = CUID()
print(id)

// C++ (ਇੱਕ ਕਸਟਮ ਕਾਰਜਨਵਿਤੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
#include <iostream>
#include <chrono>
#include <random>
#include <sstream>
#include <iomanip>

std::string generateCUID() {
    auto now = std::chrono::system_clock::now();
    auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
    auto value = now_ms.time_since_epoch();
    long duration = value.count();

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, 35);

    std::stringstream ss;
    ss << 'c';
    ss << std::hex << std::setfill('0') << std::setw(8) << duration;
    for (int i = 0; i < 8; i++) {
        int r = dis(gen);
        ss << (char)(r < 10 ? '0' + r : 'a' + r - 10);
    }
    return ss.str();
}

int main() {
    std::string id = generateCUID();
    std::cout << id << std::endl;
    return 0;
}

% MATLAB (ਇੱਕ ਕਸਟਮ ਕਾਰਜਨਵਿਤੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
function id = generateCUID()
    timestamp = dec2hex(round(posixtime(datetime('now'))*1000), 8);
    random = '';
    for i = 1:8
        random = [random char(randi([48 57 97 122]))];
    end
    id = ['c' timestamp random];
end

% ਵਰਤੋਂ
id = generateCUID();
disp(id);

## R (ਇੱਕ ਕਸਟਮ ਕਾਰਜਨਵਿਤੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
library(lubridate)

generate_cuid <- function() {
  timestamp <- format(as.numeric(now()) * 1000, scientific = FALSE)
  timestamp <- substr(timestamp, 1, 8)
  random <- paste0(sample(c(0:9, letters[1:6]), 8, replace = TRUE), collapse = "")
  paste0("c", timestamp, random)
}

## ਵਰਤੋਂ
id <- generate_cuid()
print(id)

' Excel VBA (ਇੱਕ ਕਸਟਮ ਕਾਰਜਨਵਿਤੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ)
Function GenerateCUID() As String
    Dim timestamp As String
    Dim random As String
    Dim i As Integer
    
    timestamp = Right("00000000" & Hex(CLng(CDbl(Now()) * 86400000)), 8)
    
    For i = 1 To 8
        random = random & Mid("0123456789abcdef", Int(Rnd() * 16) + 1, 1)
    Next i
    
    GenerateCUID = "c" & timestamp & random
End Function

' ਇੱਕ ਸੈੱਲ ਵਿੱਚ ਵਰਤੋਂ
'=GenerateCUID()

ਇਤਿਹਾਸ ਅਤੇ ਵਿਕਾਸ

CUID ਪਹਿਲਾਂ 2012 ਵਿੱਚ ਐਰਿਕ ਐਲਿਟ ਦੁਆਰਾ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਸੀ ਜਿਵੇਂ ਕਿ ਵੰਡੇ ਗਏ ਸਿਸਟਮਾਂ ਵਿੱਚ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਜਨਰੇਟ ਕਰਨ ਦੀ ਸਮੱਸਿਆ ਦਾ ਹੱਲ। ਇਹ ਧਾਰਨਾ ਟਵਿੱਟਰ ਦੇ ਸਨੋਫਲੇਕ ID ਸਿਸਟਮ ਤੋਂ ਪ੍ਰੇਰਿਤ ਸੀ ਪਰ ਇਹ ਵੱਖ-ਵੱਖ ਪਲੇਟਫਾਰਮਾਂ 'ਤੇ ਬਹੁਤ ਆਸਾਨੀ ਨਾਲ ਲਾਗੂ ਅਤੇ ਵਰਤਣ ਲਈ ਡਿਜ਼ਾਇਨ ਕੀਤੀ ਗਈ ਸੀ।

CUID ਦੇ ਵਿਕਾਸ ਨੂੰ ਇੱਕ ਸਧਾਰਣ, ਟਕਰਾਅ-ਰੋਧੀ ID ਸਿਸਟਮ ਦੀ ਲੋੜ ਦੇ ਨਾਲ ਚਲਾਇਆ ਗਿਆ ਜੋ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਵਾਤਾਵਰਨਾਂ ਵਿੱਚ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ। ਐਲਿਟ ਦਾ ਲਕਸ਼ ਸੀ ਕਿ ਇੱਕ ਐਸਾ ਸਿਸਟਮ ਬਣਾਇਆ ਜਾਵੇ ਜੋ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਆਸਾਨ ਹੋਵੇ, ਕੇਂਦਰੀ ਸਹਿਯੋਗ ਦੀ ਲੋੜ ਨਾ ਹੋਵੇ, ਅਤੇ ਅੱਡੇ-ਪੈਮਾਨੇ ਤੇ ਸਕੇਲ ਹੋ ਸਕੇ।

ਇਸਦੇ ਆਰੰਭ ਤੋਂ, CUID ਨੇ ਕਈ ਪੜਾਵਾਂ ਅਤੇ ਸੁਧਾਰਾਂ ਦਾ ਸਾਹਮਣਾ ਕੀਤਾ ਹੈ:

1. ਮੂਲ CUID ਕਾਰਜਨਵਿਤੀ ਸਾਦਗੀ ਅਤੇ ਵਰਤਣ ਵਿੱਚ ਆਸਾਨੀ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਸੀ।
2. ਜਿਵੇਂ ਜਿਵੇਂ ਅਪਣਾਉਣ ਵਧਿਆ, ਸਮੁਦਾਇ ਨੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਕਾਰਜਨਵਿਤੀਆਂ ਵਿੱਚ ਯੋਗਦਾਨ ਦਿੱਤਾ।
3. 2021 ਵਿੱਚ, CUID2 ਨੂੰ ਮੂਲ CUID ਦੀਆਂ ਕੁਝ ਸੀਮਾਵਾਂ ਨੂੰ ਦੂਰ ਕਰਨ ਅਤੇ ਹੋਰ ਚੰਗੀ ਕਾਰਗੁਜ਼ਾਰੀ ਅਤੇ ਟਕਰਾਅ-ਰੋਧੀਤਾ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ।
4. CUID2 ਨੇ ਮੂਲ ਦੇ ਉੱਤੇ ਸੁਧਾਰ ਕੀਤਾ ਅਤੇ ਇੱਕ ਹੋਰ ਸੁਰੱਖਿਅਤ ਬੇਰੁਖਾ ਨੰਬਰ ਜਨਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਅਤੇ ਪਛਾਣਕਰਤਾ ਦੀ ਕੁੱਲ ਲੰਬਾਈ ਨੂੰ ਵਧਾਇਆ।

CUID ਦਾ ਵਿਕਾਸ ਵੰਡੇ ਗਏ ਸਿਸਟਮਾਂ ਦੀ ਬਦਲਦੀ ਲੋੜਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਜਨਰੇਸ਼ਨ ਵਿੱਚ ਸਾਦਗੀ, ਸੁਰੱਖਿਆ, ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਦੇ ਵਿਚਕਾਰ ਸੰਤੁਲਨ ਬਣਾਉਣ ਲਈ ਚਲ ਰਹੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

ਹਵਾਲੇ

1. ਆਧਿਕਾਰਿਕ CUID GitHub ਰਿਪੋਜ਼ਿਟਰੀ
2. CUID2 ਵਿਸ਼ੇਸ਼ਤਾ
3. ਐਲਿਟ, ਐਰਿਕ। "ਵੰਡੇ ਗਏ ਵਾਤਾਵਰਣ ਵਿੱਚ ਵਿਲੱਖਣ ID ਜਨਰੇਟ ਕਰਨਾ।" ਮੀਡਿਅਮ, 2015।
4. "ਵੰਡੇ ਗਏ ਸਿਸਟਮਾਂ ਲਈ ਟਕਰਾਅ-ਰੋਧੀ ID।" DZone, 2018।

ਇਹ CUID ਜਨਰੇਟਰ ਟੂਲ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ CUID ਜਨਰੇਟ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਸਹਾਇਤਾ ਦਿੰਦਾ ਹੈ। ਸਿਰਫ "ਜਨਰੇਟ" ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਨਵਾਂ CUID ਬਣਾਉਣ ਲਈ, ਅਤੇ ਆਪਣੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਆਸਾਨੀ ਨਾਲ ਵਰਤਣ ਲਈ ਕਲਿਪਬੋਰਡ 'ਤੇ ਕਾਪੀ ਕਰਨ ਲਈ "ਕਾਪੀ" ਬਟਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।