Latest Update as of August 2020:

shortid has now been replaced by a faster and more compact alternative called nanoid:

• Compact. Only 108 bytes when minified and gzipped with no dependencies, controlled by Size Limit.
• Speedy. Runs 40% faster than UUID.
• Secure. Utilizes strong random APIs for cryptographic use in clusters.
• Economical. Employs a wider alphabet than UUID (A-Za-z0-9_-), reducing ID size from 36 to 21 symbols.
• Versatile. Nano ID is adaptable across 14 different programming languages.

import { nanoid } from 'nanoid'

// Default: 21 characters
// Probability of collision after ~149 billion years with 1% certainty.
console.log(nanoid()) //=> "V1StGXR8_Z5jdHi6B-myT"

// 11 characters
// Probability of collision after ~139 years with 1% certainty.
console.log(nanoid(11)) //=> "bdkjNOkq9PO"

For additional information visit :

Previous Recommendation

An excellent npm package alternative is also available for generating unique ids: shortid

Incredibly short non-sequential url-friendly unique id generator.

ShortId creates remarkably short non-sequential url-friendly unique identifiers suitable for various purposes such as url shorteners, MongoDB and Redis ids, and any other id presentation needs.

• Generates default 7-14 url-friendly characters: A-Z, a-z, 0-9, _-
• Non-predictable sequence for enhanced security.
• Supports cluster functionality (automatically), customizable seeds, custom alphabets.
• Capable of producing endless unique ids without duplication, even millions per day.
• Ideal for gaming applications, especially those concerned about cheating prevention through non-guessable ids.
• Apps can be restarted multiple times without risk of repeating an id.
• Popularity as a replacement for Mongo ID/Mongoose ID usage.
• Compatible with Node.js, io.js, and web browsers.
• Incorporates Mocha testing suite.

How to Use

var shortid = require('shortid');
console.log(shortid.generate()); //PPBqWA9

Check out this simple code snippet for generating a random string with lowercase letters and numbers:

const randomString = Math.random().toString(36).slice(-6);

console.log(randomString);

Begin with a basic counter set at 100000000, then transform the number into radix 36.

(100000000).toString(36);  //1njchs

(2100000000).toString(36); //yqaadc

You now have the capability to generate 2 billion sophisticated and distinctive ids, similar to what YouTube does.

By utilizing the code snippet provided, it is possible to generate a total of 238,328 unique values consisting of 3 characters each while maintaining case sensitivity and allowing digits in any position. For scenarios where case insensitivity is essential, the removal of either upper or lower case characters from the character string would result in 42,875 unique values derived from 35^3 combinations.

Furthermore, customization options exist to ensure that the first character is always a letter or all characters are solely letters.

Potential optimization opportunities may improve the efficiency of this solution and introduce a mechanism to decline issuing an ID once the limit has been reached.

var nextId = (function() {
  var nextIndex = [0,0,0];
  var chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
  var num = chars.length;

  return function() {
    var a = nextIndex[0];
    var b = nextIndex[1];
    var c = nextIndex[2];
    var id = chars[a] + chars[b] + chars[c];

    a = ++a % num;

    if (!a) {
      b = ++b % num; 

      if (!b) {
        c = ++c % num; 
      }
    }
    nextIndex = [a, b, c]; 
    return id;
  }
}());

By harnessing the true power of ES6 functionalities, it is now possible to create hash IDs in JavaScript without depending on external libraries.

I have devised a straightforward generator using the built-in capabilities that modern JavaScript provides. This method utilizes Crypto.getRandomValues() and Uint8Array() as illustrated in the code snippet below:

const hashID = size => {
  const MASK = 0x3d
  const LETTERS = 'abcdefghijklmnopqrstuvwxyz'
  const NUMBERS = '1234567890'
  const charset = `${NUMBERS}${LETTERS}${LETTERS.toUpperCase()}`.split('')

  const bytes = new Uint8Array(size)
  crypto.getRandomValues(bytes)

  return bytes.reduce((acc, byte) => `${acc}${charset[byte & MASK]}`, '')
}

console.log({id: hashID(6)})

This approach incorporates the characters: [A-Z], [a-z], [0-9], totaling 62 characters. By including _ and -, the character count extends to 64 characters like so:

const hashID = size => {
  const MASK = 0x3d
  const LETTERS = 'abcdefghijklmnopqrstuvwxyz'
  const NUMBERS = '1234567890'
  const charset = `${NUMBERS}${LETTERS}${LETTERS.toUpperCase()}_-`.split('')

  const bytes = new Uint8Array(size)
  crypto.getRandomValues(bytes)

  return bytes.reduce((acc, byte) => `${acc}${charset[byte & MASK]}`, '')
}

console.log(`id: ${hashID(6)}`)

Note:

It is estimated that it will take approximately 2 days for a 1% chance of encountering at least one collision when generating 1000 IDs per hour with a length of 6 characters. This information should be considered before implementing this solution into your project.

const alphabet = 'abcdefghijklmnopqrstuvwxyz';
const numbers = '1234567890';
const characterSet = alphabet + alphabet.toUpperCase() + numbers;

function getRandomElement(array) {
    with (Math)
        return array[floor(random()*array.length)];
}

function generateRandomString(length) {
    let randomString = '';
    for(let i=0; i<length; i++)
        randomString += getRandomElement(characterSet);
    return randomString;
}

This code snippet is designed to create a series of unique values by incrementing through a specified character set until all possible combinations have been exhausted. It features an enhancement over RobG's original solution by dynamically increasing the string length as needed.

var UniqueValueGenerator = (function () {

    var defaultCharset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()_-+=[]{};:?/.>,<|".split("");

    var UniqueValueGenerator = function UniqueValueGenerator(charset) {
        this._charset = (typeof charset === "undefined") ? defaultCharset : charset;
        this.reset();
    };

    UniqueValueGenerator.prototype._str = function () {
        var str = "",
            perm = this._perm,
            chars = this._charset,
            len = perm.length,
            i;
        for (i = 0; i < len; i++) {
            str += chars[perm[i]];
        }
        return str;
    };

    UniqueValueGenerator.prototype._inc = function () {
        var perm = this._perm,
            max = this._charset.length - 1,
            i;
        for (i = 0; true; i++) {
            if (i > perm.length - 1) {
                perm.push(0);
                return;
            } else {
                perm[i]++;
                if (perm[i] > max) {
                    perm[i] = 0;
                } else {
                    return;
                }
            }
        }
    };

    UniqueValueGenerator.prototype.reset = function () {
        this._perm = [];
    };

    UniqueValueGenerator.prototype.current = function () {
        return this._str();
    };

    UniqueValueGenerator.prototype.next = function () {
        this._inc();
        return this._str();
    };

    return UniqueValueGenerator;

}).call(null);

Usage:

var generator = new UniqueValueGenerator(),
    index;

for (index = 0; index < 100; index++) {
   console.log(generator.next());
}

This gist includes the above code implementation and a version that utilizes recursion.

Here is a simple function that generates random strings:

function generateRandomString(length){
    var characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
          output = '';

    for(var i=0, charLength=characters.length; i<length; i++){
       output += characters.substr(0|Math.random() * charLength, 1);
    }

    // make sure the string is unique for this specific context
    return generateRandomString.strings[output] ? generateRandomString(length) : (generateRandomString.strings[output] = output);
}
generateRandomString.strings = {};

It is possible to reduce a GUID to 20 printable ASCII characters without compromising its integrity or uniqueness.

This concept was discussed by Jeff Atwood in a blog post several years ago:
Equipping our ASCII Armor

This strategy marries the Math.random() function with a counter.

While Math.random() on its own provides approximately 53 bits of entropy (in contrast to UUIDv4's 128), when paired with a counter, it generates enough uniqueness for a temporary ID.

let _id_counter = 0
function id() {
  return '_' + (_id_counter++).toString(36) + '_' + Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(36)
}

console.log(Array.from({length: 100}).map(() => id()))

Advantages:

• Straightforward implementation
• Outputs around 13 characters
• Case-insensitive
• Suitable for use as an HTML id and a React key
• Not recommended for storing in databases

To create a random string, one can utilize the md5 algorithm. The md5 function is available in the node package

 var randomChars = Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 2);
 var shortUrl = md5(originalUrl + randomChars + new Date()).substring(0, 5).toString();
 console.log(shortUrl);

With this method, a unique string will be generated each time it's called.

Utilizing this TypeScript function allows me to generate distinctive identifiers for my database that are more user-friendly than UUIDs. In cases where duplicate key exceptions occur during record insertion, I handle them by retrying with a new ID.

const idChars: string = 'ABCDEFGHJKMNPQRSTUVWXYZ'

export function createUniqueID(): string {
  const now: Date = new Date()
  let id = now.getUTCFullYear().toString()
  id += now.getUTCMonth().toString().padStart(2, '0')
  id += now.getUTCDay().toString().padStart(2, '0')
  for (let i = 0; i < 6; i++) id += idChars[Math.floor(Math.random() * idChars.length)]
  return id
}

This method produces IDs such as 20230506VJDMQD.

The inclusion of a date prefix significantly aids in ensuring uniqueness, particularly when dealing with a large volume of records generated over an extended period. Furthermore, it proves advantageous for tasks like assigning customer or invoice numbers, as the date component imparts additional context beyond just uniqueness.

This approach is easily customizable to cater to any desired set of characters, and removing the date prefix is straightforward if needed.

In scenarios requiring generation of millions of IDs daily, increasing the loop count from 6 to a higher value may be considered, though eventually transitioning to using UUIDs might become preferable.

For those specifically seeking to generate 6 characters, a simplified JavaScript version is available:

const idChars = 'ABCDEFGHJKMNPQRSTUVWXYZ'

function createShortID() {
  let id = ''
  for (let i = 0; i < 6; i++) id += idChars[Math.floor(Math.random() * idChars.length)]
  return id
}