UUID ਜਨਰੇਟਰ

ਜਾਣ-ਪਛਾਣ

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

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

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

UUID ਢਾਂਚਾ

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

1550e8400-e29b-41d4-a716-446655440000
2

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 ਢਾਂਚੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ:

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 ਬਣਾਉਣ ਲਈ ਫਾਰਮੂਲਾ ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰਗਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

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

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

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

1UUID = random_128_bit_number
2

ਨਿਰਧਾਰਿਤ ਬਿਟਾਂ ਨੂੰ ਵਰਜਨ (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 ਬਣਾਉਣ ਦੇ ਉਦਾਹਰਣ ਹਨ:

1import uuid
2
3## ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
4random_uuid = uuid.uuid4()
5print(f"ਵਰਜਨ 4 UUID: {random_uuid}")
6
7## ਵਰਜਨ 1 (ਸਮਾਂ-ਅਧਾਰਿਤ) UUID ਬਣਾਓ
8time_based_uuid = uuid.uuid1()
9print(f"ਵਰਜਨ 1 UUID: {time_based_uuid}")
10

1const { v1: uuidv1, v4: uuidv4 } = require('uuid');
2
3// ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
4const randomUuid = uuidv4();
5console.log(`ਵਰਜਨ 4 UUID: ${randomUuid}`);
6
7// ਵਰਜਨ 1 (ਸਮਾਂ-ਅਧਾਰਿਤ) UUID ਬਣਾਓ
8const timeBasedUuid = uuidv1();
9console.log(`ਵਰਜਨ 1 UUID: ${timeBasedUuid}`);
10

1import java.util.UUID;
2
3public class UuidGenerator {
4    public static void main(String[] args) {
5        // ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
6        UUID randomUuid = UUID.randomUUID();
7        System.out.println("ਵਰਜਨ 4 UUID: " + randomUuid);
8
9        // ਵਰਜਨ 1 (ਸਮਾਂ-ਅਧਾਰਿਤ) UUID ਬਣਾਓ
10        UUID timeBasedUuid = UUID.fromString(new com.eaio.uuid.UUID().toString());
11        System.out.println("ਵਰਜਨ 1 UUID: " + timeBasedUuid);
12    }
13}
14

1require 'securerandom'
2
3## ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
4random_uuid = SecureRandom.uuid
5puts "ਵਰਜਨ 4 UUID: #{random_uuid}"
6
7## ਰੂਬੀ ਵਿੱਚ ਵਰਜਨ 1 UUIDs ਲਈ ਕੋਈ ਬਿਲਟ-ਇਨ ਵਿਧੀ ਨਹੀਂ ਹੈ
8## ਤੁਹਾਨੂੰ ਇਸ ਲਈ 'uuidtools' ਜੇਮ ਵਰਤਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ
9

1<?php
2// ਵਰਜਨ 4 (ਯਾਦਰਸ਼) UUID ਬਣਾਓ
3$randomUuid = sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
4    mt_rand(0, 0xffff), mt_rand(0, 0xffff),
5    mt_rand(0, 0xffff),
6    mt_rand(0, 0x0fff) | 0x4000,
7    mt_rand(0, 0x3fff) | 0x8000,
8    mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
9);
10echo "ਵਰਜਨ 4 UUID: " . $randomUuid . "\n";
11
12// PHP ਵਿੱਚ ਵਰਜਨ 1 UUIDs ਲਈ ਕੋਈ ਬਿਲਟ-ਇਨ ਵਿਧੀ ਨਹੀਂ ਹੈ
13// ਤੁਹਾਨੂੰ ਇਸ ਲਈ 'ramsey/uuid' ਵਰਤਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ
14?>
15

ਹਵਾਲੇ

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