Random uppercase letter generator

// Uniform over the alphabet, with no modulo bias.
// The alphabet is spread into code points first, so an emoji or an
// accented character counts as one symbol rather than two UTF-16 units.
function randomString(length, alphabetStr) {
  const alphabet = [...new Set([...alphabetStr])];
  const n = alphabet.length;
  if (n < 1) throw new RangeError("empty alphabet");

  const limit = 4294967296 - (4294967296 % n);   // largest multiple of n <= 2^32
  const buf = new Uint32Array(1);
  let out = "";

  for (let i = 0; i < length; i++) {
    let x;
    do { crypto.getRandomValues(buf); x = buf[0]; } while (x >= limit);
    out += alphabet[x % n];
  }
  return out;
}

randomString(16, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");

The do/while is the whole point. Dropping it in favour of a bare x % n reintroduces modulo bias.

import secrets

ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

"".join(secrets.choice(ALPHABET) for _ in range(16))

# secrets.choice is backed by secrets.randbelow, which rejects and redraws,
# so it is uniform. random.choice is not a secure source and must not be used.

Iterating a Python str yields code points, so non-ASCII alphabets work without extra handling.

import (
    "crypto/rand"
    "math/big"
)

func RandomString(length int, alphabet string) (string, error) {
    runes := []rune(alphabet)
    n := big.NewInt(int64(len(runes)))
    out := make([]rune, length)
    for i := range out {
        j, err := rand.Int(rand.Reader, n)   // rejection sampled internally
        if err != nil {
            return "", err
        }
        out[i] = runes[j.Int64()]
    }
    return string(out), nil
}

Convert to []rune, not []byte. Indexing a Go string yields bytes, which splits any multi-byte character.

// rand = "0.9"
use rand::Rng;

const ALPHABET: &[u8] =
    b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

fn random_string(length: usize) -> String {
    // rand::rng() is a thread-local ChaCha12 CSPRNG seeded from the OS.
    let mut rng = rand::rng();
    (0..length)
        .map(|_| ALPHABET[rng.random_range(0..ALPHABET.len())] as char)
        .collect()
}

random_range rejection-samples, so it is unbiased. On rand 0.8 the method is named gen_range and the constructor is rand::thread_rng().

<?php
function random_string(int $length, string $alphabet): string {
    $n = strlen($alphabet);
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        $out .= $alphabet[random_int(0, $n - 1)];
    }
    return $out;
}

echo random_string(16, 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789');

random_int throws on entropy failure and is unbiased. rand and mt_rand are neither.

import java.security.SecureRandom;

static String randomString(int length, String alphabet) {
    SecureRandom rng = new SecureRandom();
    StringBuilder sb = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
        sb.append(alphabet.charAt(rng.nextInt(alphabet.length())));
    }
    return sb.toString();
}

nextInt(bound) rejects and redraws, so it is uniform. Reuse one SecureRandom instance rather than constructing one per call.

using System.Security.Cryptography;

const string Alphabet =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

// .NET 8 and later
string s = RandomNumberGenerator.GetString(Alphabet, 16);

// Earlier versions, same distribution
var sb = new System.Text.StringBuilder(16);
for (int i = 0; i < 16; i++)
    sb.Append(Alphabet[RandomNumberGenerator.GetInt32(Alphabet.Length)]);

# 16 alphanumeric characters from the kernel CSPRNG.
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 16; echo

# tr -dc discards every byte outside the set rather than folding it in,
# which makes it a rejection sampler. Each of the 62 bytes has exactly one
# preimage, so the output is uniform.

# openssl, when you want bytes rather than a character set
openssl rand -hex 16
openssl rand -base64 24