Hacker News Reader

Comment by STRML | Hacker News Reader

The basic function is simply defined as:

  function clamp(num, min, max) {
    return Math.max(min, Math.min(num, max));
  }

That is, if you don't try to do anything fancy and make any parameters optional. Lodash does and it makes the implementation much more complex.

  _.clamp(input: number, lower?: number, upper: number): number;

https://github.com/lodash/lodash/blob/ddfd9b11a0126db2302cb7...

View on HN

Or to make sure it's crystal clear what's going on:

    function clamp(num, min, max) {
      if (num > max)
        return max;
      if (num < min)
        return min;
      return num;
    }

Seriously. This is about a million times better.

Absolutely. With the above implementation, I can see exactly what's going on, with the others, I'm trying to work out potential edge cases.

I prefer the min/max-based definition for the same reason: Its easier to work out the edge cases around NaN and comparisons against NaN.

NaN always returns false on comparisons. So seems pretty straight forward that this would return NaN if NaN is passed in.

That doesn't seem unreasonable. (In fact, that's what happens with the min/max approach).

Speaking only to JS is there any reason to write it any other way outside of being clever or as a lambda for singular use? I definitely prefer this version. (Assuming any necessary runtime checks are included for a given project)

There are many reasons to forego readability, especially when writing a library: performance, compatibility, requirements, interpreter/compiler optimizations or even cyclomatic complexity.

In lodash's case it might even be all of the above, although I can't speak for the intentions of the authors since there are no comments to guide readers through the process.

Note GP's link points to what looks like the v3 branch. Check out the latest implementation of clamp, with a few less if statements, and what looks like a NaN check using strict equality if you want your mind blown. https://github.com/lodash/lodash/blob/86a852fe763935bb64c125...

Reading that code it looks to me that:

clamp(null) returns 0

clamp(undefined) returns NaN

clamp(1, NaN, NaN) returns 0

clamp(1) returns 0

clamp(1, 5, NaN) returns 5

JavaScript is hard to write safe code for.

those extra newline characters slow down the page load :)

You’re joking right

Now in C# with pattern matching:

    int clamp(num, min, max)  
    {  
      return num switch  
             {  
               _ when num > max => max,  
               _ when num < min => min,  
               _ => num  
             };  
    }

Or as a lambda:

    Func<int, int, int, int> clamp = (num, min, max) => num switch {_ when num > max => max, _ when num < min => min,_ => num};

Yep, I came to the same conclusion https://twitter.com/jaffathecake/status/1296423819238944768

Reply on news.ycombinator.com