Nomchy/discord.js
1
0
Fork 0
mirror of https://github.com/discordjs/discord.js.git synced 2026-03-16 11:33:30 +01:00
Code Issues Packages Projects Releases Wiki Activity

perf(collection): optimisations (#10552)

Browse Source 
* perf: `merge()`: deduplicate boolean checks

* perf: `toSorted()`: remove redundant closure

* perf: `last[Key]()`: order of operations

- do not perform iterable-to-array until required
- test ! before <

* perf: `{at,keyAt}()`: manually iterate to target

* perf: `first[Key]()`: avoid `Array.from()`

* perf: `map()`: avoid `Array.from()`

* perf: `random[Key]()`: avoid `Array.from()`

* test: `.{at,keyAt}()` indices

* perf: `last[Key]()`: use `.at()`/`.keyAt()` for single element

* perf: `first[Key]()`: use iterable-to-array if returning all

* perf: `random[Key]()`: use `{at,keyAt}()` for single value

- skip iterable-to-array for returning single value
- short-circuit if amount or collection size is zero

* perf: `random[Key]()`: use Durstenfeld shuffle

* refactor: `{key,keyAt}()`: reorder index check

---------

Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com>
This commit is contained in:
René
2024-11-07 11:03:26 +00:00
committed by GitHub
parent c34a57b798
commit ea042458a3
2 changed files with 115 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
packages/collection/__tests__/collection.test.ts
View File

@@ -70,12 +70,20 @@ describe('at() tests', () => {
expect(coll.at(0)).toStrictEqual(1); expect(coll.at(0)).toStrictEqual(1);
}); });
test('positive non-integer index', () => {
expect(coll.at(1.5)).toStrictEqual(2);
});
test('negative index', () => { test('negative index', () => {
expect(coll.at(-1)).toStrictEqual(3); expect(coll.at(-1)).toStrictEqual(3);
}); });
test('negative non-integer index', () => {
expect(coll.at(-2.5)).toStrictEqual(2);
});
test('invalid positive index', () => { test('invalid positive index', () => {
expect(coll.at(4)).toBeUndefined(); expect(coll.at(3)).toBeUndefined();
}); });
test('invalid negative index', () => { test('invalid negative index', () => {
@@ -432,12 +440,20 @@ describe('keyAt() tests', () => {
expect(coll.keyAt(0)).toStrictEqual('a'); expect(coll.keyAt(0)).toStrictEqual('a');
}); });
test('positive non-integer index', () => {
expect(coll.keyAt(1.5)).toStrictEqual('b');
});
test('negative index', () => { test('negative index', () => {
expect(coll.keyAt(-1)).toStrictEqual('c'); expect(coll.keyAt(-1)).toStrictEqual('c');
}); });
test('negative non-integer index', () => {
expect(coll.keyAt(-2.5)).toStrictEqual('b');
});
test('invalid positive index', () => { test('invalid positive index', () => {
expect(coll.keyAt(4)).toBeUndefined(); expect(coll.keyAt(3)).toBeUndefined();
}); });
test('invalid negative index', () => { test('invalid negative index', () => {

142
packages/collection/src/collection.ts
View File

@@ -85,9 +85,16 @@ export class Collection<Key, Value> extends Map<Key, Value> {
public first(amount?: number): Value | Value[] | undefined { public first(amount?: number): Value | Value[] | undefined {
if (amount === undefined) return this.values().next().value; if (amount === undefined) return this.values().next().value;
if (amount < 0) return this.last(amount * -1); if (amount < 0) return this.last(amount * -1);
amount = Math.min(this.size, amount); if (amount >= this.size) return [...this.values()];
const iter = this.values(); const iter = this.values();
return Array.from({ length: amount }, (): Value => iter.next().value!); // eslint-disable-next-line unicorn/no-new-array
const results: Value[] = new Array(amount);
for (let index = 0; index < amount; index++) {
results[index] = iter.next().value!;
}
return results;
} }
/** /**
@@ -102,9 +109,16 @@ export class Collection<Key, Value> extends Map<Key, Value> {
public firstKey(amount?: number): Key | Key[] | undefined { public firstKey(amount?: number): Key | Key[] | undefined {
if (amount === undefined) return this.keys().next().value; if (amount === undefined) return this.keys().next().value;
if (amount < 0) return this.lastKey(amount * -1); if (amount < 0) return this.lastKey(amount * -1);
amount = Math.min(this.size, amount); if (amount >= this.size) return [...this.keys()];
const iter = this.keys(); const iter = this.keys();
return Array.from({ length: amount }, (): Key => iter.next().value!); // eslint-disable-next-line unicorn/no-new-array
const results: Key[] = new Array(amount);
for (let index = 0; index < amount; index++) {
results[index] = iter.next().value!;
}
return results;
} }
/** /**
@@ -117,11 +131,12 @@ export class Collection<Key, Value> extends Map<Key, Value> {
public last(): Value | undefined; public last(): Value | undefined;
public last(amount: number): Value[]; public last(amount: number): Value[];
public last(amount?: number): Value | Value[] | undefined { public last(amount?: number): Value | Value[] | undefined {
const arr = [...this.values()]; if (amount === undefined) return this.at(-1);
if (amount === undefined) return arr[arr.length - 1];
if (amount < 0) return this.first(amount * -1);
if (!amount) return []; if (!amount) return [];
return arr.slice(-amount); if (amount < 0) return this.first(amount * -1);
const arr = [...this.values()];
return arr.slice(amount * -1);
} }
/** /**
@@ -134,11 +149,12 @@ export class Collection<Key, Value> extends Map<Key, Value> {
public lastKey(): Key | undefined; public lastKey(): Key | undefined;
public lastKey(amount: number): Key[]; public lastKey(amount: number): Key[];
public lastKey(amount?: number): Key | Key[] | undefined { public lastKey(amount?: number): Key | Key[] | undefined {
const arr = [...this.keys()]; if (amount === undefined) return this.keyAt(-1);
if (amount === undefined) return arr[arr.length - 1];
if (amount < 0) return this.firstKey(amount * -1);
if (!amount) return []; if (!amount) return [];
return arr.slice(-amount); if (amount < 0) return this.firstKey(amount * -1);
const arr = [...this.keys()];
return arr.slice(amount * -1);
} }
/** /**
@@ -148,10 +164,21 @@ export class Collection<Key, Value> extends Map<Key, Value> {
* *
* @param index - The index of the element to obtain * @param index - The index of the element to obtain
*/ */
public at(index: number) { public at(index: number): Value | undefined {
index = Math.floor(index); index = Math.trunc(index);
const arr = [...this.values()]; if (index >= 0) {
return arr.at(index); if (index >= this.size) return undefined;
} else {
index += this.size;
if (index < 0) return undefined;
}
const iter = this.values();
for (let skip = 0; skip < index; skip++) {
iter.next();
}
return iter.next().value!;
} }
/** /**
@@ -161,10 +188,21 @@ export class Collection<Key, Value> extends Map<Key, Value> {
* *
* @param index - The index of the key to obtain * @param index - The index of the key to obtain
*/ */
public keyAt(index: number) { public keyAt(index: number): Key | undefined {
index = Math.floor(index); index = Math.trunc(index);
const arr = [...this.keys()]; if (index >= 0) {
return arr.at(index); if (index >= this.size) return undefined;
} else {
index += this.size;
if (index < 0) return undefined;
}
const iter = this.keys();
for (let skip = 0; skip < index; skip++) {
iter.next();
}
return iter.next().value!;
} }
/** /**
@@ -176,13 +214,17 @@ export class Collection<Key, Value> extends Map<Key, Value> {
public random(): Value | undefined; public random(): Value | undefined;
public random(amount: number): Value[]; public random(amount: number): Value[];
public random(amount?: number): Value | Value[] | undefined { public random(amount?: number): Value | Value[] | undefined {
const arr = [...this.values()]; if (amount === undefined) return this.at(Math.floor(Math.random() * this.size));
if (amount === undefined) return arr[Math.floor(Math.random() * arr.length)]; amount = Math.min(this.size, amount);
if (!arr.length || !amount) return []; if (!amount) return [];
return Array.from(
{ length: Math.min(amount, arr.length) }, const values = [...this.values()];
(): Value => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]!, for (let sourceIndex = 0; sourceIndex < amount; sourceIndex++) {
); const targetIndex = sourceIndex + Math.floor(Math.random() * (values.length - sourceIndex));
[values[sourceIndex], values[targetIndex]] = [values[targetIndex]!, values[sourceIndex]!];
}
return values.slice(0, amount);
} }
/** /**
@@ -194,13 +236,17 @@ export class Collection<Key, Value> extends Map<Key, Value> {
public randomKey(): Key | undefined; public randomKey(): Key | undefined;
public randomKey(amount: number): Key[]; public randomKey(amount: number): Key[];
public randomKey(amount?: number): Key | Key[] | undefined { public randomKey(amount?: number): Key | Key[] | undefined {
const arr = [...this.keys()]; if (amount === undefined) return this.keyAt(Math.floor(Math.random() * this.size));
if (amount === undefined) return arr[Math.floor(Math.random() * arr.length)]; amount = Math.min(this.size, amount);
if (!arr.length || !amount) return []; if (!amount) return [];
return Array.from(
{ length: Math.min(amount, arr.length) }, const keys = [...this.keys()];
(): Key => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]!, for (let sourceIndex = 0; sourceIndex < amount; sourceIndex++) {
); const targetIndex = sourceIndex + Math.floor(Math.random() * (keys.length - sourceIndex));
[keys[sourceIndex], keys[targetIndex]] = [keys[targetIndex]!, keys[sourceIndex]!];
}
return keys.slice(0, amount);
} }
/** /**
@@ -511,10 +557,14 @@ export class Collection<Key, Value> extends Map<Key, Value> {
if (typeof fn !== 'function') throw new TypeError(`${fn} is not a function`); if (typeof fn !== 'function') throw new TypeError(`${fn} is not a function`);
if (thisArg !== undefined) fn = fn.bind(thisArg); if (thisArg !== undefined) fn = fn.bind(thisArg);
const iter = this.entries(); const iter = this.entries();
return Array.from({ length: this.size }, (): NewValue => { // eslint-disable-next-line unicorn/no-new-array
const results: NewValue[] = new Array(this.size);
for (let index = 0; index < this.size; index++) {
const [key, value] = iter.next().value!; const [key, value] = iter.next().value!;
return fn(value, key, this); results[index] = fn(value, key, this);
}); }
return results;
} }
/** /**
@@ -959,12 +1009,14 @@ export class Collection<Key, Value> extends Map<Key, Value> {
const hasInSelf = this.has(key); const hasInSelf = this.has(key);
const hasInOther = other.has(key); const hasInOther = other.has(key);
if (hasInSelf && hasInOther) { if (hasInSelf) {
const result = whenInBoth(this.get(key)!, other.get(key)!, key); if (hasInOther) {
if (result.keep) coll.set(key, result.value); const result = whenInBoth(this.get(key)!, other.get(key)!, key);
} else if (hasInSelf) { if (result.keep) coll.set(key, result.value);
const result = whenInSelf(this.get(key)!, key); } else {
if (result.keep) coll.set(key, result.value); const result = whenInSelf(this.get(key)!, key);
if (result.keep) coll.set(key, result.value);
}
} else if (hasInOther) { } else if (hasInOther) {
const result = whenInOther(other.get(key)!, key); const result = whenInOther(other.get(key)!, key);
if (result.keep) coll.set(key, result.value); if (result.keep) coll.set(key, result.value);
@@ -995,8 +1047,8 @@ export class Collection<Key, Value> extends Map<Key, Value> {
* collection.sorted((userA, userB) => userA.createdTimestamp - userB.createdTimestamp); * collection.sorted((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);
* ``` * ```
*/ */
public toSorted(compareFunction: Comparator<Key, Value> = Collection.defaultSort) { public toSorted(compareFunction: Comparator<Key, Value> = Collection.defaultSort): Collection<Key, Value> {
return new this.constructor[Symbol.species](this).sort((av, bv, ak, bk) => compareFunction(av, bv, ak, bk)); return new this.constructor[Symbol.species](this).sort(compareFunction);
} }
public toJSON() { public toJSON() {