Class SvelteSet<T>

[iterator]

• "[iterator]"(): SetIterator<T>

  Iterates over values in the set.

  Returns SetIterator<T>

difference

• difference(other: Set<T>): Set<T>

  Return the difference of two sets.

  Parameters

  • other: Set<T>

    Some other set to compare against

  Returns Set<T>

  The difference defined as objects in this which are not present in other

entries

• entries(): SetIterator<[T, T]>

  Returns an iterable of [v,v] pairs for every value v in the set.

  Returns SetIterator<[T, T]>

equals

• equals(other: Set<T>): boolean

  Test whether this set is equal to some other set. Sets are equal if they share the same members, independent of order

  Parameters

  • other: Set<T>

    Some other set to compare against

  Returns boolean

  Are the sets equal?

every

• every(test: (value: T, index: number, set: Set<T>) => boolean): boolean

  Test whether every element in this Set satisfies a certain test criterion.

  Parameters

  • test: (value: T, index: number, set: Set<T>) => boolean

    The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.

  Returns boolean

  Does every element in the set satisfy the test criterion?

  See

  Array.every | Array#every

filter

• filter<F>(test: (value: T, index: number, set: Set<T>) => value is F): Set<F>

  Filter this set to create a subset of elements which satisfy a certain test criterion.

  Type Parameters

  • F

  Parameters

  • test: (value: T, index: number, set: Set<T>) => value is F

    The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being filtered.

  Returns Set<F>

  A new Set containing only elements which satisfy the test criterion.

  See

  Array.filter | Array#filter

• filter(test: (value: T, index: number, set: Set<T>) => boolean): Set<T>

  Parameters

  • test: (value: T, index: number, set: Set<T>) => boolean

  Returns Set<T>

find

• find<F>(test: (value: T, index: number, set: Set<T>) => value is F): F

  Find the first element in this set which satisfies a certain test criterion.

  Type Parameters

  • F

  Parameters

  • test: (value: T, index: number, set: Set<T>) => value is F

    The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being searched.

  Returns F

  The first element in the set which satisfies the test criterion, or undefined.

  See

  Array.find | Array#find

• find(test: (value: T, index: number, set: Set<T>) => boolean): T

  Parameters

  • test: (value: T, index: number, set: Set<T>) => boolean

  Returns T

first

• first(): T

  Return the first value from the set.

  Returns T

  The first element in the set, or undefined

forEach

• forEach(
      callbackfn: (value: T, value2: T, set: Set<T>) => void,
      thisArg?: any,
  ): void

  Executes a provided function once per each value in the Set object, in insertion order.

  Parameters

  • callbackfn: (value: T, value2: T, set: Set<T>) => void
  • OptionalthisArg: any

  Returns void

has

• has(value: T): boolean

  Parameters

  • value: T

  Returns boolean

  a boolean indicating whether an element with the specified value exists in the Set or not.

intersection

• intersection(other: Set<T>): Set<T>

  Return the intersection of two sets.

  Parameters

  • other: Set<T>

    Some other set to compare against

  Returns Set<T>

  The intersection of both sets

intersects

• intersects(other: Set<T>): boolean

  Test whether this set has an intersection with another set.

  Parameters

  • other: Set<T>

    Another set to compare against

  Returns boolean

  Do the sets intersect?

isSubset

• isSubset(other: Set<T>): boolean

  Test whether this set is a subset of some other set. A set is a subset if all its members are also present in the other set.

  Parameters

  • other: Set<T>

    Some other set that may be a subset of this one

  Returns boolean

  Is the other set a subset of this one?

keys

• keys(): SetIterator<T>

  Despite its name, returns an iterable of the values in the set.

  Returns SetIterator<T>

map

• map<V>(transform: (value: T, index: number, set: Set<T>) => V): Set<V>

  Create a new Set where every element is modified by a provided transformation function.

  Type Parameters

  • V

  Parameters

  • transform: (value: T, index: number, set: Set<T>) => V

    The transformation function to apply.Positional arguments are the value, the index of iteration, and the set being transformed.

  Returns Set<V>

  A new Set of equal size containing transformed elements.

  See

  Array.map | Array#map

reduce

• reduce<V>(
      reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V,
      accumulator: V,
  ): V

  Create a new Set with elements that are filtered and transformed by a provided reducer function.

  Type Parameters

  • V

  Parameters

  • reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V

    A reducer function applied to each value. Positional arguments are the accumulator, the value, the index of iteration, and the set being reduced.

  • accumulator: V

    The initial value of the returned accumulator.

  Returns V

  The final value of the accumulator.

  See

  Array.reduce | Array#reduce

some

• some(test: (value: T, index: number, set: Set<T>) => boolean): boolean

  Test whether any element in this Set satisfies a certain test criterion.

  Parameters

  • test: (value: T, index: number, set: Set<T>) => boolean

    The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.

  Returns boolean

  Does any element in the set satisfy the test criterion?

  See

  Array.some | Array#some

toObject

• toObject(): T[]

  Convert a set to a JSON object by mapping its contents to an array

  Returns T[]

  The set elements as an array.

values

• values(): SetIterator<T>

  Returns an iterable of values in the set.

  Returns SetIterator<T>

Readonly[toStringTag]

Readonlysize

Static Readonly[species]