Got it, you're looking to generate a deterministic GUID—meaning the same input string (whether it's "Toto", that jumbled mess of characters you threw out, or anything else) always spits out the exact same GUID. You already know the uniqueness is tied directly to your input, so we can skip beating that dead horse and jump straight to working solutions for common languages.

C# Example #

The .NET framework has built-in tools to handle this cleanly. We'll hash the input string (using SHA256 for consistency) and convert the hash bytes into a RFC-compliant GUID.

using System;
using System.Security.Cryptography;
using System.Text;

public static Guid GenerateDeterministicGuid(string input)
{
    // Create a SHA256 hash of the input string
    using (var sha256 = SHA256.Create())
    {
        byte[] hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(input));
        // Grab the first 16 bytes to form the GUID's base
        byte[] guidBytes = new byte[16];
        Array.Copy(hashBytes, guidBytes, 16);
        
        // Set GUID version (5 = SHA-256 name-based) and variant to follow RFC 4122
        guidBytes[6] = (byte)((guidBytes[6] & 0x0F) | 0x50);
        guidBytes[8] = (byte)((guidBytes[8] & 0x3F) | 0x80);
        
        return new Guid(guidBytes);
    }
}

Note: Skipping the version/variant adjustment works too, but following RFC standards makes the result recognizable as a valid GUID rather than a random byte string.

Python Example #

In Python, we can use hashlib for hashing and the built-in uuid module to convert the hash into a proper GUID.

import hashlib
import uuid

def generate_deterministic_guid(input_str):
    # Hash the input with SHA256
    hash_obj = hashlib.sha256(input_str.encode('utf-8'))
    hash_bytes = hash_obj.digest()
    
    # Take the first 16 bytes and convert to a UUID
    guid = uuid.UUID(bytes=hash_bytes[:16])
    
    # Optional: Uncomment below to enforce RFC 4122 version 5 compliance
    # guid = uuid.UUID(bytes=hash_bytes[:16], version=5)
    
    return str(guid)

JavaScript/TypeScript Example #

For JS/TS, we use platform-native crypto APIs to hash the input, then format the result into a GUID string.

Node.js Version #

const crypto = require('crypto');

function generateDeterministicGuid(input) {
    const hash = crypto.createHash('sha256').update(input, 'utf8').digest();
    const guidBytes = hash.slice(0, 16);
    
    // Set RFC 4122 version 5 and variant
    guidBytes[6] = (guidBytes[6] & 0x0f) | 0x50;
    guidBytes[8] = (guidBytes[8] & 0x3f) | 0x80;
    
    // Format bytes into standard GUID string
    return [...guidBytes].map((b, i) => {
        const hex = b.toString(16).padStart(2, '0');
        return (i === 4 || i === 6 || i === 8 || i === 10) ? `-${hex}` : hex;
    }).join('');
}

Browser Version #

async function generateDeterministicGuid(input) {
    const encoder = new TextEncoder();
    const hashBuffer = await crypto.subtle.digest('SHA-256', encoder.encode(input));
    const guidBytes = Array.from(new Uint8Array(hashBuffer)).slice(0, 16);
    
    // Set RFC 4122 version 5 and variant
    guidBytes[6] = (guidBytes[6] & 0x0f) | 0x50;
    guidBytes[8] = (guidBytes[8] & 0x3f) | 0x80;
    
    // Format into GUID string
    return guidBytes.reduce((acc, byte, idx) => {
        acc += byte.toString(16).padStart(2, '0');
        if ([4, 6, 8, 10].includes(idx)) acc += '-';
        return acc;
    }, '');
}

Quick Notes #

• All these methods use hashing as the core—since hashing is deterministic, the same input will always produce the same hash, which we then map to a GUID.
• SHA256 is used here for its strong collision resistance, but you could swap it for MD5 or SHA1 if you don't need strict security (though MD5/SHA1 are not recommended for sensitive use cases).

内容的提问来源于stack exchange，提问作者J4N