NanoID Generator

Was ist NanoID?

NanoID ist ein kleiner, schneller, URL-sicherer Zufalls-ID-Generator. Standardmäßig erzeugt er 21-Zeichen-Strings mit einem 64-Zeichen-Alphabet (A-Za-z0-9_-), was ungefähr 126 Bits Entropie bietet — vergleichbar mit UUID v4's 122 Bits, aber in einem kürzeren String.

NanoID enthält keinen Zeitstempel oder strukturierte Daten. Jede ID ist rein zufällig, generiert aus dem kryptografisch sicheren Zufallszahlengenerator des Betriebssystems (crypto.getRandomValues() in Browsern, crypto.randomBytes() in Node.js).

NanoID vs UUID v4

NanoID und UUID v4 sind beide durch einen CSPRNG unterstützte Zufalls-ID-Generatoren. Sie unterscheiden sich in Format, Länge und Ökosystem-Unterstützung:

Wählen Sie UUID v4, wenn Interoperabilität mit externen Systemen wichtig ist — Datenbanken mit nativen UUID-Spalten, APIs, die UUID-Format erwarten, oder Logging-Infrastruktur, die UUIDs parst. Wählen Sie NanoID, wenn Sie kürzere IDs wollen und den gesamten Stack kontrollieren.

Kollisionswahrscheinlichkeit nach Größe

NanoIDs Kollisionswahrscheinlichkeit hängt von der ID-Länge und der Generierungsrate ab. Die folgende Tabelle verwendet das Standard-64-Zeichen-Alphabet:

Die Standard-21-Zeichen-Größe ist gewählt, um UUID v4's Kollisionsresistenz (~126 Bits) zu entsprechen, während sie 41% kürzer ist. Für die meisten Anwendungen ist 21 Zeichen die richtige Wahl.

Benutzerdefinierte Alphabete

NanoIDs Alphabet ist vollständig anpassbar. Die Bibliothek akzeptiert jeden String eindeutiger Zeichen als Alphabet und generiert IDs nur mit diesen Zeichen:

Wichtig: Verwenden Sie nanoid/non-secure nur für nicht sicherheitssensible Anwendungen (z. B. UI-Element-IDs). Für jede ID, die nicht erratbar sein muss, verwenden Sie immer den Standard-sicheren Import.

Wie NanoID Zufälligkeit generiert

NanoID verwendet den kryptografisch sicheren Pseudozufallszahlengenerator (CSPRNG) des Betriebssystems. In Browsern ist das crypto.getRandomValues(); in Node.js ist es crypto.randomFillSync(). Das ist dieselbe Entropiequelle, die für TLS-Sitzungsschlüssel verwendet wird — weit stärker als Math.random().

Rejection-Sampling (Modulo-Verzerrung vermeiden)

Ein naiver Ansatz zur Generierung zufälliger Zeichen wäre: ein zufälliges Byte (0–255) nehmen und byte % alphabetSize berechnen. Das führt zu Modulo-Verzerrung — einige Zeichen erscheinen etwas häufiger als andere, wenn die Alphabetgröße 256 nicht gleichmäßig teilt.

NanoID eliminiert diese Verzerrung durch Rejection-Sampling:

1. Die kleinste Zweierpotenz-Maske bestimmen, die die Alphabetgröße abdeckt (z. B. für ein 64-Zeichen-Alphabet ist die Maske 63 = 0b00111111)
2. Zufällige Bytes generieren und die Maske anwenden: byte & mask
3. Wenn der maskierte Wert im Alphabetbereich liegt, verwenden. Andernfalls verwerfen und erneut versuchen.

Das bedeutet, einige zufällige Bytes werden verworfen, aber das Ergebnis ist eine perfekt gleichmäßige Verteilung über das Alphabet — kein Zeichen ist wahrscheinlicher als ein anderes.

// 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"

Umgebungsunterstützung

Code-Beispiele

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 kann direkt im Browser über einen CDN-Import verwendet werden. Kein Build-Schritt für schnelles Prototyping erforderlich.

// 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
}

Häufig gestellte Fragen