Comparison of various styles of writing a `clamp` function in PHP

README-comparison-of-clamp-functions.md

Introduction

PHP does not have a native "clamp" (or range constraint) function⁽¹⁾.

As always, there are several ways to resolve this problem.

This repo contains several variations that all achieve the same thing: clamp a given value between a given maximum and minimum range.⁽²⁾

The question is: which one has your preference and why?

It is important to note that there is no right or wrong answer, all of the implementations are fully functional. the goal is not to see which variation is more popular but to gain an understanding of why a developer prefers one over the other.

Concerns

When judging code, developers tend to look at the following things⁽³⁾:

• Amount of code
• Code complexity
• Execution speed
• Fault tolerance (being bug free)
• Readability

Of these, only "Readability" is subjective. Complexity, fault tolerance, speed and size can all be measured.

• Full details on ammount of code can be found here.
• Full details on execution speed can be found here.
• Full details on code complexity can be found here.

Scope

To reduce the feature scope to the absolute minimum, the code in the functions is assumed to be low-level code. Validation, type coersion, etc are considered out of scope for the sake of this discussion.

At the point clamp is called:

• $value, $min and $max are all assumed to be integers
• $min is assumed to be smaller than $max

---

Footnotes

1. Although one is proposed for PHP8+
2. To avoid the order of the files causing a bias, the filenames contain a partial MD5 hash of their content.
3. Let me know if I missed anything

clamp.60AA891E.php

<?php

function clamp($value, $min, $max)
{
    return $value < $min ? $min : ( $value > $max ? $max : $value );
}

clamp.7BC1F85B.php

<?php

function clamp($value, $min, $max)
{
    if ($value < $min) {
        $value = $min;
    }
  
    if ($value > $max) {
        $value = $max;
    }

    return $value;
}

clamp.832B9C44.php

<?php

function clamp($value, $min, $max)
{
    return min($max, max($min, $value));
}

clamp.8389C469.php

<?php

function clamp($value, $min, $max)
{
    if ($value < $min) {
        $value = $min;
    } elseif ($value > $max) {
        $value = $max;
    }      

    return $value;
}

clamp.83C742FF.php

<?php

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

    return $value;
}

clamp.A13E087E.php

<?php

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

clamp.CAB599E9.php

<?php

function clamp($value, $min, $max)
{
    if ($value < $min) {
        return $min;
    } elseif ($value > $max) {
        return $max;
    } else {
        return $value;
    }      
}

I'd say number 4 (clamp.83C742FF.php), for readability's sake and executes the least amount of code.
Min/max you have to read carefully what's happening, and does two extra function calls.

clamp.832b9c44.php for me: intent is cleaner, and has a simpler phi representation, which means easier to optimise for future compiler versions

Min/max maybe written in 3 lines, no ifelse needed so less code paths to follow mentally

@mjrider Good point! I will add the variation. Could you show me how you'd write it?

I'd like to nominate yet another alternative... namely one that uses ternary operators :

function clamp($value, $min, $max) {
    return $value < $min ? $min : ( $value > $max ? $max : $value );
}

I like this option because I love oneliners, and because using ternary operators is much faster than going for min($max, max($min, $value));.

Here's the benchmark I used to compare performance :

function clamp1($value, $min, $max) {
    return $value < $min ? $min : ( $value > $max ? $max : $value );
}

function clamp2($value, $min, $max) {
    if ($value < $min) {
        $value = $min;
    } elseif ($value > $max) {
        $value = $max;
    }      
    return $value;
}

function clamp3($value, $min, $max) {
    if ($value < $min) return $min;
    if ($value > $max) return $max;
    return $value;
}

function clamp4($value, $min, $max) {
    return min($max, max($min, $value));
}

$start_time = microtime(TRUE);

for($i = 0; $i < 10000000; $i++) {
    clamp1 (18, 12, 25); // Replace function and/or parameters and rerun the benchmark to compare
}

$end_time = microtime(TRUE);

echo $end_time - $start_time;

Still, my preference goes to the following option :

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

It's not a oneliner, but it's still pretty compact, it's very readable and it's also very fast!

And I think that's the threeliner @mjrider was talking about.

@jpoorthuis I am interested in how you define executes the least amount of code. What are we counting here?
In regards to Min/max [...] does two extra function calls, what is your concern with that?

@jslegers Thanks for responding!

Both of your suggestions have been added.

I've also added some benchmarks.

@Potherca

It looks like your benchmarks produce results very different from my own.

As your results are probably more accurate than my quick-and-dirty tests, I'd like to change my answer to 832b9c44, considering it's the option with both the least code ánd the one with the best performance!

just for the record, i was refering to 832B9C44