각 요소에 대해 호출 된 함수가 true또는을 반환하는지 여부에 따라 두 개로 분할하려는 Javascript 배열이 false있습니다. 기본적으로 이것은이다 array.filter, 그러나 나는 또한 손에 필터링 된 요소를 가지고 싶습니다 아웃 .
현재 내 계획은 array.forEach각 요소에 대해 조건 자 함수 를 사용 하고 호출하는 것입니다. 이것이 참인지 거짓인지에 따라 현재 요소를 두 개의 새로운 배열 중 하나에 푸시합니다. 더 우아하거나 더 나은 방법이 있습니까? 예 를 들어 array.filter는 반환하기 전에 요소를 다른 배열로 푸시합니다 false.
.filter있지만 이러한 부작용은 추적하고 이해하기 어렵습니다. 배열을 반복하고 한 배열 또는 다른 배열로 푸시하십시오.
답변:
ES6를 사용하면 reduce로 스프레드 구문을 사용할 수 있습니다.
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']]
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' } ]
이를 위해 reduce를 사용할 수 있습니다.
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]]);
}
[...left, current]또는 [...right, current]-를 구성합니다. 정확한 내부 구조는 모르지만 단순히 요소를 배열에 밀어 넣는 것보다 구성이 더 비싸다고 확신합니다. 또한 일반적으로 재귀 는 매번 "스택 프레임"을 생성하기 때문에 반복 보다 비용이 많이 듭니다 .
이것은 Ruby의Enumerable#partition 방법 과 매우 유사하게 들립니다 .
함수가 부작용을 가질 수없는 경우 (즉, 원래 배열을 변경할 수없는 경우), 각 요소를 반복하고 요소를 두 배열 중 하나로 푸시하는 것보다 배열을 분할하는 더 효율적인 방법은 없습니다.
즉, Array이 기능을 수행 하는 방법을 만드는 것이 틀림없이 더 "우아하다" . 이 예제에서 필터 함수는 원래 배열의 컨텍스트에서 실행되고 (즉, this원래 배열이 됨) 요소와 요소의 인덱스를 인수로받습니다 ( jQuery의 each메서드 와 유사 함 ).
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);for@qwertymk의 이전 답변에서와 같이 간단한 루프 보다 훨씬 느리다는 것을 알았습니다. 예를 들어 100,000 요소를 포함하는 배열의 경우 내 시스템에서 두 배 느 렸습니다.
필터 함수에서 거짓 항목을 함수 외부의 다른 변수로 푸시 할 수 있습니다.
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)
여기에서 많은 답변 Array.prototype.reduce을 사용하여 가변 누산기를 구축하고 큰 배열의 경우 스프레드 연산자를 사용하여 반복 할 때마다 새 배열을 복사하는 것보다 더 효율적임을 지적합니다. 단점은 짧은 람다 구문을 사용하는 "순수한"표현식만큼 예쁘지 않다는 것입니다.
그러나 그 방법은 쉼표 연산자를 사용하는 것입니다. C와 유사한 언어에서 쉼표는 항상 오른손 피연산자를 반환하는 연산자입니다. 이를 사용하여 void 함수를 호출하고 값을 반환하는 식을 만들 수 있습니다.
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']
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));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), [[], []]);
이해하기 쉽기 때문에 (그리고 타이프 스크립트로 완전히 타이핑 되었기 때문에) 이렇게했습니다.
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)