Katakanlah saya memiliki yang berikut ini:

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

Kedua tes di atas akan lulus. Apakah ada perbedaan antara toBe()dan toEqual()kapan harus mengevaluasi angka? Jika demikian, kapan saya harus menggunakan yang satu dan bukan yang lain?

Untuk tipe primitif (mis. Angka, boolean, string, dll.), Tidak ada perbedaan antara toBedan toEqual; salah satu akan bekerja untuk 5, trueatau "the cake is a lie".

Untuk memahami perbedaan antara toBedan toEqual, mari kita bayangkan tiga objek.

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

Menggunakan perbandingan yang ketat ( ===), beberapa hal "sama":

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

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

> c.foo === b.foo
true

Tetapi beberapa hal, meskipun mereka "sama", tidak "sama", karena mereka mewakili objek yang hidup di lokasi yang berbeda dalam memori.

> b === c
false

toBeMatcher Jasmine tidak lebih dari pembungkus untuk perbandingan kesetaraan yang ketat

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

adalah hal yang sama dengan

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

Jangan hanya mengambil kata-kata saya untuk itu; lihat kode sumber untuk toBe .

Tetapi bdan cmewakili objek yang secara fungsional setara; mereka berdua terlihat seperti

{ foo: { bar: 'baz' } }

Bukankah lebih bagus jika kita bisa mengatakan itu bdan c"setara" walaupun mereka tidak mewakili objek yang sama?

Masukkan toEqual, yang memeriksa "kesetaraan mendalam" (yaitu melakukan pencarian rekursif melalui objek untuk menentukan apakah nilai untuk kunci mereka setara). Kedua tes berikut akan lulus:

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

Harapan itu membantu memperjelas beberapa hal.

toBe()versus toEqual(): toEqual()memeriksa kesetaraan. toBe(), di sisi lain, memastikan bahwa mereka adalah objek yang sama persis.

Saya akan mengatakan penggunaan toBe()saat membandingkan nilai, dan toEqual()ketika membandingkan objek.

Saat membandingkan tipe primitif, toEqual()dan toBe()akan menghasilkan hasil yang sama. Ketika membandingkan objek, toBe()adalah perbandingan yang lebih ketat, dan jika bukan objek yang sama persis dalam memori ini akan menghasilkan false. Jadi, kecuali Anda ingin memastikan itu adalah objek yang sama persis dalam memori, gunakan toEqual()untuk membandingkan objek.

Lihat tautan ini untuk info lebih lanjut: http://evanhahn.com/how-do-i-jasmine/

Sekarang ketika melihat perbedaan antara toBe()dan toEqual()ketika datang ke angka, seharusnya tidak ada perbedaan selama perbandingan Anda benar. 5akan selalu setara dengan 5.

Tempat yang bagus untuk bermain-main dengan ini untuk melihat hasil yang berbeda ada di sini

Memperbarui

Cara mudah untuk melihat toBe()dan toEqual()memahami apa yang sebenarnya mereka lakukan dalam JavaScript. Menurut Jasmine API, ditemukan di sini :

toEqual () berfungsi untuk literal dan variabel sederhana, dan harus berfungsi untuk objek

toBe () dibandingkan dengan ===

Pada dasarnya apa yang dikatakan adalah toEqual()dan toBe()merupakan ===operator Javascripts yang serupa kecuali toBe()juga memeriksa untuk memastikan itu adalah objek yang sama persis, dalam contoh di bawah ini objectOne === objectTwo //returns falsejuga. Namun, toEqual()akan kembali benar dalam situasi itu.

Sekarang, Anda setidaknya bisa mengerti mengapa ketika diberikan:

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

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

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

Itu karena, sebagaimana tercantum dalam jawaban ini untuk pertanyaan yang berbeda, namun mirip, yang ===operator yang benar-benar berarti bahwa kedua operan referensi objek yang sama, atau dalam hal jenis nilai, memiliki nilai yang sama.

Mengutip proyek jasmine github,

expect(x).toEqual(y); membandingkan objek atau primitif x dan y dan melewati jika mereka setara

expect(x).toBe(y);membandingkan objek atau primitif x dan y dan melewati jika mereka adalah objek yang sama

Melihat kode sumber Jasmine menjelaskan lebih lanjut tentang masalah ini.

toBesangat sederhana dan hanya menggunakan identitas / operator kesetaraan yang ketat, ===:

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

toEqual, Di sisi lain, hampir 150 garis panjang dan memiliki penanganan khusus untuk dibangun di objek seperti String, Number, Boolean, Date, Error, Elementdan RegExp. Untuk objek lain itu secara rekursif membandingkan properti.

Ini sangat berbeda dengan perilaku operator persamaan ==,. Sebagai contoh:

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()membandingkan nilai jika Primitif atau konten jika Objek. toBe()membandingkan referensi.

Kode / suite berikut harus jelas:

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

Pikir seseorang mungkin menyukai penjelasan dengan contoh (beranotasi):

Di bawah, jika fungsi deepClone () saya melakukan tugasnya dengan benar, tes (seperti yang dijelaskan dalam panggilan 'it ()') akan berhasil:

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

Tentu saja ini bukan suite tes lengkap untuk deepClone saya (), karena saya belum menguji di sini jika objek literal dalam array (dan yang bersarang di dalamnya) juga memiliki identitas yang berbeda tetapi nilai yang sama.

Saya pikir toEqual memeriksa sama dalam, toBe adalah referensi yang sama dari 2 variabel

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

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

Poin yang perlu diperhatikan:

• toBe()memperlakukan perbandingan seperti bagaimana caranya Object.is().
• toEqual()memperlakukan perbandingan seperti bagaimana caranya ===.

Itu sebabnya untuk tipe primitif, toBedan toEqualtidak memiliki banyak perbedaan saat menguji kesetaraan, tetapi untuk tipe referensi seperti objek, Anda lebih suka menggunakan toEqualuntuk menguji kesetaraan.