NanoID Generator

Wat is NanoID?

NanoID is een kleine, snelle, URL-veilige willekeurige ID-generator. Standaard produceert het 21-teken strings met een 64-teken alfabet (A-Za-z0-9_-), wat ongeveer 126 bits entropie biedt — vergelijkbaar met UUID v4's 122 bits maar in een kortere string.

NanoID bevat geen tijdstempel of gestructureerde gegevens. Elke ID is puur willekeurig, gegenereerd uit de cryptografisch veilige willekeurige getallengenerator van het besturingssysteem (crypto.getRandomValues() in browsers, crypto.randomBytes() in Node.js).

NanoID vs UUID v4

NanoID en UUID v4 zijn beide willekeurige ID-generators ondersteund door een CSPRNG. Ze verschillen in formaat, lengte en ecosysteemondersteuning:

Kies UUID v4 wanneer interoperabiliteit met externe systemen van belang is — databases met native UUID-kolommen, API's die UUID-formaat verwachten, of logging-infrastructuur die UUIDs parseert. Kies NanoID wanneer u kortere ID's wilt en de volledige stack beheert.

Botsingskans per grootte

NanoIDs botsingskans hangt af van de ID-lengte en de generatiesnelheid. De volgende tabel gebruikt het standaard 64-teken alfabet:

De standaard 21-teken grootte is gekozen om overeen te komen met UUID v4's botsingsbestendigheid (~126 bits) terwijl het 41% korter is. Voor de meeste toepassingen is 21 tekens de juiste keuze.

Aangepaste alfabetten

NanoIDs alfabet is volledig aanpasbaar. De bibliotheek accepteert elke string van unieke tekens als het alfabet en genereert ID's met alleen die tekens:

Belangrijk: gebruik nanoid/non-secure alleen voor niet-beveiligingsgevoelige toepassingen (bijv. UI-element-ID's). Voor elke ID die onraadbaar moet zijn, gebruik altijd de standaard veilige import.

Hoe NanoID willekeurigheid genereert

NanoID gebruikt de cryptografisch veilige pseudo-willekeurige getallengenerator (CSPRNG) van het besturingssysteem. In browsers is dat crypto.getRandomValues(); in Node.js is het crypto.randomFillSync(). Dit is dezelfde entropiebron die wordt gebruikt voor TLS-sessiesleutels — veel sterker dan Math.random().

Rejection-sampling (modulo-bias vermijden)

Een naïeve aanpak voor het genereren van willekeurige tekens zou zijn: neem een willekeurig byte (0–255) en bereken byte % alphabetSize. Dit introduceert modulo-bias — sommige tekens komen iets vaker voor dan andere wanneer de alfabetgrootte 256 niet gelijkmatig deelt.

NanoID elimineert deze bias met rejection-sampling:

1. Bepaal het kleinste macht-van-twee-masker dat de alfabetgrootte dekt (bijv. voor een 64-teken alfabet is het masker 63 = 0b00111111)
2. Genereer willekeurige bytes en pas het masker toe: byte & mask
3. Als de gemaskeerde waarde binnen het alfabetbereik valt, gebruik die. Anders verwerpen en opnieuw proberen.

Dit betekent dat sommige willekeurige bytes worden verworpen, maar het resultaat is een perfect uniforme verdeling over het alfabet — geen teken is waarschijnlijker dan een ander.

// Pure browser — no npm package needed
function generateNanoid(alphabet, size) {
  const mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
  const step = Math.ceil((1.6 * mask * size) / alphabet.length)
  let id = ''
  while (id.length < size) {
    const bytes = crypto.getRandomValues(new Uint8Array(step))
    for (const byte of bytes) {
      const idx = byte & mask
      if (idx < alphabet.length) {
        id += alphabet[idx]
        if (id.length === size) break
      }
    }
  }
  return id
}

const URL_SAFE = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
generateNanoid(URL_SAFE, 21)  // → "V1StGXR8_Z5jdHi6B-myT"

Omgevingsondersteuning

Codevoorbeelden

JavaScript / TypeScript

// npm i nanoid
import { nanoid } from 'nanoid'
nanoid()          // → "V1StGXR8_Z5jdHi6B-myT" (21 chars, URL-safe)
nanoid(8)         // → "Uakgb_J5" (custom size)

// Custom alphabet
import { customAlphabet } from 'nanoid'
const hexId  = customAlphabet('0123456789abcdef', 16)
hexId()       // → "4f3a1b8c9d2e0f7a"

const numId  = customAlphabet('0123456789', 8)
numId()       // → "30812894"

Browser (CDN)

NanoID kan direct in de browser worden gebruikt via een CDN-import. Geen build-stap vereist voor snel prototypen.

// Pure browser — no npm package needed
function generateNanoid(alphabet, size) {
  const mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
  const step = Math.ceil((1.6 * mask * size) / alphabet.length)
  let id = ''
  while (id.length < size) {
    const bytes = crypto.getRandomValues(new Uint8Array(step))
    for (const byte of bytes) {
      const idx = byte & mask
      if (idx < alphabet.length) {
        id += alphabet[idx]
        if (id.length === size) break
      }
    }
  }
  return id
}

const URL_SAFE = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
generateNanoid(URL_SAFE, 21)  // → "V1StGXR8_Z5jdHi6B-myT"

Python

# pip install nanoid
from nanoid import generate

generate()              # → "V1StGXR8_Z5jdHi6B-myT"
generate(size=8)        # → "Uakgb_J5"
generate('0123456789abcdef', 16)  # custom alphabet + size

Node.js (CommonJS)

// Node.js — stdlib only, no npm needed
const { randomFillSync } = require('crypto')

function nanoid(alphabet, size) {
  const mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
  const step = Math.ceil((1.6 * mask * size) / alphabet.length)
  let id = ''
  while (id.length < size) {
    const bytes = randomFillSync(Buffer.alloc(step))
    for (const byte of bytes) {
      const idx = byte & mask
      if (idx < alphabet.length) { id += alphabet[idx]; if (id.length === size) break }
    }
  }
  return id
}

Veelgestelde vragen