सरणी

Question

को छोटा करने के लिए कम करें का उपयोग करें किसी आइटम को किसी सरणी में कितनी बार ढूंढने के लिए कम करें। सरणी में रिकर्सली के अंदर सरणी हो सकती है।

var foo = [ 
    1, 
    [2, 3, 4], 
    4, [5,6,7], 4 
]; 

bar(foo, 4) लौट 3.

Answer 1

यह एक Array.prototype.reduce का उपयोग करें।

var foo = [1, [2, 3, 4], 4, [5, 6, 7], 4]; 
 

 
function f(arr, item) { 
 
    return arr.reduce(function (s, i) { 
 
    if (Array.isArray(i)) return s+f(i, item); 
 
    return s+(i==item?1:0); 
 
    }, 0); 
 
} 
 

 
console.log(f(foo, 4))

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

Answer 2

आप Array.prototype.forEach()

साथ forEach() विधि सरणी तत्व प्रति एक बार एक प्रदान की फ़ंक्शन निष्पादित एक कॉल के साथ सभी वस्तुओं भरोसा कर सकते हैं होगा।

और यदि कोई तत्व सरणी है, तो जांच करें, फिर फ़ंक्शन को पैरामीटर के रूप में सरणी के साथ फिर से बुलाया जाता है।

var foo = ["a", ["b", "c", "d"], "a"], 
 
    object = {}; 
 

 
function count(a, o) { 
 
    a.forEach(function (b) { 
 
     if (Array.isArray(b)) { 
 
      count(b, o); 
 
     } else { 
 
      o[b] = (o[b] || 0) + 1; 
 
     } 
 
    }) 
 
} 
 

 
count(foo, object); 
 
document.write('<pre>' + JSON.stringify(object, 0, 4) + '</pre>');

Answer 3

तो अगर आप एक प्रत्यावर्तन चाहते हैं (और यह किसी भी ब्राउज़र में काम करेंगे):

var foo = [ 
    "a", 
    ["b", "c", "d"], 
    "a" 
]; 

function bar(arr, item) { 
    var count = 0; 
    if (arr.length == 0) { 
     return 0; 
    } 

    for (var i = 0, l = arr.length; i < l; i++) { 
     var v = arr[i]; 
     if (typeof v === "string") { 
      if (v === item) { 
       count++; 
      } 
     } else { 
      count = count + bar(v, item); 
     } 
    } 

    return count; 
} 

console.log(bar(foo, "a")); 

Answer 4

यहाँ, व्याख्या यह है कि एक बाहरी राज्य की आवश्यकता नहीं है की एक और कार्यात्मक प्रकार है, हालांकि अधिक अक्षम हो जाएगा।

var foo = [ 
 
    "a", 
 
    ["b", "c", "d"], 
 
    ["a", "b"], 
 
    "a" 
 
]; 
 

 
function flatten(arr){ 
 
    return arr.reduce(function(ret, curr){ 
 
    return ret.concat(Array.isArray(curr) ? flatten(curr) : [ curr ]); 
 
    }, []); 
 
} 
 

 
function filterBy(arr, val){ 
 
    return arr.filter(function(item){ 
 
    return item === val; 
 
    }) 
 
} 
 

 
console.log(flatten(foo)); 
 
console.log(filterBy(flatten(foo), 'a'));

<script src="http://codepen.io/synthet1c/pen/WrQapG.js"></script>

Answer 5

underscore का उपयोग करके आप इस कोड के साथ प्रत्येक तत्व की घटना की संख्या की गणना कर सकते हैं:

_.countBy(_.flatten(array), _.identity) 

तो समारोह foo इस तरह लागू किया जा सकता:

function bar(foo, element){ 
    return _.countBy(_.flatten(foo), _.identity)[element]; 
} 
var foo = ["a", ["b", "c", "d"], "a"] 
console.log(bar(foo, "a")); 

हालांकि यह समाधान आयन रिकर्सिव नहीं है मुझे इसका उल्लेख करने लायक लगता है।