toBe(true) vs toBeTruthy() vs toBeTrue()

Question

expect(something).toBe(true)、expect(something).toBeTruthy()和expect(something).toBeTrue()有什么区别？

请注意 toBeTrue() 是在 jasmine-matchers 中引入的 自定义匹配器 以及 toHaveMethod() 或 [=17= 等其他有用且方便的匹配器].

这个问题是通用的，但是，作为一个真实世界的例子，我正在测试 protractor 中是否显示了一个元素。在这种情况下我应该使用哪个匹配器？

expect(elm.isDisplayed()).toBe(true);
expect(elm.isDisplayed()).toBeTruthy();
expect(elm.isDisplayed()).toBeTrue();

Answer 1

在javascript中有真有假。当某件事为真时，它显然是真或假。当某物为真时，它可能是也可能不是布尔值，但 "cast" 的值是布尔值。

示例。

true == true; // (true) true
1 == true; // (true) truthy
"hello" == true;  // (true) truthy
[1, 2, 3] == true; // (true) truthy
[] == false; // (true) truthy
false == false; // (true) true
0 == false; // (true) truthy
"" == false; // (true) truthy
undefined == false; // (true) truthy
null == false; // (true) truthy

如果您想检查字符串是否已设置或数组是否具有任何值，这可以使事情变得更简单。

var users = [];

if(users) {
  // this array is populated. do something with the array
}

var name = "";

if(!name) {
  // you forgot to enter your name!
}

如前所述。 expect(something).toBe(true) 和 expect(something).toBeTrue() 是一样的。但是 expect(something).toBeTruthy() 与其中任何一个都不相同。

Answer 2

Disclamer: This is just a wild guess

我知道每个人都喜欢易于阅读的列表：

toBe(<value>) - 返回值与 <value>
toBeTrue() - 检查返回值是否为 true
toBeTruthy() - 检查值在转换为布尔值时是否为真值

真实值是所有不属于 0、''（空字符串）、false、null、NaN、[= 的值20=] 或 []（空数组）*.

_{* 请注意，当您运行 !![] 时，它 returns true，但是当您运行 [] == false 它也returns true。这取决于它是如何实现的。换句话说：(!![]) === ([] == false)}

在您的示例中，toBe(true) 和 toBeTrue() 将产生相同的结果。

Answer 3

当我想知道类似此处提出的问题时，我所做的就是找到源头。

toBe()

expect().toBe() 定义为：

function toBe() {
  return {
    compare: function(actual, expected) {
      return {
        pass: actual === expected
      };
    }
  };
}

它用 === 执行测试，这意味着当用作 expect(foo).toBe(true) 时，只有当 foo 实际具有值 true 时，它才会通过。真值不会使测试通过。

toBeTruthy()

expect().toBeTruthy() 定义为：

function toBeTruthy() {
  return {
    compare: function(actual) {
      return {
        pass: !!actual
      };
    }
  };
}

类型强制

如果将此值强制转换为布尔值得到值 true，则该值为真值。操作 !! 通过将传递给 expect 的值强制转换为布尔值来测试真实性。请注意，与当前接受的答案 implies 相反，== true 不是正确的真实性测试。你会得到有趣的东西，比如

> "hello" == true
false
> "" == true
false
> [] == true
false
> [1, 2, 3] == true
false

而使用 !! 会产生：

> !!"hello"
true
> !!""
false
> !![1, 2, 3]
true
> !![] 
true

(是的，不管是否为空，数组为真。)

toBeTrue()

expect().toBeTrue() 是 Jasmine-Matchers 的一部分（在后来的项目先注册 jasmine-matchers 之后，它在 npm 上注册为 jasmine-expect）。

expect().toBeTrue() 定义为：

function toBeTrue(actual) {
  return actual === true ||
    is(actual, 'Boolean') &&
    actual.valueOf();
}

与expect().toBeTrue()和expect().toBe(true)的区别在于expect().toBeTrue()测试它是否正在处理一个Boolean对象。 expect(new Boolean(true)).toBe(true) 会失败，而 expect(new Boolean(true)).toBeTrue() 会通过。这是因为一件有趣的事：

> new Boolean(true) === true
false
> new Boolean(true) === false
false

至少是真的:

> !!new Boolean(true)
true

哪个最适合与 `elem.isDisplayed()` 一起使用？

最终 Protractor 将这个请求交给了 Selenium。 documentation 指出 .isDisplayed() 产生的价值是一个解析为 boolean 的承诺。我会按面值使用 .toBeTrue() 或 .toBe(true)。如果我发现实现 returns truthy/falsy 值的情况，我会提交错误报告。

Answer 4

那里有很多好的答案，我只是想添加一个使用这些期望值可能会有所帮助的场景。使用 element.all(xxx)，如果我需要检查是否所有元素都显示在单个运行，我可以执行 -

expect(element.all(xxx).isDisplayed()).toBeTruthy(); //Expectation passes
expect(element.all(xxx).isDisplayed()).toBe(true); //Expectation fails
expect(element.all(xxx).isDisplayed()).toBeTrue(); //Expectation fails

原因是 .all() returns 一个值数组，因此各种期望（getText、isPresent 等...）都可以用 toBeTruthy() 当 .all() 出现时。希望这会有所帮助。

Answer 5

当您通读下面的示例时，请记住这个区别

true === true // true
"string" === true // false
1 === true // false
{} === true // false

但是

Boolean("string") === true // true
Boolean(1) === true // true
Boolean({}) === true // true

1。期望（声明）.toBe（真）

当传递给 expect() 的语句计算结果为 true

时断言通过

expect(true).toBe(true) // pass
expect("123" === "123").toBe(true) // pass

在所有其他情况下都会失败

expect("string").toBe(true) // fail
expect(1).toBe(true); // fail
expect({}).toBe(true) // fail

即使所有这些语句在执行 Boolean() 时都会计算为 true:

所以你可以认为它是'strict'比较

2。期望（声明）.toBeTrue（）

这个与 .toBe(true) 进行完全相同类型的比较，但最近于 2019 年 9 月 20 日在版本 3.5.0 中引入了 Jasmine

3。期望（声明）.toBeTruthy（）

toBeTruthy 另一方面，首先将语句的输出评估为布尔值，然后进行比较

expect(false).toBeTruthy() // fail
expect(null).toBeTruthy() // fail
expect(undefined).toBeTruthy() // fail
expect(NaN).toBeTruthy() // fail
expect("").toBeTruthy() // fail
expect(0).toBeTruthy() // fail

并且在所有其他情况下它都会通过，例如

expect("string").toBeTruthy() // pass
expect(1).toBeTruthy() // pass
expect({}).toBeTruthy() // pass

toBe(true) vs toBeTruthy() vs toBeTrue()