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

How to deal with lists in the Linden Scripting Language:

the basics

Usual list with 10 items:

<lsl> list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]; </lsl>

Then start with a for-loop:

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

integer index = 0; for (index = 0;index < llGetListLength(listOfTenItems);index++) {

   //do something

} </lsl>

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

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

integer index = 0; for (;index < llGetListLength(listOfTenItems);index++) {

   //do something

} </lsl>

Setting the default value to 0 is redundant, too.

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

integer index; for (;index < llGetListLength(listOfTenItems);index++) {

   //do something

} </lsl>

Calculating the list length every step is redundant too because the length doesn't change.

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

integer index; for (;index < lengthOfList;index++) {

   //do something

} </lsl>

slightly more advanced now

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

 0,  1,  2,  3,  4,  5,  6,  7,  8,  9

//  or

-10, -9, -8, -7, -6, -5, -4, -3, -2, -1

Because ++index is faster than index++ 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
<lsl> 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 } </lsl>	<lsl> 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 } </lsl>

Now trying to simplify the math for calculating the index default value we can use bitwise-NOT of the length which is the same as the negative length minus one:

if indexes can be negative	if indexes can NOT be negative
<lsl> list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]; integer lengthOfList = llGetListLength(listOfTenItems); // it's bitwise-NOT (~) not minus (-) integer index = ~lengthOfList; for (;index < 0;++index) { //do something } </lsl>	<lsl> 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 } </lsl>

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
<lsl> list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]; // it's bitwise-NOT (~) not minus (-) integer index = ~llGetListLength(listOfTenItems); for (;index < 0;++index) { //do something } </lsl>	<lsl> 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 } </lsl>

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
<lsl> list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]; // it's bitwise-NOT (~) not minus (-) integer index = ~llGetListLength(listOfTenItems); for (;index;++index) { //do something } </lsl>	<lsl> 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 } </lsl>

and improve readability by using a while-loop:

if indexes can be negative	if indexes can NOT be negative
<lsl> list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]; // it's bitwise-NOT (~) not minus (-) integer index = ~llGetListLength(listOfTenItems); while (++index) { //do something } </lsl>	<lsl> 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 } </lsl>

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
<lsl> list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]; // negative length now! integer index = -llGetListLength(listOfTenItems); do { //do something } while (++index); </lsl>	<lsl> list listOfTenItems = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]; integer lengthOfList = llGetListLength(listOfTenItems); integer index; do { //do something } while (++index < lengthOfList); </lsl>