जैस्मीन जावास्क्रिप्ट परीक्षण - toBe vs toququal

Question

मान लें कि मेरे पास निम्नलिखित हैं:

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

उपरोक्त दोनों टेस्ट पास होंगे। वहाँ के बीच एक अंतर है toBe()और toEqual()जब यह संख्या का मूल्यांकन करने के लिए आता है? यदि हां, तो मुझे एक का उपयोग करना चाहिए और दूसरे का नहीं?

Comments

संक्षेप में: आदिमों की तुलना करते समय दोनों के बीच कोई अंतर नहीं; वस्तुओं के लिए -> toEqual()कुंजी / मूल्यों-सामग्री द्वारा तुलना करेंगे; toBe()वस्तु संदर्भ से तुलना करेंगे।

— आंद्रे एलरिको

Answer 1

आदिम प्रकार (उदाहरण के लिए नंबर, बूलियन्स, तार, आदि) के लिए, वहाँ कोई अंतर नहीं है 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);

आशा है कि कुछ चीजों को स्पष्ट करने में मदद करता है।

Comments

"आदिम प्रकारों (जैसे संख्या, बूलियन, स्ट्रिंग्स, आदि) के लिए, टोब और इक्वेल के बीच कोई अंतर नहीं है" - क्योंकि यह पता चला है कि यह पूरी तरह से सच नहीं है। expect(0).toBe(-0)पास होगा लेकिन expect(0).toEqual(-0)फेल हो जाएगा।

— 9

tl; dr - toBeसख्त समानता का उपयोग करता है - संदर्भ द्वारा तुलना, toEqualसंपत्ति तुल्यता का उपयोग करता है। toEqualप्राइमिटिव्स के लिए उपयोग करने की सिफारिश की गई

— Drenai

तो हमें कौन से प्राइमिटिव के लिए उपयोग करना चाहिए, और क्यों? Drenai, तुम क्यों की सिफारिश करते हैं?

— पैट्रिक सज्जापस्की

@PatrickSzalapski मैं केवल डेनाई के तर्क पर अनुमान लगा सकता हूं, लेकिन toEqualसमानता ( 0 != -0और "hi" = new String("hi"), आदि) के बारे में अधिक सावधान है , इसलिए मैं toEqual विशेष रूप से उपयोग करने की सलाह दूंगा जब तक कि आप वास्तव में संदर्भ समानता के बारे में चिंतित नहीं हों। सभी चेक देखें toEqualमें बनाता eqविधि यहाँ: github.com/jasmine/jasmine/blob/master/src/core/matchers/...

— नदी

मुझे लगता है कि जब ओवरऑल किया जाता है, तो ओवरहेड को बचाने के लिए आदिमों की तुलना करना बेहतर होगा।

— गारफील्डकॉन

Answer 2

toBe()बनाम toEqual(): toEqual()तुल्यता की जाँच करता है। toBe()दूसरी ओर, यह सुनिश्चित करता है कि वे एक ही वस्तु हों।

मैं कहूंगा कि toBe()मूल्यों की तुलना करते समय उपयोग करें , औरtoEqual() वस्तुओं की ।

जब आदिम प्रकारों की तुलना करते हैं, toEqual()और toBe()समान परिणाम प्राप्त करेंगे। वस्तुओं की तुलना करते समय, toBe()एक सख्त तुलना है, और अगर यह स्मृति में सटीक एक ही वस्तु नहीं है तो यह गलत वापस आ जाएगी। इसलिए जब तक आप यह सुनिश्चित नहीं करना चाहते कि यह स्मृति में सटीक एक ही वस्तु है, toEqual()वस्तुओं की तुलना के लिए उपयोग करें ।

अधिक जानकारी के लिए इस लिंक को देखें: http://evanhahn.com/how-do-i-jasmine/

अब जब संख्याओं के बीच के अंतर को देखते हुए toBe()और toEqual()जब संख्या की बात आती है, तो कोई अंतर नहीं होना चाहिए जब तक कि आपकी तुलना सही न हो। 5हमेशा के बराबर होगा 5।

विभिन्न परिणामों को देखने के लिए इसके साथ खेलने के लिए एक अच्छी जगह यहाँ है

अपडेट करें

देखने का एक आसान तरीका है toBe()और 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

है यही कारण है, क्योंकि के रूप में में कहा गया है , एक अलग, लेकिन इसी तरह सवाल का जवाब इस=== ऑपरेटर वास्तव में इसका मतलब है दोनों ऑपरेंड संदर्भ है कि एक ही वस्तु है, या मूल्य प्रकार के मामले में, एक ही मूल्य है।

Comments

यह सवाल का जवाब देने से बचता है। आप समझाते हैं कि toEqual()यह कहने से क्या होता है कि toEqual()समानता की जाँच होती है , लेकिन स्पष्ट अगला प्रश्न ठीक है, इसलिए "समतुल्य" का क्या अर्थ है? एल्गोरिथ्म का वर्णन "समतुल्यता" निर्धारित करने के लिए उपयोग किया जाता है, या ऐसे मामलों के कम से कम उदाहरण हैं जहां toEqual()और toBe()अलग - अलग व्यवहार , इस अधिक उपयोगी को प्रस्तुत करेंगे।

— मार्क अमेरी

न केवल यह सवाल का जवाब नहीं देता है, लेकिन यह गलत है । toEqualवस्तुओं के बीच गहरी तुलना के लिए इस्तेमाल किया जाना चाहिए, नहीं toBe। jsfiddle.net/bBL9P/67

— लॉयड बैंक

ऐसा लगता है कि लोग परीक्षण करने के लिए परेशान नहीं हैं अगर वे जो कह रहे हैं वह सही है। दोनों toBe और toququal की तुलना सख्त लगती है। इसका परीक्षण करें ... इसलिए अंतर खोजने के लिए मेरे परीक्षण में अभी तक। उदाहरण के लिए: var f = 1; var g = "1" उम्मीद (f == g) .toEqual (सच); // सच्ची उम्मीद (f) .toEqual (g); // झूठी उम्मीद (f) .toBe (g); // झूठी

— user1759104

यह पूरी तरह से गलत है। toEqualके रूप में ही नहीं है== ।

— meagar

ऊपर दिए गए टिप्पणियों को पढ़ें। सच है expect(1).toEqual('1'), जबकि विफल रहता 1 == '1'है। toEqualकुछ नहीं करना है ==। यह इस तरह है ===कि यह वस्तुओं की तुलना में मूल्य की तुलना के समान तरीके से तुलना करेगा।

— meagar

Answer 3

चमेली गितुब परियोजना को उद्धृत करने के लिए,

expect(x).toEqual(y); वस्तुओं और आदिम एक्स और वाई की तुलना करता है और यदि वे समकक्ष हैं तो गुजरता है

expect(x).toBe(y);वस्तुओं और आदिम x और y की तुलना करता है और गुजरता है अगर वे एक ही वस्तु हैं

Answer 4

जैस्मीन स्रोत कोड को देखते हुए मुद्दे पर अधिक प्रकाश डाला गया।

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

Answer 5

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

Answer 6

सोचा कि कोई व्यक्ति व्याख्या (व्याख्या) उदाहरण द्वारा पसंद कर सकता है:

नीचे, अगर मेरा डीप क्लॉक () फ़ंक्शन अपना काम सही करता है, तो परीक्षण (जैसा कि 'इट ()' कॉल में वर्णित है) सफल होगा:

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

निश्चित रूप से यह मेरे डीप क्लेंक () के लिए एक पूर्ण परीक्षण सूट नहीं है, क्योंकि मैंने यहाँ परीक्षण नहीं किया है यदि सरणी में वस्तु शाब्दिक (और एक नेस्टेड) ​​भी अलग पहचान है लेकिन समान मान हैं।

Answer 7

मुझे लगता है कि inEqual गहरी बराबर जाँच कर रहा है, toBe 2 चर का एक ही संदर्भ है

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

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

Answer 8

नोट करने के लिए अंक:

• toBe()तुलना करता है जैसे कैसे Object.is()करता है।
• toEqual()तुलना करता है जैसे कैसे ===करता है।

इसलिए आदिम प्रकारों के लिए, toBeऔर toEqualसमानता के लिए परीक्षण करते समय बहुत अंतर नहीं होता है, लेकिन वस्तुओं जैसे संदर्भ प्रकारों के लिए, आप toEqualसमानता के लिए परीक्षण करने के लिए उपयोग करेंगे।