Chia mảng theo chức năng lọc

Tôi có một mảng Javascript mà tôi muốn chia thành hai dựa trên việc một hàm được gọi trên mỗi phần tử trả về truehoặc false. Về cơ bản, đây là một array.filter, nhưng tôi cũng muốn có trong tay các yếu tố đã được lọc ra .

Hiện tại, kế hoạch của tôi là sử dụng array.forEachvà gọi hàm vị từ trên mỗi phần tử. Tùy thuộc vào việc điều này đúng hay sai, tôi sẽ đẩy phần tử hiện tại lên một trong hai mảng mới. Có cách nào thanh lịch hơn hoặc cách khác tốt hơn để làm điều này không? Ví dụ: một array.filternơi sẽ đẩy phần tử lên một mảng khác trước khi nó trả về false?

Với ES6, bạn có thể sử dụng cú pháp spread với giảm:

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

Hoặc trên một dòng:

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

Bạn có thể sử dụng 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']]

hoặc 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' }  ]

Bạn có thể sử dụng giảm cho nó:

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

Cập nhật. Sử dụng cú pháp ES6, bạn cũng có thể làm điều đó bằng cách sử dụng đệ quy:

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

Điều này nghe rất giống với phương pháp của RubyEnumerable#partition .

Nếu hàm không thể có hiệu ứng phụ (tức là nó không thể thay đổi mảng ban đầu), thì không có cách nào hiệu quả hơn để phân vùng mảng hơn là lặp lại từng phần tử và đẩy phần tử vào một trong hai mảng của bạn.

Điều đó được cho là "thanh lịch" hơn để tạo ra một phương pháp Arrayđể thực hiện chức năng này. Trong ví dụ này, hàm bộ lọc được thực thi trong ngữ cảnh của mảng ban đầu (tức là thissẽ là mảng ban đầu), và nó nhận phần tử và chỉ mục của phần tử dưới dạng đối số (tương tự như phương thức của jQueryeach ):

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

Tôi đến với anh chàng nhỏ bé này. Nó sử dụng cho từng và tất cả những thứ như bạn đã mô tả, nhưng theo ý kiến ​​của tôi thì nó trông sạch sẽ và ngắn gọn.

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

Trong hàm bộ lọc, bạn có thể đẩy các mục sai của mình vào một biến khác bên ngoài hàm:

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

Tất nhiên value === falsecần phải so sánh thực sự;)

Nhưng nó gần như hoạt động tương tự như vậy forEach. Tôi nghĩ bạn nên sử dụng forEachđể dễ đọc mã hơn.

Dễ dàng để đọc một.

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)

Thử đi:

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

BẢN GIỚI THIỆU

Cái này thì sao?

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

Có lẽ điều này hiệu quả hơn sau đó toán tử spread

Hoặc ngắn hơn một chút, nhưng xấu hơn

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

Rất nhiều câu trả lời ở đây sử dụng Array.prototype.reduceđể xây dựng một bộ tích lũy có thể thay đổi và chỉ ra một cách chính xác rằng đối với các mảng lớn, điều này hiệu quả hơn, giả sử, sử dụng toán tử spread để sao chép một mảng mới mỗi lần lặp lại. Nhược điểm là nó không đẹp như một biểu thức "thuần túy" sử dụng cú pháp lambda ngắn.

Nhưng một cách giải quyết đó là sử dụng toán tử dấu phẩy. Trong các ngôn ngữ giống C, dấu phẩy là một toán tử luôn trả về toán hạng bên phải. Bạn có thể sử dụng nó để tạo một biểu thức gọi một hàm void và trả về một giá trị.

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

Nếu bạn tận dụng thực tế là biểu thức boolean chuyển ngầm thành một số là 0 và 1, và bạn có thể làm cho nó ngắn gọn hơn nữa, mặc dù tôi không nghĩ rằng nó có thể đọc được:

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

Sử dụng:

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

Phân vùng MỘT LINER

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

BẢN GIỚI THIỆU

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

Đối với chữ viết

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

Tôi đã kết thúc việc này vì nó dễ hiểu (và được đánh máy đầy đủ bằng bản đánh máy).

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)