Javascript：在余数为0时产生除数的实现模数

Question

In my current project, I've often needed to know the position of a number within a given interval (and it needed to be 1-based, not 0 based). Let's use converting time as an example -- going from the 0-based 24 hour clock to the 1-based 12 hour clock (so 12 is the interval). Given 2 hrs or 14 hrs, the 'position' should be 2. Given 0 or 12, the position equals 12 (not 0).

The obvious method is modulo -- 14 % 12 = 2 as expected. However, 12 % 12 = 0 , and like I said, it needs to be 1-based. I couldn't just add 1 to the result of the modulo to make it 1-based, because then the position of 12 in the interval 12 would be 1, the position of 14 in 12 would be 3, and so on.

I came up with 2 methods to solve this:

1. position = value % interval || interval position = value % interval || interval (relying on the falsey 0)
2. position = (value - 1) % interval + 1 (or if you need to support values that start at 0, like in the 24-hour clock, it would be (value + interval - 1) instead)

Which of these methods should be used?
Are there pros / cons / potential pitfalls I should be aware of?
Or is there a better method that I'm unaware of?

Answer 1

So based on the comments I received, both methods I originally came up with were lacking in type checking and in how they handled zeros or negatives. Based on that feedback, I changed my function to the following:

function positionInInterval( value, interval ) {

    // Check for valid input
    // Rather than throw an error, you could return undefined or NaN
    if ( typeof value !== 'number' || typeof interval !== 'number' )
        throw new TypeError('Argument type must be Number');
    if ( interval < 2 )
        throw new RangeError('Interval must be greater than 1');

    if ( value < 0 )
        return value % interval + interval;

    return value % interval || interval;
}

It treats all numbers as being on a continuous 'number line', including negative numbers, so that by increasing value by 1, its 'position' in interval always increases by 1, until the next interval.

^{Note: user Slai indicated that || might make Method 1 slightly slower than Method 2, but at least in Chrome, they seemed neck and neck, except when I determined value with Math.random() , in which case || was always slightly faster.}

---

I know the use cases related to this question are limited, but I hope it helps someone out! This is the sort of information that I never know I need until I stumble across it. :)