javascript - জাভাস্ক্রিপ্ট টিউটোরিয়াল pdf



কিভাবে জাভাস্ক্রিপ্ট মধ্যে অ্যারে তুলনা? (20)

আমি দুটি অ্যারে তুলনা করতে চাই ... আদর্শভাবে, দক্ষতার সাথে। কিছুই অভিনব, তারা অভিন্ন যদি শুধু true , এবং যদি না false । আশ্চর্যজনক নয়, তুলনা অপারেটর কাজ বলে মনে হচ্ছে না।

var a1 = [1,2,3];
var a2 = [1,2,3];
console.log(a1==a2);    // Returns false
console.log(JSON.stringify(a1)==JSON.stringify(a2));    // Returns true

প্রতিটি অ্যারে JSON এনকোডিং করে, কিন্তু প্রতিটি মানের মাধ্যমে পুনরাবৃত্তি না করে কেবল অ্যারে তুলনা করার জন্য একটি দ্রুত বা "ভাল" উপায় আছে?

https://src-bin.com


Answer #1

প্রাকটিক্যাল ওয়ে

"ভুল পথ" যদি এটি "সঠিক" সমাধানটির বিপরীতে কেবল "সঠিক" ("সঠিক") হয় তবে এটি একটি বিশেষ বাস্তবায়ন বলে মনে করা ভুল। Tomas এর সমাধান স্ট্রিং-ভিত্তিক অ্যারের তুলনা উপর একটি স্পষ্ট উন্নতি হয়, কিন্তু এর অর্থ এটি বস্তুগতভাবে "ডান" নয়। যাইহোক ঠিক কি? এটা কি দ্রুততম? এটা সবচেয়ে নমনীয় হয়? এটা বোঝার সবচেয়ে সহজ? এটি ডিবাগ দ্রুততম হয়? এটা অন্তত অপারেশন ব্যবহার করে? এটা কোন পার্শ্ব প্রতিক্রিয়া আছে? কোন এক সমাধান সবকিছুর সেরা থাকতে পারে।

Tomas এর তার সমাধান দ্রুত বলতে পারে কিন্তু আমি এটা অযৌক্তিক জটিল বলা হবে। এটি একটি অল-ইন-ওয়ান সমাধান যা সমস্ত অ্যারে, নেস্টেড বা না জন্য কাজ করে। আসলে, এটি এমনকি একটি ইনপুট হিসাবে কেবল অ্যারের চেয়েও বেশি গ্রহণ করে এবং এখনও একটি "বৈধ" উত্তর দিতে চেষ্টা করে।

জেনেরিক reusability অফার

আমার উত্তর সমস্যা ভিন্নভাবে যোগাযোগ করবে। আমি একটি জেনেরিক arrayCompare পদ্ধতি দিয়ে শুরু করব যা কেবল অ্যারেগুলির মাধ্যমে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে ধাপে সেখানে থেকে, আমরা আমাদের অন্যান্য মৌলিক তুলনা ফাংশন যেমন arrayEqual এবং arrayDeepEqual , ইত্যাদি তৈরি করব

// arrayCompare :: (a -> a -> Bool) -> [a] -> [a] -> Bool
const arrayCompare = f => ([x,...xs]) => ([y,...ys]) =>
  x === undefined && y === undefined
    ? true
    : Boolean (f (x) (y)) && arrayCompare (f) (xs) (ys)

আমার মতে, সেরা ধরণের কোড এমনকি মন্তব্যের দরকার নেই এবং এটি ব্যতিক্রম নয়। এখানে এমন কিছু ঘটেছে যে আপনি প্রায়শই কোনও প্রচেষ্টা ছাড়াই এই পদ্ধতির আচরণ বুঝতে পারেন। অবশ্যই, ES6 সিনট্যাক্সের কিছু এখন আপনার কাছে বিদেশী বলে মনে হতে পারে তবে এটি কেবলমাত্র ES6 তুলনামূলকভাবে নতুন।

যেমন টাইপ প্রস্তাব করে, arrayCompare তুলনা ফাংশন, f , এবং দুটি ইনপুট অ্যারে, xs এবং arrayCompare নেয়। অধিকাংশ অংশে, আমরা ইনপুট অ্যারে প্রতিটি উপাদানটির জন্য f (x) (y) কল করি। ব্যবহারকারী-সংজ্ঞায়িত f false ফেরত যদি আমরা একটি প্রাথমিক false ফিরে - ধন্যবাদ & এর সংক্ষিপ্ত বর্তনী মূল্যায়ন ধন্যবাদ। সুতরাং হ্যাঁ, এর অর্থ হল তুলনাকারীটি পুনরাবৃত্তি বন্ধ করতে এবং অপ্রয়োজনীয় সময় ইনপুট অ্যারের মাধ্যমে লুপিং প্রতিরোধ করতে পারে।

কঠোর তুলনা

পরবর্তীতে, আমাদের arrayCompare ফাংশন ব্যবহার করে, আমরা সহজেই অন্যান্য ফাংশন তৈরি করতে পারি যা আমাদের প্রয়োজন হতে পারে। আমরা প্রাথমিক arrayEqual সাথে শুরু করব ...

// equal :: a -> a -> Bool
const equal = x => y =>
  x === y // notice: triple equal

// arrayEqual :: [a] -> [a] -> Bool
const arrayEqual =
  arrayCompare (equal)

const xs = [1,2,3]
const ys = [1,2,3]
console.log (arrayEqual (xs) (ys))      //=> true
// (1 === 1) && (2 === 2) && (3 === 3)  //=> true

const zs = ['1','2','3']
console.log (arrayEqual (xs) (zs))      //=> false
// (1 === '1')                          //=> false

যে হিসাবে সহজ। arrayEqual arrayCompare এবং একটি তুলনাকারী ফাংশন দিয়ে সংজ্ঞায়িত করা যেতে পারে যা === (কঠোর সমতা জন্য) ব্যবহার করে b to তুলনা করে।

লক্ষ্য করুন যে আমরা তার নিজস্ব ফাংশন হিসাবে equal সংজ্ঞায়িত। এটি অন্য ডাটা টাইপের (অ্যারে) প্রেক্ষাপটে আমাদের প্রথম ক্রম তুলনাকারীর ব্যবহার করার জন্য একটি উচ্চ-ক্রম ফাংশন হিসাবে arrayCompare ভূমিকা তুলে ধরে।

আলগা তুলনা

আমরা পরিবর্তে একটি == ব্যবহার করে সহজেই সংজ্ঞায়িত arrayLooseEqual হিসাবে সংজ্ঞায়িত করতে পারে। এখন 1 (সংখ্যা) থেকে '1' (স্ট্রিং) এর তুলনা করলে, ফলাফলটি true ...

// looseEqual :: a -> a -> Bool
const looseEqual = x => y =>
  x == y // notice: double equal

// arrayLooseEqual :: [a] -> [a] -> Bool
const arrayLooseEqual =
  arrayCompare (looseEqual)

const xs = [1,2,3]
const ys = ['1','2','3']
console.log (arrayLooseEqual (xs) (ys))    //=> true
// (1 == '1') && (2 == '2') && (3 == '3')  //=> true

গভীর তুলনা (recursive)

আপনি সম্ভবত এই শুধুমাত্র অগভীর তুলনা যে লক্ষ্য করেছি। অবশ্যই টমাসের সমাধান "দ্য ওয়েই ওয়ে ™" কারণ এটি গভীর গভীর তুলনা করে, তাই না?

ওয়েল আমাদের arrayCompare পদ্ধতি একটি বহুমুখী সমানতা একটি বায়ু পরীক্ষা করে তোলে যে একটি উপায়ে যথেষ্ট বহুমুখী ...

// isArray :: a -> Bool
const isArray =
  Array.isArray

// arrayDeepCompare :: (a -> a -> Bool) -> [a] -> [a] -> Bool
const arrayDeepCompare = f =>
  arrayCompare (a => b =>
    isArray (a) && isArray (b)
      ? arrayDeepCompare (f) (a) (b)
      : f (a) (b))

const xs = [1,[2,[3]]]
const ys = [1,[2,['3']]]
console.log (arrayDeepCompare (equal) (xs) (ys)) //=> false
// (1 === 1) && (2 === 2) && (3 === '3')         //=> false

console.log (arrayDeepCompare (looseEqual) (xs) (ys)) //=> true
// (1 == 1) && (2 == 2) && (3 == '3')                 //=> true

যে হিসাবে সহজ। আমরা আরেকটি উচ্চ-ক্রম ফাংশন ব্যবহার করে একটি গভীর তুলনাকারী নির্মাণ। এই সময় আমরা একটি কাস্টম arrayCompare ব্যবহার করে অ্যারে arrayCompare মোড়ানো করছি যা a এবং b অ্যারে কিনা তা পরীক্ষা করবে। যদি তাই হয়, অন্যথায় arrayDeepCompare পুনরায় ব্যবহারকারীর নির্দিষ্ট তুলনাকারী ( f ) তে a এবং b তুলনা করুন। এটি আসলে আমরা পৃথক উপাদানের তুলনা করে কিভাবে গভীর তুলনা আচরণ আলাদা রাখতে সক্ষম হব। looseEqual , উপরের শোগুলির উদাহরণের মতো, আমরা equal , looseEqual , বা অন্য কোন looseEqual ব্যবহার করে তুলনা করতে পারি।

কারণ arrayDeepCompare হয়, আমরা আংশিকভাবে এটি প্রয়োগ করতে পারি যেমন আমরা আগের উদাহরণগুলিতেও করেছি

// arrayDeepEqual :: [a] -> [a] -> Bool
const arrayDeepEqual =
  arrayDeepCompare (equal)

// arrayDeepLooseEqual :: [a] -> [a] -> Bool
const arrayDeepLooseEqual =
  arrayDeepCompare (looseEqual)

আমার কাছে, এটি ইতিমধ্যে টমাসের সমাধান সম্পর্কে একটি স্পষ্ট উন্নতি কারণ আমি স্পষ্টভাবে আমার অ্যারের জন্য অগভীর বা গভীর তুলনা পছন্দ করতে পারি।

বস্তু তুলনা (উদাহরণস্বরূপ)

এখন যদি আপনার বস্তু বা কিছু একটি অ্যারে আছে? হয়তো আপনি ঐ অ্যারেগুলিকে "সমান" হিসাবে বিবেচনা করতে চান যদি প্রতিটি বস্তুর একই id মান থাকে ...

// idEqual :: {id: Number} -> {id: Number} -> Bool
const idEqual = x => y =>
  x.id !== undefined && x.id === y.id

// arrayIdEqual :: [a] -> [a] -> Bool
const arrayIdEqual =
  arrayCompare (idEqual)

const xs = [{id:1}, {id:2}]
const ys = [{id:1}, {id:2}]
console.log (arrayIdEqual (xs) (ys)) //=> true
// (1 === 1) && (2 === 2)            //=> true

const zs = [{id:1}, {id:6}]
console.log (arrayIdEqual (xs) (zs)) //=> false
// (1 === 1) && (2 === 6)            //=> false

যে হিসাবে সহজ। এখানে আমি ভ্যানিলা জেএস বস্তু ব্যবহার করেছি, কিন্তু এই ধরনের তুলনাকারী কোনও বস্তুর জন্য কাজ করতে পারে; এমনকি আপনার কাস্টম বস্তু। Tomas এর সমাধান সম্পূর্ণরূপে এই ধরনের সমতা পরীক্ষা সমর্থন করার জন্য পুনর্ব্যক্ত করা প্রয়োজন হবে

বস্তু সঙ্গে গভীর অ্যারে? কোন সমস্যা নেই. আমরা অত্যন্ত বহুমুখী, জেনেরিক ফাংশন তৈরি করেছি, তাই তারা ব্যবহার ক্ষেত্রে বিভিন্ন ক্ষেত্রে কাজ করব।

const xs = [{id:1}, [{id:2}]]
const ys = [{id:1}, [{id:2}]]
console.log (arrayCompare (idEqual) (xs) (ys))     //=> false
console.log (arrayDeepCompare (idEqual) (xs) (ys)) //=> true

নির্বিচারে তুলনা (উদাহরণস্বরূপ)

অথবা যদি আপনি অন্য কোন ধরনের সম্পূর্ণরূপে নির্বিচারে তুলনা করতে চেয়েছিলেন? সম্ভবত আমি জানতে চাই যে প্রতিটি x প্রতিটি y চেয়ে বড় কিনা ...

// gt :: Number -> Number -> Bool
const gt = x => y =>
  x > y

// arrayGt :: [a] -> [a] -> Bool
const arrayGt = arrayCompare (gt)

const xs = [5,10,20]
const ys = [2,4,8]
console.log (arrayGt (xs) (ys))     //=> true
// (5 > 2) && (10 > 4) && (20 > 8)  //=> true

const zs = [6,12,24]
console.log (arrayGt (xs) (zs))     //=> false
// (5 > 6)                          //=> false

কমই বেশি

আপনি দেখতে পারেন আমরা আসলে কম কোড দিয়ে আরো কিছু করছি। arrayCompare সম্পর্কে জটিল কিছুই নেই নিজের সাথে তুলনা করুন এবং আমরা তৈরি করেছি এমন প্রতিটি কাস্টম তুলনাকারীদের একটি খুব সহজ বাস্তবায়ন আছে।

স্বাচ্ছন্দ্য সহ, আমরা কীভাবে দুটি অ্যারে arrayCompare নির্ধারণ করতে পারি - অগভীর, গভীর, কঠোর, আলগা, কিছু বস্তুর সম্পত্তি, অথবা কিছু ইচ্ছাকৃত গণনা, বা এর কোনও সমন্বয় - সমস্ত একটি পদ্ধতি ব্যবহার করে , arrayCompare । এমনকি একটি RegExp তুলনাকারী স্বপ্ন আপ! আমি জানি কিভাবে বাচ্চারা ঐ রেজেক্সস ভালবাসে ...

এটা কি দ্রুততম? নাঃ। কিন্তু সম্ভবত এটি হতে হবে না। যদি গতি আমাদের কোডের গুণমান পরিমাপের জন্য ব্যবহৃত একমাত্র মেট্রিক হয়, তবে অনেকগুলি দুর্দান্ত কোড ছড়িয়ে দেওয়া হবে - এজন্যই আমি এই পদ্ধতিটি অনুশীলন পদ্ধতিটি বলছি। অথবা হতে পারে আরো ন্যায্য, একটি প্রাকটিক্যাল ওয়ে। এই বর্ণনাটি এই উত্তরের জন্য উপযুক্ত কারণ আমি বলছি না যে এই উত্তরটি কেবল অন্য কোন উত্তর তুলনায় ব্যবহারিক; এটা বস্তুগত সত্য। আমরা খুব কম কোডের সাথে উচ্চমানের কার্যকারিতা অর্জন করেছি যা সম্পর্কে যুক্তিযুক্ত। অন্য কোন কোড আমরা এই বিবরণ অর্জিত না বলতে পারেন।

এটা কি আপনার জন্য "সঠিক" সমাধান করে তোলে? আপনি সিদ্ধান্ত নিতে যে আপ। এবং অন্য কেউ আপনার জন্য যে করতে পারেন না; শুধুমাত্র আপনি আপনার প্রয়োজন কি জানেন। প্রায় সব ক্ষেত্রে, আমি চতুর এবং দ্রুত ধরনের উপর সহজবোধ্য, ব্যবহারিক, এবং বহুমুখী কোড মূল্য। আপনি মূল্য কি পার্থক্য হতে পারে, তাই আপনার জন্য কি কাজ করে।

সম্পাদন করা

আমার পুরনো উত্তরটি ছোট পদ্ধতিতে arrayEqual বিচ্ছিন্ন করার উপর আরও বেশি মনোযোগী ছিল। এটি একটি আকর্ষণীয় ব্যায়াম, তবে প্রকৃতপক্ষে এই সমস্যাটির সাথে যোগাযোগ করার জন্য সর্বোত্তম (সর্বাধিক ব্যবহারিক) উপায় নয়। আপনি আগ্রহী হন, আপনি এই সংশোধন ইতিহাস দেখতে পারেন।


Answer #2

JSON.encode হিসাবে একই লাইন যোগদান () ব্যবহার করতে হয়।

function checkArrays( arrA, arrB ){

    //check if lengths are different
    if(arrA.length !== arrB.length) return false;


    //slice so we do not effect the original
    //sort makes sure they are in order
    //join makes it a string so we can do a string compare
    var cA = arrA.slice().sort().join(","); 
    var cB = arrB.slice().sort().join(",");

    return cA===cB;

}

var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"];  //will return true

console.log( checkArrays(a,b) );  //true
console.log( checkArrays(a,c) );  //false
console.log( checkArrays(a,d) );  //false
console.log( checkArrays(a,e) );  //true

আপনি শুধুমাত্র ধরনের তুলনা যা পরীক্ষা সম্পর্কে যত্ন যদি শুধুমাত্র সমস্যা। আপনি যদি ধরনের সম্পর্কে যত্ন, আপনি লুপ হবে।

function checkArrays( arrA, arrB ){

    //check if lengths are different
    if(arrA.length !== arrB.length) return false;

    //slice so we do not effect the orginal
    //sort makes sure they are in order
    var cA = arrA.slice().sort(); 
    var cB = arrB.slice().sort();

    for(var i=0;i<cA.length;i++){
         if(cA[i]!==cB[i]) return false;
    }

    return true;

}

var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"];

console.log( checkArrays(a,b) );  //true
console.log( checkArrays(a,c) );  //false
console.log( checkArrays(a,d) );  //false
console.log( checkArrays(a,e) );  //false

যদি অর্ডারটি একই থাকা উচিত তবে এটি একটি লুপ মাত্র, কোনও ধরণের প্রয়োজন নেই।

function checkArrays( arrA, arrB ){

    //check if lengths are different
    if(arrA.length !== arrB.length) return false;


    for(var i=0;i<arrA.length;i++){
         if(arrA[i]!==arrB[i]) return false;
    }

    return true;

}

var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"];

console.log( checkArrays(a,a) );  //true
console.log( checkArrays(a,b) );  //false
console.log( checkArrays(a,c) );  //false
console.log( checkArrays(a,d) );  //false
console.log( checkArrays(a,e) );  //false

Answer #3

অ্যারে তুলনা, তাদের মাধ্যমে লুপ এবং প্রতিটি মান তুলনা:

অ্যারে তুলনা:

// Warn if overriding existing method
if(Array.prototype.equals)
    console.warn("Overriding existing Array.prototype.equals. Possible causes: New API defines the method, there's a framework conflict or you've got double inclusions in your code.");
// attach the .equals method to Array's prototype to call it on any array
Array.prototype.equals = function (array) {
    // if the other array is a falsy value, return
    if (!array)
        return false;

    // compare lengths - can save a lot of time 
    if (this.length != array.length)
        return false;

    for (var i = 0, l=this.length; i < l; i++) {
        // Check if we have nested arrays
        if (this[i] instanceof Array && array[i] instanceof Array) {
            // recurse into the nested arrays
            if (!this[i].equals(array[i]))
                return false;       
        }           
        else if (this[i] != array[i]) { 
            // Warning - two different object instances will never be equal: {x:20} != {x:20}
            return false;   
        }           
    }       
    return true;
}
// Hide method from for-in loops
Object.defineProperty(Array.prototype, "equals", {enumerable: false});

ব্যবহার:

[1, 2, [3, 4]].equals([1, 2, [3, 2]]) === false;
[1, "2,3"].equals([1, 2, 3]) === false;
[1, 2, [3, 4]].equals([1, 2, [3, 4]]) === true;
[1, 2, 1, 2].equals([1, 2, 1, 2]) === true;

আপনি বলতে পারেন " কিন্তু স্ট্রিং তুলনা করা খুব দ্রুত - কোন লুপ ... " ভাল, তাহলে আপনাকে অবশ্যই লুপ থাকা উচিত। অ্যারে স্ট্রিং এবং দ্বিতীয় রূপান্তর করে যে প্রথম recursive লুপ, যে দুটি স্ট্রিং তুলনায়। সুতরাং এই পদ্ধতি স্ট্রিং ব্যবহার চেয়ে দ্রুত

আমি বিশ্বাস করি যে বড় পরিমাণে ডেটা সবসময় অ্যারেগুলিতে সংরক্ষণ করা উচিত, বস্তুগুলিতে নয়। তবে আপনি যদি বস্তুগুলি ব্যবহার করেন তবে তাদেরও আংশিকভাবে তুলনা করা যেতে পারে।
এখানে কিভাবে:

বস্তুর তুলনা:

আমি উপরে বর্ণিত করেছি, যে দুটি বস্তুর উদাহরণ সমান হবে না, এমনকি যদি এই মুহুর্তে একই তথ্য থাকে:

({a:1, foo:"bar", numberOfTheBeast: 666}) == ({a:1, foo:"bar", numberOfTheBeast: 666})  //false

এটি একটি কারণ আছে, যেমন হতে পারে, উদাহরণস্বরূপ বস্তুর মধ্যে ব্যক্তিগত ভেরিয়েবল।

যাইহোক, যদি আপনি তথ্য ধারণ করার জন্য বস্তুর কাঠামো ব্যবহার করেন তবে তুলনা করা এখনও সম্ভব:

Object.prototype.equals = function(object2) {
    //For the first loop, we only check for types
    for (propName in this) {
        //Check for inherited methods and properties - like .equals itself
        //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
        //Return false if the return value is different
        if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
            return false;
        }
        //Check instance type
        else if (typeof this[propName] != typeof object2[propName]) {
            //Different types => not equal
            return false;
        }
    }
    //Now a deeper check using other objects property names
    for(propName in object2) {
        //We must check instances anyway, there may be a property that only exists in object2
            //I wonder, if remembering the checked values from the first loop would be faster or not 
        if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
            return false;
        }
        else if (typeof this[propName] != typeof object2[propName]) {
            return false;
        }
        //If the property is inherited, do not check any more (it must be equa if both objects inherit it)
        if(!this.hasOwnProperty(propName))
          continue;

        //Now the detail check and recursion

        //This returns the script back to the array comparing
        /**REQUIRES Array.equals**/
        if (this[propName] instanceof Array && object2[propName] instanceof Array) {
                   // recurse into the nested arrays
           if (!this[propName].equals(object2[propName]))
                        return false;
        }
        else if (this[propName] instanceof Object && object2[propName] instanceof Object) {
                   // recurse into another objects
                   //console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
           if (!this[propName].equals(object2[propName]))
                        return false;
        }
        //Normal value comparison for strings and numbers
        else if(this[propName] != object2[propName]) {
           return false;
        }
    }
    //If everything passed, let's say YES
    return true;
}  

যাইহোক, মনে রাখবেন যে এটি JSON যেমন ডাটা, ক্লাসের উদাহরণ নয় এবং অন্যান্য উপাদানগুলির তুলনায় পরিবেশন করা হয়। আপনি যদি জটিল জটিল বস্তুর তুলনা করতে চান তবে এই উত্তরটি দেখুন এবং এটি superlong ফাংশন ।
Array.equals সহ এই কাজটি করার জন্য আপনাকে অবশ্যই মূল ফাংশনটি সামান্য বিট সম্পাদনা করতে হবে:

...
    // Check if we have nested arrays
    if (this[i] instanceof Array && array[i] instanceof Array) {
        // recurse into the nested arrays
        if (!this[i].equals(array[i]))
            return false;
    }
    /**REQUIRES OBJECT COMPARE**/
    else if (this[i] instanceof Object && array[i] instanceof Object) {
        // recurse into another objects
        //console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
        if (!this[i].equals(array[i]))
            return false;
        }
    else if (this[i] != array[i]) {
...

আমি উভয় ফাংশন জন্য একটি সামান্য পরীক্ষা সরঞ্জাম তৈরি।

বোনাস: indexOf সহ Nested অ্যারে এবং contains

আপনি যে ন্যস্ত অ্যারেগুলির একটি নির্দিষ্ট বস্তুর জন্য অনুসন্ধান করছেন সেটির জন্য সামি বেনচারিফ দরকারী ফাংশন তৈরি করেছেন , যা এখানে পাওয়া যায়: https://jsfiddle.net/SamyBencherif/8352y6yw/


Answer #4

আমি অ্যারে / বস্তু ভারী কোডিং প্রকল্পগুলির জন্য আন্ডারস্কোর লাইব্রেরিটি ব্যবহার করতে চাই ... আন্ডারস্কোর এবং লোডশে আপনি অ্যারে বা বস্তুর তুলনা করছেন কিনা তা ঠিক মনে হচ্ছে:

_.isEqual(array1, array2)   // returns a boolean
_.isEqual(object1, object2) // returns a boolean

Answer #5

এটা "অভিন্ন" দ্বারা আপনি কি বোঝাতে পারছেন না। উদাহরণস্বরূপ, নীচের অ্যারে a এবং b (ন্যস্ত অ্যারে নোট)?

var a = ["foo", ["bar"]], b = ["foo", ["bar"]];

এখানে একটি অপটিমাইজড অ্যারে তুলনা ফাংশন যা কঠোর সমতা ব্যবহার করে প্রতিটি অ্যারের সংশ্লিষ্ট উপাদানগুলির সাথে তুলনা করে এবং অ্যারের উপাদানগুলির পুনরাবৃত্তিমূলক তুলনা যা নিজেরাই অ্যারে নয়, অর্থাত্ উপরের উদাহরণের জন্য, arraysIdentical(a, b) false ফেরত দেবে। এটি সাধারণ ক্ষেত্রে কাজ করে, যা JSON- এবং join() -ভিত্তিক সমাধানগুলি করবে না:

function arraysIdentical(a, b) {
    var i = a.length;
    if (i != b.length) return false;
    while (i--) {
        if (a[i] !== b[i]) return false;
    }
    return true;
};

Answer #6

এটি আমার মনে হয় JSON স্ট্রিংফাই ব্যবহার করে এটি করার সবচেয়ে সহজ উপায়, এবং এটি কিছু পরিস্থিতিতে সর্বোত্তম সমাধান হতে পারে:

JSON.stringify(a1) === JSON.stringify(a2);

এটি বস্তুগুলি a1 এবং a2 স্ট্রিংগুলিতে রূপান্তরিত করে যাতে তাদের তুলনা করা যায়। বেশিরভাগ ক্ষেত্রেই ক্রমটি গুরুত্বপূর্ণ, কারণ উপরের একটি উত্তরের মধ্যে দেখানো একটি সাজানোর অ্যালগরিদম ব্যবহার করে বস্তুর ক্রম অনুসারে সাজানো যায়।

অনুগ্রহ করে লক্ষ্য করুন যে আপনি আর বস্তুর তুলনা করছেন না বরং বস্তুর স্ট্রিং উপস্থাপনা। এটা আপনি চান কি ঠিক নাও হতে পারে।


Answer #7

যদিও এইগুলির অনেকগুলি উত্তর আছে, যেটি আমি সাহায্যের জন্য বিশ্বাস করি:

const newArray = [ ...new Set( [...arr1, ...arr2] ) ]

প্রশ্নে বলা হয় না কিভাবে অ্যারের গঠনটি দেখতে যাচ্ছে, তাই যদি আপনি নিশ্চিত হন যে আপনার নিখুঁত অ্যারে বা অ্যারের বস্তু থাকবে না (এটি আমার সাথে ঘটেছে, তাই আমি এটার জন্য এসেছি উত্তর) উপরের কোড কাজ করবে।

কী হয় যে আমরা উভয় অ্যারেকে সংহত করার জন্য স্প্রেড অপারেটর (...) ব্যবহার করি, তারপরে আমরা কোন সদৃশকে বাদ দেওয়ার জন্য সেট ব্যবহার করি। একবার আপনার যদি এটি থাকে তবে আপনি তাদের আকারগুলি তুলনা করতে পারেন, যদি তিনটি অ্যারের একই আকার থাকে তবে আপনি যেতে ভাল।

এই উত্তরটি উপাদানগুলির ক্রমকেও উপেক্ষা করে , যেমন আমি বলেছিলাম, সঠিক পরিস্থিতি আমার সাথে ঘটেছে, তাই সম্ভবত একই পরিস্থিতির মধ্যে কেউ এখানে শেষ হতে পারে (যেমন আমি করেছি)।

Edit1।

দিমিত্রি গ্রিনকো এর প্রশ্নের উত্তরঃ "কেন আপনি স্প্রেড অপারেটর (...) এখানে ব্যবহার করেছেন - ... নতুন সেট? এটা কাজ করে না"

এই কোড বিবেচনা করুন:

const arr1 = [ 'a', 'b' ]
const arr2 = [ 'a', 'b', 'c' ]
const newArray = [ new Set( [...arr1, ...arr2] ) ]
console.log(newArray)

তুমি পাবে

[ Set { 'a', 'b', 'c' } ]

যে মান দিয়ে কাজ করার জন্য আপনাকে কিছু সেট বৈশিষ্ট্য ব্যবহার করতে হবে ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set )। অন্যদিকে, যখন আপনি এই কোড ব্যবহার করেন:

const arr1 = [ 'a', 'b' ]
const arr2 = [ 'a', 'b', 'c' ]
const newArray = [ ...new Set( [...arr1, ...arr2] ) ]
console.log(newArray)

তুমি পাবে

[ 'a', 'b', 'c' ]

যে পার্থক্য, প্রাক্তন একটি সেট আমাকে দিতে হবে, আমি সেট যে আকার পেতে পারে হিসাবে এটি কাজ করবে, কিন্তু পরবর্তীতে আমাকে প্রয়োজন অ্যারে দেয়, রেজল্যুশন কি আরো সরাসরি দেয়।


Answer #8

2 অ্যারের তুলনা:

var arr1 = [1,2,3];
var arr2 = [1,2,3];

function compare(arr1,arr2)
{
  if((arr1 == arr2) && (arr1.length == arr2.length))
    return true;
  else
    return false;
}

কলিং ফাংশন

var isBool = compare(arr1.sort().join(),arr2.sort().join());

Answer #9

[A] এবং লুপ থেকে প্রতিটি [b]: ফলাফল: 1, 5 থেকে প্রতিটি চয়ন করুন

var a = [1,4,5,9];
var b = [1,6,7,5];

for (i = 0; i < a.length; i++) {
    for (z = 0; z < a.length; z++) {
        if (a[i] === b[z]) {
            console.log(b[z]); // if match > console.log it 
        }
    }
}

Answer #10

এই ফাংশন নির্বিচারে আকৃতি এবং dimesionality দুটি অ্যারে তুলনা:

function equals(a1, a2) {

    if (!Array.isArray(a1) || !Array.isArray(a2)) {
        throw new Error("Arguments to function equals(a1, a2) must be arrays.");
    }

    if (a1.length !== a2.length) {
        return false;
    }

    for (var i=0; i<a1.length; i++) {
        if (Array.isArray(a1[i]) && Array.isArray(a2[i])) {
            if (equals(a1[i], a2[i])) {
                continue;
            } else {
                return false;
            }
        } else {
            if (a1[i] !== a2[i]) {
                return false;
            }
        }
    }

    return true;
}

Answer #11

একক মাত্রা অ্যারের জন্য আপনি কেবল ব্যবহার করতে পারেন:

arr1.sort().toString() == arr2.sort().toString()

এই মিশ্রিত সূচক সঙ্গে অ্যারের যত্ন নিতে হবে।


Answer #12

এখানে একটি প্রকারের সংস্করণ রয়েছে:

//https://.com/a/16436975/2589276
export function arraysEqual<T>(a: Array<T>, b: Array<T>): boolean {
    if (a === b) return true
    if (a == null || b == null) return false
    if (a.length != b.length) return false

    for (var i = 0; i < a.length; ++i) {
        if (a[i] !== b[i]) return false
    }
    return true
}

//https://.com/a/16436975/2589276
export function arraysDeepEqual<T>(a: Array<T>, b: Array<T>): boolean {
    return JSON.stringify(a) === JSON.stringify(b)
}

Mocha জন্য কিছু পরীক্ষা ক্ষেত্রে:

it('arraysEqual', function () {
    let a = [1,2]
    let b = [1,2]
    let c = [2,3]
    let d = [2, 3]
    let e = ['car','apple','banana']
    let f = ['car','apple','banana']
    let g = ['car','apple','banan8']

    expect(arraysEqual(a, b)).to.equal(true)
    expect(arraysEqual(c, d)).to.equal(true)
    expect(arraysEqual(a, d)).to.equal(false)
    expect(arraysEqual(e, f)).to.equal(true)
    expect(arraysEqual(f, g)).to.equal(false)
})

it('arraysDeepEqual', function () {
    let a = [1,2]
    let b = [1,2]
    let c = [2,3]
    let d = [2, 3]
    let e = ['car','apple','banana']
    let f = ['car','apple','banana']
    let g = ['car','apple','banan8']
    let h = [[1,2],'apple','banan8']
    let i = [[1,2],'apple','banan8']
    let j = [[1,3],'apple','banan8']

    expect(arraysDeepEqual(a, b)).to.equal(true)
    expect(arraysDeepEqual(c, d)).to.equal(true)
    expect(arraysDeepEqual(a, d)).to.equal(false)
    expect(arraysDeepEqual(e, f)).to.equal(true)
    expect(arraysDeepEqual(f, g)).to.equal(false)
    expect(arraysDeepEqual(h, i)).to.equal(true)
    expect(arraysDeepEqual(h, j)).to.equal(false)
})

Answer #13

কারণটি হল পরিচয় বা কঠোর অপারেটর (===), এটি কোনও রূপান্তরকরণের সাথে তুলনা করে না, এর অর্থ যদি উভয় মানগুলির একই মান এবং একই ধরণের না থাকে, তাহলে তারা সমান বিবেচিত হবে না।

এই লিংকটি দেখুন, এটি শনাক্ত করা সহজ উপায় কীভাবে পরিচয় অপারেটর কাজ করে তা বোঝায়


Answer #14

যদি অ্যারেটি সমতল এবং ক্রমটি গুরুত্বপূর্ণ তবে এই দুটি লাইনগুলি সাহায্য করতে পারে

//Assume
var a = ['a','b', 'c']; var b = ['a','e', 'c'];  

if(a.length !== b.length) return false;
return !a.reduce(
  function(prev,next,idx, arr){ return prev || next != b[idx] },false
); 

অ্যারের মাধ্যমে হাঁটা হ্রাস করুন এবং 'মিথ্যা' প্রদান করুন যদি 'কম' এর একটি উপাদানটি 'বি' এর উপাদান না হয় এবং 'b' এর উপাদান সমান হয় তবে এটি ফাংশনে মোড়ানো করুন


Answer #15

Tomas Zato ধারণা প্রসারিত। টমাস এর Array.prototype.com অংশটিকে অবশ্যই অ্যারে বলা উচিত। প্রোটোটাইপ.comপ্রেডআইডেন্টিকাল।

এটা পাস করে:

[1, 2, [3, 4]].compareIdentical ([1, 2, [3, 2]]) === false;
[1, "2,3"].compareIdentical ([1, 2, 3]) === false;
[1, 2, [3, 4]].compareIdentical ([1, 2, [3, 4]]) === true;
[1, 2, 1, 2].compareIdentical ([1, 2, 1, 2]) === true;

কিন্তু ব্যর্থ হয়:

[[1, 2, [3, 2]],1, 2, [3, 2]].compareIdentical([1, 2, [3, 2],[1, 2, [3, 2]]])

এখানে ভাল (আমার মতে) সংস্করণ:

Array.prototype.compare = function (array) {
    // if the other array is a falsy value, return
    if (!array)
        return false;

    // compare lengths - can save a lot of time
    if (this.length != array.length)
        return false;

    this.sort();
    array.sort();
    for (var i = 0; i < this.length; i++) {
        // Check if we have nested arrays
        if (this[i] instanceof Array && array[i] instanceof Array) {
            // recurse into the nested arrays
            if (!this[i].compare(array[i]))
                return false;
        }
        else if (this[i] != array[i]) {
            // Warning - two different object instances will never be equal: {x:20} != {x:20}
            return false;
        }
    }
    return true;
}

http://jsfiddle.net/igos/bcfCY/


Answer #16

আপনি যদি Chai অ্যাসারেশন লাইব্রেরির সাথে Mocha মত একটি পরীক্ষার কাঠামো ব্যবহার করেন , তবে আপনি অ্যারে তুলনা করার জন্য deep সমতা ব্যবহার করতে পারেন ।Chaideep

expect(a1).to.deep.equal(a2)

অ্যারেগুলির অনুরূপ সূচকগুলিতে সমান উপাদান থাকলেই এটি সত্যই প্রত্যাবর্তন করা উচিত।


Answer #17

আমার ক্ষেত্রে তুলনা অ্যারে শুধুমাত্র সংখ্যা এবং স্ট্রিং ধারণ করে। অ্যারে একই উপাদান থাকে যদি এই ফাংশন আপনাকে দেখাবে।

function are_arrs_match(arr1, arr2){
    return arr1.sort().toString() === arr2.sort().toString()
}

চল এটা পরীক্ষা করি!

arr1 = [1, 2, 3, 'nik']
arr2 = ['nik', 3, 1, 2]
arr3 = [1, 2, 5]

console.log (are_arrs_match(arr1, arr2)) //true
console.log (are_arrs_match(arr1, arr3)) //false

Answer #18

আমার সমাধান বস্তু, অ্যারে তুলনা করে। এটি একইভাবে কাজ করবে যেমন টোমাসের অ্যারে অবজেক্টস, তবে সতর্কতা ছাড়াই:

Object.prototype.compare_to = function(comparable){

    // Is the value being compared an object
    if(comparable instanceof Object){

        // Count the amount of properties in @comparable
        var count_of_comparable = 0;
        for(p in comparable) count_of_comparable++;

        // Loop through all the properties in @this
        for(property in this){

            // Decrements once for every property in @this
            count_of_comparable--;

            // Prevents an infinite loop
            if(property != "compare_to"){

                // Is the property in @comparable
                if(property in comparable){

                    // Is the property also an Object
                    if(this[property] instanceof Object){

                        // Compare the properties if yes
                        if(!(this[property].compare_to(comparable[property]))){

                            // Return false if the Object properties don't match
                            return false;
                        }
                    // Are the values unequal
                    } else if(this[property] !== comparable[property]){

                        // Return false if they are unequal
                        return false;
                    }
                } else {

                    // Return false if the property is not in the object being compared
                    return false;
                }
            }
        }
    } else {

        // Return false if the value is anything other than an object
        return false;
    }

    // Return true if their are as many properties in the comparable object as @this
    return count_of_comparable == 0;
}

এই আপনি বা অন্য কেউ একটি উত্তর অনুসন্ধান করতে সাহায্য করে আশা করি।


Answer #19
function compareArrays(arrayA, arrayB) {
    if (arrayA.length != arrayB.length) return true;
    for (i = 0; i < arrayA.length; i++)
        if (arrayB.indexOf(arrayA[i]) == -1) {
            return true;
        }
    }
    for (i = 0; i < arrayB.length; i++) {
        if (arrayA.indexOf(arrayB[i]) == -1) {
            return true;
        }
    }
    return false;
}

Answer #20
var a1 = [1,2,3,6];
var a2 = [1,2,3,5];

function check(a, b) {
  return (a.length != b.length) ? false : 
  a.every(function(row, index) {
    return a[index] == b[index];
  });
}  

check(a1, a2);

////// OR ///////

var a1 = [1,2,3,6];
var a2 = [1,2,3,6];

function check(a, b) {
  return (a.length != b.length) ? false : 
  !(a.some(function(row, index) {
    return a[index] != b[index];
  }));
}  

check(a1, a2)





json