Class Lists

किसी भी प्रकार के आइटम के सादे एरे को पढ़ना, बनाना और पुनर्गठित करना। स्थितियाँ 0-आधारित हैं: इंडेक्स 0 पहला आइटम है। अधिकांश मेथड एक clone विकल्प लेते हैं, जो डिफ़ॉल्ट रूप से चालू है, जो पहले सूची की डीप-कॉपी बनाता है ताकि इनपुट कभी न बदले; बंद होने पर, संशोधन करने वाले मेथड सूची पर उसी जगह काम करते हैं, जो बड़े डेटा के लिए तेज़ है। removeAllItems हमेशा दी गई सूची को खाली करता है।

Constructors

constructor

new Lists(): Bit.Lists
Returns Bit.Lists

add

addItemAtIndex

addItemAtIndex<T>(inputs: AddItemAtIndexDto<T>): T[]
किसी स्थिति पर आइटम डालता है; उस स्थिति से आगे के आइटम एक-एक ऊपर खिसकते हैं।

उदाहरण: [10, 20, 30, 40] में 99 इंडेक्स 2 पर -> [10, 20, 99, 30, 40]
Type Parameters
- T
Parameters
- inputs: AddItemAtIndexDto<T>
  सूची, आइटम, इंडेक्स और क्या प्रतिलिपि बनानी है
Returns T[]
आइटम डाली हुई सूची
Example
```
const longer = bitbybit.lists.addItemAtIndex({ list: [10, 20, 30, 40], item: 99, index: 2, clone: true });
```
- Defined in bitbybit-docs.d.ts:54431

addItemAtIndexes

addItemAtIndexes<T>(inputs: AddItemAtIndexesDto<T>): T[]
मूल सूची की कई स्थितियों पर एक ही आइटम डालता है।

उदाहरण: [10, 20, 30] में 99 इंडेक्स [0, 2] पर -> [99, 10, 20, 99, 30]
Type Parameters
- T
Parameters
- inputs: AddItemAtIndexesDto<T>
  सूची, आइटम, इंडेक्स और क्या प्रतिलिपि बनानी है
Returns T[]
प्रत्येक इंडेक्स पर आइटम डाली हुई सूची
Example
```
const marked = bitbybit.lists.addItemAtIndexes({ list: [10, 20, 30], item: 99, indexes: [0, 2], clone: true });
```
- Defined in bitbybit-docs.d.ts:54446

addItemsAtIndexes

addItemsAtIndexes<T>(inputs: AddItemsAtIndexesDto<T>): T[]
कई आइटम डालता है, पहला पहले इंडेक्स पर, दूसरा दूसरे पर, और इसी तरह आगे, सभी मूल सूची पर गिने हुए।

इंडेक्स बढ़ते क्रम में होने चाहिए और प्रति आइटम एक होना चाहिए, अन्यथा त्रुटि फेंकी जाती है। उदाहरण: [10, 20, 30] में आइटम [88, 99] इंडेक्स [1, 2] पर -> [10, 88, 20, 99, 30]
Type Parameters
- T
Parameters
- inputs: AddItemsAtIndexesDto<T>
  सूची, आइटम, प्रत्येक आइटम के लिए एक इंडेक्स और क्या प्रतिलिपि बनानी है
Returns T[]
आइटम डाली हुई सूची
Example
```
const merged = bitbybit.lists.addItemsAtIndexes({ list: [10, 20, 30], items: [88, 99], indexes: [1, 2], clone: true });
```
- Defined in bitbybit-docs.d.ts:54463

addItem

addItem<T>(inputs: AddItemDto<T>): T[]
सूची के अंत में आइटम जोड़ता है।

उदाहरण: [10, 20, 30] में 40 जोड़ने पर -> [10, 20, 30, 40]
Type Parameters
- T
Parameters
- inputs: AddItemDto<T>
  सूची, आइटम और क्या प्रतिलिपि बनानी है
Returns T[]
अंत में आइटम जोड़ी हुई सूची
Example
```
const longer = bitbybit.lists.addItem({ list: [10, 20, 30], item: 40, clone: true });
```
- Defined in bitbybit-docs.d.ts:54626

prependItem

prependItem<T>(inputs: AddItemDto<T>): T[]
सूची की शुरुआत में आइटम जोड़ता है।

उदाहरण: [10, 20, 30] में 5 आगे जोड़ने पर -> [5, 10, 20, 30]
Type Parameters
- T
Parameters
- inputs: AddItemDto<T>
  सूची, आइटम और क्या प्रतिलिपि बनानी है
Returns T[]
शुरू में आइटम जोड़ी हुई सूची
Example
```
const longer = bitbybit.lists.prependItem({ list: [10, 20, 30], item: 5, clone: true });
```
- Defined in bitbybit-docs.d.ts:54641

addItemFirstLast

addItemFirstLast<T>(inputs: AddItemFirstLastDto<T>): T[]
सूची की शुरुआत या अंत में आइटम जोड़ता है, जैसा चुना गया हो।

उदाहरण: [10, 20, 30] में 5 पहले जोड़ने पर -> [5, 10, 20, 30]; अंत में -> [10, 20, 30, 5]
Type Parameters
- T
Parameters
- inputs: AddItemFirstLastDto<T>
  सूची, आइटम, स्थिति और क्या प्रतिलिपि बनानी है
Returns T[]
आइटम जोड़ी हुई सूची
Example
```
const longer = bitbybit.lists.addItemFirstLast({ list: [10, 20, 30], item: 5, position: Bit.Inputs.Lists.firstLastEnum.first, clone: true });
```
- Defined in bitbybit-docs.d.ts:54656

concatenate

concatenate<T>(inputs: ConcatenateDto<T>): T[]
कई सूचियों को सिरे से सिरे एक में जोड़ता है।

उदाहरण: [[1, 2], [3, 4], [5, 6]] -> [1, 2, 3, 4, 5, 6]
Type Parameters
- T
Parameters
- inputs: ConcatenateDto<T>
  जोड़ी जाने वाली सूचियाँ और क्या प्रतिलिपि बनानी है
Returns T[]
सभी आइटमों वाली एक सूची
Example
```
const all = bitbybit.lists.concatenate({ lists: [[1, 2], [3, 4], [5, 6]], clone: true });
```
- Defined in bitbybit-docs.d.ts:54671

create

createEmptyList

createEmptyList(): []
बिना कुछ रखे नई सूची बनाता है।

उदाहरण: -> []

Returns []
एक खाली सूची
- Defined in bitbybit-docs.d.ts:54681

repeat

repeat<T>(inputs: MultiplyItemDto<T>): T[]
ऐसी सूची बनाता है जिसमें वही आइटम कई बार हो।

उदाहरण: 5 तीन बार -> [5, 5, 5]
Type Parameters
- T
Parameters
- inputs: MultiplyItemDto<T>
  आइटम और उसे कितनी बार दोहराना है
Returns T[]
दोहरावों की सूची
Example
```
const fives = bitbybit.lists.repeat({ item: 5, times: 3 });
```
- Defined in bitbybit-docs.d.ts:54696

repeatInPattern

repeatInPattern<T>(inputs: RepeatInPatternDto<T>): T[]
आइटम के पैटर्न को बार-बार दोहराता है जब तक सूची दी गई लंबाई तक न पहुँच जाए।

उदाहरण: [1, 2, 3] लंबाई 7 तक -> [1, 2, 3, 1, 2, 3, 1]
Type Parameters
- T
Parameters
- inputs: RepeatInPatternDto<T>
  पैटर्न, वह लंबाई जहाँ तक पहुँचना है और क्या प्रतिलिपि बनानी है
Returns T[]
दोहराया गया पैटर्न, लंबाई तक काटा हुआ
Example
```
const cycle = bitbybit.lists.repeatInPattern({ list: [1, 2, 3], lengthLimit: 7, clone: true });
```
- Defined in bitbybit-docs.d.ts:54711

edit

reverse

reverse<T>(inputs: ListCloneDto<T>): T[]
आइटम का क्रम उलटता है।

उदाहरण: [1, 2, 3, 4, 5] -> [5, 4, 3, 2, 1]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  सूची और क्या पहले उसकी प्रतिलिपि बनानी है
Returns T[]
उलटी सूची
- Defined in bitbybit-docs.d.ts:54318

shuffle

shuffle<T>(inputs: ListCloneDto<T>): T[]
आइटम को यादृच्छिक क्रम में रखता है, हर कॉल पर अलग।

उदाहरण: [1, 2, 3, 4, 5] -> शायद [3, 1, 5, 2, 4]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  सूची और क्या पहले उसकी प्रतिलिपि बनानी है
Returns T[]
फेंटी गई सूची
- Defined in bitbybit-docs.d.ts:54329

flipLists

flipLists<T>(inputs: ListCloneDto<T[]>): T[][]
सूचियों की सूची को करवट देता है: पंक्तियाँ कॉलम बन जाती हैं और कॉलम पंक्तियाँ।

सभी भीतरी सूचियों की लंबाई समान होनी चाहिए। उदाहरण: [[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T[]>
  सूचियों की सूची और क्या पहले उसकी प्रतिलिपि बनानी है
Returns T[][]
सूचियों की ट्रांसपोज़ की गई सूची
Example
```
const columns = bitbybit.lists.flipLists({ list: [[0, 1, 2], [3, 4, 5]], clone: true });
```
- Defined in bitbybit-docs.d.ts:54345

groupNth

groupNth<T>(inputs: GroupListDto<T>): T[][]
सूची को n आइटम के समूहों में बाँटता है।

अंत में बचे आइटम हटा दिए जाते हैं जब तक keepRemainder चालू न हो, जो उन्हें छोटे अंतिम समूह के रूप में जोड़ता है। उदाहरण: [0, 1, 2, 3, 4, 5, 6, 7, 8] 3 के समूहों में -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
Type Parameters
- T
Parameters
- inputs: GroupListDto<T>
  सूची, समूह का आकार और क्या आंशिक अंतिम समूह रखना है
Returns T[][]
समूह, क्रम में
Example
```
const pairs = bitbybit.lists.groupNth({ list: [0, 1, 2, 3, 4], nrElements: 2, keepRemainder: true });
```
- Defined in bitbybit-docs.d.ts:54362

get

getItem

getItem<T>(inputs: ListItemDto<T>): T
सूची में किसी स्थिति का आइटम पढ़ता है, 0 से गिनते हुए।

सूची के बाहर का इंडेक्स त्रुटि फेंकता है। उदाहरण: [10, 20, 30, 40] इंडेक्स 2 पर -> 30
Type Parameters
- T
Parameters
- inputs: ListItemDto<T>
  सूची, इंडेक्स और क्या आइटम की प्रतिलिपि बनानी है
Returns T
उस इंडेक्स पर का आइटम
Example
```
const third = bitbybit.lists.getItem({ list: [10, 20, 30, 40], index: 2, clone: true });
```
- Defined in bitbybit-docs.d.ts:54189

getFirstItem

getFirstItem<T>(inputs: ListCloneDto<T>): T
सूची का पहला आइटम पढ़ता है।

उदाहरण: [10, 20, 30, 40] -> 10
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  सूची और क्या आइटम की प्रतिलिपि बनानी है
Returns T
पहला आइटम
- Defined in bitbybit-docs.d.ts:54200

getLastItem

getLastItem<T>(inputs: ListCloneDto<T>): T
सूची का अंतिम आइटम पढ़ता है।

उदाहरण: [10, 20, 30, 40] -> 40
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  सूची और क्या आइटम की प्रतिलिपि बनानी है
Returns T
अंतिम आइटम
- Defined in bitbybit-docs.d.ts:54211

randomGetThreshold

randomGetThreshold<T>(inputs: RandomThresholdDto<T>): T[]
सूची के हर आइटम को दी गई संभावना से रखता है और बाकी हटाता है, इसलिए परिणाम हर कॉल पर अलग होता है।

उदाहरण: [1, 2, 3, 4, 5] सीमा 0.5 के साथ -> शायद [1, 3, 5]
Type Parameters
- T
Parameters
- inputs: RandomThresholdDto<T>
  सूची, किसी आइटम को रखने की 0 से 1 तक की प्रायिकता, और क्या प्रतिलिपि बनानी है
Returns T[]
रखे गए आइटम, अपने मूल क्रम में
Example
```
const some = bitbybit.lists.randomGetThreshold({ list: [1, 2, 3, 4, 5], threshold: 0.5, clone: true });
```
- Defined in bitbybit-docs.d.ts:54227

getSubList

getSubList<T>(inputs: SubListDto<T>): T[]
शुरुआती इंडेक्स से अंतिम इंडेक्स तक के, पर उसे छोड़कर, आइटम काटकर निकालता है।

उदाहरण: [10, 20, 30, 40, 50] 1 से 4 तक -> [20, 30, 40]
Type Parameters
- T
Parameters
- inputs: SubListDto<T>
  सूची, आरंभ और अंत इंडेक्स, और क्या प्रतिलिपि बनानी है
Returns T[]
उस रेंज के आइटम
Example
```
const middle = bitbybit.lists.getSubList({ list: [10, 20, 30, 40, 50], indexStart: 1, indexEnd: 4, clone: true });
```
- Defined in bitbybit-docs.d.ts:54242

getNthItem

getNthItem<T>(inputs: GetNthItemDto<T>): T[]
हर nवाँ आइटम रखता है, एक ऑफ़सेट से शुरू करते हुए।

उदाहरण: [0, 1, 2, 3, 4, 5, 6, 7, 8] nth 3 और ऑफ़सेट 0 के साथ -> [0, 3, 6]; nth 2 और ऑफ़सेट 1 के साथ -> [1, 3, 5, 7]
Type Parameters
- T
Parameters
- inputs: GetNthItemDto<T>
  सूची, स्टेप, वह ऑफसेट जहाँ से शुरू करना है, और क्या प्रतिलिपि बनानी है
Returns T[]
हर n-वाँ आइटम, क्रम में
Example
```
const everyThird = bitbybit.lists.getNthItem({ list: [0, 1, 2, 3, 4, 5, 6, 7, 8], nth: 3, offset: 0, clone: true });
```
- Defined in bitbybit-docs.d.ts:54258

getByPattern

getByPattern<T>(inputs: GetByPatternDto<T>): T[]
उन आइटम को रखता है जहाँ दोहराया जाने वाला true/false पैटर्न true कहता है और बाकी हटाता है।

पैटर्न खत्म होने पर फिर से शुरू होता है। उदाहरण: [0, 1, 2, 3, 4, 5] पैटर्न [true, true, false] के साथ -> [0, 1, 3, 4]
Type Parameters
- T
Parameters
- inputs: GetByPatternDto<T>
  सूची और पैटर्न
Returns T[]
पैटर्न द्वारा रखे गए आइटम, क्रम में
Example
```
const kept = bitbybit.lists.getByPattern({ list: [0, 1, 2, 3, 4, 5], pattern: [true, true, false] });
```
- Defined in bitbybit-docs.d.ts:54274

mergeElementsOfLists

mergeElementsOfLists<T>(inputs: MergeElementsOfLists<T[]>): T[]
नेस्टेड सूचियों को स्थिति के अनुसार फिर से समूहित करता है: हर सूची के पहले आइटम एक साथ जाते हैं, फिर दूसरे आइटम, और इसी तरह आगे।

level बताता है कि पहले हर सूची के भीतर नेस्टिंग के कितने स्तर सपाट किए जाएँ; 0 उन्हें जैसे हैं वैसे फिर से समूहित करता है। उदाहरण: [[0, 1, 2], [3, 4, 5]] स्तर 0 पर -> [[0, 3], [1, 4], [2, 5]]
Type Parameters
- T
Parameters
- inputs: MergeElementsOfLists<T[]>
  सूचियाँ और वह गहराई जिस पर पुनः समूहित करना है
Returns T[]
पुनः समूहित सूचियाँ
Example
```
const columns = bitbybit.lists.mergeElementsOfLists({ lists: [[0, 1, 2], [3, 4, 5]], level: 0 });
```
- Defined in bitbybit-docs.d.ts:54292

getLongestListLength

getLongestListLength<T>(inputs: GetLongestListLength<T[]>): number
कई सूचियों में से सबसे लंबी मापता है।

उदाहरण: [[1, 2], [3, 4, 5, 6], [7]] -> 4
Type Parameters
- T
Parameters
- inputs: GetLongestListLength<T[]>
  मापी जाने वाली सूचियाँ
Returns number
सबसे लंबी सूची की लंबाई
Example
```
const longest = bitbybit.lists.getLongestListLength({ lists: [[1, 2], [3, 4, 5, 6], [7]] });
```
- Defined in bitbybit-docs.d.ts:54307

includes

includes<T>(inputs: IncludesDto<T>): boolean
बताता है कि कोई आइटम सूची में है या नहीं।

आइटम की तुलना पहचान से होती है, इसलिए ऑब्जेक्ट तभी मिलता है जब ठीक वही ऑब्जेक्ट सूची में हो। उदाहरण: [10, 20, 30, 40] में 30 शामिल -> true, 50 शामिल -> false
Type Parameters
- T
Parameters
- inputs: IncludesDto<T>
  सूची और खोजा जाने वाला आइटम
Returns boolean
true जब आइटम सूची में हो
Example
```
const found = bitbybit.lists.includes({ list: [10, 20, 30, 40], item: 30 });
```
- Defined in bitbybit-docs.d.ts:54379

findIndex

findIndex<T>(inputs: IncludesDto<T>): number
किसी आइटम की पहली उपस्थिति की स्थिति खोजता है, या सूची में न होने पर -1।

उदाहरण: [10, 20, 30, 20, 40] में 20 खोजने पर -> 1, 50 खोजने पर -> -1
Type Parameters
- T
Parameters
- inputs: IncludesDto<T>
  सूची और खोजा जाने वाला आइटम
Returns number
0-आधारित इंडेक्स, या -1
Example
```
const where = bitbybit.lists.findIndex({ list: [10, 20, 30, 20, 40], item: 20 });
```
- Defined in bitbybit-docs.d.ts:54394

getListDepth

getListDepth(inputs: ListCloneDto<[]>): number
मापता है कि सूची के भीतर सूचियाँ कितनी गहराई तक नेस्टेड हैं।

उदाहरण: [1, 2, 3] -> 1, [[1, 2], [3, 4]] -> 2, [[[1]]] -> 3
Parameters
- inputs: ListCloneDto<[]>
  सूची
Returns number
नेस्टिंग स्तरों की संख्या
- Defined in bitbybit-docs.d.ts:54405

listLength

listLength<T>(inputs: ListCloneDto<T>): number
सूची के आइटम गिनता है।

उदाहरण: [10, 20, 30, 40, 50] -> 5, [] -> 0
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  सूची
Returns number
आइटमों की संख्या
- Defined in bitbybit-docs.d.ts:54416

remove

removeItemAtIndex

removeItemAtIndex<T>(inputs: RemoveItemAtIndexDto<T>): T[]
किसी स्थिति का आइटम हटाता है।

उदाहरण: [10, 20, 30, 40, 50] इंडेक्स 2 हटाने पर -> [10, 20, 40, 50]
Type Parameters
- T
Parameters
- inputs: RemoveItemAtIndexDto<T>
  सूची, इंडेक्स और क्या प्रतिलिपि बनानी है
Returns T[]
उस आइटम के बिना सूची
Example
```
const shorter = bitbybit.lists.removeItemAtIndex({ list: [10, 20, 30, 40, 50], index: 2, clone: true });
```
- Defined in bitbybit-docs.d.ts:54478

removeFirstItem

removeFirstItem<T>(inputs: ListCloneDto<T>): T[]
पहला आइटम हटाता है।

उदाहरण: [10, 20, 30, 40] -> [20, 30, 40]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  सूची और क्या पहले उसकी प्रतिलिपि बनानी है
Returns T[]
अपने पहले आइटम के बिना सूची
- Defined in bitbybit-docs.d.ts:54489

removeLastItem

removeLastItem<T>(inputs: ListCloneDto<T>): T[]
अंतिम आइटम हटाता है।

उदाहरण: [10, 20, 30, 40] -> [10, 20, 30]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  सूची और क्या पहले उसकी प्रतिलिपि बनानी है
Returns T[]
अपने अंतिम आइटम के बिना सूची
- Defined in bitbybit-docs.d.ts:54500

removeItemAtIndexFromEnd

removeItemAtIndexFromEnd<T>(inputs: RemoveItemAtIndexDto<T>): T[]
अंत से गिना गया आइटम हटाता है: इंडेक्स 0 अंतिम आइटम है, 1 उससे पहले वाला।

उदाहरण: [10, 20, 30, 40, 50] अंत से इंडेक्स 1 हटाने पर -> [10, 20, 30, 50]
Type Parameters
- T
Parameters
- inputs: RemoveItemAtIndexDto<T>
  सूची, अंत से इंडेक्स और क्या प्रतिलिपि बनानी है
Returns T[]
उस आइटम के बिना सूची
Example
```
const shorter = bitbybit.lists.removeItemAtIndexFromEnd({ list: [10, 20, 30, 40, 50], index: 1, clone: true });
```
- Defined in bitbybit-docs.d.ts:54515

removeItemsAtIndexes

removeItemsAtIndexes<T>(inputs: RemoveItemsAtIndexesDto<T>): T[]
कई स्थितियों के आइटम हटाता है, सभी मूल सूची पर गिने हुए।

उदाहरण: [10, 20, 30, 40, 50] इंडेक्स [1, 3] हटाने पर -> [10, 30, 50]
Type Parameters
- T
Parameters
- inputs: RemoveItemsAtIndexesDto<T>
  सूची, इंडेक्स और क्या प्रतिलिपि बनानी है
Returns T[]
उन आइटमों के बिना सूची
Example
```
const kept = bitbybit.lists.removeItemsAtIndexes({ list: [10, 20, 30, 40, 50], indexes: [1, 3], clone: true });
```
- Defined in bitbybit-docs.d.ts:54530

removeAllItems

removeAllItems<T>(inputs: ListDto<T>): T[]
दी गई सूची को उसी जगह खाली करता है: वही ऐरे बिना किसी आइटम के वापस आता है।

उदाहरण: [10, 20, 30, 40] -> []
Type Parameters
- T
Parameters
- inputs: ListDto<T>
  खाली की जाने वाली सूची
Returns T[]
वही सूची, अब खाली
- Defined in bitbybit-docs.d.ts:54541

removeNthItem

removeNthItem<T>(inputs: RemoveNthItemDto<T>): T[]
हर nवाँ आइटम हटाता है, एक ऑफ़सेट से शुरू करते हुए।

उदाहरण: [0, 1, 2, 3, 4, 5, 6, 7, 8] nth 3 और ऑफ़सेट 0 के साथ -> [1, 2, 4, 5, 7, 8]
Type Parameters
- T
Parameters
- inputs: RemoveNthItemDto<T>
  सूची, स्टेप, वह ऑफसेट जहाँ से शुरू करना है और क्या प्रतिलिपि बनानी है
Returns T[]
हर n-वें आइटम के बिना सूची
Example
```
const thinned = bitbybit.lists.removeNthItem({ list: [0, 1, 2, 3, 4, 5, 6, 7, 8], nth: 3, offset: 0, clone: true });
```
- Defined in bitbybit-docs.d.ts:54556

randomRemoveThreshold

randomRemoveThreshold<T>(inputs: RandomThresholdDto<T>): T[]
सूची के हर आइटम को दी गई संभावना से हटाता है और बाकी रखता है, इसलिए परिणाम हर कॉल पर अलग होता है।

उदाहरण: [1, 2, 3, 4, 5] सीमा 0.5 के साथ -> शायद [2, 4]
Type Parameters
- T
Parameters
- inputs: RandomThresholdDto<T>
  सूची, किसी आइटम को हटाने की 0 से 1 तक की प्रायिकता, और क्या प्रतिलिपि बनानी है
Returns T[]
बचे हुए आइटम, अपने मूल क्रम में
Example
```
const some = bitbybit.lists.randomRemoveThreshold({ list: [1, 2, 3, 4, 5], threshold: 0.5, clone: true });
```
- Defined in bitbybit-docs.d.ts:54572

removeDuplicateNumbers

removeDuplicateNumbers(inputs: RemoveDuplicatesDto<number>): number[]
दोहराई गई संख्याएँ हटाता है, हर एक की पहली उपस्थिति रखते हुए।

उदाहरण: [1, 2, 3, 2, 4, 3, 5] -> [1, 2, 3, 4, 5]
Parameters
- inputs: RemoveDuplicatesDto<number>
  संख्याएँ और क्या प्रतिलिपि बनानी है
Returns number[]
दोहराव रहित संख्याएँ, अपने मूल क्रम में
- Defined in bitbybit-docs.d.ts:54583

removeDuplicateNumbersTolerance

removeDuplicateNumbersTolerance(
inputs: RemoveDuplicatesToleranceDto<number>,
): number[]
उन संख्याओं को हटाता है जो पहले से रखी किसी संख्या के टॉलरेंस के भीतर हैं, ताकि केवल फ़्लोटिंग-पॉइंट शोर से भिन्न मान एक जैसे गिने जाएँ।

उदाहरण: [1.0, 1.001, 2.0, 2.002, 3.0] टॉलरेंस 0.01 के साथ -> [1.0, 2.0, 3.0]
Parameters
- inputs: RemoveDuplicatesToleranceDto<number>
  संख्याएँ, टॉलरेंस और क्या प्रतिलिपि बनानी है
Returns number[]
लगभग-दोहराव रहित संख्याएँ, अपने मूल क्रम में
Example
```
const distinct = bitbybit.lists.removeDuplicateNumbersTolerance({ list: [1.0, 1.001, 2.0], tolerance: 0.01, clone: true });
```
- Defined in bitbybit-docs.d.ts:54599

removeDuplicates

removeDuplicates<T>(inputs: RemoveDuplicatesDto<T>): T[]
किसी भी प्रकार के दोहराए गए आइटम हटाता है, हर एक की पहली उपस्थिति रखते हुए।

आइटम की तुलना पहचान से होती है, इसलिए दो एक जैसे दिखने वाले ऑब्जेक्ट दोनों रहते हैं। उदाहरण: ['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']
Type Parameters
- T
Parameters
- inputs: RemoveDuplicatesDto<T>
  सूची और क्या प्रतिलिपि बनानी है
Returns T[]
दोहराव रहित सूची, अपने मूल क्रम में
- Defined in bitbybit-docs.d.ts:54611

sorting

sortNumber

sortNumber(inputs: SortDto<number>): number[]
संख्याओं को सबसे छोटी से सबसे बड़ी तक, या सबसे बड़ी से सबसे छोटी तक क्रमबद्ध करता है।

उदाहरण: [5, 2, 8, 1, 9] आरोही -> [1, 2, 5, 8, 9]; अवरोही -> [9, 8, 5, 2, 1]
Parameters
- inputs: SortDto<number>
  संख्याएँ, दिशा और क्या प्रतिलिपि बनानी है
Returns number[]
क्रमबद्ध संख्याएँ
Example
```
const sorted = bitbybit.lists.sortNumber({ list: [5, 2, 8, 1, 9], orderAsc: true, clone: true });
```
- Defined in bitbybit-docs.d.ts:54726

sortTexts

sortTexts(inputs: SortDto<string>): string[]
टेक्स्ट को वर्णानुक्रम में क्रमबद्ध करता है, A से Z तक या Z से A तक।

उदाहरण: ['dog', 'apple', 'cat'] आरोही -> ['apple', 'cat', 'dog']
Parameters
- inputs: SortDto<string>
  टेक्स्ट, दिशा और क्या प्रतिलिपि बनानी है
Returns string[]
क्रमबद्ध टेक्स्ट
Example
```
const sorted = bitbybit.lists.sortTexts({ list: ["dog", "apple", "cat"], orderAsc: true, clone: true });
```
- Defined in bitbybit-docs.d.ts:54741

sortByPropValue

sortByPropValue(inputs: SortJsonDto<any>): any[]
ऑब्जेक्ट को उनकी किसी एक प्रॉपर्टी में रखी संख्या से क्रमबद्ध करता है।

उदाहरण: [{age: 30}, {age: 20}, {age: 25}] 'age' से आरोही -> [{age: 20}, {age: 25}, {age: 30}]
Parameters
- inputs: SortJsonDto<any>
  ऑब्जेक्ट, वह गुण जिसके अनुसार क्रमबद्ध करना है, दिशा और क्या प्रतिलिपि बनानी है
Returns any[]
क्रमबद्ध ऑब्जेक्ट
Example
```
const byAge = bitbybit.lists.sortByPropValue({ list: [{ age: 30 }, { age: 20 }], property: "age", orderAsc: true, clone: true });
```
- Defined in bitbybit-docs.d.ts:54757

transform

interleave

interleave<T>(inputs: InterleaveDto<T>): T[]
कई सूचियों को बारी-बारी से हर एक का पहला आइटम, फिर हर एक का दूसरा, और इसी तरह आगे लेकर एक में बुनता है।

छोटी सूची खत्म होते ही बस बाहर हो जाती है। सूचियों की खाली सूची त्रुटि फेंकती है। उदाहरण: [[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]
Type Parameters
- T
Parameters
- inputs: InterleaveDto<T>
  एक साथ बुनी जाने वाली सूचियाँ और क्या प्रतिलिपि बनानी है
Returns T[]
बारी-बारी से आइटमों वाली एक सूची
Example
```
const woven = bitbybit.lists.interleave({ lists: [[0, 1, 2], [3, 4, 5]], clone: true });
```
- Defined in bitbybit-docs.d.ts:54774

Class Lists

Index

Constructors

add

create

edit

get

remove

sorting

transform

Constructors

constructor

Returns Bit.Lists

add

addItemAtIndex

Type Parameters

Parameters

Returns T[]

Example

addItemAtIndexes

Type Parameters

Parameters

Returns T[]

Example

addItemsAtIndexes

Type Parameters

Parameters

Returns T[]

Example

addItem

Type Parameters

Parameters

Returns T[]

Example

prependItem

Type Parameters

Parameters

Returns T[]

Example

addItemFirstLast

Type Parameters

Parameters

Returns T[]

Example

concatenate

Type Parameters

Parameters

Returns T[]

Example

create

createEmptyList

Returns []

repeat

Type Parameters

Parameters

Returns T[]

Example

repeatInPattern

Type Parameters

Parameters

Returns T[]

Example

edit

reverse

Type Parameters

Parameters

Returns T[]

shuffle

Type Parameters

Parameters

Returns T[]

flipLists

Type Parameters

Parameters

Returns T[][]

Example

groupNth

Type Parameters

Parameters

Returns T[][]