https://github.com/codeandcats/reliable-round
A rounding library for JavaScript that behaves predictably (unlike Math.round, Math.floor, Math.ceil).
https://github.com/codeandcats/reliable-round
Last synced: 11 months ago
JSON representation
A rounding library for JavaScript that behaves predictably (unlike Math.round, Math.floor, Math.ceil).
- Host: GitHub
- URL: https://github.com/codeandcats/reliable-round
- Owner: codeandcats
- License: mit
- Created: 2018-11-12T10:54:28.000Z (over 7 years ago)
- Default Branch: master
- Last Pushed: 2023-01-05T16:14:35.000Z (over 3 years ago)
- Last Synced: 2025-07-20T01:34:39.096Z (12 months ago)
- Language: JavaScript
- Size: 1.03 MB
- Stars: 9
- Watchers: 1
- Forks: 0
- Open Issues: 19
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
# reliable-round
A reliable rounding library for JavaScript/TypeScript that actually behaves predictably (unlike Math.round).
[](https://badge.fury.io/js/reliable-round)
[](https://travis-ci.org/codeandcats/reliable-round)
[](https://coveralls.io/github/codeandcats/reliable-round?branch=master)
## Install
```sh
npm install reliable-round --save
```
## Usage
```javascript
import { round } from "reliable-round";
console.log(round(1.005)); // Rounds to a whole integer, returning 1
console.log(round(1.005, 2)); // Rounds to 2 decimal places returning 1.01
```
## Why do I need this?
Because JavaScript floating point math often results in quirky and unpredictable results.
The classic JS WTF example is:
```javascript
console.log(0.1 + 0.2);
// Evaluates to 0.30000000000000004
```
Maybe not what you expected right?
As for rounding, lets say you need to round to 2 decimal places then you can create your own function like this:
```javascript
function roundToTwoDecimalPlaces(value) {
return Math.round(value * 100) / 100;
}
console.log(roundToTwoDecimalPlaces(1.006));
// Returns 1.01 - Correct!
```
At first glace, the output of the above function looks correct. But unfortunately its only correct some of the time!
```javascript
console.log(roundToTwoDecimalPlaces(1.005));
// Returns 1 - Wrong!
// The correct answer is 1.01
```
If you deal with rounding many floats in JS you will inevitably encounter many quirky inconsistencies like this.
[**reliable-round**](https://www.npmjs.com/package/reliable-round) to the rescue!
```javascript
import { round } from "reliable-round";
console.log(round(1.005, 2));
// Correctly returns 1.01
```
While you will get predictable, reliable results using `reliable-round` be aware that it is at the expense of performance. Traditional methods of rounding that use the `Math` class are much faster but at the expense of accuracy. You need to decide what's more important for your use-case.
## Contributing
Got an issue or a feature request? [Log it](https://github.com/codeandcats/reliable-round/issues).
[Pull-requests](https://github.com/codeandcats/reliable-round/pulls) are also welcome. 😸