Whiz Tools

ਯੂਯੂਆਈਡੀ ਜਨਰੇਟਰ

ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਯੂਯੂਆਈਡੀ

ਯੂਯੂਆਈਡੀ ਢਾਂਚਾ
ਸਮਾਂ ਘੱਟ

UUID ਜਨਰੇਟਰ

ਜਾਣ-ਪਛਾਣ

ਇੱਕ ਯੂਨੀਵਰਸਲ ਯੂਨੀਕ ਆਈਡੈਂਟੀਫਾਇਰ (UUID) 128-ਬਿਟ ਨੰਬਰ ਹੈ ਜੋ ਕੰਪਿਊਟਰ ਸਿਸਟਮਾਂ ਵਿੱਚ ਜਾਣਕਾਰੀ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। UUID ਨੂੰ ਓਪਨ ਸਾਫਟਵੇਅਰ ਫਾਉਂਡੇਸ਼ਨ (OSF) ਦੁਆਰਾ ਵੰਡਿਤ ਕੰਪਿਊਟਿੰਗ ਵਾਤਾਵਰਨ (DCE) ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਮਿਆਰੀਕ੍ਰਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਪਛਾਣਕਰਤਾਵਾਂ ਸਮੇਂ ਅਤੇ ਸਥਾਨ ਦੋਨੋਂ ਵਿੱਚ ਵਿਲੱਖਣ ਹੋਣ ਲਈ ਡਿਜ਼ਾਇਨ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ, ਜਿਸ ਨਾਲ ਇਹ ਵੰਡਿਤ ਸਿਸਟਮਾਂ ਅਤੇ ਹੋਰਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਆਦਰਸ਼ ਬਣ ਜਾਂਦੀਆਂ ਹਨ।

ਇਹ UUID ਜਨਰੇਟਰ ਟੂਲ ਵਰਜਨ 1 (ਸਮਾਂ-ਅਧਾਰਿਤ) ਅਤੇ ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇਹ ਪਛਾਣਕਰਤਾਵਾਂ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਵਰਤਣ ਲਈ ਉਪਯੋਗੀ ਹਨ ਜਿੱਥੇ ਵਿਲੱਖਣ ਪਛਾਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਡੇਟਾਬੇਸ ਕੁੰਜੀਆਂ, ਵੰਡਿਤ ਸਿਸਟਮ, ਅਤੇ ਨੈੱਟਵਰਕ ਪ੍ਰੋਟੋਕੋਲ।

UUIDs ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ

UUID ਢਾਂਚਾ

ਇੱਕ UUID ਆਮ ਤੌਰ 'ਤੇ 32 ਹੇਕਸਾਡੇਜੀਟਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਪੰਜ ਸਮੂਹਾਂ ਵਿੱਚ ਹਾਈਫਨ ਦੁਆਰਾ ਵੱਖਰੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਜੋ ਕਿ 8-4-4-4-12 ਦੇ ਰੂਪ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਕੁੱਲ 36 ਅੱਖਰ ਹੁੰਦੇ ਹਨ (32 ਅਲਫਾਨੁਮਰਿਕ ਅੱਖਰ ਅਤੇ 4 ਹਾਈਫਨ)। ਉਦਾਹਰਨ ਵਜੋਂ:

550e8400-e29b-41d4-a716-446655440000

UUID ਦੇ 128 ਬਿਟ ਵਿਸ਼ੇਸ਼ ਖੇਤਰਾਂ ਵਿੱਚ ਵੰਡੇ ਜਾਂਦੇ ਹਨ, ਹਰ ਇੱਕ UUID ਦੇ ਵਰਜਨ ਦੇ ਅਨੁਸਾਰ ਵੱਖ-ਵੱਖ ਜਾਣਕਾਰੀ ਰੱਖਦਾ ਹੈ:

  • 32 ਬਿਟ ਲਈ time_low ਖੇਤਰ
  • 16 ਬਿਟ ਲਈ time_mid ਖੇਤਰ
  • 16 ਬਿਟ ਲਈ time_hi_and_version ਖੇਤਰ
  • 8 ਬਿਟ ਲਈ clock_seq_hi_and_reserved ਖੇਤਰ
  • 8 ਬਿਟ ਲਈ clock_seq_low ਖੇਤਰ
  • 48 ਬਿਟ ਲਈ node ਖੇਤਰ

ਇੱਥੇ ਇੱਕ ਡਾਇਗ੍ਰਾਮ ਹੈ ਜੋ UUID ਢਾਂਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ:

A B C D E F A: time_low (32 ਬਿਟ) B: time_mid (16 ਬਿਟ) C: time_hi_and_version (16 ਬਿਟ) D: clock_seq_hi_and_reserved (8 ਬਿਟ) E: clock_seq_low (8 ਬਿਟ) F: node (48 ਬਿਟ)

UUID ਵਰਜਨ

UUID ਦੇ ਕਈ ਵਰਜਨ ਹਨ, ਹਰ ਇੱਕ ਦਾ ਆਪਣਾ ਜਨਰੇਸ਼ਨ ਤਰੀਕਾ ਹੈ:

  1. ਵਰਜਨ 1 (ਸਮਾਂ-ਅਧਾਰਿਤ): ਮੌਜੂਦਾ ਸਮੇਂ ਅਤੇ ਕੰਪਿਊਟਰ ਦੇ MAC ਪਤੇ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।
  2. ਵਰਜਨ 2 (DCE ਸੁਰੱਖਿਆ): ਵਰਜਨ 1 ਦੇ ਸਮਾਨ, ਪਰ ਇੱਕ ਸਥਾਨਕ ਡੋਮੇਨ ਪਛਾਣਕਰਤਾ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।
  3. ਵਰਜਨ 3 (ਨਾਮ-ਅਧਾਰਿਤ, MD5): ਇੱਕ ਨਾਮਸਪੇਸ ਪਛਾਣਕਰਤਾ ਅਤੇ ਨਾਮ ਨੂੰ ਹੈਸ਼ ਕਰਕੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।
  4. ਵਰਜਨ 4 (ਯਾਦਰਸ਼): ਇੱਕ ਯਾਦਰਸ਼ ਜਾਂ ਪੂਰਨ ਯਾਦਰਸ਼ ਨੰਬਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।
  5. ਵਰਜਨ 5 (ਨਾਮ-ਅਧਾਰਿਤ, SHA-1): ਵਰਜਨ 3 ਦੇ ਸਮਾਨ, ਪਰ SHA-1 ਹੈਸ਼ਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

ਇਹ ਟੂਲ ਵਰਜਨ 1 ਅਤੇ ਵਰਜਨ 4 UUID ਬਣਾਉਣ 'ਤੇ ਧਿਆਨ ਕੇਂਦ੍ਰਿਤ ਕਰਦਾ ਹੈ।

ਫਾਰਮੂਲਾ

ਵਰਜਨ 1 UUID ਜਨਰੇਸ਼ਨ

ਵਰਜਨ 1 UUIDs ਨੂੰ ਹੇਠ ਲਿਖੇ ਕੰਪੋਨੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ:

  1. ਸਮਾਂ: 60-ਬਿਟ ਮੁੱਲ ਜੋ 15 ਅਕਤੂਬਰ 1582 ਤੋਂ (ਗ੍ਰੇਗੋਰੀਅਨ ਕੈਲੰਡਰ ਦੇ ਸੁਧਾਰ ਦੀ ਤਾਰੀਖ) 100-ਨੈਨੋਸੈਕੰਡ ਦੇ ਅੰਤਰਾਲਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
  2. ਘੜੀ ਲੜੀ: 14-ਬਿਟ ਮੁੱਲ ਜੋ ਘੜੀ ਨੂੰ ਪਿਛੇ ਵੱਧਣ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਨਕਲਾਂ ਤੋਂ ਬਚਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
  3. ਨੋਡ: 48-ਬਿਟ ਮੁੱਲ, ਆਮ ਤੌਰ 'ਤੇ ਕੰਪਿਊਟਰ ਦੇ MAC ਪਤੇ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਵਰਜਨ 1 UUID ਬਣਾਉਣ ਲਈ ਫਾਰਮੂਲਾ ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰਗਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

UUID = (timestamp * 2^64) + (clock_sequence * 2^48) + node

ਵਰਜਨ 4 UUID ਜਨਰੇਸ਼ਨ

ਵਰਜਨ 4 UUIDs ਨੂੰ ਇੱਕ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਤੌਰ 'ਤੇ ਮਜ਼ਬੂਤ ਯਾਦਰਸ਼ ਨੰਬਰ ਜਨਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ। ਫਾਰਮੂਲਾ ਸਿਰਫ਼ ਇਹ ਹੈ:

UUID = random_128_bit_number

ਨਿਰਧਾਰਿਤ ਬਿਟਾਂ ਨੂੰ ਵਰਜਨ (4) ਅਤੇ ਵੈਰੀਐਂਟ ਦਰਸਾਉਣ ਲਈ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ।

ਵਰਤੋਂ ਦੇ ਕੇਸ

UUIDs ਦੇ ਕਈ ਐਪਲੀਕੇਸ਼ਨ ਹਨ ਜੋ ਕੰਪਿਊਟਰ ਵਿਗਿਆਨ ਅਤੇ ਸਾਫਟਵੇਅਰ ਇੰਜੀਨੀਅਰਿੰਗ ਦੇ ਵੱਖ-ਵੱਖ ਖੇਤਰਾਂ ਵਿੱਚ ਹਨ:

  1. ਡੇਟਾਬੇਸ ਕੁੰਜੀਆਂ: UUIDs ਨੂੰ ਅਕਸਰ ਡੇਟਾਬੇਸਾਂ ਵਿੱਚ ਪ੍ਰਾਇਮਰੀ ਕੁੰਜੀਆਂ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਵੰਡਿਤ ਸਿਸਟਮਾਂ ਵਿੱਚ ਜਿੱਥੇ ਕਈ ਨੋਡ ਇੱਕਸਾਥ ਰਿਕਾਰਡ ਬਣਾਉਂਦੇ ਹੋ ਸਕਦੇ ਹਨ।

  2. ਵੰਡਿਤ ਸਿਸਟਮ: ਵੱਡੇ ਪੱਧਰ ਦੇ ਵੰਡਿਤ ਸਿਸਟਮਾਂ ਵਿੱਚ, UUIDs ਸਰੋਤਾਂ, ਲੈਣ-ਦੇਣਾਂ, ਜਾਂ ਘਟਨਾਵਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਨੋਡਾਂ ਜਾਂ ਡੇਟਾ ਕੇਂਦਰਾਂ ਵਿੱਚ ਵਿਲੱਖਣ ਪਛਾਣ ਦੇਣ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ।

  3. ਸਮੱਗਰੀ ਦਾ ਪਤਾ ਲਗਾਉਣਾ: UUIDs ਨੂੰ ਸਮੱਗਰੀ ਲਈ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾਵਾਂ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਸਮੱਗਰੀ-ਪਤਾ ਲਗਾਉਣ ਵਾਲੇ ਸਟੋਰੇਜ ਸਿਸਟਮਾਂ ਵਿੱਚ ਹਨ।

  4. ਸੈਸ਼ਨ ਪ੍ਰਬੰਧਨ: ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਅਕਸਰ ਯੂਜ਼ਰ ਸੈਸ਼ਨਾਂ ਨੂੰ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ UUIDs ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀਆਂ ਹਨ ਕਿ ਹਰ ਸੈਸ਼ਨ ਦਾ ਇੱਕ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਹੈ।

  5. IoT ਡਿਵਾਈਸ ਪਛਾਣ: ਇੰਟਰਨੈੱਟ ਆਫ਼ ਥਿੰਗਜ਼ (IoT) ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ, UUIDs ਨੂੰ ਨੈੱਟਵਰਕ ਵਿੱਚ ਵਿਅਕਤੀਗਤ ਡਿਵਾਈਸਾਂ ਦੀ ਵਿਲੱਖਣ ਪਛਾਣ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਵਿਕਲਪ

ਜਦੋਂ ਕਿ UUIDs ਨੂੰ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਪਰ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾਵਾਂ ਬਣਾਉਣ ਲਈ ਹੋਰ ਵਿਕਲਪ ਹਨ:

  1. ਆਟੋ-ਇੰਕ੍ਰਿਮੈਂਟਿੰਗ IDs: ਸਧਾਰਣ ਅਤੇ ਇਕਲ ਡੇਟਾਬੇਸ ਸਿਸਟਮਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਪਰ ਵੰਡਿਤ ਵਾਤਾਵਰਣਾਂ ਲਈ ਉਪਯੋਗੀ ਨਹੀਂ।

  2. ਸਮਾਂ-ਅਧਾਰਿਤ IDs: ਸਮੇਂ ਦੇ ਆਧਾਰ 'ਤੇ ਡੇਟਾ ਲਈ ਉਪਯੋਗੀ ਹੋ ਸਕਦੇ ਹਨ ਪਰ ਉੱਚ-ਸਹਿਯੋਗ ਸਥਿਤੀਆਂ ਵਿੱਚ ਟਕਰਾਵਾਂ ਦੀ ਸਮੱਸਿਆ ਦਾ ਸਾਹਮਣਾ ਕਰ ਸਕਦੇ ਹਨ।

  3. ਸਨੋਫਲੇਕ IDs: ਟਵਿੱਟਰ ਦੁਆਰਾ ਵਿਕਸਿਤ, ਇਹ IDs ਸਮੇਂ ਅਤੇ ਵਰਕਰ ਨੰਬਰ ਨੂੰ ਜੋੜ ਕੇ ਵੰਡਿਤ ਸਿਸਟਮਾਂ ਵਿੱਚ ਵਿਲੱਖਣ IDs ਬਣਾਉਂਦੇ ਹਨ।

  4. ULID (ਯੂਨੀਵਰਸਲੀ ਯੂਨੀਕ ਲੈਕਸਿਕੋਗ੍ਰਾਫਿਕਲੀ ਸੋਰਟੇਬਲ ਆਈਡੈਂਟੀਫਾਇਰ): ਇੱਕ ਹੋਰ ਹਾਲੀਆ ਵਿਕਲਪ ਜੋ UUIDs ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਮਨੁੱਖ-ਮਿੱਤਰ ਅਤੇ ਸੋਰਟੇਬਲ ਹੋਣ ਦਾ ਉਦੇਸ਼ ਰੱਖਦਾ ਹੈ।

ਇਤਿਹਾਸ

UUIDs ਦਾ ਵਿਚਾਰ ਪਹਿਲਾਂ ਐਪੋਲੋ ਨੈੱਟਵਰਕ ਕੰਪਿਊਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਬਾਅਦ ਵਿੱਚ 1990 ਦੇ ਦਹਾਕੇ ਵਿੱਚ ਓਪਨ ਸਾਫਟਵੇਅਰ ਫਾਉਂਡੇਸ਼ਨ (OSF) ਦੁਆਰਾ ਮਿਆਰੀਕ੍ਰਿਤ ਕੀਤਾ ਗਿਆ। ਪਹਿਲੀ ਵਿਸ਼ੇਸ਼ਤਾ 1997 ਵਿੱਚ ISO/IEC 11578:1996 ਵਜੋਂ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਗਈ ਸੀ ਅਤੇ ਬਾਅਦ ਵਿੱਚ 2005 ਵਿੱਚ ISO/IEC 9834-8:2005 ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਦੁਬਾਰਾ ਸੰਸ਼ੋਧਿਤ ਕੀਤੀ ਗਈ।

UUID ਇਤਿਹਾਸ ਵਿੱਚ ਕੁਝ ਮੁੱਖ ਮੋੜ:

  • 1980 ਦੇ ਦਹਾਕੇ: ਐਪੋਲੋ ਕੰਪਿਊਟਰ ਆਪਣੇ ਨੈੱਟਵਰਕ ਕੰਪਿਊਟਿੰਗ ਸਿਸਟਮ ਲਈ UUID ਵਿਚਾਰ ਵਿਕਸਿਤ ਕਰਦਾ ਹੈ।
  • 1997: ਪਹਿਲੀ UUID ਵਿਸ਼ੇਸ਼ਤਾ ISO/IEC 11578:1996 ਵਜੋਂ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
  • 2005: UUID ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਦੁਬਾਰਾ ਸੰਸ਼ੋਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ISO/IEC 9834-8:2005 ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
  • 2009: RFC 4122 UUID ਫਾਰਮੈਟ ਅਤੇ ਜਨਰੇਸ਼ਨ ਅਲਗੋਰਿਦਮ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਅੱਜ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਸਮੇਂ ਦੇ ਨਾਲ, UUIDs ਵੰਡਿਤ ਸਿਸਟਮਾਂ ਅਤੇ ਡੇਟਾਬੇਸ ਡਿਜ਼ਾਈਨ ਵਿੱਚ ਇੱਕ ਅਹਮ ਟੂਲ ਬਣ ਗਏ ਹਨ, ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਪਲੇਟਫਾਰਮਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਾਰਜਾਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਨਾਲ।

ਕੋਡ ਉਦਾਹਰਣ

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

import uuid

## ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
random_uuid = uuid.uuid4()
print(f"ਵਰਜਨ 4 UUID: {random_uuid}")

## ਵਰਜਨ 1 (ਸਮਾਂ-ਅਧਾਰਿਤ) UUID ਬਣਾਓ
time_based_uuid = uuid.uuid1()
print(f"ਵਰਜਨ 1 UUID: {time_based_uuid}")

const { v1: uuidv1, v4: uuidv4 } = require('uuid');

// ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
const randomUuid = uuidv4();
console.log(`ਵਰਜਨ 4 UUID: ${randomUuid}`);

// ਵਰਜਨ 1 (ਸਮਾਂ-ਅਧਾਰਿਤ) UUID ਬਣਾਓ
const timeBasedUuid = uuidv1();
console.log(`ਵਰਜਨ 1 UUID: ${timeBasedUuid}`);

import java.util.UUID;

public class UuidGenerator {
    public static void main(String[] args) {
        // ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
        UUID randomUuid = UUID.randomUUID();
        System.out.println("ਵਰਜਨ 4 UUID: " + randomUuid);

        // ਵਰਜਨ 1 (ਸਮਾਂ-ਅਧਾਰਿਤ) UUID ਬਣਾਓ
        UUID timeBasedUuid = UUID.fromString(new com.eaio.uuid.UUID().toString());
        System.out.println("ਵਰਜਨ 1 UUID: " + timeBasedUuid);
    }
}

require 'securerandom'

## ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
random_uuid = SecureRandom.uuid
puts "ਵਰਜਨ 4 UUID: #{random_uuid}"

## ਰੂਬੀ ਵਿੱਚ ਵਰਜਨ 1 UUIDs ਲਈ ਕੋਈ ਬਿਲਟ-ਇਨ ਵਿਧੀ ਨਹੀਂ ਹੈ
## ਤੁਹਾਨੂੰ ਇਸ ਲਈ 'uuidtools' ਜੇਮ ਵਰਤਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ

<?php
// ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
$randomUuid = sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
    mt_rand(0, 0xffff), mt_rand(0, 0xffff),
    mt_rand(0, 0xffff),
    mt_rand(0, 0x0fff) | 0x4000,
    mt_rand(0, 0x3fff) | 0x8000,
    mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
);
echo "ਵਰਜਨ 4 UUID: " . $randomUuid . "\n";

// PHP ਵਿੱਚ ਵਰਜਨ 1 UUIDs ਲਈ ਕੋਈ ਬਿਲਟ-ਇਨ ਵਿਧੀ ਨਹੀਂ ਹੈ
// ਤੁਹਾਨੂੰ ਇਸ ਲਈ 'ramsey/uuid' ਵਰਤਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ
?>

ਹਵਾਲੇ

  1. ਲੀਚ, ਪੀ., ਮੀਲਿੰਗ, ਐਮ., & ਸਾਲਜ਼, ਆਰ. (2005). A Universally Unique IDentifier (UUID) URN Namespace. RFC 4122. https://tools.ietf.org/html/rfc4122
  2. ਅੰਤਰਰਾਸ਼ਟਰੀ ਸੰਗਠਨ ਲਈ ਮਿਆਰੀਕਰਨ. (2005). ਜਾਣਕਾਰੀ ਤਕਨਾਲੋਜੀ – ਖੁੱਲ੍ਹੇ ਸਿਸਟਮਾਂ ਦੇ ਇੰਟਰਕੋਨੈਕਸ਼ਨ – OSI ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਅਧਿਕਾਰੀਆਂ ਦੇ ਕਾਰਜਾਂ ਲਈ ਪ੍ਰਕਿਰਿਆਵਾਂ: ਯੂਨੀਵਰਸਲੀ ਯੂਨੀਕ ਆਈਡੈਂਟੀਫਾਇਰ (UUIDs) ਦੀ ਪੀੜ੍ਹੀ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ASN.1 ਵਸਤੂ ਪਛਾਣਕਰਤਾ ਦੇ ਤੱਤ ਵਜੋਂ. ISO/IEC 9834-8:2005. https://www.iso.org/standard/62795.html
  3. ਯੂਨੀਵਰਸਲੀ ਯੂਨੀਕ ਆਈਡੈਂਟੀਫਾਇਰ. (2023). ਵਿਖਿਆਨ ਵਿੱਚ. https://en.wikipedia.org/wiki/Universally_unique_identifier
  4. ਸਨੋਫਲੇਕ ID. (2023). ਵਿਖਿਆਨ ਵਿੱਚ. https://en.wikipedia.org/wiki/Snowflake_ID
  5. ULID ਵਿਸ਼ੇਸ਼ਤਾ. (n.d.). GitHub. https://github.com/ulid/spec

ਸੰਬੰਧਿਤ ਸੰਦ

ਬ੍ਰਾਜ਼ੀਲ ਲਈ ਟੈਸਟਿੰਗ ਲਈ ਵੈਧ CPF ਨੰਬਰ ਜਨਰੇਟਰ
ਵੈੱਬ ਵਿਕਾਸ ਟੈਸਟਿੰਗ ਲਈ ਰੈਂਡਮ ਯੂਜ਼ਰ ਏਜੰਟ ਜਨਰੇਟਰ
ਯਾਦਰਸ਼ ਸਥਾਨ ਜਨਰੇਟਰ: ਗਲੋਬਲ ਕੋਆਰਡੀਨੇਟ ਬਣਾਉਣ ਵਾਲਾ
MongoDB ObjectID Generator for Testing and Development
ਐਮਡੀ5 ਹੈਸ਼ ਜਨਰੇਟਰ
ਯਾਦ੍ਰਿਕ ਪ੍ਰੋਜੈਕਟ ਨਾਮ ਜਨਰੇਟਰ
ਸਨੋਫਲੇਕ ਆਈਡੀ ਜਨਰੇਟਰ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਟੂਲ
ਗਿੱਲੀ ਪਰਿਮਿਟਰ ਕੈਲਕੂਲੇਟਰ: ਹਾਈਡ੍ਰੌਲਿਕ ਇੰਜੀਨੀਅਰਿੰਗ ਲਈ
ਨੈਨੋ ID ਜਨਰੇਟਰ: ਸੁਰੱਖਿਅਤ ਅਤੇ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾਂ ਬਣਾਓ
ਕੇਐਸਯੂਆਈਡੀ ਜਨਰੇਟਰ: ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਬਣਾਓ
Feedback