Jest使用“匹配器”让你可以用各种方式测试你的代码。 这篇文档将向你介绍一些常用的匹配器， 在 expect API 的文档里可以看到完整的列表。

普通匹配器

最简单的测试值的方法是看是否精确匹配。

  1. test('two plus two is four', () => {
  2.   expect(2 + 2).toBe(4);
  3. });

在此代码中，expect (2 + 2) 返回一个"期望"的对象。 你通常不会对这些期望对象调用过多的匹配器。 在此代码中，.toBe(4) 是匹配器。 当 Jest 运行时，它会跟踪所有失败的匹配器，以便它可以为你打印出很好的错误消息。

toBe 使用 Object.is 来测试精确相等。 如果您想要检查对象的值，请使用 toEqual 代替：

  1. test('object assignment', () => {
  2.   const data = {one: 1};
  3.   data['two'] = 2;
  4.   expect(data).toEqual({one: 1, two: 2});
  5. });

toEqual 递归检查对象或数组的每个字段。

您还可以测试相反的匹配︰

  1. test('adding positive numbers is not zero', () => {
  2.   for (let a = 1; a < 10; a++) {
  3.     for (let b = 1; b < 10; b++) {
  4.       expect(a + b).not.toBe(0);
  5.     }
  6.   }
  7. });

Truthiness

在测试中，你有时需要区分 undefined、 null，和 false，但有时你又不需要区分。 Jest 让你明确你想要什么。

  • toBeNull 只匹配 null
  • toBeUndefined 只匹配 undefined
  • toBeDefined 与 toBeUndefined 相反
  • toBeTruthy 匹配任何 if 语句为真
  • toBeFalsy 匹配任何 if 语句为假

例如：

  1. test('null', () => {
  2.   const n = null;
  3.   expect(n).toBeNull();
  4.   expect(n).toBeDefined();
  5.   expect(n).not.toBeUndefined();
  6.   expect(n).not.toBeTruthy();
  7.   expect(n).toBeFalsy();
  8. });
  10. test('zero', () => {
  11.   const z = 0;
  12.   expect(z).not.toBeNull();
  13.   expect(z).toBeDefined();
  14.   expect(z).not.toBeUndefined();
  15.   expect(z).not.toBeTruthy();
  16.   expect(z).toBeFalsy();
  17. });

您应该使用匹配器最精确地对应您的代码你想要什么。

数字

大多数的比较数字有等价的匹配器。

  1. test('two plus two', () => {
  2.   const value = 2 + 2;
  3.   expect(value).toBeGreaterThan(3);
  4.   expect(value).toBeGreaterThanOrEqual(3.5);
  5.   expect(value).toBeLessThan(5);
  6.   expect(value).toBeLessThanOrEqual(4.5);
  8.   // toBe and toEqual are equivalent for numbers
  9.   expect(value).toBe(4);
  10.   expect(value).toEqual(4);
  11. });

对于比较浮点数相等，使用 toBeCloseTo 而不是 toEqual，因为你不希望测试取决于一个小小的舍入误差。

  1. test('两个浮点数字相加', () => {
  2.   const value = 0.1 + 0.2;
  3.   //expect(value).toBe(0.3);           这句会报错，因为浮点数有舍入误差
  4.   expect(value).toBeCloseTo(0.3); // 这句可以运行
  5. });

字符串

您可以检查对具有 toMatch 正则表达式的字符串︰

  1. test('there is no I in team', () => {
  2.   expect('team').not.toMatch(/I/);
  3. });
  5. test('but there is a "stop" in Christoph', () => {
  6.   expect('Christoph').toMatch(/stop/);
  7. });

Arrays and iterables

你可以通过 toContain来检查一个数组或可迭代对象是否包含某个特定项：

  1. const shoppingList = [
  2.   'diapers',
  3.   'kleenex',
  4.   'trash bags',
  5.   'paper towels',
  6.   'beer',
  7. ];
  9. test('the shopping list has beer on it', () => {
  10.   expect(shoppingList).toContain('beer');
  11.   expect(new Set(shoppingList)).toContain('beer');
  12. });

例外

如果你想要测试的特定函数抛出一个错误，在它调用时，使用 toThrow。

  1. function compileAndroidCode() {
  2.   throw new Error('you are using the wrong JDK');
  3. }
  5. test('compiling android goes as expected', () => {
  6.   expect(compileAndroidCode).toThrow();
  7.   expect(compileAndroidCode).toThrow(Error);
  9.   // You can also use the exact error message or a regexp
  10.   expect(compileAndroidCode).toThrow('you are using the wrong JDK');
  11.   expect(compileAndroidCode).toThrow(/JDK/);
  12. });

以及更多

这些只是浅尝辄止。 这些只是一部分，有关匹配器的完整列表，请查阅 参考文档。

一旦你学会了如何使用匹配器后，接下来可以学习 Jest 是如何让你可以 测试异步代码的。