From 40d74e6a2f1e11769e065ad012a4150989e458d8 Mon Sep 17 00:00:00 2001 From: Vladimir Gorej Date: Thu, 24 Aug 2017 13:35:53 +0200 Subject: [PATCH] feat: add isFloat Ref #98 --- src/index.d.ts | 7 +++++- src/index.js | 7 ++++-- src/isFloat.js | 38 +++++++++++++++++++++++++++++ src/{isInterger.js => isInteger.js} | 2 +- src/isNotInteger.js | 2 +- src/isNumber.js | 3 ++- test/isFloat.js | 28 +++++++++++++++++++++ test/isInteger.js | 2 ++ 8 files changed, 83 insertions(+), 6 deletions(-) create mode 100644 src/isFloat.js rename src/{isInterger.js => isInteger.js} (94%) create mode 100644 test/isFloat.js diff --git a/src/index.d.ts b/src/index.d.ts index 1a674fb1fc..e443719a64 100644 --- a/src/index.d.ts +++ b/src/index.d.ts @@ -218,10 +218,15 @@ declare namespace RamdaAdjunct { isNotFinite(val: any): boolean; /** - * Checks whether the passed value is a an `integer`. + * Checks whether the passed value is an `integer`. */ isInteger(val: any): boolean; + /** + * Checks whether the passed value is a `float`. + */ + isFloat(val: any): boolean; + /** * Checks whether the passed value is complement of `integer`. */ diff --git a/src/index.js b/src/index.js index 6b0442720d..cf8466bd2f 100644 --- a/src/index.js +++ b/src/index.js @@ -36,7 +36,8 @@ import isNaN from './isNaN'; import isNotNaN from './isNotNaN'; import isFinite from './isFinite'; import isNotFinite from './isNotFinite'; -import isInteger from './isInterger'; +import isInteger from './isInteger'; +import isFloat from './isFloat'; import isNotInteger from './isNotInteger'; // Function import stubUndefined from './stubUndefined'; @@ -114,7 +115,8 @@ export { default as isNaN } from './isNaN'; export { default as isNotNaN } from './isNotNaN'; export { default as isFinite } from './isFinite'; export { default as isNotFinite } from './isNotFinite'; -export { default as isInteger } from './isInterger'; +export { default as isInteger } from './isInteger'; +export { default as isFloat } from './isFloat'; export { default as isNotInteger } from './isNotInteger'; // Function export { default as stubUndefined } from './stubUndefined'; @@ -198,6 +200,7 @@ const RA = { isFinite, isNotFinite, isInteger, + isFloat, isNotInteger, // Function stubUndefined, diff --git a/src/isFloat.js b/src/isFloat.js new file mode 100644 index 0000000000..102f448c3f --- /dev/null +++ b/src/isFloat.js @@ -0,0 +1,38 @@ +import { complement, allPass } from 'ramda'; + +import isInteger from './isInteger'; +import isNumber from './isNumber'; +import isNotNaN from './isNotNaN'; +import isFinite from './isFinite'; + +/** + * Checks whether the passed value is a `float`. + * + * @func isFloat + * @memberOf RA + * @since {@link https://char0n.github.io/ramda-adjunct/1.14.0|v1.14.0} + * @category Type + * @sig * -> Boolean + * @param {*} val The value to test + * @return {Boolean} + * @see {@link RA.isNotFloat|isNotFloat} + * @example + * + * RA.isFloat(0); //=> false + * RA.isFloat(1); //=> false + * RA.isFloat(-100000); //=> false + * + * RA.isFloat(0.1); //=> true + * RA.isFloat(Math.PI); //=> true + * + * RA.isFloat(NaN); //=> false + * RA.isFloat(Infinity); //=> false + * RA.isFloat(-Infinity); //=> false + * RA.isFloat('10'); //=> false + * RA.isFloat(true); //=> false + * RA.isFloat(false); //=> false + * RA.isFloat([1]); //=> false + */ +const isFloat = allPass([isNumber, isNotNaN, isFinite, complement(isInteger)]); + +export default isFloat; diff --git a/src/isInterger.js b/src/isInteger.js similarity index 94% rename from src/isInterger.js rename to src/isInteger.js index a382794877..1f96279c53 100644 --- a/src/isInterger.js +++ b/src/isInteger.js @@ -3,7 +3,7 @@ import { or } from 'ramda'; import polyfill from './internal/polyfills/Number.isInteger'; /** - * Checks whether the passed value is a an `integer`. + * Checks whether the passed value is an `integer`. * * @func isInteger * @memberOf RA diff --git a/src/isNotInteger.js b/src/isNotInteger.js index abf12d483b..f3645575fb 100644 --- a/src/isNotInteger.js +++ b/src/isNotInteger.js @@ -1,6 +1,6 @@ import { complement } from 'ramda'; -import isInteger from './isInterger'; +import isInteger from './isInteger'; /** diff --git a/src/isNumber.js b/src/isNumber.js index af8e3b606a..ff6f70df07 100644 --- a/src/isNumber.js +++ b/src/isNumber.js @@ -16,7 +16,8 @@ import _isNumber from 'ramda/src/internal/_isNumber'; * RA.isNumber(5); // => true * RA.isNumber(Number.MAX_VALUE); // => true * RA.isNumber(-Infinity); // => true - * RA.isNumber('5'); // => false + * RA.isNumber(NaN); // => true + * RA.isNumber('5'); // => false * */ const isNumber = _isNumber; diff --git a/test/isFloat.js b/test/isFloat.js new file mode 100644 index 0000000000..1370a0844c --- /dev/null +++ b/test/isFloat.js @@ -0,0 +1,28 @@ +import RA from '../src/index'; +import MAX_SAFE_INTEGER from '../src/internal/polyfills/Number.MAX_SAFE_INTEGER'; +import MIN_SAFE_INTEGER from '../src/internal/polyfills/Number.MIN_SAFE_INTEGER'; +import eq from './shared/eq'; + + +describe('isFloat', function() { + it('tests a value for `float`', function() { + eq(RA.isFloat(0), false); + eq(RA.isFloat(1), false); + eq(RA.isFloat(-100000), false); + eq(RA.isFloat(MAX_SAFE_INTEGER), false); + eq(RA.isFloat(MIN_SAFE_INTEGER), false); + eq(RA.isFloat(5e+0), false); + + eq(RA.isFloat(0.1), true); + eq(RA.isFloat(Math.PI), true); + eq(RA.isFloat(5.56789e+0), true); + + eq(RA.isFloat(NaN), false); + eq(RA.isFloat(Infinity), false); + eq(RA.isFloat(-Infinity), false); + eq(RA.isFloat('10'), false); + eq(RA.isFloat(true), false); + eq(RA.isFloat(false), false); + eq(RA.isFloat([1]), false); + }); +}); diff --git a/test/isInteger.js b/test/isInteger.js index 3f6a64f3bd..eb1c6d056d 100644 --- a/test/isInteger.js +++ b/test/isInteger.js @@ -11,9 +11,11 @@ describe('isInteger', function() { eq(RA.isInteger(-100000), true); eq(RA.isInteger(MAX_SAFE_INTEGER), true); eq(RA.isInteger(MIN_SAFE_INTEGER), true); + eq(RA.isInteger(5e+0), true); eq(RA.isInteger(0.1), false); eq(RA.isInteger(Math.PI), false); + eq(RA.isInteger(5.56789e+0), false); eq(RA.isInteger(NaN), false); eq(RA.isInteger(Infinity), false);