0
# lodash.isfinite
1

2
lodash.isfinite is a modularized version of the Lo-Dash `_.isFinite` function that provides stricter finite number validation than JavaScript's native `isFinite()`. It's designed for cases where precise finite number validation is required, avoiding the quirks of the native implementation.
3

4
## Package Information
5

6
- **Package Name**: lodash.isfinite
7
- **Package Type**: npm
8
- **Language**: JavaScript
9
- **Installation**: `npm install lodash.isfinite`
10

11
## Core Imports
12

13
```javascript
14
const isFinite = require('lodash.isfinite');
15
```
16

17
ES6 (if supported):
18

19
```javascript
20
import isFinite from 'lodash.isfinite';
21
```
22

23
## Basic Usage
24

25
```javascript
26
const isFinite = require('lodash.isfinite');
27

28
// Finite numbers
29
isFinite(-101);
30
// => true
31

32
isFinite(42);
33
// => true
34

35
// Numeric strings that can be parsed as finite numbers
36
isFinite('10');
37
// => true
38

39
isFinite('42.5');
40
// => true
41

42
// Values that native isFinite would incorrectly accept
43
isFinite(true);
44
// => false (native would return true)
45

46
isFinite('');
47
// => false (native would return true)
48

49
// Infinite and invalid values
50
isFinite(Infinity);
51
// => false
52

53
isFinite(-Infinity);
54
// => false
55

56
isFinite(NaN);
57
// => false
58

59
isFinite('abc');
60
// => false
61
```
62

63
## Capabilities
64

65
### Finite Number Validation
66

67
Checks if a value is, or can be coerced to, a finite number with stricter validation than native `isFinite()`.
68

69
```javascript { .api }
70
/**
71
 * Checks if `value` is, or can be coerced to, a finite number.
72
 *
73
 * Note: This is not the same as native `isFinite` which will return true for
74
 * booleans and empty strings.
75
 *
76
 * @param {*} value The value to check.
77
 * @returns {boolean} Returns `true` if the `value` is finite, else `false`.
78
 */
79
function isFinite(value);
80
```
81

82
**Key Differences from Native `isFinite()`:**
83

84
- Returns `false` for booleans (`true`, `false`) - native returns `true`
85
- Returns `false` for empty strings (`''`) - native returns `true`
86
- Returns `false` for whitespace-only strings - native returns `true`
87
- Returns `true` only for actual finite numbers and numeric strings that parse to finite numbers
88
- More predictable behavior for input validation and type checking
89

90
**Parameters:**
91
- `value` (any): The value to check for finite number status
92

93
**Returns:**
94
- `boolean`: Returns `true` if the value is finite, else `false`
95

96
**Internal Implementation:**
97
The function uses a combination of native `isFinite()` and additional validation:
98
```javascript
99
function isFinite(value) {
100
  return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));
101
}
102
```
103

104
This ensures that:
105
1. The value passes native `isFinite()` check
106
2. The value can be parsed as a valid number (not NaN when parsed with `parseFloat`)
107

108
## Examples
109

110
### Comparison with Native `isFinite()`
111

112
```javascript
113
const lodashIsFinite = require('lodash.isfinite');
114

115
// Cases where lodash.isfinite differs from native isFinite()
116
console.log('Boolean values:');
117
console.log('lodash.isfinite(true):', lodashIsFinite(true));   // false
118
console.log('native isFinite(true):', global.isFinite(true));        // true
119

120
console.log('Empty strings:');
121
console.log('lodash.isfinite(""):', lodashIsFinite(''));      // false
122
console.log('native isFinite(""):', global.isFinite(''));           // true
123

124
console.log('Whitespace strings:');
125
console.log('lodash.isfinite("   "):', lodashIsFinite('   ')); // false
126
console.log('native isFinite("   "):', global.isFinite('   '));      // true
127

128
// Cases where both behave the same
129
console.log('Valid numbers:');
130
console.log('lodash.isfinite(42):', lodashIsFinite(42));      // true
131
console.log('native isFinite(42):', global.isFinite(42));           // true
132

133
console.log('Numeric strings:');
134
console.log('lodash.isfinite("42"):', lodashIsFinite('42'));  // true
135
console.log('native isFinite("42"):', global.isFinite('42'));       // true
136
```
137

138
### Input Validation Use Case
139

140
```javascript
141
const isFinite = require('lodash.isfinite');
142

143
function processNumericInput(input) {
144
  if (!isFinite(input)) {
145
    throw new Error('Input must be a finite number or numeric string');
146
  }
147
  
148
  return parseFloat(input) * 2;
149
}
150

151
// Valid inputs
152
console.log(processNumericInput(42));     // 84
153
console.log(processNumericInput('42'));   // 84
154
console.log(processNumericInput(-10.5));  // -21
155

156
// Invalid inputs (will throw errors)
157
try {
158
  processNumericInput(true);    // Error: Input must be a finite number
159
} catch (e) {
160
  console.log(e.message);
161
}
162

163
try {
164
  processNumericInput('');      // Error: Input must be a finite number  
165
} catch (e) {
166
  console.log(e.message);
167
}
168
```