Is there a way to always floor the result?

[masinamichele]

Hello,
Is there an option to specify the library should always floor the rounding?
Currently 1390 gets displayed as 1.4k, I would like for it to show 1.3k while the input value is strictly less than 1400.

In other words, I'd like to never show a value actually higher than the input.

Just for reference, the options I'm currently using are { maxDecimals: 'auto', separator: '' }.

Thank you.

[julien-f]

Unfortunately that's not possible ATM, what option would you suggest for this?

[masinamichele]

Hello,
Sorry for the late reply, I just recently got back to working on the project where I'm using this library.

I don't have any elegant solutions ready for this situation.

For me, on a system where I know my numbers won't exceed the billions, I came up with the very dirty solution of subtracting the ceiling-round part of the number:

Details

  // Please don't use this code
  const scale = new humanFormat.Scale({ '': 1, K: 1_000, M: 1_000_000, B: 1_000_000_000 });
  if (value >= 10_500_000_000_000_000) value -= 500_000_000_000_000;
  else if (value >= 10_500_000_000_000) value -= 500_000_000_000;
  else if (value >= 10_500_000_000) value -= 500_000_000;
  else if (value >= 10_500_000) value -= 500_000;
  else if (value >= 10_500) value -= 500;
  else if (value >= 1_050) value -= 50;
  return humanFormat(value, { maxDecimals: 'auto', separator: '', scale });

Of course, this is a terrible and unmaintainable solution. I'm even scared of writing tests for it right now.
I guess I could come up with an automated system to calculate how much to subtract (besides the last case, there is a clear pattern), but I don't think I want to invest time on this.

Some other ways I thought about are the following, of course, that will only be if a alwaysFloor option is passed:

1. Use Math.floor() instead of Math.round()
   I saw you make a couple of calls to it. I don't know the implications and consequences of switching to the floor function, but I guess that will be the first thing to try.
2. Have a way to "un-humanize" the result
   What I mean is, let's say I pass 1390 and get 1.4K as output. "Unhumanizing" the result will yield 1400, which is higher than the input, so the result should be lowered by one unit (that is, one less "K") in order to become 1.3K and be lower than the input.

[masinamichele]

Well hello again,
Just after I posted the last message I realized there is a parse() function that does exactly what I needed (for the second point above).

So basically, I just check if the humanized value is higher than the input, and if it is, I lower the last number by 1 with a regex.

  // Don't use this, see next message!
  const scale = new humanFormat.Scale({ '': 1, K: 1_000, M: 1_000_000, B: 1_000_000_000 });
  const humanized = humanFormat(value, { maxDecimals: 'auto', separator: '', scale });
  if (humanFormat.parse(humanized, { scale }) <= value) return humanized;
  return humanized.replace(/(\d)(\w)$/, (_, lastDigit, unit) => `${+lastDigit - 1}${unit}`);

I will probably continue working on it to see if I can ease up that regex a little, but for now this is a working solution, and definitely better than the previous one.

(edit: forgot a line in the snippet)

[masinamichele]

Hello, it's me again.
I found a bug with my previous solution.
Values like 19900 would normally be formatted as 20K, using my solution I would subtract 1 from the last digit, zero, giving a result of 2-1K instead of the expected 19K.

The solution I came up with is to use the regex to match all the numbers possibly following a dot, if present. Those numbers will then be considered as a whole, so instead of subtrating 1 from 0 I'd subtract it from 20, correctly yielding 19.
The dot has to be re-added, if it matched before.

The final snippet becomes:

  const scale = new humanFormat.Scale({ '': 1, K: 1_000, M: 1_000_000, B: 1_000_000_000 });
  const humanized = humanFormat(value, { maxDecimals: 'auto', separator: '', scale });
  if (humanFormat.parse(humanized, { scale }) <= value) return humanized;
  return humanized
    .replace(/(\.)?(\d+)(\w)$/, (_, dot, num, unit) => `${dot || ''}${+num - 1}${unit}`)
    .replace(/\.0(\w)/, (_, unit) => unit);

I really hope I'm helping someone else that happes to stumble here :)

(edit) Added another replace to handle cases like 1050 would be otherwise written as 1.0K instead of 1K