Bir diziyi filtre işlevine göre bölme

Her öğede çağrılan bir işlevin trueveya dönmesine bağlı olarak ikiye bölmek istediğim bir Javascript dizim var false. Esasen, bu bir olduğunu array.filter, ama aynı zamanda taraftan filtrelenen unsurları olmasını istiyorum dışarı .

Şu anda, planım array.forEachher elemanda yüklem işlevini kullanmak ve çağırmak. Bunun doğru veya yanlış olmasına bağlı olarak, mevcut elemanı iki yeni diziden birine göndereceğim. Bunu yapmanın daha zarif veya daha iyi bir yolu var mı? Bir array.filtergeri döndürür önce burada başka bir dizi üzerine elemanı itecektir falseÖrneğin,?

ES6 ile, yayılma sözdizimini azaltarak kullanabilirsiniz:

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);

Veya tek bir satırda:

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

Lodash.partition kullanabilirsiniz

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']]

veya 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' }  ]

Bunun için azaltmayı kullanabilirsiniz:

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;
      }, [[],[]]
    );
 };

Güncelleme. ES6 sözdizimini kullanarak, bunu özyinelemeyi kullanarak da yapabilirsiniz:

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]]);
}

Bu Ruby'ninEnumerable#partition yöntemine çok benziyor .

İşlevin yan etkileri yoksa (yani, orijinal diziyi değiştiremezse), diziyi bölümlemenin her bir öğe üzerinde yinelemekten ve öğeyi iki dizinizden birine itmekten daha etkili bir yolu yoktur.

Bununla birlikte, Arraybu işlevi gerçekleştirmek için bir yöntem oluşturmak tartışmaya açık bir şekilde daha "zariftir" . Bu örnekte, filtre işlevi orijinal dizi bağlamında yürütülür (yani, thisorijinal dizi olacaktır) ve öğeyi ve öğenin dizinini argüman olarak alır ( jQuery eachyöntemine benzer ):

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 ] ]

Bu küçük adamla geldim. Tarif ettiğiniz gibi her biri için kullanıyor, ancak bence temiz ve özlü görünüyor.

//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);

Filtre işlevinde, yanlış öğelerinizi başka bir değişken dışındaki işlevin içine itebilirsiniz:

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

Tabii ki value === falsegerçek bir karşılaştırma olmalı;)

Ama neredeyse aynı işlemi yapıyor forEach. Daha forEachiyi bir kod okunabilirliği için kullanmanız gerektiğini düşünüyorum .

Okuması kolay.

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)

Bunu dene:

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;
}

DEMO

Peki buna ne dersin?

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

Muhtemelen bu, yayma operatöründen daha verimlidir

Ya da biraz daha kısa ama daha çirkin

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

Buradaki birçok cevap Array.prototype.reduce, değiştirilebilir bir toplayıcı oluşturmak için kullanılır ve haklı olarak, bunun, örneğin, her yinelemede yeni bir diziyi kopyalamak için bir yayılma operatörü kullanmaktan daha verimli olduğuna işaret edin. Olumsuz yanı, kısa lambda sözdizimini kullanan "saf" bir ifade kadar güzel olmamasıdır.

Ancak bunun bir yolu virgül operatörünü kullanmaktır. C benzeri dillerde virgül, her zaman sağ el operandını döndüren bir operatördür. Bunu, bir void işlevini çağıran ve bir değer döndüren bir ifade oluşturmak için kullanabilirsiniz.

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

Bir boole ifadesinin örtük olarak 0 ve 1 olarak bir sayıya dönüştürülmesinden yararlanırsanız ve okunabilir olduğunu düşünmeme rağmen onu daha da kısa hale getirebilirsiniz:

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

Kullanım:

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

ONE-LINER Bölme

const partition = (a,f)=>a.reduce((p,q)=>(p[+!f(q)].push(q),p),[[],[]]);

DEMO

// to make it consistent to filter pass index and array as arguments
const partition = (a, f) =>
    a.reduce((p, q, i, ar) => (p[+!f(q, i, ar)].push(q), p), [[], []]);

console.log(partition([1, 2, 3, 4, 5], x => x % 2 === 0));
console.log(partition([..."ABCD"], (x, i) => i % 2 === 0));

Typescript için

const partition = <T>(
  a: T[],
  f: (v: T, i?: number, ar?: T[]) => boolean
): [T[], T[]] =>
  a.reduce((p, q, i, ar) => (p[+!f(q, i, ar)].push(q), p), [[], []]);

Bunu yaptım çünkü anlaşılması kolay (ve tamamen typcript ile yazılmış).

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)