打字稿转换为布尔值

Question

在 Typescript 中我可以这样做：

var xxx : some_type;

if (xxx)
    foo();
else
    bar();

此处的 xxx 将被视为布尔值，无论其类型如何。

我想在函数参数中做同样的事情。我有这个功能：

function foo(b : boolean) { ... }

我希望能够调用 foo(xxx) 并将 xxx 视为布尔值，无论其类型如何。但是 Typescript 不允许这样做。

我试过了：

foo(<boolean>xxx);

但 Typescript 也不允许这样做。

我可以这样做：

foo(xxx ? true : false);

但这似乎有点傻。有没有更好的方法？

Answer 1

您可以使用 Typescript 允许并且在 JavaScript 中可以正常工作的 double exclamation sign 技巧：

foo(!!xxx);

或者，将其转换为 any

foo(<any>xxx);

Answer 2

这是我对"typescript": "^3.3.3" 的解决方案：

function toBool(a: any) {
  return Boolean(a).valueOf();
}

export { toBool };

单元测试：

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();
    });
  });
});

单元测试结果：

 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

Answer 3

虽然您不能将数字直接转换为布尔值，但您可以将其转换为包装器布尔类并立即解包。例如：

foo(<boolean><Boolean>xxx);

虽然笨拙，但它避免了类型擦除转换为<any>。与!! 方法相比，它也可以说不那么晦涩且更具可读性（在转译的 js 代码中肯定如此）。

Answer 4

使用 TypeScript 2.0.2，您可以这样做：

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!'

Answer 5

使用这个

YourMethod(!!isEnabled);

'！！'用于类型转换为布尔值

Answer 6

foo(!!xxx); // This is the common way of coercing variable to booleans.
// Or less pretty
foo(xxx && true); // Same as foo(xxx || false)

但是，每次在代码中调用 foo 时，您可能最终都会复制双键，因此更好的解决方案是将强制转换为函数 DRY 内的布尔值

foo(xxx);

foo(b: any){
  const _b = !!b;
  // Do foo with _b ...
}
  /*** OR ***/
foo(b: any){
  if(b){
    // Do foo ...
  }
}

Answer 7

这是一个简单的函数，可以处理大多数情况，包括将布尔值作为输入处理（以防万一）：

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; 
}

还有一个有趣的测试：

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);
        });
    })
});

Answer 8

使用 typescript 最明显的方法是使用布尔构造函数：

Boolean(someVal);

你的情况是：

foo(Boolean(xxx));

请注意，使用的构造函数没有“new”关键字。因为如果添加它，您将创建一个新的布尔对象而不是强制转换值：

Boolean(false) == false 

但是

new Boolean(false) == true

因为它是一个对象

Answer 9

if(xxx) {...} //如果 xxx 不是未定义或为空，则读取为 TRUE if(!xxx) {...} //如果 xxx 未定义或为空，则读取为 TRUE

对于像 'true' 或 'false' 这样的字符串： xxx.toLowerCase().trim() === 'true' ？真：假

所以：

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;
  }
}