This is probably the most commonly used matcher, and you should use it whenever you want to check equality between two values.

It works for all primitive values (number, string, and Boolean) as well as any object (including arrays).

describe("toEqual", function() {
  it("should pass equal numbers", function() {
    expect(1).toEqual(1);
  });

  it("should pass equal strings", function() {
    expect("testing").toEqual("testing");
  });

  it("should pass equal booleans", function() {
    expect(true).toEqual(true);
  });

  it("should pass equal objects", function() {
    expect({a: "testing"}).toEqual({a: "testing"});
  });

  it("should pass equal arrays", function() {
    expect([1, 2, 3]).toEqual([1, 2, 3]);
  });
});

The toBe matcher has a very similar behavior to the toEqual matcher, in fact it gives the same result while comparing primitive values, but the similarities stop there.

While the toEqual matcher has a complex implementation (you should take a look at the Jasmine source code) that checks if all attributes of an object and all elements of an array are the same, here it is a simple use of the strict equals operator (===).

If you are unfamiliar with the strict equals operator, its main difference from the equals operator (==) is that the latter performs type coercion if the compared values aren't of the same type.

Here are some examples of how this matcher (and the strict equals operator) works:

describe("toBe", function() {
  it("should pass equal numbers", function() {
    expect(1).toBe(1);
  });

  it("should pass equal strings", function() {
    expect("testing").toBe("testing");
  });

  it("should pass equal booleans", function() {
    expect(true).toBe(true);
  });

  it("should pass same objects", function() {
    var object = {a: "testing"};
    expect(object).toBe(object);
  });

  it("should pass same arrays", function() {
    var array = [1, 2, 3];
    expect(array).toBe(array);
  });

  it("should not pass equal objects", function() {
    expect({a: "testing"}).not.toBe({a: "testing"});
  });

  it("should not pass equal arrays", function() {
    expect([1, 2, 3]).not.toBe([1, 2, 3]);
  });
});

It is advised to use the toEqual operator in most cases, and resort to the toBe matcher only when you want to check if two variables reference the same object.

Besides its primitive Boolean type, everything else in the JavaScript language also has an inherent Boolean value, which is generally known as being either truthy or falsy.

Luckily in JavaScript, there are only a few values that are identified as falsy, as shown in the following examples for the toBeFalsy matcher.

describe("toBeFalsy", function () {
  it("should pass undefined", function() {
    expect(undefined).toBeFalsy();
  });

  it("should pass null", function() {
    expect(null).toBeFalsy();
  });

  it("should pass NaN", function() {
    expect(NaN).toBeFalsy();
  });

  it("should pass the false boolean value", function() {
    expect(false).toBeFalsy();
  });

  it("should pass the number 0", function() {
    expect(0).toBeFalsy();
  });

  it("should pass an empty string", function() {
    expect("").toBeFalsy();
  });
});

Everything else is considered truthy, as demonstrated by these examples of the toBeTruthy matcher:

describe("toBeTruthy", function() {
  it("should pass the true boolean value", function() {
    expect(true).toBeTruthy();
  });

  it("should pass any number different than 0", function() {
    expect(1).toBeTruthy();
  });
  it("should pass any non empty string", function() {
    expect("a").toBeTruthy();
  });

  it("should pass any object (including an array)", function() {
    expect([]).toBeTruthy();
    expect({}).toBeTruthy();
  });
});

But if you want to check if something is equal to an actual Boolean value, it might be a better idea to use the toEqual matcher.

These matchers are pretty straightforward, and should be used to check for undefined, null, and NaN values.

describe("toBeNull", function() {
  it("should pass null", function() {
    expect(null).toBeNull();
  });
});

describe("toBeUndefined", function() {
  it("should pass undefined", function() {
    expect(undefined).toBeUndefined();
  });
});

describe("toBeNaN", function() {
  it("should pass NaN", function() {
    expect(NaN).toBeNaN();
  });
});

Both toBeNull and toBeUndefined can be written as toBe(null) and toBe(undefined) respectively, but that is not the case with toBeNaN.

In JavaScript, the NaN value is not equal to any value, not even NaN. So trying to compare it to itself is always false.

NaN === NaN // false

The Jasmine toBeNaN matcher is actually implemented taking into account that NaN is the only value that is not equal to itself. Here is how it is implemented:

jasmine.Matchers.prototype.toBeNaN = function() {
  return (this.actual !== this.actual);
};

See how it checks if the actual is different from itself? So as a good practice, try to use these matchers whenever possible instead of their toBe counterparts.

This matcher is useful if you want to check whether a variable is defined and you don't care about its value.

describe("toBeDefined", function() {
  it("should pass any value other than undefined", function() {
    expect(null).toBeDefined();
  });
});

Anything except undefined will pass under this matcher, even null.

Sometimes it is desirable to check if an array contains an element or if a string can be found inside another string. For these use cases, you can use the toContain matcher.

describe("toContain", function() {
  it("should pass if a string contains another string", function(){
    expect("My big string").toContain("big");
  });

  it("should pass if an array contains an element", function() {
    expect([1, 2, 3]).toContain(2);
  });
});

Although the toContain and the toEqual matchers can be used in most string comparisons, sometimes the only way to assert if a string value is correct, is through a regular expression. For these cases, you can use the toMatch matcher along with a regular expression.

describe("toMatch", function() {
  it("should pass a matching string", function() {
    expect("My big matched string").toMatch(/My(.+)string/);
  });
});

The matcher works by testing the actual value ("My big matched string") against the expected regular expression (/My(.+)string/).

The toBeLessThan and toBeGreaterThan are two simple matchers to perform numeric comparisons, as best described by the following examples:

  describe("toBeLessThan", function() {
    it("should pass when the actual is less than expected",function() {
      expect(1).toBeLessThan(2);
    });
  });

  describe("toBeGreaterThan", function() {
    it("should pass when the actual is greater than expected",function() {
      expect(2).toBeGreaterThan(1);
    });
  });

Exceptions are a language's way to demonstrate when something goes wrong.

So for example while coding an API, you might decide to throw an exception when a parameter is passed incorrectly. So how do you test this code?

Jasmine has the built-in toThrow matcher that can be used to verify that an exception has been thrown.

The way it works is a little bit different from the other matchers. Since the matcher has to run a piece of code and check if it throws an exception, the matcher's actual value must be a function.

Here is an example of how it works:

describe("toThrow", function() {
  it("should pass when the exception is thrown", function() {
    expect(function () {
      throw("Some exception");
    }).toThrow("Some exception");
  });
});

When the test is run, the anonymous function gets executed, and if it throws the Some exception exception, the test passes.