IStripeSelection

Remarks

Remarks

Remarks

Overrides

Remarks

Parameters

items - IStripe

The item(s) to prepend to the enumeration

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that has each of the items appended to it.

Examples

const list = List.fromArray([1, 2, 3, 4])

const appendedEnumerable = list.append(5, 6)
console.log(appendedEnumerable.toArray()) // yields [1,2,3,4,5,6]

// show live updates
list.add(4.5)

console.log(appendedEnumerable.toArray()) // yields [1,2,3,4,4.5,5,6]

See Also

Overrides

Parameters

index - number

The index of the element to return. Supports relative indexing from the end of the enumerable when passed a negative index. In other words, if a negative number is used, the returned element will be found by counting back from the end of the enumerable.

Returns

↪IStripe

The element at the given index, or undefined if the index is not within the range of this enumerable.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])
console.log(enumerable.at(0)) // yields 1
console.log(enumerable.at(-1)) // yields 4
console.log(enumerable.at(5)) // yields undefined

Overrides

Remarks

See Also

Defined in

Remarks

Parameters

elements - Object

Rest arguments to be appended. In case the elements are enumerable-like, too, they will be will be enumerated after the others have been enumerated. But this can also be simple objects of type T in which case they will be appended to the enumerable just like with append

Returns

↪IEnumerable<IStripe>

A dynamic composite enumerable.

Examples

const enumerable1 = IEnumerable.from([1, 2])
const enumerable2 = IEnumerable.from([3, 4])

console.log(enumerable1.concat(enumerable2).toArray()) // yields [1,2,3,4]

// single values can be used, too
console.log(enumerable1.concat(3, 4).toArray()) // yields [1,2,3,4]

// arrays are flattened
console.log(enumerable1.concat([5, 6], [7, 8]).toArray()) // now contains [1,2,5,6,7,8]

// works with arrays and array-like collections, too
console.log(enumerable1.concat([3, 4]).toArray()) // yields [1,2,3,4]

const list1 = List.fromArray([1, 2])
const list2 = List.fromArray([3, 4])

const result = list1.concat(list2)

console.log(result.toArray()) // yields [1,2,3,4]

list1.add(2.5)

// result changed also
console.log(result.toArray()) // yields [1,2,2.5,3,4]

list2.add(5)

// result changed also
console.log(result.toArray()) // yields [1,2,2.5,3,4,5]

See Also

Overrides

Remarks

ParametersOptions Overload

keySelector - function(IStripe):Object

The optional function that determines the key to determine distinctness of the elements. If omitted, the element itself is used.

Signature Details

function(element: IStripe) : Object

A function which creates a key for the given element.

Parameters

element - IStripe

The element to get the key for.

Returns

Object

The key for the element.

thisArg - Object

The optional object to use for thisin the keySelector function.

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that yields each element with a given key at most once.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 3, 4])

const result = enumerable.distinct()

console.log(result.toArray()) // yields [1,2,3,4]

See Also

Overrides

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if the element matches a condition.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪boolean

true if all elements of the enumerable match the given predicate, false otherwise.

Throws

Exception({ name: 'ArgumentError' })

predicate is null.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

console.log(enumerable.every((item) => item < 5)) // true

console.log(enumerable.every((item) => item < 4)) // false

Overrides

Remarks

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if the given element should be included in the resulting enumerable.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IEnumerable<IStripe>

A dynamic enumerable of the elements which match the given predicate.

Examples

const enumerable = IEnumerable.from([10, 2, 30, 4, 5, 6])

const result = enumerable.filter((item) => item < 5)

console.log(result.toArray()) // yields [2,4]

const list = List.fromArray([10, 2, 30, 4, 5, 6])

const result = list.filter((item) => item < 5)

list.add(1)

// result changed also
console.log(result.toArray()) // yields [2,4,1]

Overrides

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if the given element should be returned.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IStripe

The first element of this enumerable, its first element that matches a given predicate, or null if there is no such element.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.find((item) => item < 5)) // yields 2

// no matches with the given predicate
console.log(enumerable.find((item) => item < 2)) // yields null

Overrides

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if an item matches the search conditions.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪number

The index of the first item for which predicate returns true or -1 if there is no such item in the enumerable.

Overrides

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if the given element should be returned.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IStripe

The last element of this enumerable, its last element that matches a given predicate, or null if there is no such element.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.findLast((item) => item < 5)) // yields 3

// no matches with the given predicate
console.log(enumerable.findLast((item) => item < 2)) // yields null

Overrides

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A predicate function which returns true if an item matches the search conditions.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪number

The index of the last item for which predicate returns true or -1 if there is no such item in the enumerable.

Overrides

Remarks

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A function which returns true if the given element should be returned.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IStripe

The first matching element of this enumerable.

Throws

Exception({ name: 'InvalidOperationError' })

If this enumerable does not contain a matching element.

Examples

const enumerable = IEnumerable.from([10, 2, 3, 9, 5, 6])

console.log(enumerable.first((item) => item < 5)) // yields 2

// no matches with the given predicate
console.log(enumerable.first((item) => item < 2)) // throws exception

See Also

Overrides

Remarks

Type Parameters

TResult

Parameters

selector - function(IStripe, number, IEnumerable<IStripe>):IEnumerable<TResult>

A function which returns an enumerable for each element of this enumerable.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : IEnumerable<TResult>

The selector to use for the IEnumerable<T>.

A function which returns a result of type IEnumerable<T> for each element.

Parameters

element - IStripe

The current element create a result for.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

IEnumerable<TResult>

A result of type of TResult created from the element.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IEnumerable<TResult>

A flattened dynamic enumerable of the enumerables provided for each element of this enumerable.

Examples

const enumerable = IEnumerable.from([1, 2, 3])

const result = enumerable.flatMap((item) =>
  IEnumerable.from([item, item * 2])
)

console.log(result.toArray()) // yields [1,2,2,4,3,6]const enumerable = IEnumerable.from<number>([1, 2, 3])

const result = enumerable.flatMap((item) =>
  IEnumerable.from<number>([item, item * 2])
)

console.log(result.toArray()) // yields [1,2,2,4,3,6]

const list = List.fromArray([[1], [2], [3]])

const result = list.flatMap((item) => IEnumerable.from([item[0] * 2]))

list.add([4])

// result changed also
console.log(result.toArray()) // yields [2,4,6,8]const list = List.fromArray<number[]>([[1], [2], [3]])

const result = list.flatMap((item) =>
  IEnumerable.from<number>([item[0] * 2])
)

list.add([4])

// result changed also
console.log(result.toArray()) // yields [2,4,6,8]

Overrides

Parameters

action - function(IStripe, number, IEnumerable<IStripe>):void

The function to call for each element.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>)

An action to execute for each element of an IEnumerable<T>.

Parameters

element - IStripe

The current element.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

thisArg - Object

The optional object to use for this in the function.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

enumerable.forEach((item) => console.log(item)) // 1 2 3 4

// accessing the index
enumerable.forEach((item, index) =>
  console.log(`Item #${index} is ${item}`)
)

Overrides

Remarks

Returns

↪IEnumerator<IStripe>

The IEnumerator<T> which can be used to iterate over the items in this instance

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

const enumerator = enumerable.getEnumerator()
while (enumerator.moveNext()) {
  console.log(enumerator.current)
}
// 1 2 3 4

// enumerators can be reused
enumerator.reset()
while (enumerator.moveNext()) {
  console.log(enumerator.current)
}
// 1 2 3 4

Implements

Remarks

Type Parameters

TKey

The type of the key elements.

TResult

The type of the created elements.

ParametersOptions Overload

keySelector - function(IStripe, number, IEnumerable<IStripe>):TKey

A function which selects from each element the key.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : TKey

A function which creates a key for the given element.

Parameters

element - IStripe

The element to get the key for.

index - number

The index of the element in the underlying .

source - IEnumerable<IStripe>

The underlying

Returns

TKey

resultCreator - function(TKey, IEnumerable<IStripe>, number):TResult

An optional function which transforms each group of elements and their common key into a resulting object. If omitted, the default implementation will create arrays of length 2 where the first element is the key and the second element is an IEnumerable<TSource> of the elements with the corresponding key.

Signature Details

function(key: TKey, group: IEnumerable<IStripe>, index: number) : TResult

A function which transforms a group of elements and their common key into a resulting object.

Parameters

key - TKey

The key of the provided group.

group - IEnumerable<IStripe>

The group of elements with the given key.

index - number

The index of the group.

Returns

TResult

A resulting object for the given group with the given key.

thisArg - Object

The optional value to use as this when executing the keySelector and resultCreator .

Returns

↪IEnumerable<TResult>

An enumeration of groups of the original enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'A', amount: 1 },
  { type: 'A', amount: 2 },
  { type: 'B', amount: 4 }
])

// without result creator
const groups1 = enumerable.groupBy((element) => element.type)

for (const g of groups1) {
  console.log(`Type is ${g[0]} and has ${g[1].length} members.`)
}
// Type is A and has 2 members.
// Type is B and has 1 members.

// with result creator
const groups2 = enumerable.groupBy(
  (element) => element.type,
  (type, elements) => ({
    type,
    amount: elements.sum((item) => item.amount)
  })
)

console.log(groups2.toArray()) // yields [{"type":"A","amount":4},{"type":"B","amount":4}]const enumerable = IEnumerable.from([
  { type: 'A', amount: 1 },
  { type: 'A', amount: 2 },
  { type: 'B', amount: 4 }
])

// without result creator
const groups1 = enumerable.groupBy<string, string>(
  (element) => element.type
)

for (const g of groups1) {
  console.log(`Type is ${g[0]} and has ${g[1].length} members.`)
}
// Type is A and has 2 members.
// Type is B and has 1 members.

// with result creator
const groups2 = enumerable.groupBy(
  (element) => element.type,
  (type, elements) => ({
    type,
    amount: elements!.sum((item) => item.amount)
  })
)

console.log(groups2.toArray()) // yields [{"type":"A","amount":4},{"type":"B","amount":4}]

const val = IEnumerable.ofRange(1, 10)
  .groupBy(
    (value, index) => index % 2,
    (key, items, index) => [`key ${index % 2}`, items.toArray()]
  )
  .toArray()

// [
//   ["key 0",[1,3,5,7,9]],
//   ["key 1",[2,4,6,8,10]]
// ]const val = IEnumerable.ofRange(1, 10)
  .groupBy(
    (value, index) => index % 2,
    (key, items, index) => [`key ${index % 2}`, items!.toArray()]
  )
  .toArray()

// [
//   ["key 0",[1,3,5,7,9]],
//   ["key 1",[2,4,6,8,10]]
// ]

const enumerable = IEnumerable.from([
  { value: 0, key: 'a' },
  { value: 1, key: 'b' },
  { value: 2, key: 'b' },
  { value: 3, key: 'a' }
])

const obj = Object.fromEntries(
  enumerable.groupBy(
    (item) => item.key,
    (key, items) => [key, items.toArray()]
  )
)

// {
//   a: [{value:0, key:a}, {value:3, key:a}],
//   b: [{value:1, key:b}, {value:2, key:b}]
// }const enumerable: IEnumerable<{ value: number; key: string }> =
  IEnumerable.from([
    { value: 0, key: 'a' },
    { value: 1, key: 'b' },
    { value: 2, key: 'b' },
    { value: 3, key: 'a' }
  ])

const obj = Object.fromEntries(
  enumerable.groupBy(
    (item) => item.key,
    (key, items) => [key, items!.toArray()]
  ) as Iterable<[unknown, unknown]>
)

// {
//   a: [{value:0, key:a}, {value:3, key:a}],
//   b: [{value:1, key:b}, {value:2, key:b}]
// }

Overrides

Parameters

value - IStripe

The value to search for.

Returns

↪boolean

true if this enumerable contains the given value, false otherwise.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4])

console.log(enumerable.includes(2)) // true

console.log(enumerable.includes(5)) // false

Overrides

Parameters

item - IStripe

The item to search for.

fromIndex - number

Returns

↪number

The index of the given item in the enumerable. -1 if the item is not in the enumerable.

Overrides

Parameters

item - IStripe

The item to check.

Returns

↪boolean

Whether it is currently selected.

See Also

Defined in

Remarks

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A function which returns true if the given element should be returned.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪IStripe

The last element of this enumerable.

Throws

Exception({ name: 'InvalidOperationError' })

If the enumerable is empty.

Examples

const enumerable1 = IEnumerable.from([1, 2, 3, 4])
console.log(enumerable1.last()) // yields 4

// if the enumerable is empty then an exception will be thrown
const enumerable2 = IEnumerable.from([])
console.log(enumerable2.last()) // throws exception

See Also

Overrides

Remarks

Type Parameters

TResult

The type of the mapped elements.

Parameters

selector - function(IStripe, number, IEnumerable<IStripe>):TResult

A function which converts each element into a new element of the type TResult.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : TResult

The selector to use for the IEnumerable<T>.

A function which returns a result of type TResult for each element.

Parameters

element - IStripe

The current element create a result for.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

TResult

A result of type TResult created from the element.

thisArg - Object

The optional value to use as this when executing the selector.

Returns

↪IEnumerable<TResult>

A dynamic enumerable of the results of the provided function.

Examples

const enumerable = IEnumerable.from([1, 2, 3])

const result = enumerable.map((item) => item * 2)

console.log(result.toArray()) // yields [2, 4, 6]

// with index
const result2 = enumerable.map((item, index) => item * index)

console.log(result2.toArray()) // yields [0, 2, 6]

// with index and enumerable
const result3 = enumerable.map(
  (item, index, enumerable) =>
    `Item no ${index} of ${enumerable.size} is ${item}`
)

console.log(result3.toArray())
// ["Item no 0 of 3 is 1","Item no 1 of 3 is 2","Item no 2 of 3 is 3"]const enumerable = IEnumerable.from([1, 2, 3])

const result = enumerable.map((item) => item * 2)

console.log(result.toArray()) // yields [2, 4, 6]

// with index
const result2 = enumerable.map((item, index) => item * index)

console.log(result2.toArray()) // yields [0, 2, 6]

// with index and enumerable
const result3 = enumerable.map(
  (item, index, enumerable) =>
    `Item no ${index} of ${enumerable!.size} is ${item}`
)

console.log(result3.toArray())
// ["Item no 0 of 3 is 1","Item no 1 of 3 is 2","Item no 2 of 3 is 3"]

const list = List.fromArray([1, 2, 3])

const result = list.map((item) => item * 2)

list.add(4)

// result changed also
console.log(result.toArray()) // yields [2,4,6,8]

Overrides

Remarks

Type Parameters

TResult

Returns

↪IEnumerable<TResult>

A typed enumerable.

Overrides

Remarks

Type Parameters

TKey

ParametersOptions Overload

keySelector - function(IStripe):TKey

The function that determines the key for sorting the elements. If omitted, the element itself is used.

Signature Details

function(element: IStripe) : TKey

A function which creates a key for the given element.

Parameters

element - IStripe

The element to get the key for.

Returns

TKey

The key for the element.

comparer - function(TKey, TKey):number

A function with the signature function(key1, key2):Number which is used for the sort operation to compare the key elements in the enumerable. May be omitted.

Signature Details

function(value1: TKey, value2: TKey) : number

Compares the given values.

Parameters

value1 - TKey

The first value to compare.

value2 - TKey

The second value to compare.

Returns

number

A value less than 0 if value 1 is smaller than value2, 0 if both values are equal, greater than 0 otherwise.

thisArg - Object

Returns

↪IEnumerable<IStripe>

An enumeration of groups of the original enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'name-6', rank: 8 },
  { type: 'name-23', rank: 4 },
  { type: 'name-3', rank: 5 }
])

// order by the elements' rank, without a comparer function
const sortedEnumerable1 = enumerable.orderBy((entry) => entry.rank)

console.log(sortedEnumerable1.toArray())
// [{ "type": "name-23", "rank": 4 }, { "type": "name-3", "rank": 5 }, { "type": "name-6", "rank": 8 }]

// order by the elements' type using numeric collation to get a more "natural" order, with a comparer function
const collator = new Intl.Collator(undefined, {
  numeric: true,
  sensitivity: 'base'
})
const sortedEnumerable2 = enumerable.orderBy(
  (entry) => entry.type,
  collator.compare
)

console.log(sortedEnumerable2.toArray())
// [{ "type": "name-3", "rank": 5 }, { "type": "name-6", "rank": 8 },{ "type": "name-23", "rank": 4 }]

Overrides

Remarks

Type Parameters

TKey

ParametersOptions Overload

keySelector - function(IStripe):TKey

The function that determines the key for sorting the elements. If omitted, the element itself is used.

Signature Details

function(element: IStripe) : TKey

A function which creates a key for the given element.

Parameters

element - IStripe

The element to get the key for.

Returns

TKey

The key for the element.

comparer - function(TKey, TKey):number

A function with the signature function(key1, key2):Number which is used for the sort operation to compare the key elements in the enumerable. May be omitted.

Signature Details

function(value1: TKey, value2: TKey) : number

Compares the given values.

Parameters

value1 - TKey

The first value to compare.

value2 - TKey

The second value to compare.

Returns

number

A value less than 0 if value 1 is smaller than value2, 0 if both values are equal, greater than 0 otherwise.

thisArg - Object

Returns

↪IEnumerable<IStripe>

An enumeration of groups of the original enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'A' },
  { type: 'B' },
  { type: 'C' },
  { type: 'D' }
])

// order by the elements' types, without a comparer function
const sortedEnumerable1 = enumerable.orderByDescending(
  (entry) => entry.type
)

console.log(sortedEnumerable1.toArray())
// [{ "type": "D" }, { "type": "C" }, { "type": "B" }, { "type": "A" }]

Overrides

Parameters

items - IStripe

The item(s) to prepend to the enumeration

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that has items prepended to it.

Examples

const enumerable1 = IEnumerable.from([1, 2, 3, 4])
console.log(enumerable1.prepend(0).toArray()) // yields [0,1,2,3,4]

// more than one value can be used too
const enumerable2 = IEnumerable.from([3, 4, 5, 6])
console.log(enumerable2.prepend(1, 2).toArray()) // yields [1,2,3,4,5,6]

See Also

Overrides

Type Parameters

TAccumulate

The type of the accumulated value.

Parameters

accumulator - function(TAccumulate, IStripe, number, IEnumerable<IStripe>):TAccumulate

A function which "adds" (accumulates) a value depending on the element and index to the initial value and returns the result.

Signature Details

function(total: TAccumulate, element: IStripe, index: number, source: IEnumerable<IStripe>) : TAccumulate

The accumulator to use for the IEnumerable<T>.

A function which returns a result of type TAccumulate as an accumulation of total and element.

Parameters

total - TAccumulate

The previously returned value of the function.

element - IStripe

The current element to accumulate.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

TAccumulate

A result of type TAccumulate created from the element.

initialValue - TAccumulate

The initial value for the accumulator. Omit/use the reduce overload if you don't want to specify an initial value.

Returns

↪TAccumulate

The result of the accumulation.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.reduce(
  (accumulator, currentValue) => Math.max(accumulator, currentValue),
  0
)

console.log(result) // expected output: 5

See Also

Overrides

Parameters

accumulator - function(IStripe, IStripe, number, IEnumerable<IStripe>):IStripe

A function which "adds" (accumulates) a value depending on the element and index to the initial value and returns the result.

Signature Details

function(total: IStripe, element: IStripe, index: number, source: IEnumerable<IStripe>) : IStripe

The accumulator to use for the IEnumerable<T>.

A function which returns a result of type TAccumulate as an accumulation of total and element.

Parameters

total - IStripe

The previously returned value of the function.

element - IStripe

The current element to accumulate.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

IStripe

A result of type TAccumulate created from the element.

Returns

↪IStripe

The result of the accumulation.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.reduce(
  (accumulator, currentValue) => accumulator + currentValue
)

console.log(result) // expected output: 15

See Also

Overrides

Type Parameters

TAccumulate

The type of the accumulated value.

Parameters

accumulator - function(TAccumulate, IStripe, number, IEnumerable<IStripe>):TAccumulate

A function which "adds" (accumulates) a value depending on the element and index to the seed value and returns the result.

Signature Details

function(total: TAccumulate, element: IStripe, index: number, source: IEnumerable<IStripe>) : TAccumulate

The accumulator to use for the IEnumerable<T>.

A function which returns a result of type TAccumulate as an accumulation of total and element.

Parameters

total - TAccumulate

The previously returned value of the function.

element - IStripe

The current element to accumulate.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

TAccumulate

A result of type TAccumulate created from the element.

initialValue - TAccumulate

The initial value for the accumulator. Omit/use the reduceRight overload if you don't want to specify an initial value.

Returns

↪TAccumulate

The final value of the accumulation.

Examples

const enumerable = IEnumerable.from(['a', 'b', 'c', 'd'])

const result = enumerable.reduceRight(
  (accumulator, currentValue) => currentValue + accumulator,
  '.'
)

console.log(result) // yields 'abcd.'

See Also

Overrides

Parameters

accumulator - function(IStripe, IStripe, number, IEnumerable<IStripe>):IStripe

A function which "adds" (accumulates) a value depending on the element and index to the seed value and returns the result.

Signature Details

function(total: IStripe, element: IStripe, index: number, source: IEnumerable<IStripe>) : IStripe

The accumulator to use for the IEnumerable<T>.

A function which returns a result of type TAccumulate as an accumulation of total and element.

Parameters

total - IStripe

The previously returned value of the function.

element - IStripe

The current element to accumulate.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

IStripe

A result of type TAccumulate created from the element.

Returns

↪IStripe

The result of the accumulation.

Examples

const enumerable = IEnumerable.from([
  [0, 1],
  [2, 3],
  [4, 5]
])

const result = enumerable.reduceRight((accumulator, currentValue) =>
  accumulator.concat(currentValue)
)

console.log(result) // yields [4,5,2,3,0,1]

See Also

Overrides

Remarks

Parameters

item - IStripe

The item to set the selection state for.

selected - boolean

Whether to select the object.

See Also

Defined in

Parameters

amount - number

The number of elements to skip at the beginning.

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that skips amount elements.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])

const result = enumerable.skip(3)

console.log(result.toArray()) // yields [4,5,6,7]

See Also

Overrides

Remarks

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

The predicate function that determines what elements should be skipped. While the predicate yields true for the provided item, the element will not be yielded.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for thisin the predicate function.

Returns

↪IEnumerable<IStripe>

A new live view over the original enumerable that discards elements at the beginnging of the original enumeration while the predicate yields true.

Examples

const enumerable = IEnumerable.from([
  'a',
  'b',
  'c',
  'd',
  'a',
  'b',
  'c',
  'd'
])

const result = enumerable.skipWhile(
  (element) => element.charCodeAt(0) < 'c'.charCodeAt(0)
)

console.log(result.toArray()) // yields ["c", "d", "a", "b", "c", "d"]

See Also

Overrides

ParametersOptions Overload

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A function which returns true if the element matches a condition.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for this in the function.

Returns

↪boolean

Whether this enumerable contains any elements matching the given predicate.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])

const result = enumerable.some((item) => item % 2 === 0)

console.log(result) // true

Overrides

Parameters

selector - function(IStripe, number, IEnumerable<IStripe>):number

A function which returns a numeric value for the given element.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : number

The selector to use for the IEnumerable<T>.

A function which returns a result of type TResult for each element.

Parameters

element - IStripe

The current element create a result for.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

number

A result of type TResult created from the element.

thisArg - Object

The optional object to use for this in the function.

Returns

↪number

The sum of the elements of the enumerable.

Examples

const enumerable = IEnumerable.from([
  { type: 'A', amount: 3 },
  { type: 'B', amount: 2 },
  { type: 'C', amount: 2 },
  { type: 'D', amount: 5 }
])

const result = enumerable.sum((element) => element.amount)

console.log(result) // yields 12

Overrides

Parameters

count - number

The number of elements in the created enumerable. If the number is positive, the elements are taken from the beginning, otherwise, the elements are taken from the end.

Returns

↪IEnumerable<IStripe>

A dynamic iew of this enumerable with the given number of elements.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5, 6, 7])

// positive parameter means taking elements from the beginning of the enumerable
console.log(enumerable.take(2).toArray()) // yields [1,2]

// negative parameter means taking elements from the end of the enumerable
console.log(enumerable.take(-2).toArray()) // yields [6,7]

See Also

Overrides

Remarks

Parameters

predicate - function(IStripe, number, IEnumerable<IStripe>):boolean

A function which returns true as long as the elements should be added to the returned enumerable.

Signature Details

function(element: IStripe, index: number, source: IEnumerable<IStripe>) : boolean

The predicate to use for IEnumerable<T>.

Parameters

element - IStripe

The current element to test.

index - number

The element's index in the

source - IEnumerable<IStripe>

The enumerable this function is called upon.

Returns

boolean

true if the item matches the condition.

thisArg - Object

The optional object to use for thisin the function.

Returns

↪IEnumerable<IStripe>

A dynamic enumerable that is a subset of the original enumerable.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 30, 4, 5])

const result = enumerable.takeWhile((item) => item < 5)

console.log(result.toArray()) // yields [1,2,3]

Overrides

Returns

↪IStripe[]

An array with the elements of this enumerable.

Overrides

Returns

↪List<IStripe>

A List<T> of the elements of this enumerable.

Overrides

Remarks

Returns

↪IEnumerable<IStripe>

A dynamic enumerable which contains the elements of the original enumerable in reverse order.

Examples

const enumerable = IEnumerable.from([1, 2, 3, 4, 5])

const result = enumerable.toReversed()

console.log(result.toArray()) // yields [5,4,3,2,1]

const list = List.fromArray([1, 2, 3, 4, 5])

const result = list.toReversed()

list.add(0)

// result changed also
console.log(result.toArray()) // yields [0,5,4,3,2,1]

Overrides

See Also

Defined in

Event Registration

Event Deregistration