# User:Kireji Haiku/How to deal with lists in LSL

NOTE: Firstly look to see if there is a built-in function available to process your list the way you wish. This will always be faster than coding your own loops. e.g. llListFindList(), llListStatistics()

## the basics

A.) Usual List with 10 items:

```
list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
```

```
list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];

integer index = 0;
for (index = 0;index < llGetListLength(listOfTenItems);index++)
{
//do something
}
```

C.) Resetting the value to 0 for index was redundant so we can skip that:

```
list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];

integer index = 0;
for (;index < llGetListLength(listOfTenItems);index++)
{
//do something
}
```

D.) Setting the default value to 0 is also redundant, since LSL initializes integers as 0. Keep in mind that other languages may not do this.

```
list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];

integer index;
for (;index < llGetListLength(listOfTenItems);index++)
{
//do something
}
```

E.) Calculating the list length every step is also redundant because the length doesn't change - at least in the example demonstrated here.

```
list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

integer index;
for (;index < lengthOfList;index++)
{
//do something
}
```

Now the index for items in a list of ten is either:

plain English using positive indices using negative indices
first item of a list of ten 0 -10
second item of a list of ten 1 -9
third item of a list of ten 2 -8
fourth item of a list of ten 3 -7
fifth item of a list of ten 4 -6
sixth item of a list of ten 5 -5
seventh item of a list of ten 6 -4
eight item of a list of ten 7 -3
ninth item of a list of ten 8 -2
tenth item of a list of ten 9 -1

While ++index is fractionally faster than index++ in LSO, using the preferred Mono VM, there is no timing difference. See LSL_Hacks for more details.

We could start with -11 and increment first before doing something, instead of the other way around before... as long as the index stays negative. We can write:

if indexes can be negative if indexes can NOT be negative
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

integer index = -lengthOfList - 1;
for (;index < 0;++index)
{
//do something
}
```
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

integer index;                      //  pay attention here! index is 0 before loop starts and
for (;index < lengthOfList;++index) //  doesn't get incremented until JUST before the second round
{
//do something
}
```

Now trying to simplify the math for calculating the index default value we can make use of the LSL_Operators and initialize with bitwise-NOT of the length which is the same as `-1*length - 1` or the negative length minus one:

if indexes can be negative if indexes can NOT be negative
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

//  it's bitwise-NOT (~) instead of minus (-)
integer index = ~lengthOfList;
for (;index < 0;++index)
{
//do something
}
```
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

integer index;                      //  pay attention here! index is 0 before loop starts and
for (;index < lengthOfList;++index) //  doesn't get incremented until JUST before the second round
{
//do something
}
```

as you might have seen by now, we can merge two lines in the middle:

if indexes can be negative if indexes can NOT be negative
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];

//  it's bitwise-NOT (~) instead of minus (-)
integer index = ~llGetListLength(listOfTenItems);
for (;index < 0;++index)
{
//do something
}
```
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

integer index;                      //  pay attention here! index is 0 before loop starts and
for (;index < lengthOfList;++index) //  doesn't get incremented until JUST before the second round
{
//do something
}
```

and because index should have a negative value while looping and the loop stops when index reaches zero, we can change the code to:

if indexes can be negative if indexes can NOT be negative
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];

//  it's bitwise-NOT (~) instead of minus (-)
integer index = ~llGetListLength(listOfTenItems);
for (;index;++index)
{
//do something
}
```
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

integer index;                      //  pay attention here! index is 0 before loop starts and
for (;index < lengthOfList;++index) //  doesn't get incremented until JUST before the second round
{
//do something
}
```

and improve readability by using a while-loop:

if indexes can be negative if indexes can NOT be negative
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];

//  it's bitwise-NOT (~) instead of minus (-)
integer index = ~llGetListLength(listOfTenItems);
while (++index)
{
//do something
}
```
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

integer index = -1;// attention again! index is -1 before the first round
// each round index is incremented FIRST before being compared to lengthOfList and then used within the loop
while (++index < lengthOfList)
{
//do something
}
```

## finally clean code

and try to get rid of the bitwise-NOT because some people find it hard to read. The positive side effect of the next step is that you need to increment one step less in total and the loop runs the first step directly without checking first for a conditional statement:

if indexes can be negative if indexes can NOT be negative
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];

// negative length now!
integer index = -llGetListLength(listOfTenItems);

do
{
//do something
}
while (++index);
```
```list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
integer lengthOfList = llGetListLength(listOfTenItems);

integer index;
do
{
//do something
}
while (++index < lengthOfList);
```