Generate Random Strings in TypeScript

Recently, I was required to create some random strings in TypeScript. There are various methods to do so. In this tutorial, I will explain multiple approaches to generating random strings in TypeScript with examples. You might generate random strings to create unique identifiers, temporary passwords, etc.

Generate Random Strings in TypeScript

Now, let me show you various methods to generate random strings in TypeScript.

Method 1: Using Math.random() for Simple Random Strings

The most straightforward approach uses JavaScript’s built-in Math.random() function. While not cryptographically secure, it’s perfect for non-sensitive applications like generating test data.

function generateRandomString(length: number): string {
  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  let result = '';

  for (let i = 0; i < length; i++) {
    const randomIndex = Math.floor(Math.random() * characters.length);
    result += characters.charAt(randomIndex);
  }

  return result;
}

// Example usage
const randomStr = generateRandomString(10);
console.log(randomStr); // e.g., "G7H5Rfmgi2"

This method is simple and works well for most scenarios. I’ve used this approach to generate test data when building client e-commerce platforms.

I executed the above TypeScript code, and you can see the exact output in the screenshot below:

Pros and Cons of Math.random()

Check out Convert Boolean to String in TypeScript

Method 2: Cryptographically Secure Random Strings with crypto

When security matters, such as for authentication tokens or API keys, I always turn to the crypto module. In Node.js environments, we can use the built-in crypto module:

import * as crypto from 'crypto';

function generateSecureRandomString(length: number): string {
  const bytes = crypto.randomBytes(Math.ceil(length / 2));
  return bytes.toString('hex').slice(0, length);
}

// Example usage
const secureToken = generateSecureRandomString(32);
console.log(secureToken); // e.g., "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"

For browser environments, we can use the Web Crypto API:

function generateSecureRandomStringBrowser(length: number): string {
  const array = new Uint8Array(Math.ceil(length / 2));
  window.crypto.getRandomValues(array);
  return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('').slice(0, length);
}

I recently implemented this approach when building a secure document management system for a law firm in Washington D.C., where data security was non-negotiable.

Check out Convert Date to String Format DD/MM/YYYY in TypeScript

Method 3: Using UUID for Unique Random Identifiers

I typically use UUIDs (Universally Unique Identifiers) when I need globally unique identifiers. The popular uuid package makes this easy:

import { v4 as uuidv4 } from 'uuid';

function generateUUID(): string {
  return uuidv4();
}

// Example usage
const uniqueId = generateUUID();
console.log(uniqueId); // e.g., "f47ac10b-58cc-4372-a567-0e02b2c3d479"

First, install the package:

npm install uuid
npm install @types/uuid --save-dev

UUIDs are perfect when you need to ensure uniqueness across distributed systems. I used this approach extensively when building a multi-tenant SaaS application for a tech startup in Austin, Texas.

When to Use UUIDs

• Distributed Systems: When generating IDs across multiple servers
• Database Records: For unique primary keys without centralized coordination
• Frontend Components: For generating stable keys in React or Angular apps
• API Resources: For identifying resources in RESTful APIs

Check out Check if a String is a Number in TypeScript

Method 4: Customize Random Strings with nanoid

One of my favorite libraries for generating random strings is nanoid. It’s lightweight, secure, and highly customizable:

import { nanoid, customAlphabet } from 'nanoid';

// Default nanoid (21 characters, URL-friendly)
function generateNanoId(): string {
  return nanoid();
}

// Custom alphabet and length
function generateCustomNanoId(length: number, alphabet: string): string {
  const customNano = customAlphabet(alphabet, length);
  return customNano();
}

// Example usage
const defaultId = generateNanoId();
console.log(defaultId); // e.g., "V1StGXR8_Z5jdHi6B-myT"

// Only lowercase letters and numbers, 10 characters long
const customId = generateCustomNanoId(10, 'abcdefghijklmnopqrstuvwxyz0123456789');
console.log(customId); // e.g., "a3hb8cq9z5"

First, install nanoid:

npm install nanoid

I’ve recommended nanoid to numerous clients across the USA, from startups in Silicon Valley to enterprise clients in New York, thanks to its balance of security, performance, and customizability.

Nanoid vs UUID Comparison

Read Convert Date to String in TypeScript

Method 5: Human-Readable Random Strings

Sometimes, you need random strings that are easier for humans to read or remember. I’ve built several systems that generate readable codes for verification purposes:

function generateReadableRandomString(length: number = 6): string {
  // Exclude similar-looking characters: 0, O, 1, I, etc.
  const readableChars = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
  let result = '';

  for (let i = 0; i < length; i++) {
    const randomIndex = Math.floor(Math.random() * readableChars.length);
    result += readableChars.charAt(randomIndex);
  }

  return result;
}

// Example usage
const verificationCode = generateReadableRandomString(8);
console.log(verificationCode); // e.g., "KTNP46XM"

This approach has proven invaluable for user-facing codes, such as verification codes and order numbers for an e-commerce platform I built for a retail client in Chicago.

Here is the exact output in the screenshot below:

Check out Convert String to Date in TypeScript

Method 6: Random Strings with Specific Patterns

For more complex requirements, you might need strings that follow specific patterns. Here’s how I’ve implemented pattern-based random string generation:

function generatePatternedRandomString(pattern: string): string {
  return pattern.replace(/[x]/g, () => {
    return Math.floor(Math.random() * 16).toString(16);
  });
}

// Example usage
const patterned = generatePatternedRandomString('xxxx-xxxx-xxxx-xxxx');
console.log(patterned); // e.g., "a3f2-9d7b-e5c1-8h4j"

This technique is particularly useful for generating structured identifiers, such as license keys or formatted reference numbers. I used a similar approach when creating a license key system for a software company based in Seattle.

Here is the exact output in the screenshot below:

Read Error TS2550: Property ‘includes’ Does Not Exist on Type ‘String’ in TypeScript

Performance Considerations for Random String Generation

Performance is a critical consideration when implementing random string generation in production applications. Here’s what I’ve learned from optimizing high-traffic systems:

Batch Generation for Performance

If you need multiple random strings, generating them in batches can be more efficient:

function generateRandomStringBatch(length: number, count: number): string[] {
  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  const batch: string[] = [];

  for (let i = 0; i < count; i++) {
    let result = '';
    for (let j = 0; j < length; j++) {
      const randomIndex = Math.floor(Math.random() * characters.length);
      result += characters.charAt(randomIndex);
    }
    batch.push(result);
  }

  return batch;
}

// Generate 1000 random strings of length 10
const randomStrings = generateRandomStringBatch(10, 1000);

Performance Comparison

I’ve benchmarked different methods on a typical enterprise application server. Here are my findings:

Security Considerations for Random String Generation

When generating random strings for security-critical applications, keep these factors in mind:

1. Entropy Source: Use cryptographically secure random number generators for sensitive applications
2. String Length: Longer strings provide more security against brute-force attacks
3. Character Set: Larger character sets increase entropy per character
4. Predictability: Avoid patterns that might make strings predictable

Conclusion

In this tutorial, I explained how to generate random strings in TypeScript using different methods such as Math.random(), crypto module, etc.:

• Use Math.random() for simple, non-sensitive applications
• Use crypto for security-critical applications
• Use uuid for globally unique identifiers
• Use nanoid for customizable, efficient random strings
• Create custom generators for special requirements like human-readable strings

These techniques allow you to create any random string generation needs in your TypeScript applications.

You may also like:

• Check if a String Contains a Substring in TypeScript
• Convert a String to Boolean in TypeScript

Bijay Kumar

I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.

enjoysharepoint.com/