In Typescript I can do this:
var xxx : some_type;
if (xxx)
foo();
else
bar();
Here xxx will be treated as a boolean, regardless of its
Use this
YourMethod(!!isEnabled);
'!!' is used for type casting to boolean
You can use this trick which Typescript does allow and which works fine in JavaScript:
foo(!!xxx);
Alternatively, cast it to any
foo(<any>xxx);
With TypeScript 2.0.2 you can do this:
type Falsey = '' | 0 | false | null | undefined;
function eatFruit(fruit: string | Falsey) {
if (fruit) {
alert(`Ate ${fruit}`);
} else {
alert('No fruit to eat!');
}
}
const fruits = ['apple', 'banana', 'pear'];
eatFruit(fruits[0]); // alerts 'Ate apple'
eatFruit(fruits[1]); // alerts 'Ate banana'
eatFruit(fruits[2]); // alerts 'Ate pear'
eatFruit(fruits[3]); // alerts 'No fruit to eat!'
const bestBeforeDay = 12;
let day = 11;
eatFruit(day < bestBeforeDay && 'peach'); // alerts 'Ate peach'
day += 1;
eatFruit(day < bestBeforeDay && 'peach'); // alerts 'No fruit to eat!'
let numMangos = 1;
eatFruit(numMangos && 'mango'); // alerts 'Ate Mango'
numMangos -= 1;
eatFruit(numMangos && 'mango'); // alerts 'No fruit to eat!'
Here is my solution for "typescript": "^3.3.3"
:
function toBool(a: any) {
return Boolean(a).valueOf();
}
export { toBool };
unit test:
import { toBool } from '../../utils/bool';
describe('bool', () => {
describe('#toBool', () => {
it('should convert string to boolean', () => {
expect(toBool('false')).toBeTruthy();
expect(toBool('')).toBeFalsy();
});
it('should convert number to boolean', () => {
expect(toBool(1)).toBeTruthy();
expect(toBool(0)).toBeFalsy();
expect(toBool(-1)).toBeTruthy();
expect(toBool(Infinity)).toBeTruthy();
expect(toBool(-Infinity)).toBeTruthy();
});
it('should convert null to boolean', () => {
expect(toBool(null)).toBeFalsy();
});
it('should convert undefined to boolean', () => {
expect(toBool(undefined)).toBeFalsy();
});
it('should convert NaN to boolean', () => {
expect(toBool(NaN)).toBeFalsy();
});
it('should convert object to boolean', () => {
expect(toBool({})).toBeTruthy();
});
it('should convert array to boolean', () => {
expect(toBool([])).toBeTruthy();
});
});
});
unit test results:
PASS src/__tests__/utils/bool.spec.ts
bool
#toBool
✓ should convert string to boolean (3ms)
✓ should convert number to boolean (1ms)
✓ should convert null to boolean (1ms)
✓ should convert undefined to boolean
✓ should convert NaN to boolean (1ms)
✓ should convert object to boolean (1ms)
✓ should convert array to boolean
Test Suites: 1 passed, 1 total
Tests: 7 passed, 7 total
Snapshots: 0 total
Time: 3.79s, estimated 4s
if(xxx) {...} //read as TRUE if xxx is NOT undefined or null if(!xxx) {...} //read as TRUE if xxx IS undefined or null
For a string like 'true' or 'false': xxx.toLowerCase().trim() === 'true' ? true : false
so:
var zzz = 'true'; //string
var yyy = []; //array
...
if(zzz.toLowerCase().trim() === 'true') { ... } // quick string conversion
...
if(yyy ? true : false) { ... } // quick any conversion - it's TRUE if it's not null or undefined
...
// in a catch-all function
if(toBoolean(zzz)) { ... }
if(toBoolean(yyy)) { ... }
toBoolean(xxx: any): boolean {
if(xxx) {
const xStr = xxx.toString().toLowerCase().trim();
if(xStr === 'true' || x === 'false') {
return xStr === 'true' ? true : false;
} else {
return xxx ? true : false;
}
} else {
return false;
}
}
Here's a simple function that will handle most scenarios, including handling booleans as an input (just in case):
type Falsey = undefined | null;
const parseBoolean = (val: string | boolean | number | Falsey): boolean => {
const s = val && val.toString().toLowerCase().trim();
if (s == 'true' || s == '1')
return true;
return false;
}
And here's a jest test to go with it:
describe('Boolean Parser', () => {
[
{ val: 'true', expected: true },
{ val: 'false', expected: false },
{ val: 'True', expected: true },
{ val: 'False', expected: false },
{ val: 'TRUE', expected: true },
{ val: 'FALSE', expected: false },
{ val: '', expected: false },
{ val: '1', expected: true },
{ val: '0', expected: false },
{ val: false, expected: false },
{ val: true, expected: true },
{ val: undefined, expected: false },
{ val: null, expected: false },
{ val: 0, expected: false },
{ val: 1, expected: true },
{ val: 111, expected: false }
].forEach(args => {
it(`should parse ${args.val} to boolean`, () => {
expect(parseBoolean(args.val)).toBe(args.expected);
});
})
});