Overview
Introduction
A logical right shift moves every bit in a value one or more positions to the right, filling the vacated high-order positions with zeros and discarding whatever falls off the bottom, commonly used for fast unsigned division by powers of two.
This tool applies a configurable right shift to any binary string, computing the result with BigInt so long values shift correctly.
What Is Binary Right Shifter?
A fixed-width logical right-shift tool: bits move right by N positions, zeros fill in on the left, and any bits pushed past the right edge are discarded.
It's the mirror operation of Binary Left Shifter, and distinct from Binary Bit Rotator, which wraps overflow bits around instead of dropping them.
How Binary Right Shifter Works
The binary string is parsed into a BigInt representing its unsigned value.
The value is shifted right by the chosen amount using BigInt's `>>` operator (which naturally discards the low bits and never sign-extends, since the value is always treated as non-negative), then the result is re-padded to the original width with leading zeros.
When To Use Binary Right Shifter
Use it to simulate a hardware logical-right-shift instruction, quickly divide an unsigned binary value by a power of two, or extract high-order bits from a value.
It's not appropriate when you need to preserve every bit, use Binary Bit Rotator instead if the low bits shouldn't be discarded.
Often used alongside Binary Left Shifter, Binary Bit Rotator and Binary to Any Base Converter.
Features
Advantages
- BigInt-based arithmetic correctly handles binary strings of any length, not just those under 32 bits.
- Purely logical (zero-fill) behavior, with no unexpected sign-extension since binary strings here are treated as unsigned.
- Zero shift amounts and out-of-range (too-large) amounts are both handled predictably.
Limitations
- Always operates at the input string's own fixed width, there's no separate 'register size' setting beyond how many digits you type.
- Discarded low-order bits are gone for good, a right shift cannot be undone by shifting back left, that would just append zeros, not restore the original bits.
Examples
Best Practices & Notes
Best Practices
- Remember a right shift divides the represented unsigned value by 2 per position shifted, rounding toward zero (any dropped low bit is simply discarded).
- Use Binary Bit Rotator instead if you need a lossless rearrangement rather than a value-changing, bit-dropping shift.
Developer Notes
The shift is computed as `BigInt(value) >> BigInt(amount)`, then re-padded to the original width with `padStart`; BigInt's `>>` never sign-extends because the parsed value is always non-negative, so no masking step is needed the way the left-shift tool needs one.
Binary Right Shifter Use Cases
- Simulating a CPU's logical shift-right instruction
- Quickly dividing an unsigned binary value by a power of two
- Extracting the high-order bits of a value by shifting the low bits out
Common Mistakes
- Expecting a right shift to behave like a rotation, a shift permanently discards overflow bits instead of wrapping them around.
- Assuming this performs a signed arithmetic shift with sign extension, it doesn't, all binary strings here are treated as unsigned and shifted with plain zero-fill.
Tips
- A right shift by 1 is equivalent to unsigned integer division by 2, discarding any remainder.
- If you need to preserve every bit, use Binary Bit Rotator instead of a shift.