Math.clz32() — Methode · JavaScript-Referenz

Signatur

Math.clz32(x)

Beschreibung

Math.clz32() ist eine statische Methode des Math-Objekts. Sie wandelt ihr Argument zuerst in eine 32-Bit-Ganzzahl ohne Vorzeichen um (intern mit der Operation ToUint32). Danach zählt sie, wie viele Nullbits vor dem ersten gesetzten Bit stehen. Das Ergebnis ist immer eine Ganzzahl zwischen 0 und 32. Bei 0 erhält man 32, bei negativen Zahlen 0, weil dort das höchste Bit gesetzt ist.

Die Methode ist für schnelle Bit-Operationen gedacht. Moderne JavaScript-Engines übersetzen sie meist direkt in einen einzigen Prozessorbefehl (z. B. LZCNT oder CLZ). Typische Einsatzfälle:

Bitlänge einer Zahl bestimmen: 32 - Math.clz32(n)
Ganzzahligen Zweierlogarithmus berechnen: 31 - Math.clz32(n)
Nächste Zweierpotenz finden, z. B. für Puffergrößen oder Hash-Tabellen
Effizient mit Bitmasken, Bitsets und Komprimierungsverfahren arbeiten, oder Code aus C/C++ bzw. WebAssembly (asm.js) übertragen

Es gibt kein direktes Gegenstück für führende Einsen oder für Nullbits am Ende. Beide lassen sich aber mit Bitoperatoren nachbauen: führende Einsen mit Math.clz32(~x), Nullbits am Ende mit 31 - Math.clz32(x & -x).

Parameter

Name	Typ	Default	Beschreibung
$x Pflicht	number		Die zu untersuchende Zahl. Andere Typen werden erst in eine Zahl umgewandelt, danach mit `ToUint32` in eine 32-Bit-Ganzzahl ohne Vorzeichen: Nachkommastellen fallen weg, größere Werte werden modulo 2³² umgebrochen. `NaN` und `±Infinity` werden zu `0`.

Rückgabewert

Typ

number

Beschreibung

Die Anzahl der Nullbits am Anfang der 32-Bit-Darstellung, eine Ganzzahl von 0 bis 32. Ist der umgewandelte Wert 0, ist das Ergebnis 32.

Beispiele

Grundlegende Werte und Typumwandlung

console.log(Math.clz32(1));        // 0b1 → 31 führende Nullen
console.log(Math.clz32(1000));     // 10 Bits belegt
console.log(Math.clz32(0));        // kein Bit gesetzt
console.log(Math.clz32(-1));       // 0xFFFFFFFF
console.log(Math.clz32(3.9));      // Nachkommastellen fallen weg → 3
console.log(Math.clz32('12'));     // String wird zu 12 = 0b1100
console.log(Math.clz32(NaN));      // NaN → 0
console.log(Math.clz32(2 ** 32));  // Umbruch → 0

31 22 32 0 30 28 32 32

Bitlänge und ganzzahliger Zweierlogarithmus

const bitLength = (n) => 32 - Math.clz32(n);
const log2Floor = (n) => 31 - Math.clz32(n);

for (const n of [1, 255, 256, 1_000_000]) {
  console.log(`${n}: ${bitLength(n)} Bits, log2 = ${log2Floor(n)}`);
}

1: 1 Bits, log2 = 0 255: 8 Bits, log2 = 7 256: 9 Bits, log2 = 8 1000000: 20 Bits, log2 = 19

Nächste Zweierpotenz für eine Puffergröße

// Rundet auf die nächste Zweierpotenz auf (gültig für 1 bis 2^31)
const nextPowerOfTwo = (n) => (n <= 1 ? 1 : 2 ** (32 - Math.clz32(n - 1)));

const sizes = [1, 16, 17, 1000];
console.log(sizes.map(nextPowerOfTwo));

const buffer = new ArrayBuffer(nextPowerOfTwo(1000));
console.log(buffer.byteLength);

[ 1, 16, 32, 1024 ] 1024

Führende Einsen und Nullbits am Ende nachbauen

// Führende Einsen: Bits umkehren, dann Nullen zählen
const clo32 = (x) => Math.clz32(~x);

// Nullbits am Ende: niedrigstes gesetztes Bit isolieren
const ctz32 = (x) => (x === 0 ? 32 : 31 - Math.clz32(x & -x));

console.log(clo32(0xF0000000)); // 1111 0000 ...
console.log(ctz32(8));          // 0b1000
console.log(ctz32(96));         // 0b1100000

4 3 5

// Wichtig · Fallstricke

Nur 32 Bit: Werte ab 2³² werden modulo 2³² umgebrochen. Math.clz32(2 ** 32) ergibt deshalb 32, nicht 0. Für größere Ganzzahlen nimmt man BigInt, z. B. mit n.toString(2).length.
Nicht mit 0 rechnen: Für 0, NaN, Infinity und Werte zwischen 0 und 1 wird die Zahl zu 0 und das Ergebnis ist 32. Formeln wie 31 - Math.clz32(n) liefern dann -1. Solche Fälle sollte man vorher gesondert behandeln.
Negative Zahlen ergeben immer 0, weil ihr höchstes Bit in der Zweierkomplement-Darstellung gesetzt ist.
Es gibt kein Math.clz64(), und die Methode akzeptiert kein BigInt: Math.clz32(1n) wirft einen TypeError.
Die Methode ist in allen modernen Browsern und in Node.js verfügbar (Baseline). Nur sehr alte Umgebungen wie der Internet Explorer brauchen eine Ersatzimplementierung (Polyfill), z. B. mit 31 - Math.floor(Math.log2(x >>> 0)) und einer Sonderbehandlung für 0.

Siehe auch

Math.log2() Math.imul() Math.trunc() Math.fround() >>> Math