blocks|key|1933857|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1933858|function+filter(a,+fun)+{
++++var+ret+=+{+good:+[],+bad:+[]+};
++++for+(var+i+=+0;+i+<+a.length;+i%2B%2B)
++++++++if+(fun(a[i])
++++++++++++ret.good.push(a[i]);
++++++++else
++++++++++++ret.bad.push(a[i]);
++++return+ret;
}|code-block|syntax|javascript|1933859|DEMO|offset|length|1933860|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/bsdt5/^0|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Try this:

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

<h3><a href="http://jsfiddle.net/bsdt5/" rel="nofollow">DEMO</a></h3>

blocks|key|1933898|text|在filter+function中，您可以将false项推入函数外部的另一个变量中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1933899|var+bad+=+[],+good+=+[1,2,3,4,5];
good+=+good.filter(function+(value)+{+if+(value+===+false)+{+bad.push(value)+}+else+{+return+true});|code-block|syntax|javascript|1933900|当然，value+===+false需要是真正的比较;)|offset|length|style|CODE|1933901|但它所做的操作几乎与forEach相同。我认为你应该使用forEach来获得更好的代码可读性。|1933902|entityMap^0|0|0|3|F|0|A|7|S|7|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@$I|W|J|X|K|L]|$I|Y|J|Z|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

In filter function you can push your false items into another variable outside function:

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

Of course <code>value === false</code> need to be real comparasion ;) 

But it do almost that same operation like <code>forEach</code>. I think you should use <code>forEach</code> for better code readability.

blocks|key|1720239|text|这听起来非常类似于Ruby's+Enumerable#partition方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1720240|如果函数没有副作用(例如，它不能改变原始数组)，那么没有比迭代每个元素并将元素推入两个数组中的一个更有效的划分数组的方法。|1720241|也就是说，在Array上创建一个方法来执行这个功能可以说是更“优雅”的。在本例中，filter函数在原始数组的上下文中执行(即，this将是原始数组)，它接收元素和元素的索引作为参数(类似于jQuery's+each+method)：|1720242|Array.prototype.partition+=+function+(f){
++var+matched+=+[],
++++++unmatched+=+[],
++++++i+=+0,
++++++j+=+this.length;

++for+(;+i+<+j;+i%2B%2B){
++++(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+%25+2+==+0;
}));

//=>+[+[+2,+4+],+[+1,+3,+5+]+]|code-block|syntax|javascript|1720243|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ruby-doc.org/core-1.9.3/Enumerable.html#method-i-partition|1|http://api.jquery.com/each/^0|G|K|9|R|0|0|0|6|5|1S|4|2W|4|2N|K|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|J|3|K|5|L|7|1F|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

This sounds very similar to <a href="http://www.ruby-doc.org/core-1.9.3/Enumerable.html#method-i-partition" rel="noreferrer">Ruby's <code>Enumerable#partition</code></a> method.

If the function can't have side-effects (i.e., it can't alter the original array), then there's no more efficient way to partition the array than iterating over each element and pushing the element to one of your two arrays.

That being said, it's arguably more "elegant" to create a method on <code>Array</code> to perform this function. In this example, the filter function is executed in the context of the original array (i.e., <code>this</code> will be the original array), and it receives the element and the index of the element as arguments (similar to <a href="http://api.jquery.com/each/" rel="noreferrer">jQuery's <code>each</code> method</a>):

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

 for (; i &lt; 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;
}));

//=&gt; [ [ 2, 4 ], [ 1, 3, 5 ] ]
</code></pre>

blocks|key|1720250|text|您可以使用lodash.partition|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1720251|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']]|code-block|syntax|javascript|1720252|或ramda.partition|1720253|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'+}++]|1720254|entityMap|0|LINK|mutability|MUTABLE|url|https://lodash.com/docs#partition|1|http://ramdajs.com/docs/#partition^0|5|G|0|0|0|1|F|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

You can use <a href="https://lodash.com/docs#partition" rel="noreferrer">lodash.partition</a>

<pre><code>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']]
</code></pre>

or <a href="http://ramdajs.com/docs/#partition" rel="noreferrer">ramda.partition</a>

<pre><code>R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);
// =&gt; [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ]

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

blocks|key|1933976|text|您可以对其使用reduce：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1933977|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;
++++++},+[[],[]]
++++);
+};|code-block|syntax|javascript|1933978|更新。使用ES6语法，您也可以使用递归(更新以避免在每次迭代中创建新数组)：|1933979|function+partition([current,+...tail],+f,+left+=+[],+right+=+[])+{
++++if(current+===+undefined)+{
++++++++return+[left,+right];
++++}
++++if(f(current))+{
++++++++left.push(current);
++++++++return+partition(tail,+f,+left,+right);
++++}
++++right.push(current);
++++return+partition(tail,+f,+left,+right);
}|1933980|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can use reduce for it:
<pre><code>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;
 }, [[],[]]
 );
 };
</code></pre>
Update. Using ES6 syntax you also can do that using recursion (updated to avoid creating new arrays on every iteration):
<pre><code>function partition([current, ...tail], f, left = [], right = []) {
 if(current === undefined) {
 return [left, right];
 }
 if(f(current)) {
 left.push(current);
 return partition(tail, f, left, right);
 }
 right.push(current);
 return partition(tail, f, left, right);
}
</code></pre>

blocks|key|1933992|text|在ES6中，您可以使用带有reduce的扩展语法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1933993|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);|code-block|syntax|javascript|1933994|或在一行中：|1933995|const+[pass,+fail]+=+a.reduce(([p,+f],+e)+=>+(e+>+5+?+[[...p,+e],+f]+:+[p,+[...f,+e]]),+[[],+[]]);|1933996|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

With ES6 you can make use of the spread syntax with reduce:



<pre class="lang-js prettyprint-override"><code>function partition(array, isValid) {
 return array.reduce(([pass, fail], elem) =&gt; {
 return isValid(elem) ? [[...pass, elem], fail] : [pass, [...fail, elem]];
 }, [[], []]);
}

const [pass, fail] = partition(myArray, (e) =&gt; e &gt; 5);
</code></pre>

Or on a single line:

<pre class="lang-js prettyprint-override"><code>const [pass, fail] = a.reduce(([p, f], e) =&gt; (e &gt; 5 ? [[...p, e], f] : [p, [...f, e]]), [[], []]);
</code></pre>

blocks|key|1720344|text|我想到了这个小家伙。它使用了你所描述的所有东西，但在我看来，它看起来干净而简洁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1720345|​|1720346|//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);|code-block|syntax|javascript|1720347|1720348|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

I came up with this little guy. It uses for each and all that like you described, but it looks clean and succinct in my opinion.

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="true">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>//Partition function
function partition(array, filter) {
 let pass = [], fail = [];
 array.forEach((e, idx, arr) =&gt; (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 =&gt; e &lt; 5);

//Output
console.log(lessThan5);
console.log(greaterThanEqual5);</code></pre>
</div>
</div>

blocks|key|1720678|text|很容易读懂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1720679|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%252+==+0)|code-block|syntax|javascript|1720680|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Easy to read one.

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

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

blocks|key|1720700|text|我最终这样做是因为它很容易理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1720701|const+partition+=+(array,+isValid)+=>+{
++const+pass+=+[]
++const+fail+=+[]
++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)+=>+element+>+3)|code-block|syntax|javascript|1720702|以及包含typescript类型的相同方法：|1720703|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)|1720704|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I ended up doing this because it's easy to understand:
<pre><code>const partition = (array, isValid) =&gt; {
 const pass = []
 const fail = []
 array.forEach(element =&gt; {
 if (isValid(element)) {
 pass.push(element)
 } else {
 fail.push(element)
 }
 })
 return [pass, fail]
}

// usage
const [pass, fail] = partition([1, 2, 3, 4, 5], (element) =&gt; element &gt; 3)
</code></pre>
And the same method including types for typescript:
<pre><code>const partition = &lt;T&gt;(array: T[], isValid: (element: T) =&gt; boolean): [T[], T[]] =&gt; {
 const pass: T[] = []
 const fail: T[] = []
 array.forEach(element =&gt; {
 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) =&gt; element &gt; 3)
</code></pre>

blocks|key|1934386|text|那这个呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1934387|[1,4,3,5,3,2].reduce(+(s,+x)+=>+{+s[+x+>+3+].push(x);+return+s;}+,+{true:+[],+false:[]}+)|code-block|syntax|javascript|1934388|这可能比扩展运算符更有效。|1934389|或者更短一点，但更丑陋|1934390|[1,4,3,5,3,2].reduce(+(s,+x)+=>+s[+x+>+3+].push(x)?s:s+,+{true:+[],+false:[]}+)|1934391|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

What about this?
<pre class="lang-js prettyprint-override"><code>[1,4,3,5,3,2].reduce( (s, x) =&gt; { s[ x &gt; 3 ].push(x); return s;} , {true: [], false:[]} )
</code></pre>
Probably this is more efficient than the spread operator
Or a bit shorter, but uglier
<pre class="lang-js prettyprint-override"><code>[1,4,3,5,3,2].reduce( (s, x) =&gt; s[ x &gt; 3 ].push(x)?s:s , {true: [], false:[]} )

</code></pre>

blocks|key|1934717|text|这里的许多答案使用Array.prototype.reduce来构建可变累加器，并正确地指出，对于大型数组，这比每次迭代使用扩展运算符复制新数组更有效。缺点是，它不像使用简短的lambda语法的“纯”表达式那么漂亮。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1934718|但一种解决方法是使用逗号运算符。在类C语言中，逗号是一个总是返回右操作数的运算符。您可以使用它来创建一个调用void函数并返回值的表达式。|1934719|function+partition(array,+predicate)+{
++++return+array.reduce((acc,+item)+=>+predicate(item)
++++++++?+(acc[0].push(item),+acc)
++++++++:+(acc[1].push(item),+acc),+[[],+[]]);
}|code-block|syntax|javascript|1934720|如果您利用布尔表达式隐式强制转换为数字0和1的事实，您可以使其更加简洁，尽管我不认为它具有可读性：|1934721|function+partition(array,+predicate)+{
++++return+array.reduce((acc,+item)+=>+(acc[%2B!predicate(item)].push(item),+acc),+[[],+[]]);
}|1934722|用法：|1934723|const+[trues,+falses]+=+partition(['aardvark',+'cat',+'apple'],+i+=>+i.startsWith('a'));
console.log(trues);+//+['aardvark',+'apple']
console.log(falses);+//+['cat']|1934724|entityMap^0|9|M|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|V|$]]

A lot of answers here use <code>Array.prototype.reduce</code> to build a mutable accumulator, and rightfully point out that for large arrays, this is more efficient than, say, using a spread operator to copy a new array each iteration. The downside is that it's not as pretty as a &quot;pure&quot; expression using the short lambda syntax.
But a way around that is to use the comma operator. In C-like languages, comma is an operator that always returns the right hand operand. You can use this to create an expression that calls a void function and returns a value.
<pre class="lang-js prettyprint-override"><code>function partition(array, predicate) {
 return array.reduce((acc, item) =&gt; predicate(item)
 ? (acc[0].push(item), acc)
 : (acc[1].push(item), acc), [[], []]);
}
</code></pre>
If you take advantage of the fact that a boolean expression implicitly casts to a number as 0 and 1, and you can make it even more concise, although I don't think it's as readable:
<pre class="lang-js prettyprint-override"><code>function partition(array, predicate) {
 return array.reduce((acc, item) =&gt; (acc[+!predicate(item)].push(item), acc), [[], []]);
}
</code></pre>
Usage:
<pre class="lang-js prettyprint-override"><code>const [trues, falses] = partition(['aardvark', 'cat', 'apple'], i =&gt; i.startsWith('a'));
console.log(trues); // ['aardvark', 'apple']
console.log(falses); // ['cat']
</code></pre>

blocks|key|1934768|text|我知道已经有了多种解决方案，但我冒失地把上面答案中最好的部分组合在一起，并在Typescript上使用了扩展方法。复制并粘贴，它就能正常工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1934769|declare+global+{

++interface+Array<T>+{
++++partition(this:+T[],+predicate:+(e:+T)+=>+boolean):+T[][];
++}

}

if(!Array.prototype.partition){

++Array.prototype.partition+=+function<T>(this:+T[],+predicate:+(e:+T)+=>+boolean):+T[][]+{

++++return+this.reduce<T[][]>(([pass,+fail],+elem)+=>+{
++++++(predicate(elem)+?+pass+:+fail).push(elem);
++++++return+[pass,+fail];
++++},+[[],+[]]);

++}
}|code-block|syntax|javascript|1934770|用法：|1934771|const+numbers+=+[1,+2,+3,+4,+5,+6];
const+[even,+odd]+=+numbers.partition(n+=>+n+%25+2+===+0);|1934772|1934773|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|P|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

I know there are multiple solutions already but I took the liberty of putting together the best bits of the answers above and used extension methods on Typescript. Copy and paste and it just works:
<pre class="lang-js prettyprint-override"><code>declare global {

 interface Array&lt;T&gt; {
 partition(this: T[], predicate: (e: T) =&gt; boolean): T[][];
 }

}

if(!Array.prototype.partition){

 Array.prototype.partition = function&lt;T&gt;(this: T[], predicate: (e: T) =&gt; boolean): T[][] {

 return this.reduce&lt;T[][]&gt;(([pass, fail], elem) =&gt; {
 (predicate(elem) ? pass : fail).push(elem);
 return [pass, fail];
 }, [[], []]);

 }
}

</code></pre>
Usage:
<pre class="lang-js prettyprint-override"><code>
const numbers = [1, 2, 3, 4, 5, 6];
const [even, odd] = numbers.partition(n =&gt; n % 2 === 0);

</code></pre>
<pre><code></code></pre>

blocks|key|1721221|text|Lodash+partition替代，与@Yaremenko+Andrii的first+solution相同，但语法更短|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1721222|function+partition(arr,+callback)+{
++return+arr.reduce(
++++(acc,+val,+i,+arr)+=>+{
++++++acc[callback(val,+i,+arr)+?+0+:+1].push(val)
++++++return+acc
++++},
++++[[],+[]]
++)
}|code-block|syntax|javascript|1721223|entityMap|0|LINK|mutability|MUTABLE|url|https://lodash.com/docs/4.17.15#partition|1|https://stackoverflow.com/a/42299191/9751697^0|0|G|0|12|E|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

<a href="https://lodash.com/docs/4.17.15#partition" rel="nofollow noreferrer">Lodash partition</a> alternative, same as the <a href="https://stackoverflow.com/a/42299191/9751697">first solution</a> of @Yaremenko Andrii but shorter syntax
<pre class="lang-js prettyprint-override"><code>function partition(arr, callback) {
 return arr.reduce(
 (acc, val, i, arr) =&gt; {
 acc[callback(val, i, arr) ? 0 : 1].push(val)
 return acc
 },
 [[], []]
 )
}
</code></pre>

I have a Javascript array that I would like to split into two based on whether a function called on each element returns <code>true</code> or <code>false</code>. Essentially, this is an <code>array.filter</code>, but I'd like to also have on hand the elements that were filtered out.

Currently, my plan is to use <code>array.forEach</code> and call the predicate function on each element. Depending on whether this is true or false, I will push the current element onto one of the two new arrays. Is there a more elegant or otherwise better way to do this? An <code>array.filter</code> where the will push the element onto another array before it returns <code>false</code>, for instance?

Dividing an array by filter function

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个Javascript数组，我想根据每个元素上调用的函数返回true还是false将其一分为二。本质上，这是一个array.filter，但我希望手头也有被过滤掉的元素。目前，我的计划是使用array.forEach并在每个元素上调用predicate函数。根据这是真是假，我将把当前元素推入两个新数组中的一个。有...

问按过滤函数划分数组
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按过滤函数划分数组EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按过滤函数划分数组
EN