Categorise amount into "small", "medium" and "large"

Question

I have a super simple function that returns a text label for a range of the input

function fn(amount) {
  if (amount >= 1 && amount <= 10) return 'small'
  if (amount >= 11 && amount <= 20) return 'medium'
  if (amount >= 21 && amount <= 30) return 'large'
}

And this is an "over-engineered" version of the function but I think it scales better

const labelByAmounts = [
  { min: 1, max: 10, label: 'small' },
  { min: 11, max: 20, label: 'medium' },
  { min: 21, max: 30, label: 'large' },
]

function fn2(amount) {
  return labelByAmounts.find(
    (labelByAmount) =>
      amount >= labelByAmount.min && amount <= labelByAmount.max
  ).label
}

The idea is that the second approach is a table-driven method (learned from the book code complete or also called strategy pattern?) which is more modifiable and extensible. But I find the table lookup is still bit awkward since you have to loop through the list and compare the min and max.

Looking for suggestions to:

1. simplify the lookup process
2. improve the time complexity if the list grows to have thousands of records? Right I think the time complexity for both approaches is o(1) but I guess there might be ways to improve the constant factor?
3. improve the readability
4. maybe a different but better approach?
5. Lastly, is there a way to benchmark these different variants against large dataset to see which one is the fastest (in a specific environment, i.e. browser)?

Answer 1

Test on max only

Or min only, but both is not necessary. Here, I'm coding for "max":

• Array.find returns on the first element meeting the expression
• Data must be sorted by max property, ascending
• min property can be removed from the object
• table lookup is still bit awkward since you have to loop through the list
  • The data and function should be wrapped as an object with the grunt work encapsulated in clearly named and parametrized (as needed) method(s). Half the benefit of "data-driven" is lost otherwise; yeah, half sounds right.

    const rangeLabels = [
      { min: 1, max: 10, label: 'small' },
      { min: 11, max: 20, label: 'medium' },
      { min: 21, max: 30, label: 'large' },
    ]

    function labelOf (amount) {
      return rangeLabels.find( x => amount <= x.max ).label
    }
    
   console.log( labelOf(13));
   console.log( labelOf(1));
   console.log( labelOf(30)); 
    

---

Catch out of range values as if part of the data set

const rangeLabels = [
      { min: Number.MIN_SAFE_INTEGER, max: 10, label: 'small' },
      { min: 11, max: 20, label: 'medium' },
      { min: 21, max: Number.MAX_SAFE_INTEGER, label: 'large' },
    ]