Скажімо, у мене є таке:

var myNumber = 5;
expect(myNumber).toBe(5);
expect(myNumber).toEqual(5);

Обидва вищевказані тести пройдуть. Чи є різниця між toBe()і toEqual()коли йдеться про оцінку чисел? Якщо так, коли я повинен використовувати одне, а не друге?

Для примітивних типів (наприклад, чисел, булевих рядків, рядків тощо) різниця між toBeі toEqual; або один буде працювати 5, trueабо "the cake is a lie".

Щоб зрозуміти різницю між toBeі toEqual, давайте уявимо три об’єкти.

var a = { bar: 'baz' },
    b = { foo: a },
    c = { foo: a };

Використовуючи суворе порівняння ( ===), деякі речі "однакові":

> b.foo.bar === c.foo.bar
true

> b.foo.bar === a.bar
true

> c.foo === b.foo
true

Але деякі речі, навіть якщо вони "рівні", не є "однаковими", оскільки вони представляють предмети, які живуть у різних місцях пам'яті.

> b === c
false

Матч Жасмін - toBeце не що інше, як обгортка для суворого порівняння рівності

expect(c.foo).toBe(b.foo)

те саме, що і

expect(c.foo === b.foo).toBe(true)

Не приймайте моє слово за це; див . вихідний код для toBe .

Але bі cпредставляють функціонально рівнозначні об'єкти; вони обидва схожі

{ foo: { bar: 'baz' } }

Чи не було б чудово, якби ми могли це сказати bі cбули «рівними», навіть якщо вони не представляють один і той же об’єкт?

Введіть toEqual, який перевіряє "глибоку рівність" (тобто здійснює рекурсивний пошук через об'єкти, щоб визначити, чи є значення їхніх ключів еквівалентними). Пройдуть обидва наступні тести:

expect(b).not.toBe(c);
expect(b).toEqual(c);

Сподіваюсь, що допоможе з’ясувати деякі речі.

toBe()проти toEqual(): toEqual()перевіряє еквівалентність. toBe()з іншого боку, гарантує, що вони точно такий самий об’єкт.

Я б сказав, використовуйте toBe()при порівнянні значень і toEqual()при порівнянні об'єктів.

Якщо порівнювати примітивні типи, toEqual()і toBe()це дасть той же результат. Якщо порівнювати об'єкти, toBe()це суворіше порівняння, і якщо це не той самий об’єкт у пам'яті, це повернеться помилковим. Тому, якщо ви не хочете переконатися, що це абсолютно той самий об’єкт у пам'яті, використовуйте toEqual()для порівняння об'єктів.

Перегляньте це посилання, щоб отримати докладнішу інформацію: http://evanhahn.com/how-do-i-jasmine/

Тепер, коли дивимось на різницю між toBe()чи toEqual()коли мова йде про числа, не повинно бути різниці, якщо ваше порівняння є правильним. 5завжди буде рівнозначним 5.

Приємне місце, щоб пограти з цим, щоб побачити різні результати, є тут

Оновлення

Простий спосіб подивитися toBe()і toEqual()зрозуміти, що саме вони роблять в JavaScript. За даними API Жасмін, тут знайдено :

toEqual () працює для простих літералів і змінних і повинен працювати для об'єктів

toBe () порівнює з ===

За суті, що сказати, toEqual()і toBe()подібні Javascripts ===оператора , за винятком toBe()також перевірки , щоб переконатися , що це той же самий об'єкт, в тому , що на прикладі нижче , objectOne === objectTwo //returns falseа також. Однак toEqual()повернеться істинним у цій ситуації.

Тепер ви можете принаймні зрозуміти, чому, коли вам дають:

var objectOne = {
    propertyOne: str,
    propertyTwo: num    
}

var objectTwo = {
    propertyOne: str,
    propertyTwo: num    
}

expect(objectOne).toBe(objectTwo); //returns false

Це відбувається тому , що, як зазначено в цій відповіді на інший, але подібне питання,=== оператор на самому ділі означає , що обидва операнд посилається на той же об'єкт, або в разі типів значень, має однакове значення.

Щоб цитувати проект жасминового гітуба,

expect(x).toEqual(y); порівнює об'єкти або примітиви x і y і передає, якщо вони еквівалентні

expect(x).toBe(y);порівнює об'єкти або примітиви x і y і передає, якщо вони є одним і тим же об'єктом

Дивлячись на вихідний код Жасмін, проливають більше світла на це питання.

toBeдуже простий і просто використовує особу / оператор суворої рівності ===:

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

toEqual, З іншого боку, має довжину близько 150 рядків і має спеціальну обробку для вбудованих об'єктів , таких як String, Number, Boolean, Date, Error, Elementі RegExp. Для інших об'єктів рекурсивно порівнює властивості.

Це дуже відрізняється від поведінки оператора рівності, ==. Наприклад:

var simpleObject = {foo: 'bar'};
expect(simpleObject).toEqual({foo: 'bar'}); //true
simpleObject == {foo: 'bar'}; //false

var castableObject = {toString: function(){return 'bar'}};
expect(castableObject).toEqual('bar'); //false
castableObject == 'bar'; //true

toEqual()порівнює значення, якщо примітивні або вміст, якщо об'єкти. toBe()порівнює посилання.

Наступний код / ​​набір повинен бути зрозумілим:

describe('Understanding toBe vs toEqual', () => {
  let obj1, obj2, obj3;

  beforeEach(() => {
    obj1 = {
      a: 1,
      b: 'some string',
      c: true
    };

    obj2 = {
      a: 1,
      b: 'some string',
      c: true
    };

    obj3 = obj1;
  });

  afterEach(() => {
    obj1 = null;
    obj2 = null;
    obj3 = null;
  });

  it('Obj1 === Obj2', () => {
    expect(obj1).toEqual(obj2);
  });

  it('Obj1 === Obj3', () => {
    expect(obj1).toEqual(obj3);
  });

  it('Obj1 !=> Obj2', () => {
    expect(obj1).not.toBe(obj2);
  });

  it('Obj1 ==> Obj3', () => {
    expect(obj1).toBe(obj3);
  });
});

Думав, що комусь може сподобатись пояснення на (анотований) приклад:

Нижче, якщо моя функція deepClone () виконує свою роботу правильно, тест (як описано у виклику 'it ()) буде успішним:

describe('deepClone() array copy', ()=>{
    let source:any = {}
    let clone:any = source
    beforeAll(()=>{
        source.a = [1,'string literal',{x:10, obj:{y:4}}]
        clone = Utils.deepClone(source) // THE CLONING ACT TO BE TESTED - lets see it it does it right.
    })
    it('should create a clone which has unique identity, but equal values as the source object',()=>{
        expect(source !== clone).toBe(true) // If we have different object instances...
        expect(source).not.toBe(clone) // <= synonymous to the above. Will fail if: you remove the '.not', and if: the two being compared are indeed different objects.
        expect(source).toEqual(clone) // ...that hold same values, all tests will succeed.
    })
})

Звичайно, це не повний набір тестів для мого deepClone (), так як я не перевіряв тут, якщо об'єкт-літерал у масиві (і той, що вкладений у нього) також має чітку ідентичність, але однакові значення.

Я думаю, що toEqual перевіряє глибоке рівне, toBe - це те саме, що посилається на 2 змінних

  it('test me', () => {
    expect([] === []).toEqual(false) // true
    expect([] == []).toEqual(false) // true

    expect([]).toEqual([]); // true // deep check
    expect([]).toBe([]); // false
  })

Бали, які слід зазначити:

• toBe()трактує порівняння, як це Object.is()робить.
• toEqual()трактує порівняння, як це ===робить.

Ось чому для примітивних типів toBeі toEqualне має великої різниці при тестуванні на рівність, але для референтних типів, таких як об'єкти, ви краще скористаєтеся toEqualдля перевірки рівності.