Klasse Lists

Lesen, Bauen und Umformen einfacher Arrays beliebiger Elemente. Positionen sind 0-basiert: Index 0 ist das erste Element. Die meisten Methoden nehmen eine clone-Option, standardmäßig an, die die Liste zuerst tief kopiert, sodass die Eingabe nie geändert wird; ausgeschaltet arbeiten die ändernden Methoden an Ort und Stelle auf der Liste, was bei großen Daten schneller ist. removeAllItems leert immer die übergebene Liste.

Konstruktoren

constructor

new Lists(): Bit.Lists
Rückgabewert Bit.Lists

add

addItemAtIndex

addItemAtIndex<T>(inputs: AddItemAtIndexDto<T>): T[]
Fügt ein Element an einer Position ein; die Elemente ab dieser Position rücken um eins nach hinten.

Beispiel: [10, 20, 30, 40] mit 99 bei Index 2 -> [10, 20, 99, 30, 40]
Typenparameter
- T
Parameter
- inputs: AddItemAtIndexDto<T>
  Die Liste, das Element, der Index und ob kopiert wird
Rückgabewert T[]
Die Liste mit dem eingefügten Element
Example
```
const longer = bitbybit.lists.addItemAtIndex({ list: [10, 20, 30, 40], item: 99, index: 2, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54431

addItemAtIndexes

addItemAtIndexes<T>(inputs: AddItemAtIndexesDto<T>): T[]
Fügt dasselbe Element an mehreren Positionen der ursprünglichen Liste ein.

Beispiel: [10, 20, 30] mit 99 bei Indizes [0, 2] -> [99, 10, 20, 99, 30]
Typenparameter
- T
Parameter
- inputs: AddItemAtIndexesDto<T>
  Die Liste, das Element, die Indizes und ob kopiert wird
Rückgabewert T[]
Die Liste mit dem Element an jedem Index eingefügt
Example
```
const marked = bitbybit.lists.addItemAtIndexes({ list: [10, 20, 30], item: 99, indexes: [0, 2], clone: true });
```
- Definiert in bitbybit-docs.d.ts:54446

addItemsAtIndexes

addItemsAtIndexes<T>(inputs: AddItemsAtIndexesDto<T>): T[]
Fügt mehrere Elemente ein, das erste beim ersten Index, das zweite beim zweiten, und so weiter, alle auf der ursprünglichen Liste gezählt.

Die Indizes müssen in aufsteigender Reihenfolge sein und es muss einen pro Element geben, sonst wird ein Fehler ausgelöst. Beispiel: [10, 20, 30] mit Elementen [88, 99] bei Indizes [1, 2] -> [10, 88, 20, 99, 30]
Typenparameter
- T
Parameter
- inputs: AddItemsAtIndexesDto<T>
  Die Liste, die Elemente, ein Index pro Element und ob kopiert wird
Rückgabewert T[]
Die Liste mit den eingefügten Elementen
Example
```
const merged = bitbybit.lists.addItemsAtIndexes({ list: [10, 20, 30], items: [88, 99], indexes: [1, 2], clone: true });
```
- Definiert in bitbybit-docs.d.ts:54463

addItem

addItem<T>(inputs: AddItemDto<T>): T[]
Fügt ein Element am Ende der Liste hinzu.

Beispiel: [10, 20, 30] Hinzufügen von 40 -> [10, 20, 30, 40]
Typenparameter
- T
Parameter
- inputs: AddItemDto<T>
  Die Liste, das Element und ob kopiert wird
Rückgabewert T[]
Die Liste mit dem Element an ihrem Ende
Example
```
const longer = bitbybit.lists.addItem({ list: [10, 20, 30], item: 40, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54626

prependItem

prependItem<T>(inputs: AddItemDto<T>): T[]
Fügt ein Element am Anfang der Liste hinzu.

Beispiel: [10, 20, 30] Voranstellen von 5 -> [5, 10, 20, 30]
Typenparameter
- T
Parameter
- inputs: AddItemDto<T>
  Die Liste, das Element und ob kopiert wird
Rückgabewert T[]
Die Liste mit dem Element an ihrem Anfang
Example
```
const longer = bitbybit.lists.prependItem({ list: [10, 20, 30], item: 5, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54641

addItemFirstLast

addItemFirstLast<T>(inputs: AddItemFirstLastDto<T>): T[]
Fügt ein Element am Anfang oder am Ende der Liste hinzu, wie gewählt.

Beispiel: [10, 20, 30] Hinzufügen von 5 zuerst -> [5, 10, 20, 30]; zuletzt -> [10, 20, 30, 5]
Typenparameter
- T
Parameter
- inputs: AddItemFirstLastDto<T>
  Die Liste, das Element, die Position und ob kopiert wird
Rückgabewert T[]
Die Liste mit dem hinzugefügten Element
Example
```
const longer = bitbybit.lists.addItemFirstLast({ list: [10, 20, 30], item: 5, position: Bit.Inputs.Lists.firstLastEnum.first, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54656

concatenate

concatenate<T>(inputs: ConcatenateDto<T>): T[]
Verbindet mehrere Listen zu einer, Ende an Ende.

Beispiel: [[1, 2], [3, 4], [5, 6]] -> [1, 2, 3, 4, 5, 6]
Typenparameter
- T
Parameter
- inputs: ConcatenateDto<T>
  Die zu verbindenden Listen und ob kopiert wird
Rückgabewert T[]
Eine Liste mit allen Elementen
Example
```
const all = bitbybit.lists.concatenate({ lists: [[1, 2], [3, 4], [5, 6]], clone: true });
```
- Definiert in bitbybit-docs.d.ts:54671

create

createEmptyList

createEmptyList(): []
Erstellt eine neue Liste ohne Inhalt.

Beispiel: -> []

Rückgabewert []
Eine leere Liste
- Definiert in bitbybit-docs.d.ts:54681

repeat

repeat<T>(inputs: MultiplyItemDto<T>): T[]
Erstellt eine Liste, die dasselbe Element mehrmals enthält.

Beispiel: 5 dreimal -> [5, 5, 5]
Typenparameter
- T
Parameter
- inputs: MultiplyItemDto<T>
  Das Element und wie oft es wiederholt wird
Rückgabewert T[]
Die Liste der Wiederholungen
Example
```
const fives = bitbybit.lists.repeat({ item: 5, times: 3 });
```
- Definiert in bitbybit-docs.d.ts:54696

repeatInPattern

repeatInPattern<T>(inputs: RepeatInPatternDto<T>): T[]
Wiederholt ein Muster von Elementen immer wieder, bis die Liste eine gegebene Länge erreicht.

Beispiel: [1, 2, 3] auf Länge 7 -> [1, 2, 3, 1, 2, 3, 1]
Typenparameter
- T
Parameter
- inputs: RepeatInPatternDto<T>
  Das Muster, die zu erreichende Länge und ob kopiert wird
Rückgabewert T[]
Das wiederholte Muster, auf die Länge zugeschnitten
Example
```
const cycle = bitbybit.lists.repeatInPattern({ list: [1, 2, 3], lengthLimit: 7, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54711

edit

reverse

reverse<T>(inputs: ListCloneDto<T>): T[]
Kehrt die Reihenfolge der Elemente um.

Beispiel: [1, 2, 3, 4, 5] -> [5, 4, 3, 2, 1]
Typenparameter
- T
Parameter
- inputs: ListCloneDto<T>
  Die Liste und ob sie zuerst kopiert wird
Rückgabewert T[]
Die umgekehrte Liste
- Definiert in bitbybit-docs.d.ts:54318

shuffle

shuffle<T>(inputs: ListCloneDto<T>): T[]
Bringt die Elemente in eine zufällige Reihenfolge, bei jedem Aufruf anders.

Beispiel: [1, 2, 3, 4, 5] -> vielleicht [3, 1, 5, 2, 4]
Typenparameter
- T
Parameter
- inputs: ListCloneDto<T>
  Die Liste und ob sie zuerst kopiert wird
Rückgabewert T[]
Die gemischte Liste
- Definiert in bitbybit-docs.d.ts:54329

flipLists

flipLists<T>(inputs: ListCloneDto<T[]>): T[][]
Kippt eine Liste von Listen auf die Seite: Zeilen werden zu Spalten und Spalten zu Zeilen.

Alle inneren Listen müssen gleich lang sein. Beispiel: [[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]
Typenparameter
- T
Parameter
- inputs: ListCloneDto<T[]>
  Die Liste von Listen und ob sie zuerst kopiert wird
Rückgabewert T[][]
Die transponierte Liste von Listen
Example
```
const columns = bitbybit.lists.flipLists({ list: [[0, 1, 2], [3, 4, 5]], clone: true });
```
- Definiert in bitbybit-docs.d.ts:54345

groupNth

groupNth<T>(inputs: GroupListDto<T>): T[][]
Teilt die Liste in Gruppen von n Elementen.

Am Ende übrig bleibende Elemente werden verworfen, sofern keepRemainder nicht an ist, was sie als kürzere letzte Gruppe hinzufügt. Beispiel: [0, 1, 2, 3, 4, 5, 6, 7, 8] in Gruppen von 3 -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
Typenparameter
- T
Parameter
- inputs: GroupListDto<T>
  Die Liste, die Gruppengröße und ob eine unvollständige letzte Gruppe behalten wird
Rückgabewert T[][]
Die Gruppen, in Reihenfolge
Example
```
const pairs = bitbybit.lists.groupNth({ list: [0, 1, 2, 3, 4], nrElements: 2, keepRemainder: true });
```
- Definiert in bitbybit-docs.d.ts:54362

get

getItem

getItem<T>(inputs: ListItemDto<T>): T
Liest das Element an einer Position in der Liste, gezählt ab 0.

Ein Index außerhalb der Liste löst einen Fehler aus. Beispiel: [10, 20, 30, 40] bei Index 2 -> 30
Typenparameter
- T
Parameter
- inputs: ListItemDto<T>
  Die Liste, der Index und ob das Element kopiert wird
Rückgabewert T
Das Element an diesem Index
Example
```
const third = bitbybit.lists.getItem({ list: [10, 20, 30, 40], index: 2, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54189

getFirstItem

getFirstItem<T>(inputs: ListCloneDto<T>): T
Liest das erste Element der Liste.

Beispiel: [10, 20, 30, 40] -> 10
Typenparameter
- T
Parameter
- inputs: ListCloneDto<T>
  Die Liste und ob das Element kopiert wird
Rückgabewert T
Das erste Element
- Definiert in bitbybit-docs.d.ts:54200

getLastItem

getLastItem<T>(inputs: ListCloneDto<T>): T
Liest das letzte Element der Liste.

Beispiel: [10, 20, 30, 40] -> 40
Typenparameter
- T
Parameter
- inputs: ListCloneDto<T>
  Die Liste und ob das Element kopiert wird
Rückgabewert T
Das letzte Element
- Definiert in bitbybit-docs.d.ts:54211

randomGetThreshold

randomGetThreshold<T>(inputs: RandomThresholdDto<T>): T[]
Behält jedes Element der Liste mit einer gegebenen Wahrscheinlichkeit und verwirft den Rest, sodass das Ergebnis bei jedem Aufruf anders ist.

Beispiel: [1, 2, 3, 4, 5] mit Schwellenwert 0.5 -> vielleicht [1, 3, 5]
Typenparameter
- T
Parameter
- inputs: RandomThresholdDto<T>
  Die Liste, die Wahrscheinlichkeit von 0 bis 1, ein Element zu behalten, und ob kopiert wird
Rückgabewert T[]
Die behaltenen Elemente, in ihrer ursprünglichen Reihenfolge
Example
```
const some = bitbybit.lists.randomGetThreshold({ list: [1, 2, 3, 4, 5], threshold: 0.5, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54227

getSubList

getSubList<T>(inputs: SubListDto<T>): T[]
Schneidet die Elemente von einem Startindex bis, aber ohne, einen Endindex heraus.

Beispiel: [10, 20, 30, 40, 50] von 1 bis 4 -> [20, 30, 40]
Typenparameter
- T
Parameter
- inputs: SubListDto<T>
  Die Liste, der Start- und der Endindex und ob kopiert wird
Rückgabewert T[]
Die Elemente in diesem Bereich
Example
```
const middle = bitbybit.lists.getSubList({ list: [10, 20, 30, 40, 50], indexStart: 1, indexEnd: 4, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54242

getNthItem

getNthItem<T>(inputs: GetNthItemDto<T>): T[]
Behält jedes n-te Element, beginnend bei einem Versatz.

Beispiel: [0, 1, 2, 3, 4, 5, 6, 7, 8] mit nth 3 und Versatz 0 -> [0, 3, 6]; mit nth 2 und Versatz 1 -> [1, 3, 5, 7]
Typenparameter
- T
Parameter
- inputs: GetNthItemDto<T>
  Die Liste, die Schrittweite, der Versatz, ab dem begonnen wird, und ob kopiert wird
Rückgabewert T[]
Jedes n-te Element, in Reihenfolge
Example
```
const everyThird = bitbybit.lists.getNthItem({ list: [0, 1, 2, 3, 4, 5, 6, 7, 8], nth: 3, offset: 0, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54258

getByPattern

getByPattern<T>(inputs: GetByPatternDto<T>): T[]
Behält die Elemente, bei denen ein sich wiederholendes true/false-Muster true sagt, und verwirft die anderen.

Das Muster beginnt von vorn, wenn es zu Ende ist. Beispiel: [0, 1, 2, 3, 4, 5] mit Muster [true, true, false] -> [0, 1, 3, 4]
Typenparameter
- T
Parameter
- inputs: GetByPatternDto<T>
  Die Liste und das Muster
Rückgabewert T[]
Die vom Muster behaltenen Elemente, in Reihenfolge
Example
```
const kept = bitbybit.lists.getByPattern({ list: [0, 1, 2, 3, 4, 5], pattern: [true, true, false] });
```
- Definiert in bitbybit-docs.d.ts:54274

mergeElementsOfLists

mergeElementsOfLists<T>(inputs: MergeElementsOfLists<T[]>): T[]
Gruppiert verschachtelte Listen nach Position neu: die ersten Elemente jeder Liste kommen zusammen, dann die zweiten Elemente, und so weiter.

level sagt, wie viele Verschachtelungsebenen in jeder Liste zuerst abgeflacht werden; 0 gruppiert sie neu, wie sie sind. Beispiel: [[0, 1, 2], [3, 4, 5]] bei Ebene 0 -> [[0, 3], [1, 4], [2, 5]]
Typenparameter
- T
Parameter
- inputs: MergeElementsOfLists<T[]>
  Die Listen und die Tiefe, auf der neu gruppiert wird
Rückgabewert T[]
Die neu gruppierten Listen
Example
```
const columns = bitbybit.lists.mergeElementsOfLists({ lists: [[0, 1, 2], [3, 4, 5]], level: 0 });
```
- Definiert in bitbybit-docs.d.ts:54292

getLongestListLength

getLongestListLength<T>(inputs: GetLongestListLength<T[]>): number
Misst die längste Liste unter mehreren.

Beispiel: [[1, 2], [3, 4, 5, 6], [7]] -> 4
Typenparameter
- T
Parameter
- inputs: GetLongestListLength<T[]>
  Die zu messenden Listen
Rückgabewert number
Die Länge der längsten
Example
```
const longest = bitbybit.lists.getLongestListLength({ lists: [[1, 2], [3, 4, 5, 6], [7]] });
```
- Definiert in bitbybit-docs.d.ts:54307

includes

includes<T>(inputs: IncludesDto<T>): boolean
Sagt, ob ein Element in der Liste ist.

Elemente werden nach Identität verglichen, daher wird ein Objekt nur gefunden, wenn genau dasselbe Objekt in der Liste ist. Beispiel: [10, 20, 30, 40] enthält 30 -> true, enthält 50 -> false
Typenparameter
- T
Parameter
- inputs: IncludesDto<T>
  Die Liste und das gesuchte Element
Rückgabewert boolean
True, wenn das Element in der Liste ist
Example
```
const found = bitbybit.lists.includes({ list: [10, 20, 30, 40], item: 30 });
```
- Definiert in bitbybit-docs.d.ts:54379

findIndex

findIndex<T>(inputs: IncludesDto<T>): number
Ermittelt die Position des ersten Vorkommens eines Elements, oder -1, wenn es nicht in der Liste ist.

Beispiel: [10, 20, 30, 20, 40] Suche nach 20 -> 1, Suche nach 50 -> -1
Typenparameter
- T
Parameter
- inputs: IncludesDto<T>
  Die Liste und das gesuchte Element
Rückgabewert number
Der 0-basierte Index oder -1
Example
```
const where = bitbybit.lists.findIndex({ list: [10, 20, 30, 20, 40], item: 20 });
```
- Definiert in bitbybit-docs.d.ts:54394

getListDepth

getListDepth(inputs: ListCloneDto<[]>): number
Misst, wie tief Listen in der Liste verschachtelt sind.

Beispiel: [1, 2, 3] -> 1, [[1, 2], [3, 4]] -> 2, [[[1]]] -> 3
Parameter
- inputs: ListCloneDto<[]>
  Die Liste
Rückgabewert number
Die Anzahl der Verschachtelungsebenen
- Definiert in bitbybit-docs.d.ts:54405

listLength

listLength<T>(inputs: ListCloneDto<T>): number
Zählt die Elemente in der Liste.

Beispiel: [10, 20, 30, 40, 50] -> 5, [] -> 0
Typenparameter
- T
Parameter
- inputs: ListCloneDto<T>
  Die Liste
Rückgabewert number
Die Anzahl der Elemente
- Definiert in bitbybit-docs.d.ts:54416

remove

removeItemAtIndex

removeItemAtIndex<T>(inputs: RemoveItemAtIndexDto<T>): T[]
Entfernt das Element an einer Position.

Beispiel: [10, 20, 30, 40, 50] Entfernen von Index 2 -> [10, 20, 40, 50]
Typenparameter
- T
Parameter
- inputs: RemoveItemAtIndexDto<T>
  Die Liste, der Index und ob kopiert wird
Rückgabewert T[]
Die Liste ohne dieses Element
Example
```
const shorter = bitbybit.lists.removeItemAtIndex({ list: [10, 20, 30, 40, 50], index: 2, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54478

removeFirstItem

removeFirstItem<T>(inputs: ListCloneDto<T>): T[]
Entfernt das erste Element.

Beispiel: [10, 20, 30, 40] -> [20, 30, 40]
Typenparameter
- T
Parameter
- inputs: ListCloneDto<T>
  Die Liste und ob sie zuerst kopiert wird
Rückgabewert T[]
Die Liste ohne ihr erstes Element
- Definiert in bitbybit-docs.d.ts:54489

removeLastItem

removeLastItem<T>(inputs: ListCloneDto<T>): T[]
Entfernt das letzte Element.

Beispiel: [10, 20, 30, 40] -> [10, 20, 30]
Typenparameter
- T
Parameter
- inputs: ListCloneDto<T>
  Die Liste und ob sie zuerst kopiert wird
Rückgabewert T[]
Die Liste ohne ihr letztes Element
- Definiert in bitbybit-docs.d.ts:54500

removeItemAtIndexFromEnd

removeItemAtIndexFromEnd<T>(inputs: RemoveItemAtIndexDto<T>): T[]
Entfernt ein vom Ende her gezähltes Element: Index 0 ist das letzte Element, 1 das davor.

Beispiel: [10, 20, 30, 40, 50] Entfernen von Index 1 vom Ende -> [10, 20, 30, 50]
Typenparameter
- T
Parameter
- inputs: RemoveItemAtIndexDto<T>
  Die Liste, der Index vom Ende aus und ob kopiert wird
Rückgabewert T[]
Die Liste ohne dieses Element
Example
```
const shorter = bitbybit.lists.removeItemAtIndexFromEnd({ list: [10, 20, 30, 40, 50], index: 1, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54515

removeItemsAtIndexes

removeItemsAtIndexes<T>(inputs: RemoveItemsAtIndexesDto<T>): T[]
Entfernt die Elemente an mehreren Positionen, alle auf der ursprünglichen Liste gezählt.

Beispiel: [10, 20, 30, 40, 50] Entfernen der Indizes [1, 3] -> [10, 30, 50]
Typenparameter
- T
Parameter
- inputs: RemoveItemsAtIndexesDto<T>
  Die Liste, die Indizes und ob kopiert wird
Rückgabewert T[]
Die Liste ohne diese Elemente
Example
```
const kept = bitbybit.lists.removeItemsAtIndexes({ list: [10, 20, 30, 40, 50], indexes: [1, 3], clone: true });
```
- Definiert in bitbybit-docs.d.ts:54530

removeAllItems

removeAllItems<T>(inputs: ListDto<T>): T[]
Leert die übergebene Liste an Ort und Stelle: dasselbe Array kommt ohne Elemente zurück.

Beispiel: [10, 20, 30, 40] -> []
Typenparameter
- T
Parameter
- inputs: ListDto<T>
  Die zu leerende Liste
Rückgabewert T[]
Dieselbe Liste, jetzt leer
- Definiert in bitbybit-docs.d.ts:54541

removeNthItem

removeNthItem<T>(inputs: RemoveNthItemDto<T>): T[]
Entfernt jedes n-te Element, beginnend bei einem Versatz.

Beispiel: [0, 1, 2, 3, 4, 5, 6, 7, 8] mit nth 3 und Versatz 0 -> [1, 2, 4, 5, 7, 8]
Typenparameter
- T
Parameter
- inputs: RemoveNthItemDto<T>
  Die Liste, die Schrittweite, der Versatz, ab dem begonnen wird, und ob kopiert wird
Rückgabewert T[]
Die Liste ohne jedes n-te Element
Example
```
const thinned = bitbybit.lists.removeNthItem({ list: [0, 1, 2, 3, 4, 5, 6, 7, 8], nth: 3, offset: 0, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54556

randomRemoveThreshold

randomRemoveThreshold<T>(inputs: RandomThresholdDto<T>): T[]
Verwirft jedes Element der Liste mit einer gegebenen Wahrscheinlichkeit und behält den Rest, sodass das Ergebnis bei jedem Aufruf anders ist.

Beispiel: [1, 2, 3, 4, 5] mit Schwellenwert 0.5 -> vielleicht [2, 4]
Typenparameter
- T
Parameter
- inputs: RandomThresholdDto<T>
  Die Liste, die Wahrscheinlichkeit von 0 bis 1, ein Element zu entfernen, und ob kopiert wird
Rückgabewert T[]
Die übrig gebliebenen Elemente, in ihrer ursprünglichen Reihenfolge
Example
```
const some = bitbybit.lists.randomRemoveThreshold({ list: [1, 2, 3, 4, 5], threshold: 0.5, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54572

removeDuplicateNumbers

removeDuplicateNumbers(inputs: RemoveDuplicatesDto<number>): number[]
Entfernt wiederholte Zahlen und behält das erste Vorkommen jeder.

Beispiel: [1, 2, 3, 2, 4, 3, 5] -> [1, 2, 3, 4, 5]
Parameter
- inputs: RemoveDuplicatesDto<number>
  Die Zahlen und ob kopiert wird
Rückgabewert number[]
Die Zahlen ohne Wiederholungen, in ihrer ursprünglichen Reihenfolge
- Definiert in bitbybit-docs.d.ts:54583

removeDuplicateNumbersTolerance

removeDuplicateNumbersTolerance(
inputs: RemoveDuplicatesToleranceDto<number>,
): number[]
Entfernt Zahlen, die innerhalb einer Toleranz zu einer bereits behaltenen liegen, sodass Werte, die sich nur durch Gleitkommarauschen unterscheiden, als gleich gelten.

Beispiel: [1.0, 1.001, 2.0, 2.002, 3.0] mit Toleranz 0.01 -> [1.0, 2.0, 3.0]
Parameter
- inputs: RemoveDuplicatesToleranceDto<number>
  Die Zahlen, die Toleranz und ob kopiert wird
Rückgabewert number[]
Die Zahlen ohne Beinahe-Wiederholungen, in ihrer ursprünglichen Reihenfolge
Example
```
const distinct = bitbybit.lists.removeDuplicateNumbersTolerance({ list: [1.0, 1.001, 2.0], tolerance: 0.01, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54599

removeDuplicates

removeDuplicates<T>(inputs: RemoveDuplicatesDto<T>): T[]
Entfernt wiederholte Elemente beliebiger Art und behält das erste Vorkommen jedes.

Elemente werden nach Identität verglichen, daher bleiben zwei gleich aussehende Objekte beide. Beispiel: ['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']
Typenparameter
- T
Parameter
- inputs: RemoveDuplicatesDto<T>
  Die Liste und ob kopiert wird
Rückgabewert T[]
Die Liste ohne Wiederholungen, in ihrer ursprünglichen Reihenfolge
- Definiert in bitbybit-docs.d.ts:54611

sorting

sortNumber

sortNumber(inputs: SortDto<number>): number[]
Sortiert Zahlen von der niedrigsten zur höchsten oder von der höchsten zur niedrigsten.

Beispiel: [5, 2, 8, 1, 9] aufsteigend -> [1, 2, 5, 8, 9]; absteigend -> [9, 8, 5, 2, 1]
Parameter
- inputs: SortDto<number>
  Die Zahlen, die Richtung und ob kopiert wird
Rückgabewert number[]
Die sortierten Zahlen
Example
```
const sorted = bitbybit.lists.sortNumber({ list: [5, 2, 8, 1, 9], orderAsc: true, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54726

sortTexts

sortTexts(inputs: SortDto<string>): string[]
Sortiert Texte alphabetisch, von A bis Z oder von Z bis A.

Beispiel: ['dog', 'apple', 'cat'] aufsteigend -> ['apple', 'cat', 'dog']
Parameter
- inputs: SortDto<string>
  Die Texte, die Richtung und ob kopiert wird
Rückgabewert string[]
Die sortierten Texte
Example
```
const sorted = bitbybit.lists.sortTexts({ list: ["dog", "apple", "cat"], orderAsc: true, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54741

sortByPropValue

sortByPropValue(inputs: SortJsonDto<any>): any[]
Sortiert Objekte nach der Zahl in einer ihrer Eigenschaften.

Beispiel: [{age: 30}, {age: 20}, {age: 25}] nach 'age' aufsteigend -> [{age: 20}, {age: 25}, {age: 30}]
Parameter
- inputs: SortJsonDto<any>
  Die Objekte, die Eigenschaft, nach der sortiert wird, die Richtung und ob kopiert wird
Rückgabewert any[]
Die sortierten Objekte
Example
```
const byAge = bitbybit.lists.sortByPropValue({ list: [{ age: 30 }, { age: 20 }], property: "age", orderAsc: true, clone: true });
```
- Definiert in bitbybit-docs.d.ts:54757

transform

interleave

interleave<T>(inputs: InterleaveDto<T>): T[]
Verflicht mehrere Listen zu einer, indem der Reihe nach das erste Element jeder genommen wird, dann das zweite jeder, und so weiter.

Eine kürzere Liste fällt einfach weg, sobald sie erschöpft ist. Eine leere Liste von Listen löst einen Fehler aus. Beispiel: [[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]
Typenparameter
- T
Parameter
- inputs: InterleaveDto<T>
  Die zu verflechtenden Listen und ob kopiert wird
Rückgabewert T[]
Eine Liste mit den Elementen im Wechsel
Example
```
const woven = bitbybit.lists.interleave({ lists: [[0, 1, 2], [3, 4, 5]], clone: true });
```
- Definiert in bitbybit-docs.d.ts:54774

Klasse Lists

Index

Konstruktoren

add

create

edit

get

remove

sorting

transform

Konstruktoren

constructor

Rückgabewert Bit.Lists

add

addItemAtIndex

Typenparameter

Parameter

Rückgabewert T[]

Example

addItemAtIndexes

Typenparameter

Parameter

Rückgabewert T[]

Example

addItemsAtIndexes

Typenparameter

Parameter

Rückgabewert T[]

Example

addItem

Typenparameter

Parameter

Rückgabewert T[]

Example

prependItem

Typenparameter

Parameter

Rückgabewert T[]

Example

addItemFirstLast

Typenparameter

Parameter

Rückgabewert T[]

Example

concatenate

Typenparameter

Parameter

Rückgabewert T[]

Example

create

createEmptyList

Rückgabewert []

repeat

Typenparameter

Parameter

Rückgabewert T[]

Example

repeatInPattern

Typenparameter

Parameter

Rückgabewert T[]

Example

edit

reverse

Typenparameter

Parameter

Rückgabewert T[]

shuffle

Typenparameter

Parameter

Rückgabewert T[]

flipLists

Typenparameter

Parameter

Rückgabewert T[][]

Example

groupNth

Typenparameter

Parameter

Rückgabewert T[][]