जांचें कि क्या एक सरणी में जावास्क्रिप्ट में किसी अन्य सरणी का कोई तत्व है

Question

मेरे पास एक लक्ष्य सरणी है ["apple","banana","orange"], और मैं यह जांचना चाहता हूं कि क्या अन्य सरणियों में लक्ष्य सरणी तत्वों में से कोई एक है।

उदाहरण के लिए:

["apple","grape"] //returns true;

["apple","banana","pineapple"] //returns true;

["grape", "pineapple"] //returns false;

मैं इसे जावास्क्रिप्ट में कैसे कर सकता हूं?

Comments

forलूप का उपयोग करें और लक्ष्य सरणी पर पुनरावृति करें । यदि प्रत्येक तत्व वर्तमान सरणी के भीतर समाहित है (उपयोग करें current.indexOf(elem) !== -1), तो वे सभी वहां मौजूद हैं।

— ब्लेंडर

@ एलेक्स जवाब दो यार, यह अनियंत्रित एक जवाब छोड़ने के लिए अशिष्ट है, विशेष रूप से यह कई अच्छे उत्तरों के साथ। अगर मैं तुम होते तो अंडरस्कोर / लॉश को चुनता।

— लियोन गैबन

@ लियोनगबन मैं असहमत हूं। मैं सिर्फ इस ऑपरेशन को करने के लिए एक पुस्तकालय आयात नहीं करेगा।

— देवपोत

@ शिवपत्तो ने मेरा मन बदल दिया, ES6 समाधान मेरे fav है

— लियोन गबन

Arr1.some (el1 => arr2.includes (el1)) के बारे में क्या; ?

— Walaszka

Answer 1

वेनिला जेएस

ES2016:

const found = arr1.some(r=> arr2.includes(r))

ES6:

const found = arr1.some(r=> arr2.indexOf(r) >= 0)

यह काम किस प्रकार करता है

some(..)किसी परीक्षण फ़ंक्शन के विरुद्ध सरणी के प्रत्येक तत्व की जाँच करता है और यदि सरणी का कोई भी तत्व परीक्षण फ़ंक्शन को पास करता है, तो यह सही है, अन्यथा, यह गलत है। indexOf(..) >= 0और includes(..)यदि दिए गए तर्क सरणी में मौजूद है, तो दोनों सही हैं।

Comments

इस कोड को स्पष्टीकरण की आवश्यकता है - यह काम कर सकता है, लेकिन इसका कोई मूल्य नहीं है क्योंकि कोई भी कुछ भी नहीं सीख रहा है

— टॉल्मेरा

Array.prototype.some () सरणी के प्रत्येक तत्व को एक परीक्षण फ़ंक्शन के खिलाफ जाँचता है और trueयदि सरणी का कोई भी तत्व परीक्षण फ़ंक्शन को पास करता है तो वापस लौटता है। नहीं तो लौट आता है false।

— हेंडेका

यह सही उत्तर होना चाहिए!

— नाचो

क्या यह अपेक्षा की जाती है कि मेरा परिणाम [false, false, false]रिक्त सरणी के बजाय है []?

— बैटमैन

@ बाथमैन: परिणाम सच है या गलत है, लेकिन आप श्रीमान से समाधान को अनुकूलित कर सकते हैं

— 0zkr PM

Answer 2

वेनिला जे.एस.

/**
 * @description determine if an array contains one or more items from another array.
 * @param {array} haystack the array to search.
 * @param {array} arr the array providing items to check for in the haystack.
 * @return {boolean} true|false if haystack contains at least one item from arr.
 */
var findOne = function (haystack, arr) {
    return arr.some(function (v) {
        return haystack.indexOf(v) >= 0;
    });
};

Comments

अच्छा समाधान! some()रेड है। जैसे ही कुछ मेल खाता है, छोड़ देता है।

— एवेर्देव

ईवेंट टिडियर इस तरह से:arr.some(v=> haystack.indexOf(v) >= 0)

— पॉल ग्रिमशॉ

इसके अलावा ES2016 में उपलब्ध हैarr.some(v => haystack.includes(v))

— loganfsmyth

एक पंक्ति में arr1.some(v => arr2.indexOf(v) >= 0)।

— वेबजय

अभी के लिए, इसका उपयोग करने से बचने के लिए सबसे अच्छा हो सकता है includes, क्योंकि जाहिरा तौर पर यह IE में समर्थित नहीं है: stackoverflow.com/questions/36574351/…

— Shafique Jamal

Answer 3

यदि आप लाइब्राय का उपयोग करने के विरोध में नहीं हैं, तो http://underscorejs.org/ में एक चौराहा विधि है, जो इसे सरल बना सकती है:

var _ = require('underscore');

var target = [ 'apple', 'orange', 'banana'];
var fruit2 = [ 'apple', 'orange', 'mango'];
var fruit3 = [ 'mango', 'lemon', 'pineapple'];
var fruit4 = [ 'orange', 'lemon', 'grapes'];

console.log(_.intersection(target, fruit2)); //returns [apple, orange]
console.log(_.intersection(target, fruit3)); //returns []
console.log(_.intersection(target, fruit4)); //returns [orange]

चौराहे फ़ंक्शन उन आइटम्स के साथ एक नया सरणी लौटाएगा, जो इसे मेल खाते हैं और यदि मेल नहीं खाते हैं तो यह खाली सरणी देता है।

Comments

मैंने कई बार इसका उपयोग किया है, लेकिन ध्यान दें कि यह जांचने के बारे में था कि क्या कोई तत्व दूसरे सरणी में मौजूद है, पूरे चौराहे का उत्पादन करने के लिए नहीं। प्रदर्शन के मामले में, एक बड़ा अंतर है यदि सरणियां बड़ी हैं क्योंकि पहले मामले में आप एक मैच मिलते ही बाहर जमानत कर सकते हैं।

— जेएचएच

लॉश बहुत अधिक पठनीय है तो वेनिला जावास्क्रिप्ट, लिमडा की तरह यह काम हमेशा वेनिला इम्हो के बजाय इस्तेमाल किया जाना चाहिए। सभी देवों के लिए बेहतर ...

— लियोन गबन

Answer 4

ES6 (सबसे तेज़)

const a = ['a', 'b', 'c'];
const b = ['c', 'a', 'd'];
a.some(v=> b.indexOf(v) !== -1)

ES2016

const a = ['a', 'b', 'c'];
const b = ['c', 'a', 'd'];
a.some(v => b.includes(v));

अंडरस्कोर

const a = ['a', 'b', 'c'];
const b = ['c', 'a', 'd'];
_.intersection(a, b)

डेमो: https://jsfiddle.net/r257wuv5/

jsPerf: https://jsperf.com/array-contains-any-element-of-another-array

Comments

यह सबसे सरल और घोषित समाधान है

— स्ट्राइडर

मुझे पता है कि मुझे इसके लिए वास्तव में देर हो रही है, लेकिन कंसोल की जांच करने के लिए यदि JSFiddle ने JQuery एज को जोड़ा और Firebug Lite

— Rojo

जेस्परफ लिंक टूट गया

— डारकेब्लज़र

क्या समय और स्थान की जटिलता में कोई अंतर है? जटिलता के संबंध में सबसे अच्छा समाधान क्या होगा?

— नाचो

Answer 5

यदि आपको प्रकार के जोर की जरूरत नहीं है (उपयोग के कारण indexOf), तो आप निम्नलिखित की तरह कुछ आज़मा सकते हैं:

var arr = [1, 2, 3];
var check = [3, 4];

var found = false;
for (var i = 0; i < check.length; i++) {
    if (arr.indexOf(check[i]) > -1) {
        found = true;
        break;
    }
}
console.log(found);

जहां arrलक्ष्य आइटम शामिल हैं। अंत में, foundदिखाएगा कि लक्ष्य के खिलाफ दूसरे सरणी में कम से कम एक मैच था या नहीं ।

बेशक, आप अपने द्वारा उपयोग की जाने वाली किसी भी चीज़ के लिए नंबर स्वैप कर सकते हैं - तार ठीक हैं, जैसे आपका उदाहरण।

और मेरे विशिष्ट उदाहरण में, परिणाम होना चाहिए trueक्योंकि 3लक्ष्य में दूसरी सरणी मौजूद है।

---

अपडेट करें:

यहां बताया गया है कि मैं इसे एक समारोह में कैसे व्यवस्थित करूँगा (पहले से कुछ मामूली बदलावों के साथ):

var anyMatchInArray = (function () {
    "use strict";

    var targetArray, func;

    targetArray = ["apple", "banana", "orange"];
    func = function (checkerArray) {
        var found = false;
        for (var i = 0, j = checkerArray.length; !found && i < j; i++) {
            if (targetArray.indexOf(checkerArray[i]) > -1) {
                found = true;
            }
        }
        return found;
    };

    return func;
}());

डेमो: http://jsfiddle.net/u8Bzt/

इस मामले में, फ़ंक्शन को संशोधित किया targetArrayजा सकता है इसे बंद करने में हार्डकोड के बजाय एक तर्क के रूप में पारित किया जा सकता है।

---

UPDATE2:

हालांकि, मेरा समाधान ऊपर काम कर सकता है और (उम्मीद से अधिक) पठनीय हो सकता है, मेरा मानना ​​है कि जिस अवधारणा का मैंने वर्णन किया है उसे संभालने के लिए "बेहतर" तरीका कुछ अलग ढंग से करना है। उपरोक्त समाधान के साथ "समस्या" यह है कि indexOfलूप के अंदर लक्ष्य सरणी को अन्य मद में प्रत्येक आइटम के लिए पूरी तरह से लूप किए जाने का कारण बनता है। यह आसानी से "लुकअप" (एक नक्शा ... एक जावास्क्रिप्ट ऑब्जेक्ट शाब्दिक) का उपयोग करके "तय" किया जा सकता है। यह दो सरल छोरों की अनुमति देता है, प्रत्येक सरणी पर। यहाँ एक उदाहरण है:

var anyMatchInArray = function (target, toMatch) {
    "use strict";

    var found, targetMap, i, j, cur;

    found = false;
    targetMap = {};

    // Put all values in the `target` array into a map, where
    //  the keys are the values from the array
    for (i = 0, j = target.length; i < j; i++) {
        cur = target[i];
        targetMap[cur] = true;
    }

    // Loop over all items in the `toMatch` array and see if any of
    //  their values are in the map from before
    for (i = 0, j = toMatch.length; !found && (i < j); i++) {
        cur = toMatch[i];
        found = !!targetMap[cur];
        // If found, `targetMap[cur]` will return true, otherwise it
        //  will return `undefined`...that's what the `!!` is for
    }

    return found;
};

डेमो: http://jsfiddle.net/5Lv9v/

इस समाधान के लिए नकारात्मक पक्ष यह है कि केवल संख्या और तार (और बूलियन) का उपयोग किया जा सकता है (सही ढंग से), क्योंकि मान (अव्यवस्थित रूप से) तार में परिवर्तित होते हैं और लुकअप मैप की कुंजी के रूप में सेट होते हैं। यह गैर-शाब्दिक मूल्यों के लिए बिल्कुल अच्छा / संभव / आसानी से नहीं किया गया है।

Comments

एक्सेलेंट उदाहरण, दूसरा उदाहरण बस शानदार है।

— सोरिन हैदौ

जब आप कुछ या findIndex का उपयोग कर सकते हैं तो आप लूप के लिए उपयोग क्यों कर रहे हैं?

— यह मैं हूँ ...

"कुछ" कोड को बहुत सरल करता है। इसके अलावा, anyMatchInArray ([1,2,3, "बिल्लियों", "4"], ["1", 4]) सच होगा। अंत में, यह अधिक प्रदर्शनकारी हो सकता है यदि आपके पास बड़ी संख्या में लुकअप थे और टारगेट को कैश किया गया था। फिर भी, शायद प्रदर्शन में वृद्धि हो सकती है। उदाहरण के लिए, मुझे लगता है कि "पाया गया = toMatch [i]! == अपरिभाषित" अधिक प्रदर्शन वाला होगा, और कुछ मामलों में बेहतर होगा (ताकि आप "या 0 का मूल्यांकन न करें)

— csga5000

"अन्यथा यह वापस आ जाएगा undefined... यह वही है जो !!इसके लिए है" - यह गलत है। यह बूलियन विरोध वापस कर देगा !।

— एलियनवेबगि

Answer 6

ES6 समाधान:

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

let isFounded = arr1.some( ai => arr2.includes(ai) );

इसके विपरीत: इसमें सभी मान शामिल होने चाहिए।

let allFounded = arr2.every( ai => arr1.includes(ai) );

आशा है, सहायक होगा।

Comments

क्या array1 से arra2 मानों का सूचकांक प्राप्त करने का कोई तरीका है ??

— अजील खां

उस स्थिति में, हम "कुछ" के बजाय "फ़िल्टर" का उपयोग कर सकते हैं। फिर यह बूलियन के बजाय एक सरणी लौटाएगा और आप वहां से आसानी से मूल्य प्राप्त कर सकते हैं।

— tanvir993

Answer 7

आप लाकैश का उपयोग कर सकते हैं और कर सकते हैं:

_.intersection(originalTarget, arrayToCheck).length > 0

सेट चौराहे दोनों संग्रह पर समान तत्वों की एक सरणी का निर्माण किया जाता है।

Comments

यह प्रदर्शन के मामले में इष्टतम नहीं है, क्योंकि इस समस्या के लिए यह पहला मैच खोजने के लिए पर्याप्त है, जबकि intersectionउन सभी को खोजने के लिए पहला मैच खोजने के बाद भी तुलना करना जारी रहेगा। filterजब आप की जरूरत हो तो इसका उपयोग करना पसंद है find।

— अलेक्जेंडर

Answer 8

फ़िल्टर / indexOf का उपयोग करना :

function containsAny(source,target)
{
    var result = source.filter(function(item){ return target.indexOf(item) > -1});   
    return (result.length > 0);  
}    


//results

var fruits = ["apple","banana","orange"];


console.log(containsAny(fruits,["apple","grape"]));

console.log(containsAny(fruits,["apple","banana","pineapple"]));

console.log(containsAny(fruits,["grape", "pineapple"]));

Comments

यह एक ही समस्या से ग्रस्त है जैसे पुस्तकालय कार्यों में _.intersection जैसे कि यह एक खोजने के बाद भी मैचों की तलाश जारी रखेगा। छोटे सरणियों के लिए जाहिर है, हालांकि यह कोई फर्क नहीं पड़ता।

— जेएचएच

Answer 9

const areCommonElements = (arr1, arr2) => {
    const arr2Set = new Set(arr2);
    return arr1.some(el => arr2Set.has(el));
};

या आप बेहतर प्रदर्शन भी कर सकते हैं यदि आपको पहली बार पता चले कि इनमें से कौन सी दो सरणियाँ लंबी हैं और Setसबसे लंबी सरणी के लिए बना रही हैं, जबकि someसबसे छोटी विधि पर आवेदन करना है :

const areCommonElements = (arr1, arr2) => {
    const [shortArr, longArr] = (arr1.length < arr2.length) ? [arr1, arr2] : [arr2, arr1];
    const longArrSet = new Set(longArr);
    return shortArr.some(el => longArrSet.has(el));
};

Comments

जबकि लोगों को घोंसला बनाने के साथ समाधान पोस्ट करते रहें indexOfऔर includes, आपको पहले और अधिक कुशल सेट के आधार पर समाधान के साथ जवाब देने के लिए कर रहे हैं, देशी का उपयोग कर Set, 4 साल के बाद यह ECMAScript में पेश किया गया था। +1

— त्रिनकोट

Answer 10

मुझे यह संक्षिप्त और प्यारा वाक्यविन्यास मिला दो या दो सरणियों के बीच कुछ तत्वों का मिलान करने के लिए। उदाहरण के लिए

// या ऑपरेशन। यह देखें कि array1 में कोई भी array2 एलिमेंट मौजूद है या नहीं। जैसे ही फ़ंक्शन TRUE होने पर कुछ विधि टूटती है, जैसे ही पहला मैच होगा, यह वापस आ जाएगा

let array1 = ['a', 'b', 'c', 'd', 'e'], array2 = ['a', 'b'];

console.log(array2.some(ele => array1.includes(ele)));

// प्रिंट्स TRUE

// और ऑपरेशन। array2 तत्वों के सभी array1 में मौजूद हैं। जैसे ही फ़ंक्शन का TRUE होने पर कुछ विधि टूटती है, जैसे ही कोई पहला मैच होगा, यह वापस आ जाएगा

let array1 = ['a', 'b', 'c', 'd', 'e'], array2 = ['a', 'x'];

console.log(!array2.some(ele => !array1.includes(ele)));

// प्रिंट्स FALSE

आशा है कि भविष्य में किसी की मदद करता है!

Comments

मुझे वास्तव में सवाल का दूसरा हिस्सा पसंद आया, इसे ES5 के लिए काम करने के लिए, क्या यह पसंद आया:? Array2.some (function (ele) {return array1.indexOf (ele) === -1});

— फ्राइजगार्ड

Answer 11

आप नेस्टेड Array.prototype.some कॉल का उपयोग कर सकते हैं। इसका यह लाभ है कि यह अन्य समाधानों के बजाय पहले मैच में जमानत देगा जो पूर्ण नेस्टेड लूप के माध्यम से चलेगा।

जैसे।

var arr = [1, 2, 3];
var match = [2, 4];

var hasMatch = arr.some(a => match.some(m => a === m));

Answer 12

यहाँ एक दिलचस्प मामला है जो मुझे लगा कि मुझे साझा करना चाहिए।

मान लें कि आपके पास ऑब्जेक्ट्स की एक श्रेणी और चयनित फ़िल्टरों की एक सरणी है।

let arr = [
  { id: 'x', tags: ['foo'] },
  { id: 'y', tags: ['foo', 'bar'] },
  { id: 'z', tags: ['baz'] }
];

const filters = ['foo'];

इस संरचना में चयनित फ़िल्टर लागू करने के लिए हम कर सकते हैं

if (filters.length > 0)
  arr = arr.filter(obj =>
    obj.tags.some(tag => filters.includes(tag))
  );

// [
//   { id: 'x', tags: ['foo'] },
//   { id: 'y', tags: ['foo', 'bar'] }
// ]

Answer 13

मैंने 3 उपाय लिखे। अनिवार्य रूप से वे भी ऐसा ही करते हैं। वे मिलते ही सच लौटाते हैं true। मैंने सिर्फ 3 उपाय लिखे हैं कि चीजों को करने के लिए 3 अलग-अलग तरीके दिखाए जाएं। अब, यह निर्भर करता है कि आपको क्या पसंद है। आप एक समाधान या दूसरे के प्रदर्शन की जांच करने के लिए performance.now () का उपयोग कर सकते हैं । अपने समाधानों में, मैं यह भी जाँच रहा हूँ कि कौन सी सरणी सबसे बड़ी है और कौन सी सबसे छोटी है जो संचालन को अधिक कुशल बनाती है।

तीसरा समाधान सबसे प्यारे नहीं हो सकता, लेकिन कुशल है। मैंने इसे जोड़ने का फैसला किया क्योंकि कुछ कोडिंग साक्षात्कारों में आपको अंतर्निहित विधियों का उपयोग करने की अनुमति नहीं है।

अंत में, निश्चित ... हम लूप्स (ब्रूट फोर्स वे) के लिए 2 नेस्टेड के साथ एक समाधान के साथ आ सकते हैं, लेकिन आप इससे बचना चाहते हैं क्योंकि समय जटिलता खराब है ओ (एन ^ 2) ।

ध्यान दें:

.includes()कुछ अन्य लोगों की तरह उपयोग करने के बजाय , आप उपयोग कर सकते हैं .indexOf()। अगर आप सिर्फ जाँच करते हैं कि क्या मान 0. से बड़ा है। यदि मान मौजूद नहीं है तो आपको -1 देगा। यदि यह मौजूद है, तो यह आपको 0 से अधिक देगा।

indexOf () बनाम शामिल ()

बेहतर प्रदर्शन किसका है ? indexOf()थोड़ा सा, लेकिन मेरी राय में अधिक पठनीय शामिल है।

यदि मैं गलत नहीं हूं .includes()और indexOf()दृश्य के पीछे छोरों का उपयोग करता हूं , तो आप उनके साथ उपयोग करते समय O (n ^ 2) पर होंगे .some()।

पाश का उपयोग करना

 const compareArraysWithIncludes = (arr1, arr2) => {
     const [smallArray, bigArray] =
        arr1.length < arr2.length ? [arr1, arr2] : [arr2, arr1];

     for (let i = 0; i < smallArray.length; i++) {
       return bigArray.includes(smallArray[i]);
     }

      return false;
    };

उपयोग .some ()

const compareArraysWithSome = (arr1, arr2) => {
  const [smallArray, bigArray] =
    arr1.length < arr2.length ? [arr1, arr2] : [arr2, arr1];
  return smallArray.some(c => bigArray.includes(c));
};

MAPS समय जटिलता हे (2n) => O (n) का उपयोग करना

const compararArraysUsingObjs = (arr1, arr2) => {
  const map = {};

  const [smallArray, bigArray] =
    arr1.length < arr2.length ? [arr1, arr2] : [arr2, arr1];

  for (let i = 0; i < smallArray.length; i++) {
    if (!map[smallArray[i]]) {
      map[smallArray[i]] = true;
    }
  }

  for (let i = 0; i < bigArray.length; i++) {
    if (map[bigArray[i]]) {
      return true;
    }
  }

  return false;
};

कोड इन माय : स्टैकब्लिट्ज़

मैं प्रदर्शन का विशेषज्ञ नहीं हूं और न ही बिगओ तो अगर मैंने कुछ गलत कहा है तो मुझे बताएं।

Answer 14

कुछ / findIndex और indexOf के संयोजन का उपयोग करने के बारे में क्या?

तो कुछ इस तरह:

var array1 = ["apple","banana","orange"];
var array2 = ["grape", "pineapple"];

var found = array1.some(function(v) { return array2.indexOf(v) != -1; });

इसे अधिक पठनीय बनाने के लिए आप इस कार्यक्षमता को ऐरे ऑब्जेक्ट में ही जोड़ सकते हैं।

Array.prototype.indexOfAny = function (array) {
    return this.findIndex(function(v) { return array.indexOf(v) != -1; });
}

Array.prototype.containsAny = function (array) {
    return this.indexOfAny(array) != -1;
}

नोट: यदि आप एक विधेय के साथ कुछ करना चाहते हैं तो आप आंतरिक indexOf को दूसरे findIndex और एक विधेय के साथ बदल सकते हैं

Answer 15

मेरा समाधान Array.prototype.some () और Array.prototype.includes () सरणी सहायक जो उनके काम को बहुत कुशल के रूप में अच्छी तरह से लागू होता है

ES6

const originalFruits = ["apple","banana","orange"];

const fruits1 = ["apple","banana","pineapple"];

const fruits2 = ["grape", "pineapple"];

const commonFruits = (myFruitsArr, otherFruitsArr) => {
  return myFruitsArr.some(fruit => otherFruitsArr.includes(fruit))
}
console.log(commonFruits(originalFruits, fruits1)) //returns true;
console.log(commonFruits(originalFruits, fruits2)) //returns false;

Comments

क्या ओरिजिनलफ्रूट्स से शामिल वस्तुओं का सूचकांक प्राप्त करने का कोई तरीका है ??

— अजील खां

Answer 16

बस एक और उपाय

var a1 = [1, 2, 3, 4, 5]
var a2 = [2, 4]

जाँच करें कि a1 में a2 के सभी तत्व हैं

var result = a1.filter(e => a2.indexOf(e) !== -1).length === a2.length
console.log(result)

Answer 17

यह मुख्य सरणी में केवल पुनरावृत्ति करके किया जा सकता है और जांच सकता है कि अन्य सरणी में कोई लक्ष्य तत्व है या नहीं।

इसे इस्तेमाल करे:

function Check(A) {
    var myarr = ["apple", "banana", "orange"];
    var i, j;
    var totalmatches = 0;
    for (i = 0; i < myarr.length; i++) {
        for (j = 0; j < A.length; ++j) {
            if (myarr[i] == A[j]) {

                totalmatches++;

            }

        }
    }
    if (totalmatches > 0) {
        return true;
    } else {
        return false;
    }
}
var fruits1 = new Array("apple", "grape");
alert(Check(fruits1));

var fruits2 = new Array("apple", "banana", "pineapple");
alert(Check(fruits2));

var fruits3 = new Array("grape", "pineapple");
alert(Check(fruits3));

JSFIDDLE में डेमो

Answer 18

अंडरस्कोरज के साथ

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

_.every(a1, function(e){ return _.include(a2, e); } ); //=> false
_.every(a2, function(e){ return _.include(a1, e); } ); //=> true

Comments

व्यक्तिगत रूप से, हालांकि मुझे अंडरस्कोरज पसंद हैं, यह एक उत्कृष्ट उदाहरण है कि कैसे कोड को देखा जा सकता है। न केवल अंडरस्कोरजस कोड के रूप में समझना मुश्किल है, बल्कि सामान्य कोडिंग दृष्टिकोण से, यह भी सच है (उदाहरण के लिए "हर" शब्द मन में वसंत नहीं करता है जब मैं किसी सरणी में कुछ का सूचकांक ढूंढना चाहता हूं लेकिन "indexOf" करता है)। जब कुछ अतिरिक्त वर्णों के लिए शुद्ध जावास्क्रिप्ट समाधान प्रदान किया जा सकता है, तो हमें तीसरे पक्ष के टूल के अनावश्यक उपयोग से बचना चाहिए। इसके लिए अंडरस्कोरज का उपयोग करने का मतलब है कि आपका समाधान तीसरे पक्ष के कोड के साथ कसकर युग्मित हो जाता है।

— csharpforevermore

@csharpforevermore मुझे लगता है कि यह स्वाद का मामला है, आप कहते हैं कि यह समाधान अन्य लोगों की तुलना में अधिक जटिल है, जिसका उपयोग करके indexOfमुझे लगता है कि इसके विपरीत :)। दूसरी ओर मैं बाहरी पुस्तकालयों को न जोड़ने की कोशिश में सहमत हूं यदि वे वास्तव में आवश्यक नहीं हैं, लेकिन मैं वास्तव में इसके साथ जुनूनी नहीं हूं, तीसरे-भाग के पुस्तकालय न केवल उपयोगी कार्यक्षमताएं बल्कि ठोस कार्यशीलता भी प्रदान करते हैं । उदाहरण के लिए: क्या आपने अपने समाधान के साथ सभी किनारे-मामलों और महापौर-ब्राउज़रों का परीक्षण किया है? .. (वैसे, everyकिसी सूची में एक सूचकांक खोजने की कोशिश नहीं कर रहा है , लेकिन सूची में प्रत्येक तत्व में कुछ का मूल्यांकन कर रहा है )

— fguillen

Answer 19

ऐरे प्रोटोटाइप में जोड़ना

डिस्क्लेमर: कई लोग इसके खिलाफ कड़ी सलाह देंगे। केवल एक बार यह वास्तव में एक समस्या होगी अगर एक पुस्तकालय में एक ही नाम के साथ एक प्रोटोटाइप फ़ंक्शन जोड़ा गया (जो कि अलग तरह से व्यवहार किया गया) या उसके बाद कुछ।

कोड:

Array.prototype.containsAny = function(arr) {
    return this.some(
        (v) => (arr.indexOf(v) >= 0)
    )
}

बड़े तीर कार्यों का उपयोग किए बिना:

Array.prototype.containsAny = function(arr) {
    return this.some(function (v) {
        return arr.indexOf(v) >= 0
    })
}

प्रयोग

var a = ["a","b"]

console.log(a.containsAny(["b","z"]))    // Outputs true

console.log(a.containsAny(["z"]))    // Outputs false

Answer 20

वेनिला जेएस आंशिक मिलान और मामले असंवेदनशील के साथ

कुछ पिछले दृष्टिकोणों के साथ समस्या यह है कि उन्हें हर शब्द के सटीक मिलान की आवश्यकता होती है । लेकिन, क्या होगा यदि आप आंशिक मैचों के लिए परिणाम प्रदान करना चाहते हैं?

function search(arrayToSearch, wordsToSearch) {
    arrayToSearch.filter(v => 
        wordsToSearch.every(w => 
            v.toLowerCase().split(" ").
                reduce((isIn, h) => isIn || String(h).indexOf(w) >= 0, false)
            )
        )
}
//Usage
var myArray = ["Attach tag", "Attaching tags", "Blah blah blah"];
var searchText = "Tag attach";
var searchArr = searchText.toLowerCase().split(" "); //["tag", "attach"]

var matches = search(myArray, searchArr);
//Will return
//["Attach tag", "Attaching tags"]

यह तब उपयोगी होता है जब आप एक खोज बॉक्स प्रदान करना चाहते हैं जहाँ उपयोगकर्ता शब्द लिखते हैं और परिणाम उन शब्दों को किसी भी क्रम, स्थिति और मामले में रख सकते हैं।

Answer 21

@Paul Grimshaw जवाब अपडेट करें, अधिक पठनीय includesके indexOfलिए इंस्टैंड का उपयोग करें

पाया = arr1.some जाने (r => arr2.indexOf (आर)> = 0)
जाने पाया = arr1.some (r => arr2.includes (र))

Answer 22

मैं इस तरह अंडरस्कोर js का उपयोग कर नोड में एक समाधान के साथ आया:

var checkRole = _.intersection(['A','B'], ['A','B','C']);
if(!_.isEmpty(checkRole)) { 
     next();
}

Answer 23

व्यक्तिगत रूप से, मैं निम्नलिखित फ़ंक्शन का उपयोग करूंगा:

var arrayContains = function(array, toMatch) {
    var arrayAsString = array.toString();
    return (arrayAsString.indexOf(','+toMatch+',') >-1);
}

"ToString ()" विधि हमेशा मानों को अलग करने के लिए अल्पविराम का उपयोग करेगी। केवल वास्तव में आदिम प्रकारों के साथ काम करेंगे।

Comments

यह तब काम नहीं करेगा जब तत्व आरम्भ में या सरणी के अंत में हों, या किसी भिन्न क्रम में हों।

— डैनियल

-1 क्योंकि डेनियल ने कहा कि यह टूट गया है। आप एक समाधान के रूप में arrayAsString के लिए अल्पविराम को प्रस्तुत कर सकते हैं और जोड़ सकते हैं , लेकिन ईमानदारी से यह स्ट्रिंग्स का उपयोग करने के लिए एक अत्यधिक जटिल समाधान की तरह लगता है।

— JHH

Answer 24

Array .filter () एक नेस्टेड कॉल के साथ .find () पहले एरे में वे सभी तत्व लौटाएगा जो दूसरे एरे के सदस्य हैं। यह निर्धारित करने के लिए कि किसी दूसरी सरणी के पहले सरणी में हैं, तो दिए गए सरणी की लंबाई की जाँच करें।

getCommonItems(firstArray, secondArray) {
  return firstArray.filter((firstArrayItem) => {
    return secondArray.find((secondArrayItem) => {
      return firstArrayItem === secondArrayItem;
    });
  });
}

Comments

क्या सरणी को "साफ़" करने का कोई तरीका है? दूसरे सरणी में मानों को हटाने की तरह यदि वे पहले में मौजूद हैं?

— सैंड्रोको

Answer 25

console.log("searching Array: "+finding_array);
console.log("searching in:"+reference_array);
var check_match_counter = 0;
for (var j = finding_array.length - 1; j >= 0; j--) 
{
    if(reference_array.indexOf(finding_array[j]) > 0)
    {
        check_match_counter = check_match_counter + 1;
    }
}
 var match = (check_match_counter > 0) ? true : false;
console.log("Final result:"+match);

Answer 26

var target = ["apple","banana","orange"];
var checkArray = ["apple","banana","pineapple"];

var containsOneCommonItem = target.some(x => checkArray.some(y => y === x));`

["apple","grape"] //returns true;

["apple","banana","pineapple"] //returns true;

["grape", "pineapple"] //returns false;