How to generate short uid like "aX4j9Z" (in JS)

Solution 1:

See @Mohamed's answer for a pre-packaged solution (the shortid package). Prefer that instead of any other solutions on this page if you don't have special requirements.

A 6-character alphanumeric sequence is pretty enough to randomly index a 10k collection (36⁶ = 2.2 billion and 36³ = 46656).

function generateUID() {
    // I generate the UID from two parts here 
    // to ensure the random number provide enough bits.
    var firstPart = (Math.random() * 46656) | 0;
    var secondPart = (Math.random() * 46656) | 0;
    firstPart = ("000" + firstPart.toString(36)).slice(-3);
    secondPart = ("000" + secondPart.toString(36)).slice(-3);
    return firstPart + secondPart;
}

UIDs generated randomly will have collision after generating ~ √N numbers (birthday paradox), thus 6 digits are needed for safe generation without checking (the old version only generates 4 digits which would have a collision after 1300 IDs if you don't check).

If you do collision checking, the number of digits can be reduced 3 or 4, but note that the performance will reduce linearly when you generate more and more UIDs.

var _generatedUIDs = {};
function generateUIDWithCollisionChecking() {
    while (true) {
        var uid = ("0000" + ((Math.random() * Math.pow(36, 4)) | 0).toString(36)).slice(-4);
        if (!_generatedUIDs.hasOwnProperty(uid)) {
            _generatedUIDs[uid] = true;
            return uid;
        }
    }
}

Consider using a sequential generator (e.g. user134_item1, user134_item2, …) if you require uniqueness and not unpredictability. You could "Hash" the sequentially generated string to recover unpredictability.

UIDs generated using Math.random is not secure (and you shouldn't trust the client anyway). Do not rely on its uniqueness or unpredictability in mission critical tasks.

Solution 2:

Update 08/2020:

shortid has been deprecated in favor of nanoid which is smaller and faster:

• Small. 108 bytes (minified and gzipped). No dependencies. Size Limit controls the size.
• Fast. It is 40% faster than UUID.
• Safe. It uses cryptographically strong random APIs. Can be used in clusters.
• Compact. It uses a larger alphabet than UUID (A-Za-z0-9_-). So ID size was reduced from 36 to 21 symbols.
• Portable. Nano ID was ported to 14 programming languages.

import { nanoid } from 'nanoid'

// 21 characters (default)
// ~149 billion years needed, in order to have a 1% probability of at least one collision.
console.log(nanoid()) //=> "V1StGXR8_Z5jdHi6B-myT"

// 11 characters
// ~139 years needed, in order to have a 1% probability of at least one collision.
console.log(nanoid(11)) //=> "bdkjNOkq9PO"

More info here : https://zelark.github.io/nano-id-cc/

Old answer

There is also an awesome npm package for this : shortid

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

ShortId creates amazingly short non-sequential url-friendly unique ids. Perfect for url shorteners, MongoDB and Redis ids, and any other id users might see.

• By default 7-14 url-friendly characters: A-Z, a-z, 0-9, _-
• Non-sequential so they are not predictable.
• Supports cluster (automatically), custom seeds, custom alphabet.
• Can generate any number of ids without duplicates, even millions per day.
• Perfect for games, especially if you are concerned about cheating so you don't want an easily guessable id.
• Apps can be restarted any number of times without any chance of repeating an id.
• Popular replacement for Mongo ID/Mongoose ID.
• Works in Node, io.js, and web browsers.
• Includes Mocha tests.

Usage

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

Solution 3:

Here is a one liner, but it gives only lowercase letters and numbers:

var uuid = Math.random().toString(36).slice(-6);

console.log(uuid);

Solution 4:

Get a simple counter to start from 100000000, convert the number into radix 36.

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

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

You can comfortably have 2 billion elegant unique ids, just like YouTube

Solution 5:

The following generates 62^3 (238,328) unique values of 3 characters provided case sensitivity is unique and digits are allowed in all positions. If case insensitivity is required, remove either upper or lower case characters from chars string and it will generate 35^3 (42,875) unique values.

Can be easily adapted so that first char is always a letter, or all letters.

No dobut it can be optimised, and could also refuse to return an id when the limit is 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;
  }
}());