অ্যারে সমান উপেক্ষা করার আদেশের প্রত্যাশা করে

Question 1

জেসমিনের সাথে পরীক্ষা করার কোনও উপায় আছে যদি 2 অ্যারে একই উপাদান থাকে তবে প্রয়োজনীয়ভাবে একই ক্রমে হয় না? অর্থাত্

array1 = [1,2,3];
array2 = [3,2,1];

expect(array1).toEqualIgnoreOrder(array2);//should be true

Question 2

যদি এটি কেবল পূর্ণসংখ্যা বা অন্যান্য আদিম মান হয় sort()তবে তুলনা করার আগে আপনি সেগুলি করতে পারেন ।

expect(array1.sort()).toEqual(array2.sort());

যদি এর অবজেক্টস হয় তবে এটির সাথে map()ফাংশনটির সাথে একত্রিত করুন যাতে একটি সনাক্তকারীকে তুলনা করা হবে

array1 = [{id:1}, {id:2}, {id:3}];
array2 = [{id:3}, {id:2}, {id:1}];

expect(array1.map(a => a.id).sort()).toEqual(array2.map(a => a.id).sort());

Question 3

জুঁই সংস্করণ ২.৮ এবং এর পরে রয়েছে

jasmine.arrayWithExactContents()

যা প্রত্যাশা করে যে কোনও অ্যারেতে কোনও ক্রমে তালিকাবদ্ধ উপাদানগুলি রয়েছে।

array1 = [1,2,3];
array2 = [3,2,1];
expect(array1).toEqual(jasmine.arrayWithExactContents(array2))

Https://jasmine.github.io/api/3.4/jasmine.html দেখুন

Question 4

সরল ...

array1 = [1,2,3];
array2 = [3,2,1];

expect(array1).toEqual(jasmine.arrayContaining(array2));

Question 5

আপনি স্ট্যান্ডার্ড ঠাট্টা থেকে প্রত্যাশা.আররে কন্টেইনিং (অ্যারে) ব্যবহার করতে পারেন:

  const expected = ['Alice', 'Bob'];
  it('matches even if received contains additional elements', () => {
    expect(['Alice', 'Bob', 'Eve']).toEqual(expect.arrayContaining(expected));
  });

Question 6

// check if every element of array2 is element of array1
// to ensure [1, 1] !== [1, 2]
array2.forEach(x => expect(array1).toContain(x))

// check if every element of array1 is element of array2
// to ensure [1, 2] !== [1, 1]
array1.forEach(x => expect(array2).toContain(x))

// check if they have equal length to ensure [1] !== [1, 1]
expect(array1.length).toBe(array2.length)

Question 7

বিদ্রূপের বিষয় রূপে গ্রহণ-বর্ধিত প্যাকেজ আমাদের কয়েক গবেষকেরা আমাদের পরীক্ষার প্রক্রিয়া সহজ করার জন্য প্রদান করে, এটি কম বাগাড়ম্বরপূর্ণ এবং পরীক্ষা ব্যর্থ ত্রুটি অনেক বেশী সুনিদৃষ্ট হয়।

এই ক্ষেত্রে আমরা ইনক্লুডসেমেমবার্স ব্যবহার করতে পারি

expect([{foo: "bar"}, {baz: "qux"}]).toIncludeSameMembers([{baz: "qux"}, {foo: "bar"}]);

Question 8

//Compare arrays without order
//Example
//a1 = [1, 2, 3, 4, 5]
//a2 = [3, 2, 1, 5, 4]
//isEqual(a1, a2) -> true
//a1 = [1, 2, 3, 4, 5];
//a2 = [3, 2, 1, 5, 4, 6];
//isEqual(a1, a2) -> false


function isInArray(a, e) {
  for ( var i = a.length; i--; ) {
    if ( a[i] === e ) return true;
  }
  return false;
}

function isEqArrays(a1, a2) {
  if ( a1.length !== a2.length ) {
    return false;
  }
  for ( var i = a1.length; i--; ) {
    if ( !isInArray( a2, a1[i] ) ) {
      return false;
    }
  }
  return true;
}

Question 9

function equal(arr1, arr2){
    return arr1.length === arr2.length
    &&
    arr1.every((item)=>{
        return arr2.indexOf(item) >-1
    }) 
    &&
    arr2.every((item)=>{
        return arr1.indexOf(item) >-1
    })
}

এখানে ধারণাটি প্রথমে নির্ধারণ করা হয় যে দুটি অ্যারের দৈর্ঘ্য সমান কিনা, তারপরে পরীক্ষা করুন যে সমস্ত উপাদান অন্যের অ্যারেতে রয়েছে কিনা।

Question 10

এখানে এমন একটি সমাধান রয়েছে যা কোনও সংখ্যা বা অ্যারের জন্য কাজ করবে

https://gist.github.com/tvler/cc5b2a3f01543e1658b25ca567c078e4

const areUnsortedArraysEqual = (...arrs) =>
  arrs.every((arr, i, [first]) => !i || arr.length === first.length) &&
  arrs
    .map(arr =>
      arr.reduce(
        (map, item) => map.set(item, (map.get(item) || 0) + 1),
        new Map(),
      ),
    )
    .every(
      (map, i, [first]) =>
        !i ||
        [...first, ...map].every(([item]) => first.get(item) === map.get(item)),
    );

কিছু পরীক্ষা (এই প্রশ্নের কয়েকটি উত্তর একই মানের একাধিক আইটেমযুক্ত অ্যারে হিসাবে অ্যাকাউন্ট করে না, সুতরাং [1, 2, 2] এবং [1, 2] ভুলভাবে সত্যকে প্রত্যাবর্তন করবে)

[1, 2] true
[1, 2], [1, 2] true
[1, 2], [1, 2], [1, 2] true
[1, 2], [2, 1] true
[1, 1, 2], [1, 2, 1] true
[1, 2], [1, 2, 3] false
[1, 2, 3, 4], [1, 2, 3], [1, 2] false
[1, 2, 2], [1, 2] false
[1, 1, 2], [1, 2, 2] false
[1, 2, 3], [1, 2], [1, 2, 3] false

Question 11

এই অ্যালগরিদম অ্যারেগুলির জন্য দুর্দান্ত যেখানে প্রতিটি আইটেম অনন্য। যদি তা না হয় তবে ডুপ্লিকেটগুলি পরীক্ষা করতে আপনি কিছু যুক্ত করতে পারেন ...

tests = [
  [ [1,0,1] , [0,1,1] ],
  [ [1,0,1] , [0,0,1] ], //breaks on this one...
  [ [2,3,3] , [2,2,3] ], //breaks on this one also...
  [ [1,2,3] , [2,1,3] ],
  [ [2,3,1] , [1,2,2] ],
  [ [2,2,1] , [1,3,2] ]
]

tests.forEach(function(test) {
  console.log('eqArraySets( '+test[0]+' , '+test[1]+' ) = '+eqArraySets( test[0] , test[1] ));
});


function eqArraySets(a, b) {
	if ( a.length !== b.length ) { return false; }
	for ( var i = a.length; i--; ) {
		if ( !(b.indexOf(a[i])>-1) ) { return false; }
		if ( !(a.indexOf(b[i])>-1) ) { return false; }
	}
	return true;
}

স্নিপেট প্রসারিত করুন

Question 12

এই পদ্ধতির সবচেয়ে খারাপ তাত্ত্বিক সবচেয়ে খারাপ রান-টাইম পারফরম্যান্স রয়েছে, তবে এটি অ্যারেতে কোনও লেখার কাজ করে না বলে এটি অনেক পরিস্থিতিতে দ্রুত হতে পারে (এখনও পারফরম্যান্স পরীক্ষা করে দেখেনি):

সতর্কতা: টোরবেন মন্তব্যগুলিতে যেমন উল্লেখ করেছেন, কেবলমাত্র উভয় অ্যারেতে অনন্য (পুনরাবৃত্তি না করা) উপাদান থাকতে পারে (অন্য উত্তরগুলির মতো এখানেও বেশ কয়েকটি) এই পদ্ধতিটি কেবল তখনই কার্যকর হয়।

/**
 * Determine whether two arrays contain exactly the same elements, independent of order.
 * @see /programming/32103252/expect-arrays-to-be-equal-ignoring-order/48973444#48973444
 */
function cmpIgnoreOrder(a, b) {
  const { every, includes } = _;
  return a.length === b.length && every(a, v => includes(b, v));
}

// the following should be all true!
const results = [
  !!cmpIgnoreOrder([1,2,3], [3,1,2]),
  !!cmpIgnoreOrder([4,1,2,3], [3,4,1,2]),
  !!cmpIgnoreOrder([], []),
  !cmpIgnoreOrder([1,2,3], [3,4,1,2]),
  !cmpIgnoreOrder([1], []),
  !cmpIgnoreOrder([1, 3, 4], [3,4,5])
];

console.log('Results: ', results)
console.assert(_.reduce(results, (a, b) => a && b, true), 'Test did not pass!');

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.js"></script>

স্নিপেট প্রসারিত করুন

Question 13

এই ইউএসই ক্যাসের জন্য কৌতূহলীভাবে ম্যাচারার রয়েছে:

https://github.com/jest-commune/jest-extended/pull/122/files

test('passes when arrays match in a different order', () => {
  expect([1, 2, 3]).toMatchArray([3, 1, 2]);
  expect([{ foo: 'bar' }, { baz: 'qux' }]).toMatchArray([{ baz: 'qux' }, { foo: 'bar' }]);
});

Question 14

আপনি এর মতো কিছু ব্যবহার করতে পারেন:

expect(array1).toEqual(jasmine.arrayContaining(array2));

আমদানি মনে রাখবেন jasmine। অথবা এটি আপনার যুক্ত করুন.eslintrc

Question 15

জেস্টের একটি ফাংশন রয়েছে expect.arrayContainingযা আপনাকে যা চায় ঠিক তা করবে:

expect(array1).toEqual(expect.arrayContaining(array2))

তারাও একই দৈর্ঘ্যের সাথে আছে কিনা তা পরীক্ষা করতে চাইতে পারেন, যেহেতু পরীক্ষাটি পাস হয় কিনা

প্রত্যাশিত অ্যারে প্রাপ্ত প্রাপ্ত অ্যারের একটি উপসেট

ডক অনুসারে

সম্পাদনা: দুঃখিত যে আমি জুঁই ট্যাগটি খেয়াল করিনি, এটি জাস্টের সাথে কাজ করার একটি উপায়