वस्तुओं की जावास्क्रिप्ट फ़िल्टर सरणी

Question

मेरे पास वस्तुओं की एक सरणी है और मैं इसे खोजने का सबसे अच्छा तरीका सोच रहा हूं। नीचे दिए गए उदाहरण को देखते हुए मैं कैसे खोज सकता हूं name = "Joe"और age < 30? वहाँ कुछ भी jQuery के साथ मदद कर सकता है या मैं खुद को इस खोज को बल देने के लिए है?

var names = new Array();

var object = { name : "Joe", age:20, email: "[e-mail]"};
names.push(object);

object = { name : "Mike", age:50, email: "[e-mail]"};
names.push(object);

object = { name : "Joe", age:45, email: "[e-mail]"};
names.push(object);

Comments

खोज से क्या आपका मतलब फ़िल्टर है?

— joragupra

खोज! = फ़िल्टर करें। तुम्हें कौनसा चाहिए?

— टीजे क्राउडर

Answer 1

आप उपयोग कर सकते हैं jQuery.grep():

var found_names = $.grep(names, function(v) {
    return v.name === "Joe" && v.age < 30;
});

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

Answer 2

आप इसे बहुत आसानी से [].filterविधि के साथ कर सकते हैं :

var filterednames = names.filter(function(obj) {
    return (obj.name === "Joe") && (obj.age < 30);
});

आपको उन ब्राउज़रों के लिए एक शिम जोड़ना होगा जो [].filterविधि का समर्थन नहीं करते हैं : यह एमडीएन पृष्ठ इस तरह का कोड देता है।

Comments

मेरा सुझाव है कि लिंक किए गए एमडीएन पृष्ठ में पॉलीफ़िल पर एक नज़र डालें, बस कुछ मज़ेदार कोड पढ़ने और संभवतः कुछ नया सीखने के लिए।

— औरेलियो

Answer 3

आप मिलान तत्वों के एक सबसेट से तत्वों को वापस करने के लिए jQuery.filter () फ़ंक्शन का उपयोग कर सकते हैं।

var names = [
    { name : "Joe", age:20, email: "[e-mail]"},
    { name : "Mike", age:50, email: "[e-mail]"},
    { name : "Joe", age:45, email: "[e-mail]"}
   ];
   
   
var filteredNames = $(names).filter(function( idx ) {
    return names[idx].name === "Joe" && names[idx].age < 30;
}); 

$(filteredNames).each(function(){
     $('#output').append(this.name);
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<div id="output"/>

Answer 4

var nameList = [
{name:'x', age:20, email:'[e-mail]'},
{name:'y', age:60, email:'[e-mail]'},
{name:'Joe', age:22, email:'[e-mail]'},
{name:'Abc', age:40, email:'[e-mail]'}
];

var filteredValue = nameList.filter(function (item) {
      return item.name == "Joe" && item.age < 30;
});

//To See Output Result as Array
console.log(JSON.stringify(filteredValue));

आप बस जावास्क्रिप्ट का उपयोग कर सकते हैं :)

Answer 5

उन लोगों के लिए जो किसी भी कुंजी का उपयोग करके वस्तुओं की एक सरणी से फ़िल्टर करना चाहते हैं:

function filterItems(items, searchVal) {
  return items.filter((item) => Object.values(item).includes(searchVal));
}
let data = [
  { "name": "apple", "type": "fruit", "id": 123234 },
  { "name": "cat", "type": "animal", "id": 98989 },
  { "name": "something", "type": "other", "id": 656565 }]


console.log("Filtered by name: ", filterItems(data, "apple"));
console.log("Filtered by type: ", filterItems(data, "animal"));
console.log("Filtered by id: ", filterItems(data, 656565));

JSON ऑब्जेक्ट्स की एक सरणी से फ़िल्टर करें: **

Answer 6

var names = [{
        name: "Joe",
        age: 20,
        email: "[e-mail]"
    },
    {
        name: "Mike",
        age: 50,
        email: "[e-mail]"
    },
    {
        name: "Joe",
        age: 45,
        email: "[e-mail]"
    }
];
const res = _.filter(names, (name) => {
    return name.name == "Joe" && name.age < 30;

});
console.log(res);

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

Answer 7

इतना जल्दी सवाल। क्या होगा यदि आपके पास वस्तुओं के दो सरणियाँ हैं और आप इन ऑब्जेक्ट सरणियों को 'संरेखित' करना चाहेंगे ताकि आप यह सुनिश्चित कर सकें कि प्रत्येक सरणी की वस्तुएँ अन्य सरणी के क्रम में हों? क्या होगा अगर आपको पता नहीं है कि सरणियों के अंदर किसी भी वस्तु की क्या कुंजी और मूल्य हैं ... बहुत कम क्या वे किस क्रम में भी हैं?

तो आपको अपने आदि के लिए एक 'वाइल्डकार्ड अभिव्यक्ति' की आवश्यकता है [].filter, [].mapआपको एक वाइल्ड कार्ड अभिव्यक्ति कैसे मिलती है?

var jux = (function(){
    'use strict';

    function wildExp(obj){
        var keysCrude = Object.keys(obj),
            keysA = ('a["' + keysCrude.join('"], a["') + '"]').split(', '),
            keysB = ('b["' + keysCrude.join('"], b["') + '"]').split(', '),
            keys = [].concat(keysA, keysB)
                .sort(function(a, b){  return a.substring(1, a.length) > b.substring(1, b.length); });
        var exp = keys.join('').split(']b').join('] > b').split(']a').join('] || a');
        return exp;
    }

    return {
        sort: wildExp
    };

})();

var sortKeys = {
    k: 'v',
    key: 'val',
    n: 'p',
    name: 'param'
};
var objArray = [
    {
        k: 'z',
        key: 'g',
        n: 'a',
        name: 'b'
    },
    {
        k: 'y',
        key: 'h',
        n: 'b',
        name: 't'
    },
    {
        k: 'x',
        key: 'o',
        n: 'a',
        name: 'c'
    }
];
var exp = jux.sort(sortKeys);

console.log('@juxSort Expression:', exp);
console.log('@juxSort:', objArray.sort(function(a, b){
    return eval(exp);
}));

आप प्रत्येक ऑब्जेक्ट में सभी कुंजियों के लिए बेहतर सामूहिक अभिव्यक्ति बनाने के लिए प्रत्येक फ़ंक्शन के लिए एक पुनरावृत्ति पर इस फ़ंक्शन का उपयोग कर सकते हैं, और फिर अपने सरणी को इस तरह फ़िल्टर कर सकते हैं।

यह एपीआई Juxtapose से एक छोटा सा स्निपेट है, जो मेरे पास लगभग पूरा है, जो ऐसा करता है, वस्तु समानता, छूट, वस्तु एकता और सरणी संक्षेपण। यदि ये ऐसी चीजें हैं जो आपको चाहिए या आपके प्रोजेक्ट के लिए कृपया टिप्पणी करें और मैं बाद में की तुलना में जल्द ही सुलभ को सुलभ बनाऊंगा।

उम्मीद है की यह मदद करेगा! मुबारक कोडिंग :)

Answer 8

सबसे सीधा और पठनीय दृष्टिकोण देशी जावास्क्रिप्ट फ़िल्टर विधि का उपयोग होगा।

मूल javaScript फ़िल्टर सरणी तत्वों को फ़िल्टर करने में एक घोषणात्मक दृष्टिकोण लेता है। चूँकि यह Array.prototype पर परिभाषित एक विधि है, यह किसी दिए गए सरणी पर पुनरावृत्त करता है और उस पर कॉलबैक आमंत्रित करता है। यह कॉलबैक, जो हमारे फ़िल्टरिंग फ़ंक्शन के रूप में कार्य करता है, तीन पैरामीटर लेता है:

element - सरणी में वर्तमान आइटम से अधिक पुनरावृत्त किया जा रहा है

index - सरणी में वर्तमान तत्व का सूचकांक या स्थान जो इससे अधिक प्रसारित हो रहा है

array- फ़िल्टर पर लागू किया गया था कि मूल सरणी एक उदाहरण में इस फिल्टर विधि का उपयोग करते हैं। ध्यान दें कि फ़िल्टर किसी भी प्रकार के ऐरे पर लगाया जा सकता है। इस उदाहरण में, हम ऑब्जेक्ट ऑब्जेक्ट के आधार पर ऑब्जेक्ट की एक सरणी फ़िल्टर करने जा रहे हैं।

ऑब्जेक्ट गुण के आधार पर ऑब्जेक्ट्स की एक सरणी को फ़िल्टर करने का एक उदाहरण कुछ इस तरह दिख सकता है:

// Please do not hate me for bashing on pizza and burgers.
// and FYI, I totally made up the healthMetric param :)
let foods = [
  { type: "pizza", healthMetric: 25 },
  { type: "burger", healthMetric: 10 },
  { type: "salad", healthMetric: 60 },
  { type: "apple", healthMetric: 82 }
];
let isHealthy = food => food.healthMetric >= 50;

const result = foods.filter(isHealthy);

console.log(result.map(food => food.type));
// Result: ['salad', 'apple']

फ़ंक्शंस में फ़िल्टरिंग सरणियों के बारे में अधिक जानने के लिए और अपने स्वयं के फ़िल्टरिंग का निर्माण करने के लिए, इस लेख को देखें: https://medium.com/better-programming/build-your-own-filter-e88ba0dcbfae