Difference between revisions of "LlGetListLength"

From Second Life Wiki
Jump to navigation Jump to search
m (Removed a poorly written caveat that wasn't a caveat and is covered elsewhere on the page. Added info on bytecode space comparison.)
m
 
(2 intermediate revisions by 2 users not shown)
Line 9: Line 9:
|constants
|constants
|examples=
|examples=
<lsl>
<source lang="lsl2">
//Basic usage
//Basic usage
default
default
Line 20: Line 20:
     }
     }
}
}
</lsl>
</source>


|notes=
|notes=
Line 26: Line 26:
When using list length to help you loop through a list, it is better to determine the length first, then start your loop:
When using list length to help you loop through a list, it is better to determine the length first, then start your loop:


<lsl>
<source lang="lsl2">
integer length = llGetListLength(mylist);
integer length = llGetListLength(mylist);


Line 32: Line 32:
while (index < length)
while (index < length)
{
{
    // PUBLIC_CHANNEL has the integer value 0
     llSay(0, llList2String(mylist, index));
     llSay(PUBLIC_CHANNEL, llList2String(mylist, index));
 
     ++index;
     ++index;
}
}
</lsl>
</source>


The following example is to illustrate what not to do, it calculates the length in the "for" loop and is inefficient because the length gets recalculated at each pass through the loop. This should only ever be done if the list is in fact changing (in length) with each iteration of the loop{{Footnote|Recalculating the length is slow because the VM duplicates the entire list (including the values) when it is pushed on the stack (so it can be popped off the stack when the length is calculated).}}.
The following example is to illustrate what not to do, it calculates the length in the "for" loop and is inefficient because the length gets recalculated at each pass through the loop. This should only ever be done if the list is in fact changing (in length) with each iteration of the loop{{Footnote|Recalculating the length is slow because the VM duplicates the entire list (including the values) when it is pushed on the stack (so it can be popped off the stack when the length is calculated).}}.


<lsl>
<source lang="lsl2">
integer index;// default is 0
integer index;// default is 0
while (index < llGetListLength(mylist))
while (index < llGetListLength(mylist))
{
{
    // PUBLIC_CHANNEL has the integer value 0
     llSay(0, llList2String(mylist, index));
     llSay(PUBLIC_CHANNEL, llList2String(mylist, index));
 
     ++index;
     ++index;
}
}
</lsl>
</source>
{{LSL Tip|Please read [[User:Kireji_Haiku/How_to_deal_with_lists_in_LSL|this intro of how to iterate over a list in LSL]].}}


===LSO Optimizations===
===LSO Optimizations===
A faster and lighter (in bytecode) way to determine the length of a list is to do a not-equals compare with a null list. This works because the list not-equals compare returns the difference between the lengths, meaning that it returns the same result as <code>llGetListLength()</code>, minus the overhead in bytecode, and performance penalty of calling a non-native function. Note: This optimization is much less beneficial in Mono. Mono's llGetListLength function is almost twice as fast, however the bytecode saving is still about 30 bytes.
A faster and lighter (in bytecode) way to determine the length of a list is to do a not-equals compare with a null list. This works because the list not-equals compare returns the difference between the lengths, meaning that it returns the same result as <code>llGetListLength()</code>, minus the overhead in bytecode, and performance penalty of calling a non-native function. Note: This optimization is much less beneficial time-wise in Mono as Mono's llGetListLength function is almost twice as fast, however the bytecode saving is still about 30 bytes.
<lsl>
<source lang="lsl2">
list in;
list in;
integer len_in = llGetListLength(in);
integer len_in = llGetListLength(in);
Line 63: Line 60:
integer fneg_len_in = ([] != in);
integer fneg_len_in = ([] != in);
//fneg_len_in and neg_len_in will be the same
//fneg_len_in and neg_len_in will be the same
</lsl>
</source>
|helpers
|helpers
|also_functions=
|also_functions=

Latest revision as of 02:10, 22 January 2015

Summary

Function: integer llGetListLength( list src );

Returns an integer that is the number of elements in the list src.

• list src

Examples

//Basic usage
default
{
    state_entry()
    {
        list testList = ["one", "two", "three"];
        integer length = llGetListLength(testList);
        llOwnerSay("There are " + (string)length + " entries in the list.");
    }
}

Notes

Best Practices

When using list length to help you loop through a list, it is better to determine the length first, then start your loop:

integer length = llGetListLength(mylist);

integer index;// default is 0
while (index < length)
{
    llSay(0, llList2String(mylist, index));
    ++index;
}

The following example is to illustrate what not to do, it calculates the length in the "for" loop and is inefficient because the length gets recalculated at each pass through the loop. This should only ever be done if the list is in fact changing (in length) with each iteration of the loop[1].

integer index;// default is 0
while (index < llGetListLength(mylist))
{
    llSay(0, llList2String(mylist, index));
    ++index;
}
KBcaution.png Important: Please read this intro of how to iterate over a list in LSL.

LSO Optimizations

A faster and lighter (in bytecode) way to determine the length of a list is to do a not-equals compare with a null list. This works because the list not-equals compare returns the difference between the lengths, meaning that it returns the same result as llGetListLength(), minus the overhead in bytecode, and performance penalty of calling a non-native function. Note: This optimization is much less beneficial time-wise in Mono as Mono's llGetListLength function is almost twice as fast, however the bytecode saving is still about 30 bytes.

list in;
integer len_in = llGetListLength(in);
integer flen_in = (in != []);
//flen_in and len_in will be the same

integer neg_len_in = -llGetListLength(in);
integer fneg_len_in = ([] != in);
//fneg_len_in and neg_len_in will be the same

See Also

Functions

•  llListStatistics LIST_STAT_NUM_COUNT – Returns the number of integers and floats in the list
•  llStringLength Returns the number of characters in a string.

Deep Notes

All Issues

~ Search JIRA for related Issues
   Automatically optimise calls to llGetListLength(list) by replacing them with (list != [])

Source

'linden\indra\lscript\lscript_library\lscript_alloc.cpp' @ lsa_cmp_lists
'linden\indra\lscript\lscript_execute\lscript_execute.cpp' @ list_list_operation

Footnotes

  1. ^ Recalculating the length is slow because the VM duplicates the entire list (including the values) when it is pushed on the stack (so it can be popped off the stack when the length is calculated).

Signature

function integer llGetListLength( list src );