การแบ่งอาร์เรย์ด้วยฟังก์ชันตัวกรอง

ฉันมีอาร์เรย์ Javascript ที่ฉันต้องการแบ่งออกเป็นสองรายการโดยขึ้นอยู่กับว่าฟังก์ชันที่เรียกในแต่ละองค์ประกอบจะส่งกลับtrueหรือfalse. โดยพื้นฐานแล้วนี่คือarray.filterแต่ฉันก็อยากจะมีองค์ประกอบที่ถูกกรองออกไปด้วย

ปัจจุบันแผนของฉันคือการใช้array.forEachและเรียกใช้ฟังก์ชันเพรดิเคตในแต่ละองค์ประกอบ ขึ้นอยู่กับว่านี่เป็นจริงหรือเท็จฉันจะผลักองค์ประกอบปัจจุบันไปยังหนึ่งในสองอาร์เรย์ใหม่ มีวิธีที่หรูหรากว่านี้หรือดีกว่านี้ไหม? array.filterที่จะผลักดันองค์ประกอบบนอาร์เรย์อื่นก่อนที่จะส่งกลับfalseเช่น?

ด้วย 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]]), [[], []]);

คุณสามารถใช้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' }  ]

คุณสามารถใช้ลดได้:

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

ฟังดูคล้ายกับวิธีการของทับทิมEnumerable#partitionมาก

หากฟังก์ชันไม่สามารถมีผลข้างเคียงได้ (กล่าวคือไม่สามารถเปลี่ยนอาร์เรย์เดิมได้) แสดงว่าไม่มีวิธีใดที่มีประสิทธิภาพในการแบ่งพาร์ติชันอาร์เรย์ได้ดีไปกว่าการวนซ้ำในแต่ละองค์ประกอบและผลักองค์ประกอบไปยังหนึ่งในสองอาร์เรย์ของคุณ

ตามที่กล่าวไว้มันเป็นเนื้อหาที่ "สง่างาม" มากกว่าในการสร้างวิธีการArrayเพื่อทำหน้าที่นี้ ในตัวอย่างนี้ฟังก์ชันตัวกรองจะทำงานในบริบทของอาร์เรย์ดั้งเดิม (กล่าวคือthisจะเป็นอาร์เรย์ดั้งเดิม) และได้รับองค์ประกอบและดัชนีขององค์ประกอบเป็นอาร์กิวเมนต์ (คล้ายกับวิธีของ 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 ] ]

ฉันมากับผู้ชายตัวเล็ก ๆ คนนี้ มันใช้สำหรับแต่ละสิ่งที่คุณอธิบาย แต่มันดูสะอาดและรวบรัดในความคิดของฉัน

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

ในฟังก์ชันตัวกรองคุณสามารถพุชรายการเท็จของคุณไปยังฟังก์ชันภายนอกตัวแปรอื่น:

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เพื่อให้อ่านโค้ดได้ดีขึ้น

อ่านง่าย

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)

ลองสิ่งนี้:

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

การสาธิต

อะไรประมาณนี้

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

คำตอบจำนวนมากที่นี่ใช้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']

พาร์ติชั่น ONE-LINER

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

การสาธิต

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

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

ฉันลงเอยด้วยการทำสิ่งนี้เพราะมันเข้าใจง่าย (และพิมพ์ด้วย typescript)

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)