Teilen eines Arrays durch Filterfunktion

Ich habe ein Javascript-Array, das ich in zwei Teile aufteilen möchte, je nachdem, ob eine für jedes Element aufgerufene Funktion trueoder zurückgibt false. Im Wesentlichen ist dies ein array.filter, aber ich möchte auch die Elemente zur Hand haben, die herausgefiltert wurden .

Derzeit ist mein Plan, array.forEachdie Prädikatfunktion für jedes Element zu verwenden und aufzurufen. Je nachdem, ob dies wahr oder falsch ist, werde ich das aktuelle Element auf eines der beiden neuen Arrays verschieben. Gibt es einen eleganteren oder anderweitig besseren Weg, dies zu tun? Und array.filterwo wird das Element zum Beispiel auf ein anderes Array verschoben, bevor es zurückkehrt false?

Mit ES6 können Sie die Spread-Syntax mit redu verwenden:

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

Oder in einer einzigen Zeile:

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

Sie können lodash.partition verwenden

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

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

Sie können dafür reduzieren:

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

Aktualisieren. Mit der ES6-Syntax können Sie dies auch mithilfe der Rekursion tun:

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

Das klingt RubysEnumerable#partition Methode sehr ähnlich .

Wenn die Funktion keine Nebenwirkungen haben kann (dh das ursprüngliche Array kann nicht geändert werden), gibt es keine effizientere Möglichkeit, das Array zu partitionieren, als über jedes Element zu iterieren und das Element in eines Ihrer beiden Arrays zu verschieben.

ArrayDavon abgesehen ist es wohl "eleganter", eine Methode zur Ausführung dieser Funktion zu erstellen . In diesem Beispiel wird die Filterfunktion im Kontext des ursprünglichen Arrays ausgeführt (dh ist thisdas ursprüngliche Array) und empfängt das Element und den Index des Elements als Argumente (ähnlich der eachMethode von jQuery ):

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

Ich habe mir diesen kleinen Kerl ausgedacht. Es verwendet für alles, was Sie beschrieben haben, aber es sieht meiner Meinung nach sauber und prägnant aus.

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

In der Filterfunktion können Sie Ihre falschen Elemente in eine andere Variable außerhalb der Funktion verschieben:

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

Natürlich value === falsemuss ein echter Vergleich sein;)

Aber es macht fast die gleiche Operation wie forEach. Ich denke, Sie sollten forEachfür eine bessere Lesbarkeit des Codes verwenden.

Versuche dies:

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

Was ist damit?

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

Wahrscheinlich ist dies effizienter als der Spread-Operator

Oder etwas kürzer, aber hässlicher

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

Einfach zu lesen.

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)

Am Ende habe ich das gemacht, weil es leicht zu verstehen ist (und vollständig mit Typoskript getippt ist).

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)