Collection with uniqueness and value equality
npm install vecollectionTypeScript
import VECollection from { VECollection };
..
interface ExampleObject {
exampleField: string
}
..
const collection = new VECollection();
`
Constructor
`TypeScript
const collection = new VECollection();
..
const exampleObject = {"exampleField": "exampleField"};
const array = new Set([exampleField]);
const collection = new VECollection(array);
`
Methods
#### add(elem: T): void
`TypeScript
collection.add(exampleObject);
`
Adds elem to VECollection.
#### addAll(elemCollection: VECollection): void
`TypeScript
const secondCollection = new VECollection([{"primitiveField": "secondPrimitiveField"}]);
collection.addAll(secondCollection);
`
Adds each elem in elemCollection to the calling VECollection.
$3
`TypeScript
const collectionCopy = collection.copy();
`
Creates and returns copy-by-value of the calling VECollection.
#### remove(elem: T): boolean
`TypeScript
collection.remove(exampleObject);
`
Returns true if we found (and subsequently removed) an element that satisfies deep equality when elem - and false if we didn't.
$3
`TypeScript
collection.clear();
`
Empties out the calling VECollection - done in-place.
#### findAndRemoveFirstOccurrence(findFn: (_: T) => boolean): boolean
`TypeScript
collection.findAndRemoveFirstOccurrence(({primitiveField}) => primitiveField.startsWith("first"));
`
Boolean return behavior is similar to remove() above, but based on the result of findFn.
#### returnFirstOccurrenceIfFound(findFn: (_: T) => boolean): T | undefined
`TypeScript
collection.returnFirstOccurrenceIfFound(({primitiveField}) => primitiveField.startsWith("first"));
`
Returns first result satisfying findFn if found - and undefined if not found.
(filter() below satisfies any " return all occurrences " needs.)
#### map(mapFn: (_: T) => U): VECollection
`TypeScript
const mappedCollection = collection.map(
({primitiveField}): JustPrimitivesObject => {
return {primitiveField: primitiveField.toUpperCase()}
}
);
`
Returns a VECollection containing the results of mapFn applied to the current collection's elems - in the same order as said collection already had.
#### forEach(forEachFn: (_: T) => void): void
`TypeScript
collection.forEach(
({primitiveField}) => console.log(primitiveField);
);
`
Executes forEachFn on each collection elem, in the collection's current order.
#### filter(filterFn: (_: T) => boolean): VECollection
`TypeScript
const filteredCollection = collection.filter(({primitiveField}) => !primitiveField.startsWith("example"));
`
Returns a VECollection containing all elems in the current collection that satisfy filterFn - in, again, the collection's existing order.
#### isEmpty(): boolean
`TypeScript
const isEmpty = collection.isEmpty();
`
isEmpty() === true if collection.size() === 0.
#### isNonEmpty(): boolean
`TypeScript
const isNonEmpty = collection.isNonEmpty()
`
isNonEmpty() = !isEmpty().
#### size(): number
`TypeScript
const collectionSize = collection.size();
`
size() = number of elems in collection.
Deep equality here..
.. is done via recursion.
VECollection.valueEqualityCheck() splits each object into primitives and non-primitives - it verifies the equality of all primitives, then recursively calls valueEqualityCheck() on each non-primitive.
Recursion will terminate when it reaches object fields that are " all primitives, no nested objects ".
Any operation requiring ordering or indexing..
.. can be done by transforming it into an Array via the collection's iterable quality.
`TypeScript
const array = Array.from(collection);
``