फ़िल्टर फ़ंक्शन द्वारा एक सरणी विभाजित करना

Question 1

मेरे पास एक जावास्क्रिप्ट सरणी है जिसे मैं दो तत्वों में विभाजित करना चाहूंगा कि क्या प्रत्येक तत्व रिटर्न पर बुलाया गया फ़ंक्शन है trueया false। अनिवार्य रूप से, यह एक है array.filter, लेकिन मैं उन तत्वों को भी हाथ लगाना चाहूंगा जिन्हें फ़िल्टर किया गया था ।

वर्तमान में, मेरी योजना array.forEachप्रत्येक तत्व पर विधेय फ़ंक्शन का उपयोग और कॉल करना है। यह सही है या गलत इस पर निर्भर करते हुए, मैं वर्तमान तत्व को दो नए सरणियों में से एक पर धकेलूंगा। क्या ऐसा करने के लिए अधिक सुरुचिपूर्ण या अन्यथा बेहतर तरीका है? एक array.filterजहां एक और सरणी पर तत्व धक्का से पहले ही रिटर्न होगा false, उदाहरण के लिए?

Question 2

ES6 के साथ आप कम के साथ प्रसार सिंटैक्स का उपयोग कर सकते हैं:

function partition(array, isValid) {
  return array.reduce(([pass, fail], elem) => {
    return isValid(elem) ? [[...pass, elem], fail] : [pass, [...fail, elem]];
  }, [[], []]);
}

const [pass, fail] = partition(myArray, (e) => e > 5);

या एक लाइन पर:

const [pass, fail] = a.reduce(([p, f], e) => (e > 5 ? [[...p, e], f] : [p, [...f, e]]), [[], []]);

Question 3

आप lodash.partition का उपयोग कर सकते हैं

var users = [
  { 'user': 'barney',  'age': 36, 'active': false },
  { 'user': 'fred',    'age': 40, 'active': true },
  { 'user': 'pebbles', 'age': 1,  'active': false }
];

_.partition(users, function(o) { return o.active; });
// → objects for [['fred'], ['barney', 'pebbles']]

// The `_.matches` iteratee shorthand.
_.partition(users, { 'age': 1, 'active': false });
// → objects for [['pebbles'], ['barney', 'fred']]

// The `_.matchesProperty` iteratee shorthand.
_.partition(users, ['active', false]);
// → objects for [['barney', 'pebbles'], ['fred']]

// The `_.property` iteratee shorthand.
_.partition(users, 'active');
// → objects for [['fred'], ['barney', 'pebbles']]

या ramda.partition

R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);
// => [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]

R.partition(R.contains('s'), { a: 'sss', b: 'ttt', foo: 'bars' });
// => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' }  ]

Question 4

आप इसके लिए कम उपयोग कर सकते हैं:

function partition(array, callback){
  return array.reduce(function(result, element, i) {
    callback(element, i, array) 
      ? result[0].push(element) 
      : result[1].push(element);

        return result;
      }, [[],[]]
    );
 };

अपडेट करें। ES6 सिंटैक्स का उपयोग करके आप यह भी कर सकते हैं कि पुनरावर्तन का उपयोग करके:

function partition([current, ...tail], f, [left, right] = [[], []]) {
    if(current === undefined) {
        return [left, right];
    }
    if(f(current)) {
        return partition(tail, f, [[...left, current], right]);
    }
    return partition(tail, f, [left, [...right, current]]);
}

Question 5

यह रूबी के समान लगता हैEnumerable#partition विधि के ।

यदि फ़ंक्शन के साइड-इफेक्ट्स नहीं हो सकते हैं (जैसे, यह मूल सरणी को बदल नहीं सकता है), तो प्रत्येक तत्व पर पुनरावृत्ति करने और अपने दो सरणियों में से किसी एक को तत्व को पुश करने की तुलना में सरणी को विभाजित करने का कोई और अधिक कुशल तरीका नहीं है।

यह कहा जा रहा है, Arrayइस समारोह को करने के लिए एक विधि बनाने के लिए यकीनन यह अधिक "सुरुचिपूर्ण" है । इस उदाहरण में, फ़िल्टर फ़ंक्शन को मूल सरणी (अर्थात, thisमूल सरणी) के संदर्भ में निष्पादित किया जाता है , और यह तत्व और तत्व के सूचकांक को तर्क के रूप में प्राप्त करता है ( jQuery की eachविधि के समान ):

Array.prototype.partition = function (f){
  var matched = [],
      unmatched = [],
      i = 0,
      j = this.length;

  for (; i < j; i++){
    (f.call(this, this[i], i) ? matched : unmatched).push(this[i]);
  }

  return [matched, unmatched];
};

console.log([1, 2, 3, 4, 5].partition(function (n, i){
  return n % 2 == 0;
}));

//=> [ [ 2, 4 ], [ 1, 3, 5 ] ]

Question 6

मैं इस छोटे आदमी के साथ आया था। यह आपके द्वारा वर्णित प्रत्येक और सभी के लिए उपयोग करता है, लेकिन यह मेरी राय में साफ और रसीला दिखता है।

//Partition function
function partition(array, filter) {
  let pass = [], fail = [];
  array.forEach((e, idx, arr) => (filter(e, idx, arr) ? pass : fail).push(e));
  return [pass, fail];
}

//Run it with some dummy data and filter
const [lessThan5, greaterThanEqual5] = partition([0,1,4,3,5,7,9,2,4,6,8,9,0,1,2,4,6], e => e < 5);

//Output
console.log(lessThan5);
console.log(greaterThanEqual5);

स्निपेट का विस्तार करें

Question 7

फ़िल्टर फ़ंक्शन में आप अपने झूठे आइटमों को दूसरे फ़ंक्शन के बाहर फ़ंक्शन में धकेल सकते हैं:

var bad = [], good = [1,2,3,4,5];
good = good.filter(function (value) { if (value === false) { bad.push(value) } else { return true});

बेशक value === falseवास्तविक तुलना होने की आवश्यकता है;)

लेकिन यह लगभग उसी ऑपरेशन को पसंद करता है forEach। मुझे लगता है कि आपको forEachबेहतर कोड पठनीयता के लिए उपयोग करना चाहिए ।

Question 8

आसान एक पढ़ने के लिए।

const partition = (arr, condition) => {
    const trues = arr.filter(el => condition(el));
    const falses = arr.filter(el => !condition(el));
    return [trues, falses];
};

// sample usage
const nums = [1,2,3,4,5,6,7]
const [evens, odds] = partition(nums, (el) => el%2 == 0)

Question 9

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

function filter(a, fun) {
    var ret = { good: [], bad: [] };
    for (var i = 0; i < a.length; i++)
        if (fun(a[i])
            ret.good.push(a[i]);
        else
            ret.bad.push(a[i]);
    return ret;
}

डेमो

Question 10

इस बारे में क्या?

[1,4,3,5,3,2].reduce( (s, x) => { s[ x > 3 ].push(x); return s;} , {true: [], false:[]} )

संभवतः यह अधिक कुशल है फिर प्रसार ऑपरेटर

या थोड़ा छोटा, लेकिन बदसूरत

[1,4,3,5,3,2].reduce( (s, x) => s[ x > 3 ].push(x)?s:s , {true: [], false:[]} )

Question 11

यहां बहुत सारे उत्तर उपयोग किए जाते हैं Array.prototype.reduce एक उत्परिवर्तित संचायक का निर्माण करने के लिए करते हैं, और सही ढंग से इंगित करते हैं कि बड़े सरणियों के लिए, यह कहना अधिक कुशल है, एक प्रसार ऑपरेटर का उपयोग करके एक नया सरणी प्रत्येक पुनरावृत्ति की प्रतिलिपि बनाना। नकारात्मक पक्ष यह है कि यह लघु लैंबडा सिंटैक्स का उपयोग करके "शुद्ध" अभिव्यक्ति के रूप में सुंदर नहीं है।

लेकिन इसके आसपास एक तरीका कॉमा ऑपरेटर का उपयोग करना है। C जैसी भाषाओं में, अल्पविराम एक ऑपरेटर होता है जो हमेशा दाहिने हाथ का ऑपरेंड लौटाता है। आप इसका उपयोग एक अभिव्यक्ति बनाने के लिए कर सकते हैं जो एक शून्य फ़ंक्शन को कॉल करता है और एक मान लौटाता है।

function partition(array, predicate) {
    return array.reduce((acc, item) => predicate(item)
        ? (acc[0].push(item), acc)
        : (acc[1].push(item), acc), [[], []]);
}

यदि आप इस तथ्य का लाभ उठाते हैं कि एक बूलियन अभिव्यक्ति स्पष्ट रूप से 0 और 1 के रूप में एक संख्या में डालती है, और आप इसे और भी संक्षिप्त बना सकते हैं, हालांकि मुझे नहीं लगता कि यह पढ़ने योग्य है:

function partition(array, predicate) {
    return array.reduce((acc, item) => (acc[+!predicate(item)].push(item), acc), [[], []]);
}

उपयोग:

const [trues, falses] = partition(['aardvark', 'cat', 'apple'], i => i.startsWith('a'));
console.log(trues); // ['aardvark', 'apple']
console.log(falses); // ['cat']

Question 12

मैंने इसे करना समाप्त कर दिया क्योंकि यह समझना आसान है (और पूरी तरह से टाइपस्क्रिप्ट के साथ टाइप किया गया)।

const partition = <T>(array: T[], isValid: (element: T) => boolean): [T[], T[]] => {
  const pass: T[] = []
  const fail: T[] = []
  array.forEach(element => {
    if (isValid(element)) {
      pass.push(element)
    } else {
      fail.push(element)
    }
  })
  return [pass, fail]
}

// usage
const [pass, fail] = partition([1, 2, 3, 4, 5], (element: number) => element > 3)