Second Life Wiki - User contributions [en]

Link message/it

2012-08-16T17:57:11Z

Violet Hammerer: Undo revision 1161421 by Violet Hammerer (Talk)

{{LSL_Event|event_id=29|event_delay|event=link_message
|p1_type=integer|p1_name=sender_num|p1_desc=Il numero di collegamento del prim che contiene lo script che ha chiamato [[llMessageLinked]].
|p2_type=integer|p2_name=num|p2_desc=Secondo parametro della chiamata llMessageLinked.
|p3_type=string|p3_name=str|p3_desc=Terzo parametro della chiamata llMessageLinked.
|p4_type=key|p4_name=id|p4_desc=Quarto parametro della chiamata llMessageLinked.
|event_desc=Lanciato quando lo script riceva un messaggio collegato che è stato mandato da una chiamata a [[llMessageLinked]]. llMessageLinked viene usato per inviare messaggi da uno script a un altro.
|event_footnote='''id''' viene usato spesso come secondo campo stringa (in LSL il tipo [[key]] è implementato come una [[string]] con operatori personalizzati). [[typecast|La trasformazione]] tra i tipi [[string]] e [[key]] non ha effetti sui dati in essi contenuti. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|spec
|caveats=*Si possono accodare 64 eventi link_message, superati i quali, vengono scartati silenziosamente! Non fate troppe cose nell'evento se questi potrebbero arrivare velocemente.
*'''sender_num''' non rispecchia il modo in cui è stato mandato un messaggio, non c'è modo di sapere se è stato inviato col flag LINK_* o il [[llGetLinkNumber|numero specifico di collegamento]].
*Se '''str''' e '''id''' sono più grandi della memoria disponibile, lo script crasherà silenziosamente con una Collisione Stack-Heap.
|examples=
<lsl>
// Questo è solo uno script di esempio, non dovreste gestire il tocco in questo modo all'interno di un unico script.

default
{
touch_start(integer c)
{
llMessageLinked(LINK_THIS, 0, llDetectedName(0), llDetectedKey(0));
}
link_message(integer source, integer num, string str, key id)
{
llWhisper(0, str + " (" + (string)id + ") mi ha toccato!");
}
}
</lsl>
|helpers=
<lsl>
// Questo è solo uno script di esempio, non dovreste gestire i messaggi collegati in questo modo all'interno di un unico script.

default
{
// Per diffondere un numero illimitato di argomenti di qualsiasi tipo.
// Presupposto, la stringa separatrice non viene utilizzata in nessuna stringa sorgente!
state_entry()
{
list mia_lista = [1, 2.0, "una stringa", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string parametro_lista = llDumpList2String(mia_lista, "|"); // Converte la lista in una stringa
llMessageLinked(LINK_THIS, 0, parametro_lista, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list ri_elenca = llParseString2List(parametro_lista, ["|"], []); // elabora nuovamente la stringa in una lista
}
}
</lsl>
|also_header
|also_events
|also_functions={{LSL DefineRow||[[llMessageLinked/it]]}}
|also_articles
|also_footer
|notes=Uno script può ascoltare i propri messaggi.
|mode
|cat1=Link
|cat2=Communications
|cat3=Link Message
|cat4
}}

Template:LSL Function/it

2012-01-15T19:00:55Z

Violet Hammerer:

{{Multi-lang|category=LSL|2=}}{{LSL Header{{#var:lang}}}} __NOTOC__ <noinclude>
Si veda [[{{#var:langbase}}/docs{{#var:lang}}]] per la documentazione.
</noinclude><includeonly>{{#if:{{#var:sort}}||{{#if:{{{sort|}}}|{{#vardefine:sort|{{{sort|}}}}}|{{#if:{{LSL_Sort}}}}}}}}<div id="sort" style="display:none">{{DEFAULTSORT:{{#var:sort}}}}{{#var:sort}}</div>{{#if:{{#var:nofixname}}||{{#if:{{#pos:{{lc:{{FULLPAGENAMEE}}}}|{{lc:{{{func}}}}}}}|<div id="RealTitleBanner" style="display:none"><span id="RealTitle">{{#if:{{NAMESPACE}}|{{NAMESPACE}}:}}{{{func}}}</span></div>}}}}{{#if:

{{#vardefine:article_type|function}}

{{#vardefine:name|{{{func|}}}}}
{{#if:{{{func_id|}}}|{{#vardefine:func_id|{{{func_id|}}}}}}}

{{#vardefine:mode|{{#var:mode}}{{{mode|}}}}}
{{#vardefine:self|{{#var:self}}{{{self|}}}}}

{{{inject-1|}}}

{{{{#switch:{{#var:mode}}
|god=LSL_Generic/god{{#var:lang}}
|request=LSL_Generic/request{{#var:lang}}
|pre-release=LSL_Generic/pre-release{{#var:lang}}
|rc=LSL_Generic/RC{{#var:lang}}
|preview=LSL_Generic/preview{{#var:lang}}
|user=!{{#vardefine:moded|u{{#var:moded}}}}
|!}}|}}
{{{{#if:{{{deprecated|}}}|LSL_Generic/deprecated{{#var:lang}}|!}}|{{{deprecated|}}}|}}

{{{inject-2|}}}

{{#vardefine:p_{{{p1_name|}}}_desc|{{#var:p_{{{p1_name|}}}_desc}}{{{p1_desc|}}}}}
{{#vardefine:p_{{{p1_name|}}}_hover|{{#var:p_{{{p1_name|}}}_hover}}{{{p1_hover|}}}}}
{{#vardefine:p_{{{p2_name|}}}_desc|{{#var:p_{{{p2_name|}}}_desc}}{{{p2_desc|}}}}}
{{#vardefine:p_{{{p2_name|}}}_hover|{{#var:p_{{{p2_name|}}}_hover}}{{{p2_hover|}}}}}
{{#vardefine:p_{{{p3_name|}}}_desc|{{#var:p_{{{p3_name|}}}_desc}}{{{p3_desc|}}}}}
{{#vardefine:p_{{{p3_name|}}}_hover|{{#var:p_{{{p3_name|}}}_hover}}{{{p3_hover|}}}}}
{{#vardefine:p_{{{p4_name|}}}_desc|{{#var:p_{{{p4_name|}}}_desc}}{{{p4_desc|}}}}}
{{#vardefine:p_{{{p4_name|}}}_hover|{{#var:p_{{{p4_name|}}}_hover}}{{{p4_hover|}}}}}
{{#vardefine:p_{{{p5_name|}}}_desc|{{#var:p_{{{p5_name|}}}_desc}}{{{p5_desc|}}}}}
{{#vardefine:p_{{{p5_name|}}}_hover|{{#var:p_{{{p5_name|}}}_hover}}{{{p5_hover|}}}}}
{{#vardefine:p_{{{p6_name|}}}_desc|{{#var:p_{{{p6_name|}}}_desc}}{{{p6_desc|}}}}}
{{#vardefine:p_{{{p6_name|}}}_hover|{{#var:p_{{{p6_name|}}}_hover}}{{{p6_hover|}}}}}
{{#vardefine:p_{{{p7_name|}}}_desc|{{#var:p_{{{p7_name|}}}_desc}}{{{p7_desc|}}}}}
{{#vardefine:p_{{{p7_name|}}}_hover|{{#var:p_{{{p7_name|}}}_hover}}{{{p7_hover|}}}}}
{{#vardefine:p_{{{p8_name|}}}_desc|{{#var:p_{{{p8_name|}}}_desc}}{{{p8_desc|}}}}}
{{#vardefine:p_{{{p8_name|}}}_hover|{{#var:p_{{{p8_name|}}}_hover}}{{{p8_hover|}}}}}
{{#vardefine:p_{{{p9_name|}}}_desc|{{#var:p_{{{p9_name|}}}_desc}}{{{p9_desc|}}}}}
{{#vardefine:p_{{{p9_name|}}}_hover|{{#var:p_{{{p9_name|}}}_hover}}{{{p9_hover|}}}}}
{{#vardefine:p_{{{p10_name|}}}_desc|{{#var:p_{{{p10_name|}}}_desc}}{{{p10_desc|}}}}}
{{#vardefine:p_{{{p10_name|}}}_hover|{{#var:p_{{{p10_name|}}}_hover}}{{{p10_hover|}}}}}
{{#vardefine:p_{{{p11_name|}}}_desc|{{#var:p_{{{p11_name|}}}_desc}}{{{p11_desc|}}}}}
{{#vardefine:p_{{{p11_name|}}}_hover|{{#var:p_{{{p11_name|}}}_hover}}{{{p11_hover|}}}}}
{{#vardefine:p_{{{p12_name|}}}_desc|{{#var:p_{{{p12_name|}}}_desc}}{{{p12_desc|}}}}}
{{#vardefine:p_{{{p12_name|}}}_hover|{{#var:p_{{{p12_name|}}}_hover}}{{{p12_hover|}}}}}

{{{inject-3|}}}

{{#if:{{#var:header_desc}}{{{func_desc|}}}|
{{#vardefine:header_desc|{{#var:header_desc}}{{PBR}}
{{{func_desc|}}}{{PBR}}}}
}}

{{#vardefine:return_text|{{#var:return_text}}{{{return_text|}}}{{{Return_text|}}} }}

{{#if:{{#var:header_footnote}}{{{func_footnote|}}}{{{func_footer|}}}|
{{#vardefine:header_footnote|{{#var:header_footnote}}{{PBR}}
{{{func_footnote|}}}{{PBR}}
{{{func_footer|}}}{{PBR}}}}
}}

{{#if:{{#var:newbie}}||
{{#vardefine:newbie|{{#if:{{{newbie|}}}|{{{newbie|}}}|{{#var:langbase}}/Newbie Notes{{#var:lang}}}}}}
}}

{{#if:{{#var:spec}}{{{spec|}}}|
{{#vardefine:spec|{{#var:spec}}{{PBR}}
{{{spec|}}}{{PBR}}}}
}}

{{#if:{{#var:constants_nb}}{{{constants|}}}|
{{#vardefine:constants_nb|{{#var:constants_nb}}{{PBR}}
{{{constants|}}}{{PBR}}}}
}}

{{#vardefine:bugs|{{#var:bugs}}
{{{bugs|}}}}}

{{#vardefine:caveats|{{#ifexpr:{{{func_sleep|0.0}}}> 0.0|* <span id="caveats-sleep"></span> Questa funzione provoca una pausa di {{{func_sleep|}}} secondo/i nell'esecuzione dello script. {{{func_sleep_note|}}}|{{#if:{{{func_sleep_note|}}}|* <span id="caveats-sleep"></span> {{{func_sleep_note|}}}}}}}{{#if:{{#var:caveats}}|
{{#var:caveats}}}}{{#if:{{{caveats|}}}|
{{{caveats|}}}}}}}

{{#if:{{#pos:{{#var:moded}}|u}}||{{#vardefine:caveats|{{LSL_Generic/Caveats}}}}}}

{{#if:{{#var:examples}}{{{examples|}}}|
{{#vardefine:examples|{{#var:examples}}{{PBR}}
{{{examples|}}}{{PBR}}}}
}}

{{#vardefine:simple-examples|{{#var:simple-examples}}
{{{simple-examples|}}}}}

{{#vardefine:complex-examples|{{#var:complex-examples}}
{{{complex-examples|}}}}}

{{#if:{{#var:helpers}}{{{helpers|}}}|
{{#vardefine:helpers|{{#var:helpers}}{{PBR}}
{{{helpers|}}}{{PBR}}}}
}}

{{#if:{{#var:also_header}}{{{also_header|}}}|
{{#vardefine:also_header|{{#var:also_header}}{{PBR}}
{{{also_header|}}}{{PBR}}}}
}}

{{#vardefine:also_constants|{{#var:also_constants}}
{{{also_constants|}}}}}

{{#vardefine:also_events|{{#var:also_events}}
{{{also_events|}}}}}

{{#vardefine:also_functions|{{#var:also_functions}}
{{{also_functions|}}}}}

{{#vardefine:also_articles|{{#var:also_articles}}
{{{also_articles|}}}}}

{{#vardefine:also_library|{{#var:also_library}}
{{{also_library|}}}}}

{{#if:{{#var:also_footer}}{{{also_footer|}}}|
{{#vardefine:also_footer|{{#var:also_footer}}{{PBR}}
{{{also_footer|}}}{{PBR}}}}
}}

{{#if:{{#var:notes}}{{{notes|}}}|
{{#vardefine:notes|{{#var:notes}}{{PBR}}
{{{notes|}}}{{PBR}}}}
}}

{{#if:{{#var:history}}{{{history|}}}|
{{#vardefine:history|{{#var:history}}{{PBR}}
{{{history|}}}{{PBR}}}}
}}

{{#if:{{#var:deepnotes}}{{{deepnotes|}}}|
{{#vardefine:deepnotes|{{#var:deepnotes}}{{PBR}}
{{{deepnotes|}}}{{PBR}}}}
}}

{{#if:{{#var:mono}}{{{mono|}}}|
{{#vardefine:mono|{{#var:mono}}{{PBR}}
{{{mono|}}}{{PBR}}}}
}}

{{#if:{{#var:lso}}{{{lso|}}}|
{{#vardefine:lso|{{#var:lso}}{{PBR}}
{{{lso|}}}{{PBR}}}}
}}

{{#vardefine:issues|{{#var:issues}}
{{{issues|}}}}}

{{#vardefine:also_tests|{{#var:also_tests}}
{{{also_tests|}}}}}

{{#if:{{#var:location}}{{{location|}}}|
{{#vardefine:location|{{#var:location}}{{PBR}}
{{{location|}}}{{PBR}}}}
}}

{{#if:{{#var:messaging}}{{{messaging|}}}|
{{#vardefine:messaging|{{#var:messaging}}{{PBR}}
{{{messaging|}}}{{PBR}}}}
}}

}}{{#if:{{#var:self}}|| __NOEDITSECTION__
}}{{#var:header}}{{#if:{{#var:func_id}}{{#var:mode}}{{#var:moded}}||
{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}{{#if:{{#if:{{{return_type|}}}|{{#var:return_text}}}}{{{func_desc|}}}||<div id="box" style="background:yellow;">
  '''O 'func_desc', o 'return_type' e 'return_text' devono essere definiti'''
<div style="padding: 0.5em;background:#ffffff;">
''(Per favore usate 'return_text' e 'return_type', o 'func_desc' per descrivere sommariamente le azioni della funzione.)''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}
{{RightToc|font-size:80%}}
<div id="box"><h2 style="display:none"> Sommario </h2>{{#ifexpr:{{#var:BugCounter|0}} > 0|<div class="mw-headline" style="float:right; margin: 5px 0.5em 0 0.5em;">{{LSL_Bug_Icon}}</div>}}<span id="{{anchorencode:Description}}" style="display:none"></span><span id="{{anchorencode:Summary}}" class="mw-headline" style="display:block; padding-bottom:0.17em; padding-top:0.5em; background:transparent none repeat scroll 0% 0%; color:#546368; font-family:Arial,Helvetica,Sans-Serif; background-color:#F4F8FB; border-bottom:1px dotted #AAAAAA; font-size:120%; font-weight:bold; margin:0pt; padding:0.2em 0.5em; text-align:left;"> [[:Category:LSL_Functions{{#var:lang}}|Function]]: {{#if:{{{return_type|}}}|[[{{{return_type|}}}{{#var:lang}}|{{{return_type|}}}]]||}} '''{{{func}}}'''( {{#if:{{{p1_name|}}}{{{p1_type|}}}| [[{{{p1_type|}}}{{#var:lang}}|{{{p1_type|}}}]] {{LSL Param|{{{p1_name|}}}}}{{#if:{{{p2_name|}}}{{{p2_type|}}}|, [[{{{p2_type|}}}{{#var:lang}}|{{{p2_type|}}}]] {{LSL Param|{{{p2_name|}}}}}{{#if:{{{p3_name|}}}{{{p3_type|}}}|, [[{{{p3_type|}}}{{#var:lang}}|{{{p3_type|}}}]] {{LSL Param|{{{p3_name|}}}}}{{#if:{{{p4_name|}}}{{{p4_type|}}}|, [[{{{p4_type|}}}{{#var:lang}}|{{{p4_type|}}}]] {{LSL Param|{{{p4_name|}}}}}{{#if:{{{p5_name|}}}{{{p5_type|}}}|, [[{{{p5_type|}}}{{#var:lang}}|{{{p5_type|}}}]] {{LSL Param|{{{p5_name|}}}}}{{#if:{{{p6_name|}}}{{{p6_type|}}}|, [[{{{p6_type|}}}{{#var:lang}}|{{{p6_type|}}}]] {{LSL Param|{{{p6_name|}}}}}{{#if:{{{p7_name|}}}{{{p7_type|}}}|, [[{{{p7_type|}}}{{#var:lang}}|{{{p7_type|}}}]] {{LSL Param|{{{p7_name|}}}}}{{#if:{{{p8_name|}}}{{{p8_type|}}}|, [[{{{p8_type|}}}{{#var:lang}}|{{{p8_type|}}}]] {{LSL Param|{{{p8_name|}}}}}{{#if:{{{p9_name|}}}{{{p9_type|}}}|, [[{{{p9_type|}}}{{#var:lang}}|{{{p9_type|}}}]] {{LSL Param|{{{p9_name|}}}}}{{#if:{{{p10_name|}}}{{{p10_type|}}}|, [[{{{p10_type|}}}{{#var:lang}}|{{{p10_type|}}}]] {{LSL Param|{{{p10_name|}}}}}{{#if:{{{p11_name|}}}{{{p11_type|}}}|, [[{{{p11_type|}}}{{#var:lang}}|{{{p11_type|}}}]] {{LSL Param|{{{p11_name|}}}}}{{#if:{{{p12_name|}}}{{{p12_type|}}}|, [[{{{p12_type|}}}{{#var:lang}}|{{{p12_type|}}}]] {{LSL Param|{{{p12_name|}}}}}}}}}}}}}}}}}}}}}}}}}}}}} )<nowiki>;</nowiki></span>
<div style="padding: 0.5em; min-height: {{#if:{{{func_complexity|}}}|6em;|5em;}}">{{#if:{{#pos:{{#var:moded}}|u}}|{{#if:{{#var:floater}}|<div id="box" style="float:right;">{{#var:floater}}</div>}}|<div id="box" style="float:right; margin: 0 0.5em; font-size:90%;">
{{{!}} class="collapsible"
{{!}}- style="font-size:75%;"
{{!}}+
{{!}}-
{{!}} {{HoverText|{{#var:func_id}}|Il numero d'indice della funzione.}}
{{!}} [[LSL Function ID{{#var:lang}}|ID funzione]]
{{!}}-
{{!}} {{HoverText|{{{func_sleep|}}}|Il numero di secondi per cui lo script sarà in pausa dopo avere eseguito questa funzione.}}{{#if:{{{func_sleep_note|}}}|{{HoverLink|#caveats-sleep|3=*|2={{{func_sleep_note|}}}}}}}
{{!}} [[LSL Delay{{#var:lang}}|Ritardo]]
{{!}}-
{{#if:{{{func_complexity|}}}|
{{!}} {{HoverText|{{{func_complexity|}}}|La complessità della funzione, basata sui parametri.}}
{{!}} [[LSL Complexity{{#var:lang}}|Compl.]]
{{!}}-}}
{{!}} {{HoverText|{{{func_energy|}}}|La quantità di energia consumata da questa funzione.}}
{{!}} [[Energy{{#var:lang}}|Energia]]
{{!}}}</div>}}
{{#if:{{#var:header_desc}}|{{#var:header_desc}}{{PBR}}{{#if:{{{return_type|}}}|<br id="bdart"/>}}}}{{#if:{{{return_type|}}}| Restituisce {{It|{{{return_type|}}}|{{{Return_text|}}}}} {{#if:{{#var:return_text}}| {{#var:return_text}} }}{{PBR}}}}
{{#if:{{{p1_name|}}}{{{p1_type|}}}|{{{!}}
{{LSL DefineRow|1={{{p1_type|}}}|2={{{p1_name|}}}|3={{#var:p_{{{p1_name|}}}_desc}}}}
{{#if:{{{p2_name|}}}{{{p2_type|}}}|{{LSL DefineRow|1={{{p2_type|}}}|2={{{p2_name|}}}|3={{#var:p_{{{p2_name|}}}_desc}}}}
{{#if:{{{p3_name|}}}{{{p3_type|}}}|{{LSL DefineRow|1={{{p3_type|}}}|2={{{p3_name|}}}|3={{#var:p_{{{p3_name|}}}_desc}}}}
{{#if:{{{p4_name|}}}{{{p4_type|}}}|{{LSL DefineRow|1={{{p4_type|}}}|2={{{p4_name|}}}|3={{#var:p_{{{p4_name|}}}_desc}}}}
{{#if:{{{p5_name|}}}{{{p5_type|}}}|{{LSL DefineRow|1={{{p5_type|}}}|2={{{p5_name|}}}|3={{#var:p_{{{p5_name|}}}_desc}}}}
{{#if:{{{p6_name|}}}{{{p6_type|}}}|{{LSL DefineRow|1={{{p6_type|}}}|2={{{p6_name|}}}|3={{#var:p_{{{p6_name|}}}_desc}}}}
{{#if:{{{p7_name|}}}{{{p7_type|}}}|{{LSL DefineRow|1={{{p7_type|}}}|2={{{p7_name|}}}|3={{#var:p_{{{p7_name|}}}_desc}}}}
{{#if:{{{p8_name|}}}{{{p8_type|}}}|{{LSL DefineRow|1={{{p8_type|}}}|2={{{p8_name|}}}|3={{#var:p_{{{p8_name|}}}_desc}}}}
{{#if:{{{p9_name|}}}{{{p9_type|}}}|{{LSL DefineRow|1={{{p9_type|}}}|2={{{p9_name|}}}|3={{#var:p_{{{p9_name|}}}_desc}}}}
{{#if:{{{p10_name|}}}{{{p10_type|}}}|{{LSL DefineRow|1={{{p10_type|}}}|2={{{p10_name|}}}|3={{#var:p_{{{p10_name|}}}_desc}}}}
{{#if:{{{p11_name|}}}{{{p11_type|}}}|{{LSL DefineRow|1={{{p11_type|}}}|2={{{p11_name|}}}|3={{#var:p_{{{p11_name|}}}_desc}}}}
{{#if:{{{p12_name|}}}{{{p12_type|}}}|{{LSL DefineRow|1={{{p12_type|}}}|2={{{p12_name|}}}|3={{#var:p_{{{p12_name|}}}_desc}}}}
}}}}}}}}}}}}}}}}}}}}}}
{{!}}}
}}{{#if:{{#var:header_footnote}}|
<div style="margin-top:0.5em;"></div>
{{#var:header_footnote}}
}}</div>
</div>{{#ifexist:{{#var:newbie}}|<div id="box">
<h2>[[{{#var:newbie}}|Appunti dei principianti]]</h2>
<div style="padding: 0.5em; max-height:10em; overflow-x:visible; overflow-y:auto;">
{{:{{#var:newbie}}}}
</div><div style="padding:0 0.5em;">
Per proseguire la lettura si veda: [[{{#var:newbie}}|Appunti dei principianti]]
</div></div>}}{{#if:{{#var:spec}}|<div id="box">
<h2>Specificazione</h2>
<div style="padding: 0.5em;">
{{#var:spec}}
</div></div>}}{{#if:{{#var:constants_nb}}{{#var:constants}}|
{{#var:constants_nb}}
{{#if:{{#var:constants}}|
<div id="box">
<h2>Costanti</h2>
{{#var:constants}}
</div>}}}}{{#if:{{#var:caveats}}|<div id="box">
<h2>Avvertimenti</h2>
<div style="padding: 0.5em;">
{{#var:caveats}}
</div></div>}}{{#if:{{#if:{{#var:deprecated}}||t}}{{#var:examples}}{{#simple-examples}}{{#complex-examples}}|<div id="box">
<h2>Esempi</h2>
<div style="padding: 0.5em;">
{{#var:examples}}{{#if:{{#var:simple-examples}}|
<div style="float:left; min-width:200px; width:45%;">
===Esempi semplici===
{{{!}}
{{#var:simple-examples}}
{{!}}}
</div>}}{{#if:{{#var:complex-examples}}|
<div style="float:left;">
===Esempi complessi===
{{{!}}
{{#var:complex-examples}}
{{!}}}
</div>}}<div style="clear:left;"></div>
</div></div>}}{{#if:{{#var:helpers}}|<div id="box">
<h2>Ritagli di codice utili</h2>
<div style="padding: 0.5em;">
{{#var:helpers}}
</div></div>}}{{#if:{{#var:notes}}|<div id="box">
<h2>Note</h2>
<div style="padding: 0.5em;">
{{#var:notes}}
</div></div>}}{{#if:{{#var:also_footer}}{{#var:also_functions}}{{#var:also_events}}{{#var:also_articles}}{{#var:also_header}}{{#var:also_library}}{{#var:also_constants}}|<div id="box">
<h2>Si veda anche</h2>
<div style="padding: 0.5em;">
{{#if:{{#var:also_header}}|<div>
{{#var:also_header}}
</div>}}{{#if:{{#var:also_constants}}|
<h3>Costanti</h3>
{{{!}}
{{#var:also_constants}}
{{!}}} }}{{#if:{{#var:also_events}}|
<h3>Eventi</h3>
{{{!}}
{{#var:also_events}}
{{!}}} }}{{#if:{{#var:also_functions}}|
<h3>Funzioni</h3>
{{{!}}
{{#var:also_functions}}
{{!}}} }}{{#if:{{#var:also_articles}}|
<h3>Articoli</h3>
{{{!}}
{{#var:also_articles}}
{{!}}} }}{{#if:{{#var:also_library}}|
<h3>Librerie ed esempi</h3>
{{{!}}
{{#var:also_library}}
{{!}}} }}{{#if:{{#var:also_footer}}|
<div style="margin-top:0.5em;">
{{#var:also_footer}}
</div>}}
</div></div>}}
<div id="box">
== Note approfondite ==
<div style="padding: 0.5em"><div>
{{#var:deepnotes}}
</div>{{#if:{{#var:mono}}|
<h4> Note sulla Mono VM </h4><div>
{{#var:mono}}
</div>}}{{#if:{{#var:lso}}|
<h4> Note sulla LSO VM </h4><div>
{{#var:lso}}
</div>}}{{#if:{{#var:history}}|
<h4> Storia </h4><div>
{{#var:history}}
</div>}}
{{Anchor|Issues}}{{LSL_Generic/Issues}}{{#if:{{#var:also_tests}}|
<h3> Prove </h3>
{{{!}}
{{#var:also_tests}}
{{!}}}
}}{{#if:{{#var:location}}|
<h4> Fonte </h4><div>
{{#var:location}}
</div>}}{{#if:{{#var:messaging}}|
<h4> Messaggistica </h4><div>
{{#var:messaging}}
</div>}}{{#if:{{#var:footnotes}}|
<h4 style="margin-bottom:0;"> Note a pié pagina </h4>
{{{{#if:{{#var:footnotes}}|Footnotes|!}}|}}
}}
{{Collapsible_Table|collapsed=*|table-style=width:100%;|title-style=text-align:left;|title=<h4 style="margin-top:0;">Firma</h4>|content={{!}}
{{#tag:pre|{{#if:{{#pos:{{#var:moded}}|u}}||{{#if:{{#pos:{{#var:moded}}|r}}|//}}function {{#if:{{{return_type|}}}|{{{return_type|}}}|void}} {{{func}}}( {{#if:{{{p1_name|}}}{{{p1_type|}}}| {{{p1_type|}}} {{{p1_name|}}}{{#if:{{{p2_name|}}}{{{p2_type|}}}|, {{{p2_type|}}} {{{p2_name|}}}{{#if:{{{p3_name|}}}{{{p3_type|}}}|, {{{p3_type|}}} {{{p3_name|}}}{{#if:{{{p4_name|}}}{{{p4_type|}}}|, {{{p4_type|}}} {{{p4_name|}}}{{#if:{{{p5_name|}}}{{{p5_type|}}}|, {{{p5_type|}}} {{{p5_name|}}}{{#if:{{{p6_name|}}}{{{p6_type|}}}|, {{{p6_type|}}} {{{p6_name|}}}{{#if:{{{p7_name|}}}{{{p7_type|}}}|, {{{p7_type|}}} {{{p7_name|}}}{{#if:{{{p8_name|}}}{{{p8_type|}}}|, {{{p8_type|}}} {{{p8_name|}}}{{#if:{{{p9_name|}}}{{{p9_type|}}}|, {{{p9_type|}}} {{{p9_name|}}}{{#if:{{{p10_name|}}}{{{p10_type|}}}|, {{{p10_type|}}} {{{p10_name|}}}{{#if:{{{p11_name|}}}{{{p11_type|}}}|, {{{p11_type|}}} {{{p11_name|}}}{{#if:{{{p12_name|}}}{{{p12_type|}}}|, {{{p12_type|}}} {{{p12_name|}}}}}}}}}}}}}}}}}}}}}}}}}}} )<nowiki>;</nowiki>{{#if:{{{desc|}}}|//{{{desc|}}}}}
<nowiki></nowiki>}}{{#if:{{{signature|}}}|{{{signature|}}}
}}{{#if:{{#var:signature}}|{{#var:signature}}
}}|id="lsl-signature"}}}}
</div></div>{{#if:{{{comments|}}}|<div id="box">
<h2>Commenti</h2>
<div style="padding: 0.5em;">
{{{comments|}}}
</div></div>}}
<div style="display:none" class="hidden-text" id="hidden-text">{{#var:hidden-text}}</div>
{{#var:footer}} {{#if:{{#var:self}}|| {{#if:{{#pos:{{#var:moded}}|r}}{{#pos:{{#var:moded}}|u}}|| [[Category:LSL Functions{{#var:lang}}]] {{#if:{{#pos:{{#var:moded}}|f}}||{{#ifexpr:{{#var:BugCounter|0}} > 0|[[Category:LSL topics with bugs{{#var:lang}}]] [[Category:LSL topics with the most bugs{{#var:lang}}| {{#pad:{{#expr:100-{{#var:BugCounter|0}}}}|2|0}}{{PAGENAME}}]]}}}} {{#iferror:{{#expr:{{#var:func_id}}}}|[[Category:LSL Functions/Without IDs{{#var:lang}}]]|[[Category:LSL Functions/ID{{#var:lang}}| {{padleft:{{#var:func_id}}|5|0}}]]}} {{#if:{{#var:examples}}||[[Category:LSL Needs Example{{#var:lang}}]]}} {{LSL Unhelpful|{{{func}}}|}} }} {{#if:{{{cat1|}}}|[[Category:LSL {{{cat1}}}{{#var:lang}}]]}} {{#if:{{{cat2|}}}|[[Category:LSL {{{cat2}}}{{#var:lang}}]]}} {{#if:{{{cat3|}}}|[[Category:LSL {{{cat3}}}{{#var:lang}}]]}} {{#if:{{{cat4|}}}|[[Category:LSL {{{cat4}}}{{#var:lang}}]]}} {{#if:{{{cat5|}}}|[[Category:LSL {{{cat5}}}{{#var:lang}}]]}} {{#if:{{{cat6|}}}|[[Category:LSL {{{cat6}}}{{#var:lang}}]]}} {{#if:{{{cat7|}}}|[[Category:LSL {{{cat7}}}{{#var:lang}}]]}} {{#if:{{{cat8|}}}|[[Category:LSL {{{cat8}}}{{#var:lang}}]]}} }}</includeonly>

Template:LSL Function/it

2012-01-15T18:53:10Z

Violet Hammerer:

{{Multi-lang|category=LSL|2=}}{{LSL Header{{#var:lang}}}} __NOTOC__ <noinclude>
Si veda [[{{#var:langbase}}/docs{{#var:lang}}]] per la documentazione.
</noinclude><includeonly>{{#if:{{#var:sort}}||{{#if:{{{sort|}}}|{{#vardefine:sort|{{{sort|}}}}}|{{#if:{{LSL_Sort}}}}}}}}<div id="sort" style="display:none">{{DEFAULTSORT:{{#var:sort}}}}{{#var:sort}}</div>{{#if:{{#var:nofixname}}||{{#if:{{#pos:{{lc:{{FULLPAGENAMEE}}}}|{{lc:{{{func}}}}}}}|<div id="RealTitleBanner" style="display:none"><span id="RealTitle">{{#if:{{NAMESPACE}}|{{NAMESPACE}}:}}{{{func}}}</span></div>}}}}{{#if:

{{#vardefine:article_type|function}}

{{#vardefine:name|{{{func|}}}}}
{{#if:{{{func_id|}}}|{{#vardefine:func_id|{{{func_id|}}}}}}}

{{#vardefine:mode|{{#var:mode}}{{{mode|}}}}}
{{#vardefine:self|{{#var:self}}{{{self|}}}}}

{{{inject-1|}}}

{{{{#switch:{{#var:mode}}
|god=LSL_Generic/god{{#var:lang}}
|request=LSL_Generic/request{{#var:lang}}
|pre-release=LSL_Generic/pre-release{{#var:lang}}
|rc=LSL_Generic/RC{{#var:lang}}
|preview=LSL_Generic/preview{{#var:lang}}
|user=!{{#vardefine:moded|u{{#var:moded}}}}
|!}}|}}
{{{{#if:{{{deprecated|}}}|LSL_Generic/deprecated{{#var:lang}}|!}}|{{{deprecated|}}}|}}

{{{inject-2|}}}

{{#vardefine:p_{{{p1_name|}}}_desc|{{#var:p_{{{p1_name|}}}_desc}}{{{p1_desc|}}}}}
{{#vardefine:p_{{{p1_name|}}}_hover|{{#var:p_{{{p1_name|}}}_hover}}{{{p1_hover|}}}}}
{{#vardefine:p_{{{p2_name|}}}_desc|{{#var:p_{{{p2_name|}}}_desc}}{{{p2_desc|}}}}}
{{#vardefine:p_{{{p2_name|}}}_hover|{{#var:p_{{{p2_name|}}}_hover}}{{{p2_hover|}}}}}
{{#vardefine:p_{{{p3_name|}}}_desc|{{#var:p_{{{p3_name|}}}_desc}}{{{p3_desc|}}}}}
{{#vardefine:p_{{{p3_name|}}}_hover|{{#var:p_{{{p3_name|}}}_hover}}{{{p3_hover|}}}}}
{{#vardefine:p_{{{p4_name|}}}_desc|{{#var:p_{{{p4_name|}}}_desc}}{{{p4_desc|}}}}}
{{#vardefine:p_{{{p4_name|}}}_hover|{{#var:p_{{{p4_name|}}}_hover}}{{{p4_hover|}}}}}
{{#vardefine:p_{{{p5_name|}}}_desc|{{#var:p_{{{p5_name|}}}_desc}}{{{p5_desc|}}}}}
{{#vardefine:p_{{{p5_name|}}}_hover|{{#var:p_{{{p5_name|}}}_hover}}{{{p5_hover|}}}}}
{{#vardefine:p_{{{p6_name|}}}_desc|{{#var:p_{{{p6_name|}}}_desc}}{{{p6_desc|}}}}}
{{#vardefine:p_{{{p6_name|}}}_hover|{{#var:p_{{{p6_name|}}}_hover}}{{{p6_hover|}}}}}
{{#vardefine:p_{{{p7_name|}}}_desc|{{#var:p_{{{p7_name|}}}_desc}}{{{p7_desc|}}}}}
{{#vardefine:p_{{{p7_name|}}}_hover|{{#var:p_{{{p7_name|}}}_hover}}{{{p7_hover|}}}}}
{{#vardefine:p_{{{p8_name|}}}_desc|{{#var:p_{{{p8_name|}}}_desc}}{{{p8_desc|}}}}}
{{#vardefine:p_{{{p8_name|}}}_hover|{{#var:p_{{{p8_name|}}}_hover}}{{{p8_hover|}}}}}
{{#vardefine:p_{{{p9_name|}}}_desc|{{#var:p_{{{p9_name|}}}_desc}}{{{p9_desc|}}}}}
{{#vardefine:p_{{{p9_name|}}}_hover|{{#var:p_{{{p9_name|}}}_hover}}{{{p9_hover|}}}}}
{{#vardefine:p_{{{p10_name|}}}_desc|{{#var:p_{{{p10_name|}}}_desc}}{{{p10_desc|}}}}}
{{#vardefine:p_{{{p10_name|}}}_hover|{{#var:p_{{{p10_name|}}}_hover}}{{{p10_hover|}}}}}
{{#vardefine:p_{{{p11_name|}}}_desc|{{#var:p_{{{p11_name|}}}_desc}}{{{p11_desc|}}}}}
{{#vardefine:p_{{{p11_name|}}}_hover|{{#var:p_{{{p11_name|}}}_hover}}{{{p11_hover|}}}}}
{{#vardefine:p_{{{p12_name|}}}_desc|{{#var:p_{{{p12_name|}}}_desc}}{{{p12_desc|}}}}}
{{#vardefine:p_{{{p12_name|}}}_hover|{{#var:p_{{{p12_name|}}}_hover}}{{{p12_hover|}}}}}

{{{inject-3|}}}

{{#if:{{#var:header_desc}}{{{func_desc|}}}|
{{#vardefine:header_desc|{{#var:header_desc}}{{PBR}}
{{{func_desc|}}}{{PBR}}}}
}}

{{#vardefine:return_text|{{#var:return_text}}{{{return_text|}}}{{{Return_text|}}} }}

{{#if:{{#var:header_footnote}}{{{func_footnote|}}}{{{func_footer|}}}|
{{#vardefine:header_footnote|{{#var:header_footnote}}{{PBR}}
{{{func_footnote|}}}{{PBR}}
{{{func_footer|}}}{{PBR}}}}
}}

{{#if:{{#var:newbie}}||
{{#vardefine:newbie|{{#if:{{{newbie|}}}|{{{newbie|}}}|{{#var:langbase}}/Newbie Notes{{#var:lang}}}}}}
}}

{{#if:{{#var:spec}}{{{spec|}}}|
{{#vardefine:spec|{{#var:spec}}{{PBR}}
{{{spec|}}}{{PBR}}}}
}}

{{#if:{{#var:constants_nb}}{{{constants|}}}|
{{#vardefine:constants_nb|{{#var:constants_nb}}{{PBR}}
{{{constants|}}}{{PBR}}}}
}}

{{#vardefine:bugs|{{#var:bugs}}
{{{bugs|}}}}}

{{#vardefine:caveats|{{#ifexpr:{{{func_sleep|0.0}}}> 0.0|* <span id="caveats-sleep"></span> Questa funzione provoca una pausa di {{{func_sleep|}}} secondo/i nell'esecuzione dello script. {{{func_sleep_note|}}}|{{#if:{{{func_sleep_note|}}}|* <span id="caveats-sleep"></span> {{{func_sleep_note|}}}}}}}{{#if:{{#var:caveats}}|
{{#var:caveats}}}}{{#if:{{{caveats|}}}|
{{{caveats|}}}}}}}

{{#if:{{#pos:{{#var:moded}}|u}}||{{#vardefine:caveats|{{LSL_Generic/Caveats}}}}}}

{{#if:{{#var:examples}}{{{examples|}}}|
{{#vardefine:examples|{{#var:examples}}{{PBR}}
{{{examples|}}}{{PBR}}}}
}}

{{#vardefine:simple-examples|{{#var:simple-examples}}
{{{simple-examples|}}}}}

{{#vardefine:complex-examples|{{#var:complex-examples}}
{{{complex-examples|}}}}}

{{#if:{{#var:helpers}}{{{helpers|}}}|
{{#vardefine:helpers|{{#var:helpers}}{{PBR}}
{{{helpers|}}}{{PBR}}}}
}}

{{#if:{{#var:also_header}}{{{also_header|}}}|
{{#vardefine:also_header|{{#var:also_header}}{{PBR}}
{{{also_header|}}}{{PBR}}}}
}}

{{#vardefine:also_constants|{{#var:also_constants}}
{{{also_constants|}}}}}

{{#vardefine:also_events|{{#var:also_events}}
{{{also_events|}}}}}

{{#vardefine:also_functions|{{#var:also_functions}}
{{{also_functions|}}}}}

{{#vardefine:also_articles|{{#var:also_articles}}
{{{also_articles|}}}}}

{{#vardefine:also_library|{{#var:also_library}}
{{{also_library|}}}}}

{{#if:{{#var:also_footer}}{{{also_footer|}}}|
{{#vardefine:also_footer|{{#var:also_footer}}{{PBR}}
{{{also_footer|}}}{{PBR}}}}
}}

{{#if:{{#var:notes}}{{{notes|}}}|
{{#vardefine:notes|{{#var:notes}}{{PBR}}
{{{notes|}}}{{PBR}}}}
}}

{{#if:{{#var:history}}{{{history|}}}|
{{#vardefine:history|{{#var:history}}{{PBR}}
{{{history|}}}{{PBR}}}}
}}

{{#if:{{#var:deepnotes}}{{{deepnotes|}}}|
{{#vardefine:deepnotes|{{#var:deepnotes}}{{PBR}}
{{{deepnotes|}}}{{PBR}}}}
}}

{{#if:{{#var:mono}}{{{mono|}}}|
{{#vardefine:mono|{{#var:mono}}{{PBR}}
{{{mono|}}}{{PBR}}}}
}}

{{#if:{{#var:lso}}{{{lso|}}}|
{{#vardefine:lso|{{#var:lso}}{{PBR}}
{{{lso|}}}{{PBR}}}}
}}

{{#vardefine:issues|{{#var:issues}}
{{{issues|}}}}}

{{#vardefine:also_tests|{{#var:also_tests}}
{{{also_tests|}}}}}

{{#if:{{#var:location}}{{{location|}}}|
{{#vardefine:location|{{#var:location}}{{PBR}}
{{{location|}}}{{PBR}}}}
}}

{{#if:{{#var:messaging}}{{{messaging|}}}|
{{#vardefine:messaging|{{#var:messaging}}{{PBR}}
{{{messaging|}}}{{PBR}}}}
}}

}}{{#if:{{#var:self}}|| __NOEDITSECTION__
}}{{#var:header}}{{#if:{{#var:func_id}}{{#var:mode}}{{#var:moded}}||
{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}{{#if:{{#if:{{{return_type|}}}|{{#var:return_text}}}}{{{func_desc|}}}||<div id="box" style="background:yellow;">
  '''O 'func_desc', o 'return_type' e 'return_text' devono essere definiti'''
<div style="padding: 0.5em;background:#ffffff;">
''(Per favore usate 'return_text' e 'return_type', o 'func_desc' per descrivere sommariamente le azioni della funzione.)''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}
{{RightToc|font-size:80%}}
<div id="box"><h2 style="display:none"> Sommario </h2>{{#ifexpr:{{#var:BugCounter|0}} > 0|<div class="mw-headline" style="float:right; margin: 5px 0.5em 0 0.5em;">{{LSL_Bug_Icon}}</div>}}<span id="{{anchorencode:Description}}" style="display:none"></span><span id="{{anchorencode:Summary}}" class="mw-headline" style="display:block; padding-bottom:0.17em; padding-top:0.5em; background:transparent none repeat scroll 0% 0%; color:#546368; font-family:Arial,Helvetica,Sans-Serif; background-color:#F4F8FB; border-bottom:1px dotted #AAAAAA; font-size:120%; font-weight:bold; margin:0pt; padding:0.2em 0.5em; text-align:left;"> [[:Category:LSL_Functions{{#var:lang}}|Function]]: {{#if:{{{return_type|}}}|[[{{{return_type|}}}{{#var:lang}}|{{{return_type|}}}]]||}} '''{{{func}}}'''( {{#if:{{{p1_name|}}}{{{p1_type|}}}| [[{{{p1_type|}}}{{#var:lang}}|{{{p1_type|}}}]] {{LSL Param|{{{p1_name|}}}}}{{#if:{{{p2_name|}}}{{{p2_type|}}}|, [[{{{p2_type|}}}{{#var:lang}}|{{{p2_type|}}}]] {{LSL Param|{{{p2_name|}}}}}{{#if:{{{p3_name|}}}{{{p3_type|}}}|, [[{{{p3_type|}}}{{#var:lang}}|{{{p3_type|}}}]] {{LSL Param|{{{p3_name|}}}}}{{#if:{{{p4_name|}}}{{{p4_type|}}}|, [[{{{p4_type|}}}{{#var:lang}}|{{{p4_type|}}}]] {{LSL Param|{{{p4_name|}}}}}{{#if:{{{p5_name|}}}{{{p5_type|}}}|, [[{{{p5_type|}}}{{#var:lang}}|{{{p5_type|}}}]] {{LSL Param|{{{p5_name|}}}}}{{#if:{{{p6_name|}}}{{{p6_type|}}}|, [[{{{p6_type|}}}{{#var:lang}}|{{{p6_type|}}}]] {{LSL Param|{{{p6_name|}}}}}{{#if:{{{p7_name|}}}{{{p7_type|}}}|, [[{{{p7_type|}}}{{#var:lang}}|{{{p7_type|}}}]] {{LSL Param|{{{p7_name|}}}}}{{#if:{{{p8_name|}}}{{{p8_type|}}}|, [[{{{p8_type|}}}{{#var:lang}}|{{{p8_type|}}}]] {{LSL Param|{{{p8_name|}}}}}{{#if:{{{p9_name|}}}{{{p9_type|}}}|, [[{{{p9_type|}}}{{#var:lang}}|{{{p9_type|}}}]] {{LSL Param|{{{p9_name|}}}}}{{#if:{{{p10_name|}}}{{{p10_type|}}}|, [[{{{p10_type|}}}{{#var:lang}}|{{{p10_type|}}}]] {{LSL Param|{{{p10_name|}}}}}{{#if:{{{p11_name|}}}{{{p11_type|}}}|, [[{{{p11_type|}}}{{#var:lang}}|{{{p11_type|}}}]] {{LSL Param|{{{p11_name|}}}}}{{#if:{{{p12_name|}}}{{{p12_type|}}}|, [[{{{p12_type|}}}{{#var:lang}}|{{{p12_type|}}}]] {{LSL Param|{{{p12_name|}}}}}}}}}}}}}}}}}}}}}}}}}}}}} )<nowiki>;</nowiki></span>
<div style="padding: 0.5em; min-height: {{#if:{{{func_complexity|}}}|6em;|5em;}}">{{#if:{{#pos:{{#var:moded}}|u}}|{{#if:{{#var:floater}}|<div id="box" style="float:right;">{{#var:floater}}</div>}}|<div id="box" style="float:right; margin: 0 0.5em; font-size:90%;">
{{{!}} class="collapsible"
{{!}}- style="font-size:75%;"
{{!}}+
{{!}}-
{{!}} {{HoverText|{{#var:func_id}}|Il numero d'indice della funzione.}}
{{!}} [[LSL Function ID{{#var:lang}}|ID funzione]]
{{!}}-
{{!}} {{HoverText|{{{func_sleep|}}}|Il numero di secondi per cui lo script sarà in pausa dopo avere eseguito questa funzione.}}{{#if:{{{func_sleep_note|}}}|{{HoverLink|#caveats-sleep|3=*|2={{{func_sleep_note|}}}}}}}
{{!}} [[LSL Delay{{#var:lang}}|Ritardo]]
{{!}}-
{{#if:{{{func_complexity|}}}|
{{!}} {{HoverText|{{{func_complexity|}}}|La complessità della funzione, basata sui parametri.}}
{{!}} [[LSL Complexity{{#var:lang}}|Compl.]]
{{!}}-}}
{{!}} {{HoverText|{{{func_energy|}}}|La quantità di energia consumata da questa funzione.}}
{{!}} [[Energy{{#var:lang}}|Energia]]
{{!}}}</div>}}
{{#if:{{#var:header_desc}}|{{#var:header_desc}}{{PBR}}{{#if:{{{return_type|}}}|<br id="bdart"/>}}}}{{#if:{{{return_type|}}}| REstituisce un/una {{It|{{{return_type|}}}|{{{Return_text|}}}}} {{#if:{{#var:return_text}}| {{#var:return_text}} }}{{PBR}}}}
{{#if:{{{p1_name|}}}{{{p1_type|}}}|{{{!}}
{{LSL DefineRow|1={{{p1_type|}}}|2={{{p1_name|}}}|3={{#var:p_{{{p1_name|}}}_desc}}}}
{{#if:{{{p2_name|}}}{{{p2_type|}}}|{{LSL DefineRow|1={{{p2_type|}}}|2={{{p2_name|}}}|3={{#var:p_{{{p2_name|}}}_desc}}}}
{{#if:{{{p3_name|}}}{{{p3_type|}}}|{{LSL DefineRow|1={{{p3_type|}}}|2={{{p3_name|}}}|3={{#var:p_{{{p3_name|}}}_desc}}}}
{{#if:{{{p4_name|}}}{{{p4_type|}}}|{{LSL DefineRow|1={{{p4_type|}}}|2={{{p4_name|}}}|3={{#var:p_{{{p4_name|}}}_desc}}}}
{{#if:{{{p5_name|}}}{{{p5_type|}}}|{{LSL DefineRow|1={{{p5_type|}}}|2={{{p5_name|}}}|3={{#var:p_{{{p5_name|}}}_desc}}}}
{{#if:{{{p6_name|}}}{{{p6_type|}}}|{{LSL DefineRow|1={{{p6_type|}}}|2={{{p6_name|}}}|3={{#var:p_{{{p6_name|}}}_desc}}}}
{{#if:{{{p7_name|}}}{{{p7_type|}}}|{{LSL DefineRow|1={{{p7_type|}}}|2={{{p7_name|}}}|3={{#var:p_{{{p7_name|}}}_desc}}}}
{{#if:{{{p8_name|}}}{{{p8_type|}}}|{{LSL DefineRow|1={{{p8_type|}}}|2={{{p8_name|}}}|3={{#var:p_{{{p8_name|}}}_desc}}}}
{{#if:{{{p9_name|}}}{{{p9_type|}}}|{{LSL DefineRow|1={{{p9_type|}}}|2={{{p9_name|}}}|3={{#var:p_{{{p9_name|}}}_desc}}}}
{{#if:{{{p10_name|}}}{{{p10_type|}}}|{{LSL DefineRow|1={{{p10_type|}}}|2={{{p10_name|}}}|3={{#var:p_{{{p10_name|}}}_desc}}}}
{{#if:{{{p11_name|}}}{{{p11_type|}}}|{{LSL DefineRow|1={{{p11_type|}}}|2={{{p11_name|}}}|3={{#var:p_{{{p11_name|}}}_desc}}}}
{{#if:{{{p12_name|}}}{{{p12_type|}}}|{{LSL DefineRow|1={{{p12_type|}}}|2={{{p12_name|}}}|3={{#var:p_{{{p12_name|}}}_desc}}}}
}}}}}}}}}}}}}}}}}}}}}}
{{!}}}
}}{{#if:{{#var:header_footnote}}|
<div style="margin-top:0.5em;"></div>
{{#var:header_footnote}}
}}</div>
</div>{{#ifexist:{{#var:newbie}}|<div id="box">
<h2>[[{{#var:newbie}}|Appunti dei principianti]]</h2>
<div style="padding: 0.5em; max-height:10em; overflow-x:visible; overflow-y:auto;">
{{:{{#var:newbie}}}}
</div><div style="padding:0 0.5em;">
Per proseguire la lettura si veda: [[{{#var:newbie}}|Appunti dei principianti]]
</div></div>}}{{#if:{{#var:spec}}|<div id="box">
<h2>Specificazione</h2>
<div style="padding: 0.5em;">
{{#var:spec}}
</div></div>}}{{#if:{{#var:constants_nb}}{{#var:constants}}|
{{#var:constants_nb}}
{{#if:{{#var:constants}}|
<div id="box">
<h2>Costanti</h2>
{{#var:constants}}
</div>}}}}{{#if:{{#var:caveats}}|<div id="box">
<h2>Avvertimenti</h2>
<div style="padding: 0.5em;">
{{#var:caveats}}
</div></div>}}{{#if:{{#if:{{#var:deprecated}}||t}}{{#var:examples}}{{#simple-examples}}{{#complex-examples}}|<div id="box">
<h2>Esempi</h2>
<div style="padding: 0.5em;">
{{#var:examples}}{{#if:{{#var:simple-examples}}|
<div style="float:left; min-width:200px; width:45%;">
===Esempi semplici===
{{{!}}
{{#var:simple-examples}}
{{!}}}
</div>}}{{#if:{{#var:complex-examples}}|
<div style="float:left;">
===Esempi complessi===
{{{!}}
{{#var:complex-examples}}
{{!}}}
</div>}}<div style="clear:left;"></div>
</div></div>}}{{#if:{{#var:helpers}}|<div id="box">
<h2>Ritagli di codice utili</h2>
<div style="padding: 0.5em;">
{{#var:helpers}}
</div></div>}}{{#if:{{#var:notes}}|<div id="box">
<h2>Note</h2>
<div style="padding: 0.5em;">
{{#var:notes}}
</div></div>}}{{#if:{{#var:also_footer}}{{#var:also_functions}}{{#var:also_events}}{{#var:also_articles}}{{#var:also_header}}{{#var:also_library}}{{#var:also_constants}}|<div id="box">
<h2>Si veda anche</h2>
<div style="padding: 0.5em;">
{{#if:{{#var:also_header}}|<div>
{{#var:also_header}}
</div>}}{{#if:{{#var:also_constants}}|
<h3>Costanti</h3>
{{{!}}
{{#var:also_constants}}
{{!}}} }}{{#if:{{#var:also_events}}|
<h3>Eventi</h3>
{{{!}}
{{#var:also_events}}
{{!}}} }}{{#if:{{#var:also_functions}}|
<h3>Funzioni</h3>
{{{!}}
{{#var:also_functions}}
{{!}}} }}{{#if:{{#var:also_articles}}|
<h3>Articoli</h3>
{{{!}}
{{#var:also_articles}}
{{!}}} }}{{#if:{{#var:also_library}}|
<h3>Librerie ed esempi</h3>
{{{!}}
{{#var:also_library}}
{{!}}} }}{{#if:{{#var:also_footer}}|
<div style="margin-top:0.5em;">
{{#var:also_footer}}
</div>}}
</div></div>}}
<div id="box">
== Note approfondite ==
<div style="padding: 0.5em"><div>
{{#var:deepnotes}}
</div>{{#if:{{#var:mono}}|
<h4> Note sulla Mono VM </h4><div>
{{#var:mono}}
</div>}}{{#if:{{#var:lso}}|
<h4> Note sulla LSO VM </h4><div>
{{#var:lso}}
</div>}}{{#if:{{#var:history}}|
<h4> Storia </h4><div>
{{#var:history}}
</div>}}
{{Anchor|Issues}}{{LSL_Generic/Issues}}{{#if:{{#var:also_tests}}|
<h3>Tests</h3>
{{{!}}
{{#var:also_tests}}
{{!}}}
}}{{#if:{{#var:location}}|
<h4> Fonte </h4><div>
{{#var:location}}
</div>}}{{#if:{{#var:messaging}}|
<h4> Messaggistica </h4><div>
{{#var:messaging}}
</div>}}{{#if:{{#var:footnotes}}|
<h4 style="margin-bottom:0;"> Footnotes </h4>
{{{{#if:{{#var:footnotes}}|Footnotes|!}}|}}
}}
{{Collapsible_Table|collapsed=*|table-style=width:100%;|title-style=text-align:left;|title=<h4 style="margin-top:0;">Firma</h4>|content={{!}}
{{#tag:pre|{{#if:{{#pos:{{#var:moded}}|u}}||{{#if:{{#pos:{{#var:moded}}|r}}|//}}function {{#if:{{{return_type|}}}|{{{return_type|}}}|void}} {{{func}}}( {{#if:{{{p1_name|}}}{{{p1_type|}}}| {{{p1_type|}}} {{{p1_name|}}}{{#if:{{{p2_name|}}}{{{p2_type|}}}|, {{{p2_type|}}} {{{p2_name|}}}{{#if:{{{p3_name|}}}{{{p3_type|}}}|, {{{p3_type|}}} {{{p3_name|}}}{{#if:{{{p4_name|}}}{{{p4_type|}}}|, {{{p4_type|}}} {{{p4_name|}}}{{#if:{{{p5_name|}}}{{{p5_type|}}}|, {{{p5_type|}}} {{{p5_name|}}}{{#if:{{{p6_name|}}}{{{p6_type|}}}|, {{{p6_type|}}} {{{p6_name|}}}{{#if:{{{p7_name|}}}{{{p7_type|}}}|, {{{p7_type|}}} {{{p7_name|}}}{{#if:{{{p8_name|}}}{{{p8_type|}}}|, {{{p8_type|}}} {{{p8_name|}}}{{#if:{{{p9_name|}}}{{{p9_type|}}}|, {{{p9_type|}}} {{{p9_name|}}}{{#if:{{{p10_name|}}}{{{p10_type|}}}|, {{{p10_type|}}} {{{p10_name|}}}{{#if:{{{p11_name|}}}{{{p11_type|}}}|, {{{p11_type|}}} {{{p11_name|}}}{{#if:{{{p12_name|}}}{{{p12_type|}}}|, {{{p12_type|}}} {{{p12_name|}}}}}}}}}}}}}}}}}}}}}}}}}}} )<nowiki>;</nowiki>{{#if:{{{desc|}}}|//{{{desc|}}}}}
<nowiki></nowiki>}}{{#if:{{{signature|}}}|{{{signature|}}}
}}{{#if:{{#var:signature}}|{{#var:signature}}
}}|id="lsl-signature"}}}}
</div></div>{{#if:{{{comments|}}}|<div id="box">
<h2>Commenti</h2>
<div style="padding: 0.5em;">
{{{comments|}}}
</div></div>}}
<div style="display:none" class="hidden-text" id="hidden-text">{{#var:hidden-text}}</div>
{{#var:footer}} {{#if:{{#var:self}}|| {{#if:{{#pos:{{#var:moded}}|r}}{{#pos:{{#var:moded}}|u}}|| [[Category:LSL Functions{{#var:lang}}]] {{#if:{{#pos:{{#var:moded}}|f}}||{{#ifexpr:{{#var:BugCounter|0}} > 0|[[Category:LSL topics with bugs{{#var:lang}}]] [[Category:LSL topics with the most bugs{{#var:lang}}| {{#pad:{{#expr:100-{{#var:BugCounter|0}}}}|2|0}}{{PAGENAME}}]]}}}} {{#iferror:{{#expr:{{#var:func_id}}}}|[[Category:LSL Functions/Without IDs{{#var:lang}}]]|[[Category:LSL Functions/ID{{#var:lang}}| {{padleft:{{#var:func_id}}|5|0}}]]}} {{#if:{{#var:examples}}||[[Category:LSL Needs Example{{#var:lang}}]]}} {{LSL Unhelpful|{{{func}}}|}} }} {{#if:{{{cat1|}}}|[[Category:LSL {{{cat1}}}{{#var:lang}}]]}} {{#if:{{{cat2|}}}|[[Category:LSL {{{cat2}}}{{#var:lang}}]]}} {{#if:{{{cat3|}}}|[[Category:LSL {{{cat3}}}{{#var:lang}}]]}} {{#if:{{{cat4|}}}|[[Category:LSL {{{cat4}}}{{#var:lang}}]]}} {{#if:{{{cat5|}}}|[[Category:LSL {{{cat5}}}{{#var:lang}}]]}} {{#if:{{{cat6|}}}|[[Category:LSL {{{cat6}}}{{#var:lang}}]]}} {{#if:{{{cat7|}}}|[[Category:LSL {{{cat7}}}{{#var:lang}}]]}} {{#if:{{{cat8|}}}|[[Category:LSL {{{cat8}}}{{#var:lang}}]]}} }}</includeonly>

Template:LSL Function/it

2012-01-15T18:50:12Z

Violet Hammerer:

{{Multi-lang|category=LSL|2=}}{{LSL Header{{#var:lang}}}} __NOTOC__ <noinclude>
Si veda [[{{#var:langbase}}/docs{{#var:lang}}]] per la documentazione.
</noinclude><includeonly>{{#if:{{#var:sort}}||{{#if:{{{sort|}}}|{{#vardefine:sort|{{{sort|}}}}}|{{#if:{{LSL_Sort}}}}}}}}<div id="sort" style="display:none">{{DEFAULTSORT:{{#var:sort}}}}{{#var:sort}}</div>{{#if:{{#var:nofixname}}||{{#if:{{#pos:{{lc:{{FULLPAGENAMEE}}}}|{{lc:{{{func}}}}}}}|<div id="RealTitleBanner" style="display:none"><span id="RealTitle">{{#if:{{NAMESPACE}}|{{NAMESPACE}}:}}{{{func}}}</span></div>}}}}{{#if:

{{#vardefine:article_type|function}}

{{#vardefine:name|{{{func|}}}}}
{{#if:{{{func_id|}}}|{{#vardefine:func_id|{{{func_id|}}}}}}}

{{#vardefine:mode|{{#var:mode}}{{{mode|}}}}}
{{#vardefine:self|{{#var:self}}{{{self|}}}}}

{{{inject-1|}}}

{{{{#switch:{{#var:mode}}
|god=LSL_Generic/god{{#var:lang}}
|request=LSL_Generic/request{{#var:lang}}
|pre-release=LSL_Generic/pre-release{{#var:lang}}
|rc=LSL_Generic/RC{{#var:lang}}
|preview=LSL_Generic/preview{{#var:lang}}
|user=!{{#vardefine:moded|u{{#var:moded}}}}
|!}}|}}
{{{{#if:{{{deprecated|}}}|LSL_Generic/deprecated{{#var:lang}}|!}}|{{{deprecated|}}}|}}

{{{inject-2|}}}

{{#vardefine:p_{{{p1_name|}}}_desc|{{#var:p_{{{p1_name|}}}_desc}}{{{p1_desc|}}}}}
{{#vardefine:p_{{{p1_name|}}}_hover|{{#var:p_{{{p1_name|}}}_hover}}{{{p1_hover|}}}}}
{{#vardefine:p_{{{p2_name|}}}_desc|{{#var:p_{{{p2_name|}}}_desc}}{{{p2_desc|}}}}}
{{#vardefine:p_{{{p2_name|}}}_hover|{{#var:p_{{{p2_name|}}}_hover}}{{{p2_hover|}}}}}
{{#vardefine:p_{{{p3_name|}}}_desc|{{#var:p_{{{p3_name|}}}_desc}}{{{p3_desc|}}}}}
{{#vardefine:p_{{{p3_name|}}}_hover|{{#var:p_{{{p3_name|}}}_hover}}{{{p3_hover|}}}}}
{{#vardefine:p_{{{p4_name|}}}_desc|{{#var:p_{{{p4_name|}}}_desc}}{{{p4_desc|}}}}}
{{#vardefine:p_{{{p4_name|}}}_hover|{{#var:p_{{{p4_name|}}}_hover}}{{{p4_hover|}}}}}
{{#vardefine:p_{{{p5_name|}}}_desc|{{#var:p_{{{p5_name|}}}_desc}}{{{p5_desc|}}}}}
{{#vardefine:p_{{{p5_name|}}}_hover|{{#var:p_{{{p5_name|}}}_hover}}{{{p5_hover|}}}}}
{{#vardefine:p_{{{p6_name|}}}_desc|{{#var:p_{{{p6_name|}}}_desc}}{{{p6_desc|}}}}}
{{#vardefine:p_{{{p6_name|}}}_hover|{{#var:p_{{{p6_name|}}}_hover}}{{{p6_hover|}}}}}
{{#vardefine:p_{{{p7_name|}}}_desc|{{#var:p_{{{p7_name|}}}_desc}}{{{p7_desc|}}}}}
{{#vardefine:p_{{{p7_name|}}}_hover|{{#var:p_{{{p7_name|}}}_hover}}{{{p7_hover|}}}}}
{{#vardefine:p_{{{p8_name|}}}_desc|{{#var:p_{{{p8_name|}}}_desc}}{{{p8_desc|}}}}}
{{#vardefine:p_{{{p8_name|}}}_hover|{{#var:p_{{{p8_name|}}}_hover}}{{{p8_hover|}}}}}
{{#vardefine:p_{{{p9_name|}}}_desc|{{#var:p_{{{p9_name|}}}_desc}}{{{p9_desc|}}}}}
{{#vardefine:p_{{{p9_name|}}}_hover|{{#var:p_{{{p9_name|}}}_hover}}{{{p9_hover|}}}}}
{{#vardefine:p_{{{p10_name|}}}_desc|{{#var:p_{{{p10_name|}}}_desc}}{{{p10_desc|}}}}}
{{#vardefine:p_{{{p10_name|}}}_hover|{{#var:p_{{{p10_name|}}}_hover}}{{{p10_hover|}}}}}
{{#vardefine:p_{{{p11_name|}}}_desc|{{#var:p_{{{p11_name|}}}_desc}}{{{p11_desc|}}}}}
{{#vardefine:p_{{{p11_name|}}}_hover|{{#var:p_{{{p11_name|}}}_hover}}{{{p11_hover|}}}}}
{{#vardefine:p_{{{p12_name|}}}_desc|{{#var:p_{{{p12_name|}}}_desc}}{{{p12_desc|}}}}}
{{#vardefine:p_{{{p12_name|}}}_hover|{{#var:p_{{{p12_name|}}}_hover}}{{{p12_hover|}}}}}

{{{inject-3|}}}

{{#if:{{#var:header_desc}}{{{func_desc|}}}|
{{#vardefine:header_desc|{{#var:header_desc}}{{PBR}}
{{{func_desc|}}}{{PBR}}}}
}}

{{#vardefine:return_text|{{#var:return_text}}{{{return_text|}}}{{{Return_text|}}} }}

{{#if:{{#var:header_footnote}}{{{func_footnote|}}}{{{func_footer|}}}|
{{#vardefine:header_footnote|{{#var:header_footnote}}{{PBR}}
{{{func_footnote|}}}{{PBR}}
{{{func_footer|}}}{{PBR}}}}
}}

{{#if:{{#var:newbie}}||
{{#vardefine:newbie|{{#if:{{{newbie|}}}|{{{newbie|}}}|{{#var:langbase}}/Newbie Notes{{#var:lang}}}}}}
}}

{{#if:{{#var:spec}}{{{spec|}}}|
{{#vardefine:spec|{{#var:spec}}{{PBR}}
{{{spec|}}}{{PBR}}}}
}}

{{#if:{{#var:constants_nb}}{{{constants|}}}|
{{#vardefine:constants_nb|{{#var:constants_nb}}{{PBR}}
{{{constants|}}}{{PBR}}}}
}}

{{#vardefine:bugs|{{#var:bugs}}
{{{bugs|}}}}}

{{#vardefine:caveats|{{#ifexpr:{{{func_sleep|0.0}}}> 0.0|* <span id="caveats-sleep"></span> Questa funzione provoca una pausa di {{{func_sleep|}}} secondo/i nell'esecuzione dello script. {{{func_sleep_note|}}}|{{#if:{{{func_sleep_note|}}}|* <span id="caveats-sleep"></span> {{{func_sleep_note|}}}}}}}{{#if:{{#var:caveats}}|
{{#var:caveats}}}}{{#if:{{{caveats|}}}|
{{{caveats|}}}}}}}

{{#if:{{#pos:{{#var:moded}}|u}}||{{#vardefine:caveats|{{LSL_Generic/Caveats}}}}}}

{{#if:{{#var:examples}}{{{examples|}}}|
{{#vardefine:examples|{{#var:examples}}{{PBR}}
{{{examples|}}}{{PBR}}}}
}}

{{#vardefine:simple-examples|{{#var:simple-examples}}
{{{simple-examples|}}}}}

{{#vardefine:complex-examples|{{#var:complex-examples}}
{{{complex-examples|}}}}}

{{#if:{{#var:helpers}}{{{helpers|}}}|
{{#vardefine:helpers|{{#var:helpers}}{{PBR}}
{{{helpers|}}}{{PBR}}}}
}}

{{#if:{{#var:also_header}}{{{also_header|}}}|
{{#vardefine:also_header|{{#var:also_header}}{{PBR}}
{{{also_header|}}}{{PBR}}}}
}}

{{#vardefine:also_constants|{{#var:also_constants}}
{{{also_constants|}}}}}

{{#vardefine:also_events|{{#var:also_events}}
{{{also_events|}}}}}

{{#vardefine:also_functions|{{#var:also_functions}}
{{{also_functions|}}}}}

{{#vardefine:also_articles|{{#var:also_articles}}
{{{also_articles|}}}}}

{{#vardefine:also_library|{{#var:also_library}}
{{{also_library|}}}}}

{{#if:{{#var:also_footer}}{{{also_footer|}}}|
{{#vardefine:also_footer|{{#var:also_footer}}{{PBR}}
{{{also_footer|}}}{{PBR}}}}
}}

{{#if:{{#var:notes}}{{{notes|}}}|
{{#vardefine:notes|{{#var:notes}}{{PBR}}
{{{notes|}}}{{PBR}}}}
}}

{{#if:{{#var:history}}{{{history|}}}|
{{#vardefine:history|{{#var:history}}{{PBR}}
{{{history|}}}{{PBR}}}}
}}

{{#if:{{#var:deepnotes}}{{{deepnotes|}}}|
{{#vardefine:deepnotes|{{#var:deepnotes}}{{PBR}}
{{{deepnotes|}}}{{PBR}}}}
}}

{{#if:{{#var:mono}}{{{mono|}}}|
{{#vardefine:mono|{{#var:mono}}{{PBR}}
{{{mono|}}}{{PBR}}}}
}}

{{#if:{{#var:lso}}{{{lso|}}}|
{{#vardefine:lso|{{#var:lso}}{{PBR}}
{{{lso|}}}{{PBR}}}}
}}

{{#vardefine:issues|{{#var:issues}}
{{{issues|}}}}}

{{#vardefine:also_tests|{{#var:also_tests}}
{{{also_tests|}}}}}

{{#if:{{#var:location}}{{{location|}}}|
{{#vardefine:location|{{#var:location}}{{PBR}}
{{{location|}}}{{PBR}}}}
}}

{{#if:{{#var:messaging}}{{{messaging|}}}|
{{#vardefine:messaging|{{#var:messaging}}{{PBR}}
{{{messaging|}}}{{PBR}}}}
}}

}}{{#if:{{#var:self}}|| __NOEDITSECTION__
}}{{#var:header}}{{#if:{{#var:func_id}}{{#var:mode}}{{#var:moded}}||
{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}{{#if:{{#if:{{{return_type|}}}|{{#var:return_text}}}}{{{func_desc|}}}||<div id="box" style="background:yellow;">
  '''O 'func_desc', o 'return_type' e 'return_text' devono essere definiti'''
<div style="padding: 0.5em;background:#ffffff;">
''(Per favore usate 'return_text' e 'return_type', o 'func_desc' per descrivere sommariamente le azioni della funzione.)''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}
{{RightToc|font-size:80%}}
<div id="box"><h2 style="display:none"> Sommario </h2>{{#ifexpr:{{#var:BugCounter|0}} > 0|<div class="mw-headline" style="float:right; margin: 5px 0.5em 0 0.5em;">{{LSL_Bug_Icon}}</div>}}<span id="{{anchorencode:Description}}" style="display:none"></span><span id="{{anchorencode:Summary}}" class="mw-headline" style="display:block; padding-bottom:0.17em; padding-top:0.5em; background:transparent none repeat scroll 0% 0%; color:#546368; font-family:Arial,Helvetica,Sans-Serif; background-color:#F4F8FB; border-bottom:1px dotted #AAAAAA; font-size:120%; font-weight:bold; margin:0pt; padding:0.2em 0.5em; text-align:left;"> [[:Category:LSL_Functions{{#var:lang}}|Function]]: {{#if:{{{return_type|}}}|[[{{{return_type|}}}{{#var:lang}}|{{{return_type|}}}]]||}} '''{{{func}}}'''( {{#if:{{{p1_name|}}}{{{p1_type|}}}| [[{{{p1_type|}}}{{#var:lang}}|{{{p1_type|}}}]] {{LSL Param|{{{p1_name|}}}}}{{#if:{{{p2_name|}}}{{{p2_type|}}}|, [[{{{p2_type|}}}{{#var:lang}}|{{{p2_type|}}}]] {{LSL Param|{{{p2_name|}}}}}{{#if:{{{p3_name|}}}{{{p3_type|}}}|, [[{{{p3_type|}}}{{#var:lang}}|{{{p3_type|}}}]] {{LSL Param|{{{p3_name|}}}}}{{#if:{{{p4_name|}}}{{{p4_type|}}}|, [[{{{p4_type|}}}{{#var:lang}}|{{{p4_type|}}}]] {{LSL Param|{{{p4_name|}}}}}{{#if:{{{p5_name|}}}{{{p5_type|}}}|, [[{{{p5_type|}}}{{#var:lang}}|{{{p5_type|}}}]] {{LSL Param|{{{p5_name|}}}}}{{#if:{{{p6_name|}}}{{{p6_type|}}}|, [[{{{p6_type|}}}{{#var:lang}}|{{{p6_type|}}}]] {{LSL Param|{{{p6_name|}}}}}{{#if:{{{p7_name|}}}{{{p7_type|}}}|, [[{{{p7_type|}}}{{#var:lang}}|{{{p7_type|}}}]] {{LSL Param|{{{p7_name|}}}}}{{#if:{{{p8_name|}}}{{{p8_type|}}}|, [[{{{p8_type|}}}{{#var:lang}}|{{{p8_type|}}}]] {{LSL Param|{{{p8_name|}}}}}{{#if:{{{p9_name|}}}{{{p9_type|}}}|, [[{{{p9_type|}}}{{#var:lang}}|{{{p9_type|}}}]] {{LSL Param|{{{p9_name|}}}}}{{#if:{{{p10_name|}}}{{{p10_type|}}}|, [[{{{p10_type|}}}{{#var:lang}}|{{{p10_type|}}}]] {{LSL Param|{{{p10_name|}}}}}{{#if:{{{p11_name|}}}{{{p11_type|}}}|, [[{{{p11_type|}}}{{#var:lang}}|{{{p11_type|}}}]] {{LSL Param|{{{p11_name|}}}}}{{#if:{{{p12_name|}}}{{{p12_type|}}}|, [[{{{p12_type|}}}{{#var:lang}}|{{{p12_type|}}}]] {{LSL Param|{{{p12_name|}}}}}}}}}}}}}}}}}}}}}}}}}}}}} )<nowiki>;</nowiki></span>
<div style="padding: 0.5em; min-height: {{#if:{{{func_complexity|}}}|6em;|5em;}}">{{#if:{{#pos:{{#var:moded}}|u}}|{{#if:{{#var:floater}}|<div id="box" style="float:right;">{{#var:floater}}</div>}}|<div id="box" style="float:right; margin: 0 0.5em; font-size:90%;">
{{{!}} class="collapsible"
{{!}}- style="font-size:75%;"
{{!}}+
{{!}}-
{{!}} {{HoverText|{{#var:func_id}}|Il numero d'indice della funzione.}}
{{!}} [[LSL Function ID{{#var:lang}}|ID funzione]]
{{!}}-
{{!}} {{HoverText|{{{func_sleep|}}}|Il numero di secondi per cui lo script sarà in pausa dopo avere eseguito questa funzione.}}{{#if:{{{func_sleep_note|}}}|{{HoverLink|#caveats-sleep|3=*|2={{{func_sleep_note|}}}}}}}
{{!}} [[LSL Delay{{#var:lang}}|Ritardo]]
{{!}}-
{{#if:{{{func_complexity|}}}|
{{!}} {{HoverText|{{{func_complexity|}}}|La complessità della funzione, basata sui parametri.}}
{{!}} [[LSL Complexity{{#var:lang}}|Compl.]]
{{!}}-}}
{{!}} {{HoverText|{{{func_energy|}}}|La quantità di energia consumata da questa funzione.}}
{{!}} [[Energy{{#var:lang}}|Energia]]
{{!}}}</div>}}
{{#if:{{#var:header_desc}}|{{#var:header_desc}}{{PBR}}{{#if:{{{return_type|}}}|<br id="bdart"/>}}}}{{#if:{{{return_type|}}}| Returns {{It|{{{return_type|}}}|{{{Return_text|}}}}} {{#if:{{#var:return_text}}| {{#var:return_text}} }}{{PBR}}}}
{{#if:{{{p1_name|}}}{{{p1_type|}}}|{{{!}}
{{LSL DefineRow|1={{{p1_type|}}}|2={{{p1_name|}}}|3={{#var:p_{{{p1_name|}}}_desc}}}}
{{#if:{{{p2_name|}}}{{{p2_type|}}}|{{LSL DefineRow|1={{{p2_type|}}}|2={{{p2_name|}}}|3={{#var:p_{{{p2_name|}}}_desc}}}}
{{#if:{{{p3_name|}}}{{{p3_type|}}}|{{LSL DefineRow|1={{{p3_type|}}}|2={{{p3_name|}}}|3={{#var:p_{{{p3_name|}}}_desc}}}}
{{#if:{{{p4_name|}}}{{{p4_type|}}}|{{LSL DefineRow|1={{{p4_type|}}}|2={{{p4_name|}}}|3={{#var:p_{{{p4_name|}}}_desc}}}}
{{#if:{{{p5_name|}}}{{{p5_type|}}}|{{LSL DefineRow|1={{{p5_type|}}}|2={{{p5_name|}}}|3={{#var:p_{{{p5_name|}}}_desc}}}}
{{#if:{{{p6_name|}}}{{{p6_type|}}}|{{LSL DefineRow|1={{{p6_type|}}}|2={{{p6_name|}}}|3={{#var:p_{{{p6_name|}}}_desc}}}}
{{#if:{{{p7_name|}}}{{{p7_type|}}}|{{LSL DefineRow|1={{{p7_type|}}}|2={{{p7_name|}}}|3={{#var:p_{{{p7_name|}}}_desc}}}}
{{#if:{{{p8_name|}}}{{{p8_type|}}}|{{LSL DefineRow|1={{{p8_type|}}}|2={{{p8_name|}}}|3={{#var:p_{{{p8_name|}}}_desc}}}}
{{#if:{{{p9_name|}}}{{{p9_type|}}}|{{LSL DefineRow|1={{{p9_type|}}}|2={{{p9_name|}}}|3={{#var:p_{{{p9_name|}}}_desc}}}}
{{#if:{{{p10_name|}}}{{{p10_type|}}}|{{LSL DefineRow|1={{{p10_type|}}}|2={{{p10_name|}}}|3={{#var:p_{{{p10_name|}}}_desc}}}}
{{#if:{{{p11_name|}}}{{{p11_type|}}}|{{LSL DefineRow|1={{{p11_type|}}}|2={{{p11_name|}}}|3={{#var:p_{{{p11_name|}}}_desc}}}}
{{#if:{{{p12_name|}}}{{{p12_type|}}}|{{LSL DefineRow|1={{{p12_type|}}}|2={{{p12_name|}}}|3={{#var:p_{{{p12_name|}}}_desc}}}}
}}}}}}}}}}}}}}}}}}}}}}
{{!}}}
}}{{#if:{{#var:header_footnote}}|
<div style="margin-top:0.5em;"></div>
{{#var:header_footnote}}
}}</div>
</div>{{#ifexist:{{#var:newbie}}|<div id="box">
<h2>[[{{#var:newbie}}|Appunti dei principianti]]</h2>
<div style="padding: 0.5em; max-height:10em; overflow-x:visible; overflow-y:auto;">
{{:{{#var:newbie}}}}
</div><div style="padding:0 0.5em;">
Per proseguire la lettura si veda: [[{{#var:newbie}}|Appunti dei principianti]]
</div></div>}}{{#if:{{#var:spec}}|<div id="box">
<h2>Specificazione</h2>
<div style="padding: 0.5em;">
{{#var:spec}}
</div></div>}}{{#if:{{#var:constants_nb}}{{#var:constants}}|
{{#var:constants_nb}}
{{#if:{{#var:constants}}|
<div id="box">
<h2>Costanti</h2>
{{#var:constants}}
</div>}}}}{{#if:{{#var:caveats}}|<div id="box">
<h2>Avvertimenti</h2>
<div style="padding: 0.5em;">
{{#var:caveats}}
</div></div>}}{{#if:{{#if:{{#var:deprecated}}||t}}{{#var:examples}}{{#simple-examples}}{{#complex-examples}}|<div id="box">
<h2>Esempi</h2>
<div style="padding: 0.5em;">
{{#var:examples}}{{#if:{{#var:simple-examples}}|
<div style="float:left; min-width:200px; width:45%;">
===Esempi semplici===
{{{!}}
{{#var:simple-examples}}
{{!}}}
</div>}}{{#if:{{#var:complex-examples}}|
<div style="float:left;">
===Esempi complessi===
{{{!}}
{{#var:complex-examples}}
{{!}}}
</div>}}<div style="clear:left;"></div>
</div></div>}}{{#if:{{#var:helpers}}|<div id="box">
<h2>Ritagli di codice utili</h2>
<div style="padding: 0.5em;">
{{#var:helpers}}
</div></div>}}{{#if:{{#var:notes}}|<div id="box">
<h2>Note</h2>
<div style="padding: 0.5em;">
{{#var:notes}}
</div></div>}}{{#if:{{#var:also_footer}}{{#var:also_functions}}{{#var:also_events}}{{#var:also_articles}}{{#var:also_header}}{{#var:also_library}}{{#var:also_constants}}|<div id="box">
<h2>Si veda anche</h2>
<div style="padding: 0.5em;">
{{#if:{{#var:also_header}}|<div>
{{#var:also_header}}
</div>}}{{#if:{{#var:also_constants}}|
<h3>Costanti</h3>
{{{!}}
{{#var:also_constants}}
{{!}}} }}{{#if:{{#var:also_events}}|
<h3>Eventi</h3>
{{{!}}
{{#var:also_events}}
{{!}}} }}{{#if:{{#var:also_functions}}|
<h3>Funzioni</h3>
{{{!}}
{{#var:also_functions}}
{{!}}} }}{{#if:{{#var:also_articles}}|
<h3>Articoli</h3>
{{{!}}
{{#var:also_articles}}
{{!}}} }}{{#if:{{#var:also_library}}|
<h3>Librerie ed esempi</h3>
{{{!}}
{{#var:also_library}}
{{!}}} }}{{#if:{{#var:also_footer}}|
<div style="margin-top:0.5em;">
{{#var:also_footer}}
</div>}}
</div></div>}}
<div id="box">
== Note approfondite ==
<div style="padding: 0.5em"><div>
{{#var:deepnotes}}
</div>{{#if:{{#var:mono}}|
<h4> Note sulla Mono VM </h4><div>
{{#var:mono}}
</div>}}{{#if:{{#var:lso}}|
<h4> Note sulla LSO VM </h4><div>
{{#var:lso}}
</div>}}{{#if:{{#var:history}}|
<h4> Storia </h4><div>
{{#var:history}}
</div>}}
{{Anchor|Issues}}{{LSL_Generic/Issues}}{{#if:{{#var:also_tests}}|
<h3>Tests</h3>
{{{!}}
{{#var:also_tests}}
{{!}}}
}}{{#if:{{#var:location}}|
<h4> Fonte </h4><div>
{{#var:location}}
</div>}}{{#if:{{#var:messaging}}|
<h4> Messaggistica </h4><div>
{{#var:messaging}}
</div>}}{{#if:{{#var:footnotes}}|
<h4 style="margin-bottom:0;"> Footnotes </h4>
{{{{#if:{{#var:footnotes}}|Footnotes|!}}|}}
}}
{{Collapsible_Table|collapsed=*|table-style=width:100%;|title-style=text-align:left;|title=<h4 style="margin-top:0;">Firma</h4>|content={{!}}
{{#tag:pre|{{#if:{{#pos:{{#var:moded}}|u}}||{{#if:{{#pos:{{#var:moded}}|r}}|//}}function {{#if:{{{return_type|}}}|{{{return_type|}}}|void}} {{{func}}}( {{#if:{{{p1_name|}}}{{{p1_type|}}}| {{{p1_type|}}} {{{p1_name|}}}{{#if:{{{p2_name|}}}{{{p2_type|}}}|, {{{p2_type|}}} {{{p2_name|}}}{{#if:{{{p3_name|}}}{{{p3_type|}}}|, {{{p3_type|}}} {{{p3_name|}}}{{#if:{{{p4_name|}}}{{{p4_type|}}}|, {{{p4_type|}}} {{{p4_name|}}}{{#if:{{{p5_name|}}}{{{p5_type|}}}|, {{{p5_type|}}} {{{p5_name|}}}{{#if:{{{p6_name|}}}{{{p6_type|}}}|, {{{p6_type|}}} {{{p6_name|}}}{{#if:{{{p7_name|}}}{{{p7_type|}}}|, {{{p7_type|}}} {{{p7_name|}}}{{#if:{{{p8_name|}}}{{{p8_type|}}}|, {{{p8_type|}}} {{{p8_name|}}}{{#if:{{{p9_name|}}}{{{p9_type|}}}|, {{{p9_type|}}} {{{p9_name|}}}{{#if:{{{p10_name|}}}{{{p10_type|}}}|, {{{p10_type|}}} {{{p10_name|}}}{{#if:{{{p11_name|}}}{{{p11_type|}}}|, {{{p11_type|}}} {{{p11_name|}}}{{#if:{{{p12_name|}}}{{{p12_type|}}}|, {{{p12_type|}}} {{{p12_name|}}}}}}}}}}}}}}}}}}}}}}}}}}} )<nowiki>;</nowiki>{{#if:{{{desc|}}}|//{{{desc|}}}}}
<nowiki></nowiki>}}{{#if:{{{signature|}}}|{{{signature|}}}
}}{{#if:{{#var:signature}}|{{#var:signature}}
}}|id="lsl-signature"}}}}
</div></div>{{#if:{{{comments|}}}|<div id="box">
<h2>Commenti</h2>
<div style="padding: 0.5em;">
{{{comments|}}}
</div></div>}}
<div style="display:none" class="hidden-text" id="hidden-text">{{#var:hidden-text}}</div>
{{#var:footer}} {{#if:{{#var:self}}|| {{#if:{{#pos:{{#var:moded}}|r}}{{#pos:{{#var:moded}}|u}}|| [[Category:LSL Functions{{#var:lang}}]] {{#if:{{#pos:{{#var:moded}}|f}}||{{#ifexpr:{{#var:BugCounter|0}} > 0|[[Category:LSL topics with bugs{{#var:lang}}]] [[Category:LSL topics with the most bugs{{#var:lang}}| {{#pad:{{#expr:100-{{#var:BugCounter|0}}}}|2|0}}{{PAGENAME}}]]}}}} {{#iferror:{{#expr:{{#var:func_id}}}}|[[Category:LSL Functions/Without IDs{{#var:lang}}]]|[[Category:LSL Functions/ID{{#var:lang}}| {{padleft:{{#var:func_id}}|5|0}}]]}} {{#if:{{#var:examples}}||[[Category:LSL Needs Example{{#var:lang}}]]}} {{LSL Unhelpful|{{{func}}}|}} }} {{#if:{{{cat1|}}}|[[Category:LSL {{{cat1}}}{{#var:lang}}]]}} {{#if:{{{cat2|}}}|[[Category:LSL {{{cat2}}}{{#var:lang}}]]}} {{#if:{{{cat3|}}}|[[Category:LSL {{{cat3}}}{{#var:lang}}]]}} {{#if:{{{cat4|}}}|[[Category:LSL {{{cat4}}}{{#var:lang}}]]}} {{#if:{{{cat5|}}}|[[Category:LSL {{{cat5}}}{{#var:lang}}]]}} {{#if:{{{cat6|}}}|[[Category:LSL {{{cat6}}}{{#var:lang}}]]}} {{#if:{{{cat7|}}}|[[Category:LSL {{{cat7}}}{{#var:lang}}]]}} {{#if:{{{cat8|}}}|[[Category:LSL {{{cat8}}}{{#var:lang}}]]}} }}</includeonly>

Link message/it

2012-01-15T17:49:30Z

Violet Hammerer:

{{LSL_Event/it|event_id=29|event_delay|event=link_message
|p1_type=integer|p1_name=sender_num|p1_desc=Il numero di collegamento del prim che contiene lo script che ha chiamato [[llMessageLinked]].
|p2_type=integer|p2_name=num|p2_desc=Secondo parametro della chiamata llMessageLinked.
|p3_type=string|p3_name=str|p3_desc=Terzo parametro della chiamata llMessageLinked.
|p4_type=key|p4_name=id|p4_desc=Quarto parametro della chiamata llMessageLinked.
|event_desc=Lanciato quando lo script riceva un messaggio collegato che è stato mandato da una chiamata a [[llMessageLinked]]. llMessageLinked viene usato per inviare messaggi da uno script a un altro.
|event_footnote='''id''' viene usato spesso come secondo campo stringa (in LSL il tipo [[key]] è implementato come una [[string]] con operatori personalizzati). [[typecast|La trasformazione]] tra i tipi [[string]] e [[key]] non ha effetti sui dati in essi contenuti. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|spec
|caveats=*Si possono accodare 64 eventi link_message, superati i quali, vengono scartati silenziosamente! Non fate troppe cose nell'evento se questi potrebbero arrivare velocemente.
*'''sender_num''' non rispecchia il modo in cui è stato mandato un messaggio, non c'è modo di sapere se è stato inviato col flag LINK_* o il [[llGetLinkNumber|numero specifico di collegamento]].
*Se '''str''' e '''id''' sono più grandi della memoria disponibile, lo script crasherà silenziosamente con una Collisione Stack-Heap.
|examples=
<lsl>
// Questo è solo uno script di esempio, non dovreste gestire il tocco in questo modo all'interno di un unico script.

default
{
touch_start(integer c)
{
llMessageLinked(LINK_THIS, 0, llDetectedName(0), llDetectedKey(0));
}
link_message(integer source, integer num, string str, key id)
{
llWhisper(0, str + " (" + (string)id + ") mi ha toccato!");
}
}
</lsl>
|helpers=
<lsl>
// Questo è solo uno script di esempio, non dovreste gestire i messaggi collegati in questo modo all'interno di un unico script.

default
{
// Per diffondere un numero illimitato di argomenti di qualsiasi tipo.
// Presupposto, la stringa separatrice non viene utilizzata in nessuna stringa sorgente!
state_entry()
{
list mia_lista = [1, 2.0, "una stringa", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string parametro_lista = llDumpList2String(mia_lista, "|"); // Converte la lista in una stringa
llMessageLinked(LINK_THIS, 0, parametro_lista, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list ri_elenca = llParseString2List(parametro_lista, ["|"], []); // elabora nuovamente la stringa in una lista
}
}
</lsl>
|also_header
|also_events
|also_functions={{LSL DefineRow||[[llMessageLinked/it]]}}
|also_articles
|also_footer
|notes=Uno script può ascoltare i propri messaggi.
|mode
|cat1=Link
|cat2=Communications
|cat3=Link Message
|cat4
}}

LlGetObjectDesc/it

2012-01-15T17:48:15Z

Violet Hammerer:

{{LSL_Function/prim-desc}}{{LSL_Function/it
|func_id=270|func_sleep=0.0|func_energy=10.0
|func=llGetObjectDesc
|return_type=string
|func_footnote
|func_desc
|return_text=che è la descrizione del prim in cui sta lo script.
|spec
|caveats
|constants
|examples=<lsl>default
{
state_entry()
{
llSay(PUBLIC_CHANNEL, llGetObjectDesc() );
}
}</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llSetObjectDesc]]|Imposta la descrizione del prim in cui sta lo script.}}
{{LSL DefineRow||[[llGetObjectName]]|Ottiene il nome del prim.}}
{{LSL DefineRow||[[llSetObjectName]]|Imposta il nome del prim.}}
{{LSL DefineRow||[[llGetObjectDetails]]|Restituisce una serie di dati sul prim in cui sta lo script.}}
|also_events
|also_articles=
{{LSL DefineRow||[[Prim Attribute Overloading]]}}
|notes
|cat1=Prim
|cat2
|cat3
|cat4
}}

LlGetObjectDesc/it

2012-01-15T17:46:03Z

Violet Hammerer:

{{LSL_Function/prim-des{{LSL_Function/itc}}
|func_id=270|func_sleep=0.0|func_energy=10.0
|func=llGetObjectDesc
|return_type=string
|func_footnote
|func_desc
|return_text=che è la descrizione del prim in cui sta lo script.
|spec
|caveats
|constants
|examples=<lsl>default
{
state_entry()
{
llSay(PUBLIC_CHANNEL, llGetObjectDesc() );
}
}</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llSetObjectDesc]]|Imposta la descrizione del prim in cui sta lo script.}}
{{LSL DefineRow||[[llGetObjectName]]|Ottiene il nome del prim.}}
{{LSL DefineRow||[[llSetObjectName]]|Imposta il nome del prim.}}
{{LSL DefineRow||[[llGetObjectDetails]]|Restituisce una serie di dati sul prim in cui sta lo script.}}
|also_events
|also_articles=
{{LSL DefineRow||[[Prim Attribute Overloading]]}}
|notes
|cat1=Prim
|cat2
|cat3
|cat4
}}

LlGetObjectDesc/it

2012-01-15T17:45:44Z

Violet Hammerer:

{{LSL_Function/prim-des{{LSL_Function/it}}
|func_id=270|func_sleep=0.0|func_energy=10.0
|func=llGetObjectDesc
|return_type=string
|func_footnote
|func_desc
|return_text=che è la descrizione del prim in cui sta lo script.
|spec
|caveats
|constants
|examples=<lsl>default
{
state_entry()
{
llSay(PUBLIC_CHANNEL, llGetObjectDesc() );
}
}</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llSetObjectDesc]]|Imposta la descrizione del prim in cui sta lo script.}}
{{LSL DefineRow||[[llGetObjectName]]|Ottiene il nome del prim.}}
{{LSL DefineRow||[[llSetObjectName]]|Imposta il nome del prim.}}
{{LSL DefineRow||[[llGetObjectDetails]]|Restituisce una serie di dati sul prim in cui sta lo script.}}
|also_events
|also_articles=
{{LSL DefineRow||[[Prim Attribute Overloading]]}}
|notes
|cat1=Prim
|cat2
|cat3
|cat4
}}

Link message/it

2012-01-15T17:44:40Z

Violet Hammerer:

LlMessageLinked/it

2012-01-15T17:43:42Z

Violet Hammerer:

{{LSL_Function/it
|inject-2={{LSL Function/link|linknum|, controlla quale/i prim riceve/ono il link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Valore del secondo parametro dell'evento link_message risultante.
|p3_type=string|p3_name=str|p3_desc=Valore del terzo parametro dell'evento link_message risultante.
|p4_type=key|p4_name=id|p4_desc=Valore del quarto parametro dell'evento link_message risultante.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=Potete utilizzare '''id''' come campo stringa secondario{{Footnote|In LSL il tipo [[key]] è implementato come una [[string]] (ma con operatori e restrizioni differenti). [[typecast|La conversione]] tra tipi stringa e chiave non ha effetto sui dati contenuti.}}. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|func_footnote
|return_text
|spec
|caveats=*Uno script può ascoltare i suoi stessi link_messages se '''linknum''' ha come obiettivo il prim in cui è lo script{{Footnote|Uno script ha quattro modi per avere sé stesso come obiettivo: [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] e [[LINK_ALL_CHILDREN]] (se il prim è un prim collegato).}}. Ciò crea la possibilità di un circolo vizioso infinito (cosa cattiva); state molto attenti a come i messaggi vengono gestiti e passati.
* I messaggi inviati tramite llMessageLinked a uno script che è in [[llSleep|sonno]], [[LSL Delay|è rinviato]], o [[lag|laggato]], sono messi in coda fino al termine del rinvio. La coda eventi può contenere 64 eventi.
** Se la coda è piena e si riceve un evento, questo viene scartato in modo silenzioso.
** Evitate di inviare simultaneamente link_messages a grandi quantità di script poiché ciò può causare picchi di lag. Questo generalmente accade mentre si usano i flag multi-prim LINK_* e può causare l'esecuzione lenta dello script o portare ad arresti.
** Evitate di inviare link_messages a un obiettivo più velocemente di quanto questi possano essere gestiti. Farlo significa rischiare di riempire la coda eventi e di portare allo scarto silenzioso dei messaggi seguenti.
* Quando cambia lo [[state]] di uno script, tutti gli eventi in coda vengono cancellati, compresi i link_messages accodati.
* Se '''link_num''' è un numero non valido allora la funzione fallisce in modo silenzioso.
* Se '''str''' e '''id''' eccedono la memoria disponibile di uno script che prende l'evento link_message risultante, quello script crasherà con una [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Collisione Stack-Heap]].
|examples=<lsl>default
{
// presupposti // nome oggetto: LSLWiki // nome script: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// il proprietario dell'oggetto sentirà
// LSLWiki:_lslwiki
}
}</lsl>

=== Circolo infinito ===

<lsl>Controllo_Messaggio(integer l, integer n) // Mancanza_Assoluta_di_Controllo_del_Messaggio
{
integer r = (++n); // Aumenta il valore di n.
llMessageLinked( l, r, "", ""); // Invia il risultato a l
}

default
{
state_entry()
{
Controllo_Messaggio(LINK_SET, 0); // Comunica a tutti gli script nell'oggetto che siamo entrati nello stato.
}

link_message(integer Mittente, integer Numero, string Stringa, key Chiave) // Anche questo script è nell'oggetto.
{
Controllo_Messaggio(Mittente, Numero); // Non esistono condizioni filtranti.
llOwnerSay(((string)Numero)); // Guardate tutti quei bei numeri!
}
}</lsl>
|helpers=<lsl>default
{
// Correzione veloce e sporca dei link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// Questo è solo uno script di esempio, non dovreste gestire i messaggi collegati all'interno del medesimo script in questo modo.

default
{
// Per diffondere un numero illimitato di argomenti di qualsiasi tipo.
// Presupposto, la stringa separatrice non viene utilizzata in nessuna stringa sorgente!
state_entry()
{
list mia_lista = [1, 2.0, "una stringa", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string parametro_lista = llDumpList2String(mia_lista, "|"); // Converte la lista in una stringa
llMessageLinked(LINK_THIS, 0, parametro_lista, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list ri_elenca = llParseString2List(parametro_lista, ["|"], []); // elabora nuovamente la stringa in una lista
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message/it]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Utilizzare llMessageLinked in un unico oggetto permette agli sviluppatori di alleviare alcuni limiti del LSL spartendo le funzionalità tra script cooperanti e sincronizzando le azioni. Quando lo fate, siate estremamente attenti a non creare circoli infiniti come descritto prima.
*Alcuni utenti hanno osservato un ritardo di .25-.50 tra la ricezione e l'invio di llLinkedMessage
*Alcuni utenti hanno notato fallimenti sporadici di messaggi collegati quando si invia un messaggio a grandi quantità di script riceventi in prim differenti usando [[LINK_SET]], [[LINK_ALL_OTHERS]], e [[LINK_ALL_CHILDREN]]. Se incontrate questo problema, un trucco è mettere tutti gli script dei prim collegati in un singolo prim, e usare funzioni mirate come [[llSetLinkPrimitiveParams]] per modificare il prim in cui lo script stava precedentemente. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlGetObjectDesc/it

2012-01-15T17:38:54Z

Violet Hammerer:

LlMessageLinked/it

2012-01-15T17:35:07Z

Violet Hammerer:

{{LSL_Function/it
|inject-2={{LSL Function/link|linknum|, controlla quale/i prim riceve/ono il link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Valore del secondo parametro dell'evento link_message risultante.
|p3_type=string|p3_name=str|p3_desc=Valore del terzo parametro dell'evento link_message risultante.
|p4_type=key|p4_name=id|p4_desc=Valore del quarto parametro dell'evento link_message risultante.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=Potete utilizzare '''id''' come campo stringa secondario{{Footnote|In LSL il tipo [[key]] è implementato come una [[string]] (ma con operatori e restrizioni differenti). [[typecast|La conversione]] tra tipi stringa e chiave non ha effetto sui dati contenuti.}}. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|func_footnote
|return_text
|spec
|caveats=*Uno script può ascoltare i suoi stessi link_messages se '''linknum''' ha come obiettivo il prim in cui è lo script{{Footnote|Uno script ha quattro modi per avere sé stesso come obiettivo: [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] e [[LINK_ALL_CHILDREN]] (se il prim è un prim collegato).}}. Ciò crea la possibilità di un circolo vizioso infinito (cosa cattiva); state molto attenti a come i messaggi vengono gestiti e passati.
* I messaggi inviati tramite llMessageLinked a uno script che è in [[llSleep|sonno]], [[LSL Delay|è rinviato]], o [[lag|laggato]], sono messi in coda fino al termine del rinvio. La coda eventi può contenere 64 eventi.
** Se la coda è piena e si riceve un evento, questo viene scartato in modo silenzioso.
** Evitate di inviare simultaneamente link_messages a grandi quantità di script poiché ciò può causare picchi di lag. Questo generalmente accade mentre si usano i flag multi-prim LINK_* e può causare l'esecuzione lenta dello script o portare ad arresti.
** Evitate di inviare link_messages a un obiettivo più velocemente di quanto questi possano essere gestiti. Farlo significa rischiare di riempire la coda eventi e di portare allo scarto silenzioso dei messaggi seguenti.
* Quando cambia lo [[state]] di uno script, tutti gli eventi in coda vengono cancellati, compresi i link_messages accodati.
* Se '''link_num''' è un numero non valido allora la funzione fallisce in modo silenzioso.
* Se '''str''' e '''id''' eccedono la memoria disponibile di uno script che prende l'evento link_message risultante, quello script crasherà con una [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Collisione Stack-Heap]].
|examples=<lsl>default
{
// presupposti // nome oggetto: LSLWiki // nome script: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// il proprietario dell'oggetto sentirà
// LSLWiki:_lslwiki
}
}</lsl>

=== Circolo infinito ===

<lsl>Controllo_Messaggio(integer l, integer n) // Mancanza_Assoluta_di_Controllo_del_Messaggio
{
integer r = (++n); // Aumenta il valore di n.
llMessageLinked( l, r, "", ""); // Invia il risultato a l
}

default
{
state_entry()
{
Controllo_Messaggio(LINK_SET, 0); // Comunica a tutti gli script nell'oggetto che siamo entrati nello stato.
}

link_message(integer Mittente, integer Numero, string Stringa, key Chiave) // Anche questo script è nell'oggetto.
{
Controllo_Messaggio(Mittente, Numero); // Non esistono condizioni filtranti.
llOwnerSay(((string)Numero)); // Guardate tutti quei bei numeri!
}
}</lsl>
|helpers=<lsl>default
{
// Correzione veloce e sporca dei link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// Questo è solo uno script di esempio, non dovreste gestire i messaggi collegati all'interno del medesimo script in questo modo.

default
{
// Per diffondere un numero illimitato di argomenti di qualsiasi tipo.
// Presupposto, la stringa separatrice non viene utilizzata in nessuna stringa sorgente!
state_entry()
{
list mia_lista = [1, 2.0, "una stringa", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string parametro_lista = llDumpList2String(mia_lista, "|"); // Converte la lista in una stringa
llMessageLinked(LINK_THIS, 0, parametro_lista, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list ri_elenca = llParseString2List(parametro_lista, ["|"], []); // elabora nuovamente la stringa in una lista
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Utilizzare llMessageLinked in un unico oggetto permette agli sviluppatori di alleviare alcuni limiti del LSL spartendo le funzionalità tra script cooperanti e sincronizzando le azioni. Quando lo fate, siate estremamente attenti a non creare circoli infiniti come descritto prima.
*Alcuni utenti hanno osservato un ritardo di .25-.50 tra la ricezione e l'invio di llLinkedMessage
*Alcuni utenti hanno notato fallimenti sporadici di messaggi collegati quando si invia un messaggio a grandi quantità di script riceventi in prim differenti usando [[LINK_SET]], [[LINK_ALL_OTHERS]], e [[LINK_ALL_CHILDREN]]. Se incontrate questo problema, un trucco è mettere tutti gli script dei prim collegati in un singolo prim, e usare funzioni mirate come [[llSetLinkPrimitiveParams]] per modificare il prim in cui lo script stava precedentemente. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

Template:LSL Function/it

2012-01-15T17:33:59Z

Violet Hammerer:

{{Multi-lang|2=/it}}{{LSL Header/it}} __NOTOC__ <noinclude>
Si veda [[{{FULLPAGENAME}}/docs]] per la documentazione.
</noinclude><includeonly>{{#if:{{#vardefine:sort|{{#if:{{#var:sort}}|{{#var:sort}}|{{{sort|}}}}}}}{{{{#if:{{#var:sort}}|!|LSL_Sort}}|}}}}<div id="sort" style="display:none">{{DEFAULTSORT:{{#var:sort}}}}{{#var:sort}}</div>{{#if:{{#var:nofixname}}||{{#if:{{#pos:{{lc:{{FULLPAGENAMEE}}}}|{{lc:{{{func}}}}}}}|<div id="RealTitleBanner" style="display:none"><span id="RealTitle">{{#if:{{NAMESPACE}}|{{NAMESPACE}}:}}{{{func}}}</span></div>}}}}{{#if:
{{#vardefine:func_id|{{{func_id|}}}}}
{{#vardefine:p_{{{p1_name|}}}_desc|{{#var:p_{{{p1_name|}}}_desc}}{{{p1_desc|}}}}}
{{#vardefine:p_{{{p1_name|}}}_hover|{{#var:p_{{{p1_name|}}}_hover}}{{{p1_hover|}}}}}
{{#vardefine:p_{{{p2_name|}}}_desc|{{#var:p_{{{p2_name|}}}_desc}}{{{p2_desc|}}}}}
{{#vardefine:p_{{{p2_name|}}}_hover|{{#var:p_{{{p2_name|}}}_hover}}{{{p2_hover|}}}}}
{{#vardefine:p_{{{p3_name|}}}_desc|{{#var:p_{{{p3_name|}}}_desc}}{{{p3_desc|}}}}}
{{#vardefine:p_{{{p3_name|}}}_hover|{{#var:p_{{{p3_name|}}}_hover}}{{{p3_hover|}}}}}
{{#vardefine:p_{{{p4_name|}}}_desc|{{#var:p_{{{p4_name|}}}_desc}}{{{p4_desc|}}}}}
{{#vardefine:p_{{{p4_name|}}}_hover|{{#var:p_{{{p4_name|}}}_hover}}{{{p4_hover|}}}}}
{{#vardefine:p_{{{p5_name|}}}_desc|{{#var:p_{{{p5_name|}}}_desc}}{{{p5_desc|}}}}}
{{#vardefine:p_{{{p5_name|}}}_hover|{{#var:p_{{{p5_name|}}}_hover}}{{{p5_hover|}}}}}
{{#vardefine:p_{{{p6_name|}}}_desc|{{#var:p_{{{p6_name|}}}_desc}}{{{p6_desc|}}}}}
{{#vardefine:p_{{{p6_name|}}}_hover|{{#var:p_{{{p6_name|}}}_hover}}{{{p6_hover|}}}}}
{{#vardefine:p_{{{p7_name|}}}_desc|{{#var:p_{{{p7_name|}}}_desc}}{{{p7_desc|}}}}}
{{#vardefine:p_{{{p7_name|}}}_hover|{{#var:p_{{{p7_name|}}}_hover}}{{{p7_hover|}}}}}
{{#vardefine:p_{{{p8_name|}}}_desc|{{#var:p_{{{p8_name|}}}_desc}}{{{p8_desc|}}}}}
{{#vardefine:p_{{{p8_name|}}}_hover|{{#var:p_{{{p8_name|}}}_hover}}{{{p8_hover|}}}}}
{{#vardefine:p_{{{p9_name|}}}_desc|{{#var:p_{{{p9_name|}}}_desc}}{{{p9_desc|}}}}}
{{#vardefine:p_{{{p9_name|}}}_hover|{{#var:p_{{{p9_name|}}}_hover}}{{{p9_hover|}}}}}
{{#vardefine:p_{{{p10_name|}}}_desc|{{#var:p_{{{p10_name|}}}_desc}}{{{p10_desc|}}}}}
{{#vardefine:p_{{{p10_name|}}}_hover|{{#var:p_{{{p10_name|}}}_hover}}{{{p10_hover|}}}}}
{{#vardefine:p_{{{p11_name|}}}_desc|{{#var:p_{{{p11_name|}}}_desc}}{{{p11_desc|}}}}}
{{#vardefine:p_{{{p11_name|}}}_hover|{{#var:p_{{{p11_name|}}}_hover}}{{{p11_hover|}}}}}
{{#vardefine:p_{{{p12_name|}}}_desc|{{#var:p_{{{p12_name|}}}_desc}}{{{p12_desc|}}}}}
{{#vardefine:p_{{{p12_name|}}}_hover|{{#var:p_{{{p12_name|}}}_hover}}{{{p12_hover|}}}}}
{{#vardefine:return_text|{{#var:return_text}}{{{return_text|}}} }}
{{#vardefine:spec|{{#if:{{#var:spec}}|{{#var:spec}}<br/>}}{{{spec|}}}}}
{{#vardefine:examples|{{#var:examples}}{{{examples|}}}}}
{{#vardefine:helpers|{{#var:helpers}}{{{helpers|}}}}}
{{#vardefine:also_header|{{#var:also_header}}{{{also_header|}}}}}
{{#vardefine:also_tests|{{#var:also_tests}}
{{{also_tests|}}}}}
{{#vardefine:also_events|{{#var:also_events}}
{{{also_events|}}}}}
{{#vardefine:also_functions|{{#var:also_functions}}
{{{also_functions|}}}}}
{{#vardefine:also_articles|{{#var:also_articles}}
{{{also_articles|}}}}}
{{#vardefine:also_library|{{#var:also_library}}
{{{also_library|}}}}}
{{#vardefine:also_footer|{{#var:also_footer}}{{{also_footer|}}}}}
{{#vardefine:notes|{{#var:notes}}{{{notes|}}}}}
{{#vardefine:mode|{{#var:mode}}{{{mode|}}}}}
{{#vardefine:self|{{#var:self}}{{{self|}}}}}
{{#vardefine:type|funzione}}
{{#vardefine:caveats|{{#ifexpr:{{{func_sleep|0.0}}}> 0.0|*Questa funzione comporta un ritardo di {{{func_sleep|}}} secondi.}}{{#if:{{#var:caveats}}|
{{#var:caveats}}}}
{{{caveats|}}}}}
{{#vardefine:location|{{#var:location}}{{{location|}}}}}
{{#vardefine:header_footnote|{{#if:{{#var:header_footnote}}|{{#var:header_footnote}}<br/>}}{{{func_footnote|}}}{{{func_footer|}}}}}
{{#vardefine:header_desc|{{#if:{{#var:header_desc}}|{{#var:header_desc}}<br/>}}{{#var:header_desc}}{{{func_desc|}}}}}
{{{{#ifeq:{{#var:mode}}|god|LSL_Generic/god/it|!}}|}}
{{{{#ifeq:{{#var:mode}}|request|LSL_Generic/request/it|!}}|}}
{{{{#if:{{{deprecated|}}}|LSL_Generic/deprecated/it|!}}|{{{deprecated|}}}|}}
}}{{#if:{{#var:self}}|| __NOEDITSECTION__
}}{{#var:header}}{{#if:{{#var:func_id}}{{#var:mode}}||
<div id="box" style="background:red;">
  '''Non cancellate il 'func_id''''
<div style="padding: 0.5em;background:#ffffff;">
''func_id è una componente dell'informazione tecnica che non dovrebbe essere rimossa dato che è pertinente a chiunque abbia scritto un compilatore o decompilatore LSL, per cui è opportuno rimettere a posto la pagina adesso :P.''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe}]] }} }}{{#if:{{{also|}}}|<div id="box" style="background:yellow;">
  ''' 'anche' Marcatore Rimosso'''
<div style="padding: 0.5em;background:#ffffff;">
''(Per favore, utilizzate 'also_header','also_events','also_functions','also_articles', o 'also_footer')''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}{{#if:{{#if:{{{return_type|}}}|{{#var:return_text}}}}{{{func_desc|}}}||<div id="box" style="background:yellow;">
  ''' 'return_text' e 'func_desc' non possono essere entrambi non definiti'''
<div style="padding: 0.5em;background:#ffffff;">
''(Per favore, utilizzate 'return_text' o 'func_desc' per descrivere il comportamento della funzione.)''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}
<div id="box">
<h2>Funzione : {{#if:{{{return_type|}}}|[[{{{return_type|}}}]]||}} [[{{{func}}}]]( {{#if:{{{p1_name|}}}{{{p1_type|}}}| [[{{{p1_type|}}}]] {{LSL Param/fr|{{{p1_name|}}}}}{{#if:{{{p2_name|}}}{{{p2_type|}}}|, [[{{{p2_type|}}}]] {{LSL Param/fr|{{{p2_name|}}}}}{{#if:{{{p3_name|}}}{{{p3_type|}}}|, [[{{{p3_type|}}}]] {{LSL Param/it|{{{p3_name|}}}}}{{#if:{{{p4_name|}}}{{{p4_type|}}}|, [[{{{p4_type|}}}]] {{LSL Param/it|{{{p4_name|}}}}}{{#if:{{{p5_name|}}}{{{p5_type|}}}|, [[{{{p5_type|}}}]] {{LSL Param/it|{{{p5_name|}}}}}{{#if:{{{p6_name|}}}{{{p6_type|}}}|, [[{{{p6_type|}}}]] {{LSL Param/it|{{{p6_name|}}}}}{{#if:{{{p7_name|}}}{{{p7_type|}}}|, [[{{{p7_type|}}}]] {{LSL Param/it|{{{p7_name|}}}}}{{#if:{{{p8_name|}}}{{{p8_type|}}}|, [[{{{p8_type|}}}]] {{LSL Param/fr|{{{p8_name|}}}}}{{#if:{{{p9_name|}}}{{{p9_type|}}}|, [[{{{p9_type|}}}]] {{LSL Param/fr|{{{p9_name|}}}}}{{#if:{{{p10_name|}}}{{{p10_type|}}}|, [[{{{p10_type|}}}]] {{LSL Param/it|{{{p10_name|}}}}}{{#if:{{{p11_name|}}}{{{p11_type|}}}|, [[{{{p11_type|}}}]] {{LSL Param/it|{{{p11_name|}}}}}{{#if:{{{p12_name|}}}{{{p12_type|}}}|, [[{{{p12_type|}}}]] {{LSL Param/fr|{{{p12_name|}}}}}}}}}}}}}}}}}}}}}}}}}}}}} )<nowiki>;</nowiki></h2>
<div style="padding: 0.5em">{{#ifeq:{{#var:mode}}|user|{{#if:{{#var:floater}}|<div id="box" style="float:right;">{{#var:floater}}</div>}}|<div id="box" style="float:right;">
{{{!}} class="collapsible"
{{!}}- style="font-size:75%;"
{{!}}+
{{!}}-
{{!}} {{HoverText|{{#var:func_id}}|Identificativo della funzione.}}
{{!}} [[LSL Function ID/it|Id della funzione]]
{{!}}-
{{!}} {{HoverText|{{{func_sleep|}}}|Numero di secondi di ritardo quando questa funzione è eseguita.}}
{{!}} [[LSL Delay/it|Ritardo]]
{{!}}-
{{#if:{{{func_complexity|}}}|
{{!}} {{HoverText|{{{func_complexity|}}}|Complessità della funzione in termini di parametri.}}
{{!}} [[LSL Complexity/it|Complessità]]
{{!}}-}}
{{!}} {{HoverText|{{{func_energy|}}}|Quantità di energia consumata dalla funzione.}}
{{!}} [[Energy/it|Energia]]
{{!}}}</div>}}
{{#if:{{#var:header_desc}}|{{#var:header_desc}}<br/>{{#if:{{{return_type|}}}|<br/>}}}}{{#if:{{{return_type|}}}| Restituisce un {{{return_type|}}} {{#if:{{#var:return_text}}| {{#var:return_text}} }}<br/>}}
{{#if:{{{p1_name|}}}{{{p1_type|}}}|{{{!}}
{{LSL DefineRow|1={{{p1_type|}}}|2={{{p1_name|}}}|3={{#var:p_{{{p1_name|}}}_desc}}}}
{{#if:{{{p2_name|}}}{{{p2_type|}}}|{{LSL DefineRow|1={{{p2_type|}}}|2={{{p2_name|}}}|3={{#var:p_{{{p2_name|}}}_desc}}}}
{{#if:{{{p3_name|}}}{{{p3_type|}}}|{{LSL DefineRow|1={{{p3_type|}}}|2={{{p3_name|}}}|3={{#var:p_{{{p3_name|}}}_desc}}}}
{{#if:{{{p4_name|}}}{{{p4_type|}}}|{{LSL DefineRow|1={{{p4_type|}}}|2={{{p4_name|}}}|3={{#var:p_{{{p4_name|}}}_desc}}}}
{{#if:{{{p5_name|}}}{{{p5_type|}}}|{{LSL DefineRow|1={{{p5_type|}}}|2={{{p5_name|}}}|3={{#var:p_{{{p5_name|}}}_desc}}}}
{{#if:{{{p6_name|}}}{{{p6_type|}}}|{{LSL DefineRow|1={{{p6_type|}}}|2={{{p6_name|}}}|3={{#var:p_{{{p6_name|}}}_desc}}}}
{{#if:{{{p7_name|}}}{{{p7_type|}}}|{{LSL DefineRow|1={{{p7_type|}}}|2={{{p7_name|}}}|3={{#var:p_{{{p7_name|}}}_desc}}}}
{{#if:{{{p8_name|}}}{{{p8_type|}}}|{{LSL DefineRow|1={{{p8_type|}}}|2={{{p8_name|}}}|3={{#var:p_{{{p8_name|}}}_desc}}}}
{{#if:{{{p9_name|}}}{{{p9_type|}}}|{{LSL DefineRow|1={{{p9_type|}}}|2={{{p9_name|}}}|3={{#var:p_{{{p9_name|}}}_desc}}}}
{{#if:{{{p10_name|}}}{{{p10_type|}}}|{{LSL DefineRow|1={{{p10_type|}}}|2={{{p10_name|}}}|3={{#var:p_{{{p10_name|}}}_desc}}}}
{{#if:{{{p11_name|}}}{{{p11_type|}}}|{{LSL DefineRow|1={{{p11_type|}}}|2={{{p11_name|}}}|3={{#var:p_{{{p11_name|}}}_desc}}}}
{{#if:{{{p12_name|}}}{{{p12_type|}}}|{{LSL DefineRow|1={{{p12_type|}}}|2={{{p12_name|}}}|3={{#var:p_{{{p12_name|}}}_desc}}}}
}}}}}}}}}}}}}}}}}}}}}}
{{!}}} }}
{{#if:{{#var:header_footnote}}|<br/>
{{#var:header_footnote}}}}
<div style="clear:right;"></div>
</div></div>{{#if:{{#var:spec}}|<div id="box">
<h2>Specifiche</h2>
<div style="padding: 0.5em">
{{#var:spec}}
</div></div>}}{{#if:{{#var:constants_nb}}{{#var:constants}}{{{constants|}}}|
{{#var:constants_nb}}
{{{constants|}}}{{#if:{{#var:constants}}|
<div id="box">
<h2>Costanti</h2>
{{#var:constants}}
</div>}}}}{{#if:{{#var:caveats}}|<div id="box">
<h2>Avvertimenti</h2>
<div style="padding: 0.5em">
{{#var:caveats}}
</div></div>}}{{#if:{{#if:{{#var:deprecated}}||t}}{{#var:examples}}|<div id="box">
<h2>Esempi</h2>
<div style="padding: 0.5em">
{{#var:examples}}
</div></div>}}{{#if:{{#var:helpers}}|<div id="box">
<h2>Blocchi di codice utili</h2>
<div style="padding: 0.5em">
{{#var:helpers}}
</div></div>}}{{#if:{{#var:notes}}|<div id="box">
<h2>Note</h2>
<div style="padding: 0.5em">
{{#var:notes}}
</div></div>}}{{#if:{{#var:also_footer}}{{#var:also_functions}}{{#var:also_events}}{{#var:also_articles}}{{#var:also_tests}}{{#var:also_header}}{{#var:also_library}}|<div id="box">
<h2>Si veda anche</h2>
<div style="padding: 0.5em">
{{#if:{{#var:also_header}}|
{{#var:also_header}}}}{{#if:{{#var:also_events}}|
<h3>Eventi</h3>
{{{!}}
{{#var:also_events}}
{{!}}} }}{{#if:{{#var:also_functions}}|
<h3>Funzioni</h3>
{{{!}}
{{#var:also_functions}}
{{!}}} }}{{#if:{{#var:also_tests}}|
<h3>Prove</h3>
{{{!}}
{{#var:also_tests}}
{{!}}} }}{{#if:{{#var:also_articles}}|
<h3>Articoli</h3>
{{{!}}
{{#var:also_articles}}
{{!}}} }}{{#if:{{#var:also_library}}|
<h3>Libreria ed esempi</h3>
{{{!}}
{{#var:also_library}}
{{!}}} }}
{{#if:{{#var:also_footer}}|<br/>{{#var:also_footer}}}}
</div></div>}}{{#if:{{#var:location}}|<div id="box">
<h2>Problemi nel codice</h2>
<div style="padding: 0.5em">
{{#var:location}}
</div></div>}}{{#if:{{{history|}}}{{{bugs|}}}|<div id="box">
<h2>Storia</h2>
<div style="padding: 0.5em">
{{#if:{{{bugs|}}}|<h3>Bugs</h3>
{{{!}}
{{{bugs}}}
{{!}}} }}
{{{history|}}}
</div></div>}}{{#if:{{{comments|}}}|<div id="box">
<h2>Commenti</h2>
<div style="padding: 0.5em">
{{{comments|}}}
</div></div>}}
{{#var:footer}} {{#if:{{#var:self}}|| {{#switch:{{#var:mode}}|request|user=| [[Category:LSL Functions{{#var:lang}}]] {{#if:{{#var:examples}}||[[Category:LSL Needs Example{{#var:lang}}]]}}}} {{#if:{{{cat1|}}}|[[Category:LSL {{{cat1}}}]]}} {{#if:{{{cat2|}}}|[[Category:LSL {{{cat2}}}]]}} {{#if:{{{cat3|}}}|[[Category:LSL {{{cat3}}}]]}} {{#if:{{{cat4|}}}|[[Category:LSL {{{cat4}}}]]}} {{#if:{{{cat5|}}}|[[Category:LSL {{{cat5}}}]]}} {{#if:{{{cat6|}}}|[[Category:LSL {{{cat6}}}]]}} {{#if:{{{cat7|}}}|[[Category:LSL {{{cat7}}}]]}} {{#if:{{{cat8|}}}|[[Category:LSL {{{cat8}}}]]}} }}</includeonly>

Template:LSL Function/it

2012-01-15T17:31:34Z

Violet Hammerer:

{{Multi-lang|2=/it}}{{LSL Header/it}} __NOTOC__ <noinclude>
Si veda [[{{FULLPAGENAME}}/docs]] per la documentazione.
</noinclude><includeonly>{{#if:{{#vardefine:sort|{{#if:{{#var:sort}}|{{#var:sort}}|{{{sort|}}}}}}}{{{{#if:{{#var:sort}}|!|LSL_Sort}}|}}}}<div id="sort" style="display:none">{{DEFAULTSORT:{{#var:sort}}}}{{#var:sort}}</div>{{#if:{{#var:nofixname}}||{{#if:{{#pos:{{lc:{{FULLPAGENAMEE}}}}|{{lc:{{{func}}}}}}}|<div id="RealTitleBanner" style="display:none"><span id="RealTitle">{{#if:{{NAMESPACE}}|{{NAMESPACE}}:}}{{{func}}}</span></div>}}}}{{#if:
{{#vardefine:func_id|{{{func_id|}}}}}
{{#vardefine:p_{{{p1_name|}}}_desc|{{#var:p_{{{p1_name|}}}_desc}}{{{p1_desc|}}}}}
{{#vardefine:p_{{{p1_name|}}}_hover|{{#var:p_{{{p1_name|}}}_hover}}{{{p1_hover|}}}}}
{{#vardefine:p_{{{p2_name|}}}_desc|{{#var:p_{{{p2_name|}}}_desc}}{{{p2_desc|}}}}}
{{#vardefine:p_{{{p2_name|}}}_hover|{{#var:p_{{{p2_name|}}}_hover}}{{{p2_hover|}}}}}
{{#vardefine:p_{{{p3_name|}}}_desc|{{#var:p_{{{p3_name|}}}_desc}}{{{p3_desc|}}}}}
{{#vardefine:p_{{{p3_name|}}}_hover|{{#var:p_{{{p3_name|}}}_hover}}{{{p3_hover|}}}}}
{{#vardefine:p_{{{p4_name|}}}_desc|{{#var:p_{{{p4_name|}}}_desc}}{{{p4_desc|}}}}}
{{#vardefine:p_{{{p4_name|}}}_hover|{{#var:p_{{{p4_name|}}}_hover}}{{{p4_hover|}}}}}
{{#vardefine:p_{{{p5_name|}}}_desc|{{#var:p_{{{p5_name|}}}_desc}}{{{p5_desc|}}}}}
{{#vardefine:p_{{{p5_name|}}}_hover|{{#var:p_{{{p5_name|}}}_hover}}{{{p5_hover|}}}}}
{{#vardefine:p_{{{p6_name|}}}_desc|{{#var:p_{{{p6_name|}}}_desc}}{{{p6_desc|}}}}}
{{#vardefine:p_{{{p6_name|}}}_hover|{{#var:p_{{{p6_name|}}}_hover}}{{{p6_hover|}}}}}
{{#vardefine:p_{{{p7_name|}}}_desc|{{#var:p_{{{p7_name|}}}_desc}}{{{p7_desc|}}}}}
{{#vardefine:p_{{{p7_name|}}}_hover|{{#var:p_{{{p7_name|}}}_hover}}{{{p7_hover|}}}}}
{{#vardefine:p_{{{p8_name|}}}_desc|{{#var:p_{{{p8_name|}}}_desc}}{{{p8_desc|}}}}}
{{#vardefine:p_{{{p8_name|}}}_hover|{{#var:p_{{{p8_name|}}}_hover}}{{{p8_hover|}}}}}
{{#vardefine:p_{{{p9_name|}}}_desc|{{#var:p_{{{p9_name|}}}_desc}}{{{p9_desc|}}}}}
{{#vardefine:p_{{{p9_name|}}}_hover|{{#var:p_{{{p9_name|}}}_hover}}{{{p9_hover|}}}}}
{{#vardefine:p_{{{p10_name|}}}_desc|{{#var:p_{{{p10_name|}}}_desc}}{{{p10_desc|}}}}}
{{#vardefine:p_{{{p10_name|}}}_hover|{{#var:p_{{{p10_name|}}}_hover}}{{{p10_hover|}}}}}
{{#vardefine:p_{{{p11_name|}}}_desc|{{#var:p_{{{p11_name|}}}_desc}}{{{p11_desc|}}}}}
{{#vardefine:p_{{{p11_name|}}}_hover|{{#var:p_{{{p11_name|}}}_hover}}{{{p11_hover|}}}}}
{{#vardefine:p_{{{p12_name|}}}_desc|{{#var:p_{{{p12_name|}}}_desc}}{{{p12_desc|}}}}}
{{#vardefine:p_{{{p12_name|}}}_hover|{{#var:p_{{{p12_name|}}}_hover}}{{{p12_hover|}}}}}
{{#vardefine:return_text|{{#var:return_text}}{{{return_text|}}} }}
{{#vardefine:spec|{{#if:{{#var:spec}}|{{#var:spec}}<br/>}}{{{spec|}}}}}
{{#vardefine:examples|{{#var:examples}}{{{examples|}}}}}
{{#vardefine:helpers|{{#var:helpers}}{{{helpers|}}}}}
{{#vardefine:also_header|{{#var:also_header}}{{{also_header|}}}}}
{{#vardefine:also_tests|{{#var:also_tests}}
{{{also_tests|}}}}}
{{#vardefine:also_events|{{#var:also_events}}
{{{also_events|}}}}}
{{#vardefine:also_functions|{{#var:also_functions}}
{{{also_functions|}}}}}
{{#vardefine:also_articles|{{#var:also_articles}}
{{{also_articles|}}}}}
{{#vardefine:also_library|{{#var:also_library}}
{{{also_library|}}}}}
{{#vardefine:also_footer|{{#var:also_footer}}{{{also_footer|}}}}}
{{#vardefine:notes|{{#var:notes}}{{{notes|}}}}}
{{#vardefine:mode|{{#var:mode}}{{{mode|}}}}}
{{#vardefine:self|{{#var:self}}{{{self|}}}}}
{{#vardefine:type|funzione}}
{{#vardefine:caveats|{{#ifexpr:{{{func_sleep|0.0}}}> 0.0|*Questa funzione comporta un ritardo di {{{func_sleep|}}} secondi.}}{{#if:{{#var:caveats}}|
{{#var:caveats}}}}
{{{caveats|}}}}}
{{#vardefine:location|{{#var:location}}{{{location|}}}}}
{{#vardefine:header_footnote|{{#if:{{#var:header_footnote}}|{{#var:header_footnote}}<br/>}}{{{func_footnote|}}}{{{func_footer|}}}}}
{{#vardefine:header_desc|{{#if:{{#var:header_desc}}|{{#var:header_desc}}<br/>}}{{#var:header_desc}}{{{func_desc|}}}}}
{{{{#ifeq:{{#var:mode}}|god|LSL_Generic/god/it|!}}|}}
{{{{#ifeq:{{#var:mode}}|request|LSL_Generic/request/it|!}}|}}
{{{{#if:{{{deprecated|}}}|LSL_Generic/deprecated/it|!}}|{{{deprecated|}}}|}}
}}{{#if:{{#var:self}}|| __NOEDITSECTION__
}}{{#var:header}}{{#if:{{#var:func_id}}{{#var:mode}}||
<div id="box" style="background:red;">
  '''Non cancellate il 'func_id''''
<div style="padding: 0.5em;background:#ffffff;">
''func_id è una componente dell'informazione tecnica che non dovrebbe essere rimossa dato che è pertinente a chiunque abbia scritto un compilatore o decompilatore LSL, per cui è opportuno rimettere a posto la pagina adesso :P.''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe}]] }} }}{{#if:{{{also|}}}|<div id="box" style="background:yellow;">
  ''' 'anche' Marcatore Rimosso'''
<div style="padding: 0.5em;background:#ffffff;">
''(Per favore, utilizzate 'also_header','also_events','also_functions','also_articles', o 'also_footer')''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}{{#if:{{#if:{{{return_type|}}}|{{#var:return_text}}}}{{{func_desc|}}}||<div id="box" style="background:yellow;">
  ''' 'return_text' e 'func_desc' non possono essere entrambi non definiti'''
<div style="padding: 0.5em;background:#ffffff;">
''(Per favore, utilizzate 'return_text' o 'func_desc' per descrivere il comportamento della funzione.)''</div></div>{{#if:{{#var:self}}|| [[Category:LSL FixMe]] }} }}
<div id="box">
<h2>Funzione : {{#if:{{{return_type|}}}|[[{{{return_type|}}}]]||}} [[{{{func}}}]]( {{#if:{{{p1_name|}}}{{{p1_type|}}}| [[{{{p1_type|}}}]] {{LSL Param/fr|{{{p1_name|}}}}}{{#if:{{{p2_name|}}}{{{p2_type|}}}|, [[{{{p2_type|}}}]] {{LSL Param/fr|{{{p2_name|}}}}}{{#if:{{{p3_name|}}}{{{p3_type|}}}|, [[{{{p3_type|}}}]] {{LSL Param/it|{{{p3_name|}}}}}{{#if:{{{p4_name|}}}{{{p4_type|}}}|, [[{{{p4_type|}}}]] {{LSL Param/it|{{{p4_name|}}}}}{{#if:{{{p5_name|}}}{{{p5_type|}}}|, [[{{{p5_type|}}}]] {{LSL Param/it|{{{p5_name|}}}}}{{#if:{{{p6_name|}}}{{{p6_type|}}}|, [[{{{p6_type|}}}]] {{LSL Param/it|{{{p6_name|}}}}}{{#if:{{{p7_name|}}}{{{p7_type|}}}|, [[{{{p7_type|}}}]] {{LSL Param/it|{{{p7_name|}}}}}{{#if:{{{p8_name|}}}{{{p8_type|}}}|, [[{{{p8_type|}}}]] {{LSL Param/fr|{{{p8_name|}}}}}{{#if:{{{p9_name|}}}{{{p9_type|}}}|, [[{{{p9_type|}}}]] {{LSL Param/fr|{{{p9_name|}}}}}{{#if:{{{p10_name|}}}{{{p10_type|}}}|, [[{{{p10_type|}}}]] {{LSL Param/it|{{{p10_name|}}}}}{{#if:{{{p11_name|}}}{{{p11_type|}}}|, [[{{{p11_type|}}}]] {{LSL Param/it|{{{p11_name|}}}}}{{#if:{{{p12_name|}}}{{{p12_type|}}}|, [[{{{p12_type|}}}]] {{LSL Param/fr|{{{p12_name|}}}}}}}}}}}}}}}}}}}}}}}}}}}}} )<nowiki>;</nowiki></h2>
<div style="padding: 0.5em">{{#ifeq:{{#var:mode}}|user|{{#if:{{#var:floater}}|<div id="box" style="float:right;">{{#var:floater}}</div>}}|<div id="box" style="float:right;">
{{{!}} class="collapsible"
{{!}}- style="font-size:75%;"
{{!}}+
{{!}}-
{{!}} {{HoverText|{{#var:func_id}}|Identificativo della funzione.}}
{{!}} [[LSL Function ID/it|Id della funzione]]
{{!}}-
{{!}} {{HoverText|{{{func_sleep|}}}|Numero di secondi di ritardo quando questa funzione è eseguita.}}
{{!}} [[LSL Delay/it|Ritardo]]
{{!}}-
{{#if:{{{func_complexity|}}}|
{{!}} {{HoverText|{{{func_complexity|}}}|Complessità della funzione in termini di parametri.}}
{{!}} [[LSL Complexity/it|Complessità]]
{{!}}-}}
{{!}} {{HoverText|{{{func_energy|}}}|Quantità di energia consumata dalla funzione.}}
{{!}} [[Energy/it|Energia]]
{{!}}}</div>}}
{{#if:{{#var:header_desc}}|{{#var:header_desc}}<br/>{{#if:{{{return_type|}}}|<br/>}}}}{{#if:{{{return_type|}}}| Ritorna un {{{return_type|}}} {{#if:{{#var:return_text}}| {{#var:return_text}} }}<br/>}}
{{#if:{{{p1_name|}}}{{{p1_type|}}}|{{{!}}
{{LSL DefineRow|1={{{p1_type|}}}|2={{{p1_name|}}}|3={{#var:p_{{{p1_name|}}}_desc}}}}
{{#if:{{{p2_name|}}}{{{p2_type|}}}|{{LSL DefineRow|1={{{p2_type|}}}|2={{{p2_name|}}}|3={{#var:p_{{{p2_name|}}}_desc}}}}
{{#if:{{{p3_name|}}}{{{p3_type|}}}|{{LSL DefineRow|1={{{p3_type|}}}|2={{{p3_name|}}}|3={{#var:p_{{{p3_name|}}}_desc}}}}
{{#if:{{{p4_name|}}}{{{p4_type|}}}|{{LSL DefineRow|1={{{p4_type|}}}|2={{{p4_name|}}}|3={{#var:p_{{{p4_name|}}}_desc}}}}
{{#if:{{{p5_name|}}}{{{p5_type|}}}|{{LSL DefineRow|1={{{p5_type|}}}|2={{{p5_name|}}}|3={{#var:p_{{{p5_name|}}}_desc}}}}
{{#if:{{{p6_name|}}}{{{p6_type|}}}|{{LSL DefineRow|1={{{p6_type|}}}|2={{{p6_name|}}}|3={{#var:p_{{{p6_name|}}}_desc}}}}
{{#if:{{{p7_name|}}}{{{p7_type|}}}|{{LSL DefineRow|1={{{p7_type|}}}|2={{{p7_name|}}}|3={{#var:p_{{{p7_name|}}}_desc}}}}
{{#if:{{{p8_name|}}}{{{p8_type|}}}|{{LSL DefineRow|1={{{p8_type|}}}|2={{{p8_name|}}}|3={{#var:p_{{{p8_name|}}}_desc}}}}
{{#if:{{{p9_name|}}}{{{p9_type|}}}|{{LSL DefineRow|1={{{p9_type|}}}|2={{{p9_name|}}}|3={{#var:p_{{{p9_name|}}}_desc}}}}
{{#if:{{{p10_name|}}}{{{p10_type|}}}|{{LSL DefineRow|1={{{p10_type|}}}|2={{{p10_name|}}}|3={{#var:p_{{{p10_name|}}}_desc}}}}
{{#if:{{{p11_name|}}}{{{p11_type|}}}|{{LSL DefineRow|1={{{p11_type|}}}|2={{{p11_name|}}}|3={{#var:p_{{{p11_name|}}}_desc}}}}
{{#if:{{{p12_name|}}}{{{p12_type|}}}|{{LSL DefineRow|1={{{p12_type|}}}|2={{{p12_name|}}}|3={{#var:p_{{{p12_name|}}}_desc}}}}
}}}}}}}}}}}}}}}}}}}}}}
{{!}}} }}
{{#if:{{#var:header_footnote}}|<br/>
{{#var:header_footnote}}}}
<div style="clear:right;"></div>
</div></div>{{#if:{{#var:spec}}|<div id="box">
<h2>Specifiche</h2>
<div style="padding: 0.5em">
{{#var:spec}}
</div></div>}}{{#if:{{#var:constants_nb}}{{#var:constants}}{{{constants|}}}|
{{#var:constants_nb}}
{{{constants|}}}{{#if:{{#var:constants}}|
<div id="box">
<h2>Costanti</h2>
{{#var:constants}}
</div>}}}}{{#if:{{#var:caveats}}|<div id="box">
<h2>Avvertimenti</h2>
<div style="padding: 0.5em">
{{#var:caveats}}
</div></div>}}{{#if:{{#if:{{#var:deprecated}}||t}}{{#var:examples}}|<div id="box">
<h2>Esempi</h2>
<div style="padding: 0.5em">
{{#var:examples}}
</div></div>}}{{#if:{{#var:helpers}}|<div id="box">
<h2>Blocchi di codice utili</h2>
<div style="padding: 0.5em">
{{#var:helpers}}
</div></div>}}{{#if:{{#var:notes}}|<div id="box">
<h2>Note</h2>
<div style="padding: 0.5em">
{{#var:notes}}
</div></div>}}{{#if:{{#var:also_footer}}{{#var:also_functions}}{{#var:also_events}}{{#var:also_articles}}{{#var:also_tests}}{{#var:also_header}}{{#var:also_library}}|<div id="box">
<h2>Si veda anche</h2>
<div style="padding: 0.5em">
{{#if:{{#var:also_header}}|
{{#var:also_header}}}}{{#if:{{#var:also_events}}|
<h3>Eventi</h3>
{{{!}}
{{#var:also_events}}
{{!}}} }}{{#if:{{#var:also_functions}}|
<h3>Funzioni</h3>
{{{!}}
{{#var:also_functions}}
{{!}}} }}{{#if:{{#var:also_tests}}|
<h3>Prove</h3>
{{{!}}
{{#var:also_tests}}
{{!}}} }}{{#if:{{#var:also_articles}}|
<h3>Articoli</h3>
{{{!}}
{{#var:also_articles}}
{{!}}} }}{{#if:{{#var:also_library}}|
<h3>Libreria ed esempi</h3>
{{{!}}
{{#var:also_library}}
{{!}}} }}
{{#if:{{#var:also_footer}}|<br/>{{#var:also_footer}}}}
</div></div>}}{{#if:{{#var:location}}|<div id="box">
<h2>Problemi nel codice</h2>
<div style="padding: 0.5em">
{{#var:location}}
</div></div>}}{{#if:{{{history|}}}{{{bugs|}}}|<div id="box">
<h2>Storia</h2>
<div style="padding: 0.5em">
{{#if:{{{bugs|}}}|<h3>Bugs</h3>
{{{!}}
{{{bugs}}}
{{!}}} }}
{{{history|}}}
</div></div>}}{{#if:{{{comments|}}}|<div id="box">
<h2>Commenti</h2>
<div style="padding: 0.5em">
{{{comments|}}}
</div></div>}}
{{#var:footer}} {{#if:{{#var:self}}|| {{#switch:{{#var:mode}}|request|user=| [[Category:LSL Functions{{#var:lang}}]] {{#if:{{#var:examples}}||[[Category:LSL Needs Example{{#var:lang}}]]}}}} {{#if:{{{cat1|}}}|[[Category:LSL {{{cat1}}}]]}} {{#if:{{{cat2|}}}|[[Category:LSL {{{cat2}}}]]}} {{#if:{{{cat3|}}}|[[Category:LSL {{{cat3}}}]]}} {{#if:{{{cat4|}}}|[[Category:LSL {{{cat4}}}]]}} {{#if:{{{cat5|}}}|[[Category:LSL {{{cat5}}}]]}} {{#if:{{{cat6|}}}|[[Category:LSL {{{cat6}}}]]}} {{#if:{{{cat7|}}}|[[Category:LSL {{{cat7}}}]]}} {{#if:{{{cat8|}}}|[[Category:LSL {{{cat8}}}]]}} }}</includeonly>

LlGetLinkNumber/it

2012-01-15T17:27:03Z

Violet Hammerer:

{{LSL_Function/it
|func_id=139|func_sleep=0.0|func_energy=10.0
|func=llGetLinkNumber
|return_type=integer
|func_footnote=0 significa che il prim non è collegato, 1 significa che il prim è la radice, 2 significa che il prim è il primo prim collegato, ecc.
|func_desc
|return_text=che è il numero di collegamento del prim contenente lo script.
|spec
|caveats=*Per progettazione potrebbe eguagliare [[llGetNumberOfPrims]], ''esempi'', quando un prim è l'ultimo, quando l'oggetto contiene prim multipli, e nessun avatar è seduto su di esso
|constants
|examples=<lsl>default
{
state_entry()
{
llOwnerSay((string) llGetLinkNumber());
llOwnerSay((string) llGetNumberOfPrims());
}
}</lsl>
|helpers
|also_functions={{LSL DefineRow||[[llGetKey]]}}
{{LSL DefineRow||[[llGetNumberOfPrims]]}}
|also_tests
|also_events
|also_articles
|notes
|cat1=Link
|cat2
|cat3
|cat4
}}

Template:LSL Generic/Issues/it

2012-01-15T17:23:30Z

Violet Hammerer: Created page with "{{#if: <noinclude> {{#vardefine:issues|* Lorum Ipsum}} </noinclude> {{#vardefine:gi-issues|{{#ifeq:{{{issues}}}|{{{issues|}}}|{{{issues|}}}|{{#var:issues{{#var:direction|{{{dir|…"

{{#if:
<noinclude>
{{#vardefine:issues|* Lorum Ipsum}}
</noinclude>

{{#vardefine:gi-issues|{{#ifeq:{{{issues}}}|{{{issues|}}}|{{{issues|}}}|{{#var:issues{{#var:direction|{{{dir|}}}}}}}{{#vardefine:issues{{#var:direction|{{{dir|}}}}}}}}}}}

{{#vardefine:gi-line|{{JiraSearch/LSL Issues|1={{{keywords|}}} {{#var:name}}|2=Cercare sul JIRA per i problemi correlati}}}}

}}{{#if:{{#pos:{{#var:moded}}|u}}||{{#if:{{#var:gi-issues}}|<h4 style="display:inline; line-height:2em;">Tutti i problemi </h4><span style="vertical-align:1px;"> ~ {{#var:gi-line}}</span>
{{{!}} style="font-size:80%; line-height:1.1em; background-color:transparent;"
{{#var:gi-issues}}
{{!}}}|{{PBR}}{{#var:gi-line}}}}}}{{#vardefine:gi-issues}}{{#vardefine:gi-line}}

Template:LSL Generic/Caveats/it

2012-01-15T17:20:04Z

Violet Hammerer: Created page with "{{#if: <noinclude> {{#vardefine:caveats|* Lorum Ipsum}} {{#vardefine:bugs|* Lorum Ipsum}} </noinclude> {{#vardefine:gc-caveats|{{#ifeq:{{{caveats}}}|{{{caveats|}}}|{{{caveats|}}…"

{{#if:
<noinclude>
{{#vardefine:caveats|* Lorum Ipsum}}
{{#vardefine:bugs|* Lorum Ipsum}}
</noinclude>

{{#vardefine:gc-caveats|{{#ifeq:{{{caveats}}}|{{{caveats|}}}|{{{caveats|}}}|{{#var:caveats{{#var:direction|{{{dir|}}}}}}}{{#vardefine:caveats{{#var:direction|{{{dir|}}}}}}}}}}}
{{#vardefine:gc-bugs|{{#ifeq:{{{bugs}}}|{{{bugs|}}}|{{{bugs|}}}|{{#var:bugs{{#var:direction|{{{dir|}}}}}}}{{#vardefine:bugs{{#var:direction|{{{dir|}}}}}}}}}}}

{{#vardefine:gc-line|[[#All_Issues|Tutti i problemi]] ~ {{JiraSearch/LSL Bugs|1={{{keywords|}}} {{#var:name}}|2=Cercare sul JIRA per i bug correlati}}}}

}}{{#if:{{#var:gc-caveats}}|{{#if:{{{title|}}}|<h{{{h|3}}}>{{{title-pre|}}} Avvertimenti {{{title-post|}}}</h{{{h|3}}}>
}}<div>
{{#var:gc-caveats}}
</div>}}{{#if:{{#pos:{{#var:moded}}|u}}||{{#if:{{#var:gc-bugs}}|<h4 style="display:inline; line-height:2em;">Problemi importanti </h4><span style="vertical-align:1px;"> ~ {{#var:gc-line}}</span>
{{{!}} style="font-size:80%; line-height:1.1em; background-color:transparent;"
{{#var:gc-bugs}}
{{!}}}|{{PBR}}{{#var:gc-line}}}}}}{{#vardefine:gc-caveats}}{{#vardefine:gc-bugs}}{{#vardefine:gc-line}}

LlGetLinkNumber/it

2012-01-15T17:12:48Z

Violet Hammerer: Created page with "{{LSL_Function |func_id=139|func_sleep=0.0|func_energy=10.0 |func=llGetLinkNumber |return_type=integer |func_footnote=0 significa che il prim non è collegato, 1 significa che il…"

{{LSL_Function
|func_id=139|func_sleep=0.0|func_energy=10.0
|func=llGetLinkNumber
|return_type=integer
|func_footnote=0 significa che il prim non è collegato, 1 significa che il prim è la radice, 2 significa che il prim è il primo prim collegato, ecc.
|func_desc
|return_text=che è il numero di collegamento del prim contenente lo script.
|spec
|caveats=*Per progettazione potrebbe eguagliare [[llGetNumberOfPrims]], ''esempi'', quando un prim è l'ultimo, quando l'oggetto contiene prim multipli, e nessun avatar è seduto su di esso
|constants
|examples=<lsl>default
{
state_entry()
{
llOwnerSay((string) llGetLinkNumber());
llOwnerSay((string) llGetNumberOfPrims());
}
}</lsl>
|helpers
|also_functions={{LSL DefineRow||[[llGetKey]]}}
{{LSL DefineRow||[[llGetNumberOfPrims]]}}
|also_tests
|also_events
|also_articles
|notes
|cat1=Link
|cat2
|cat3
|cat4
}}

State exit/it

2012-01-15T13:26:39Z

Violet Hammerer: Created page with "{{LSL_Event |event_id=1|event_delay|event=state_exit |event_desc=Eseguito al cambio di state. |constants |spec |caveats= * Gli eventi messi in coda durante lo state_exit,…"

{{LSL_Event
|event_id=1|event_delay|event=state_exit
|event_desc=Eseguito al cambio di [[state]].
|constants
|spec
|caveats=
* Gli eventi messi in coda durante lo [[state_exit]], sono scaricati prima che si entri nel prossimo stato. Per evitare ciò quando possibile, usate lo [[state_entry]]. Si legga [[state]] per avvisi ulteriori.
|examples=<lsl>default
{
state_entry()
{
llOwnerSay("sono nello stato default");
}

touch_start(integer detected)
{
state altro;
}

state_exit()
{
llOwnerSay("abbandono lo stato default");
}
}

state altro
{
state_entry()
{
llOwnerSay("sono nello stato \"altro\"");
}

touch_start(integer detected)
{
state default;
}

state_exit()
{
llOwnerSay("abbandono lo stato \"altro\"");
}
}</lsl>
|helpers
|also_header
|also_events
|also_functions
|also_articles
|also_footer
|notes=Mentre lo stato [[default]] [[state_entry]] viene eseguito all'azzeramento dello script, lo stato state_exit non viene eseguito prima dell'azzeramento.
|mode
|deprecated
|cat1=Script
|cat2=State
|cat3
|cat4
}}

State entry/it

2012-01-15T13:13:17Z

Violet Hammerer:

{{Issues/SVC-3379}}{{LSL_Event
|event_id=0|event_delay|event=state_entry
|event_desc=Eseguito ad ogni transizione di stato e avvio
|constants
|spec=
=== Esecuzione ===
#Salvataggio dello script o aggiunta ad un oggetto
#Cambio di stato
#*Viene eseguito uno [[state_exit]] nel vecchio stato e lo [[state_entry]] viene avviato nel nuovo stato. Come risultato del cambio di stato, tutti gli altri eventi in coda sono persi.
#All'azzeramento dello script, sia tramite client che [[llResetScript]]/[[llResetOtherScript]]
#Quando l'oggetto viene rezzato ''senza'' uno stato script salvato
#*Se era una copia presa da SL
#*Se l'evento non è stato eseguito a causa di un terreno in cui gli script erano disabilitati.

=== Non esecuzione ===
#Quando l'oggetto viene rezzato ''con'' uno stato script salvato
#*In questa situazione usate l'evento [[on_rez]]
|caveats
|examples=<lsl>default
{
state_entry()
{
llSay(0, "Ciao, Avatar!");
}
}</lsl>
|helpers
|also_header
|also_events={{LSL DefineRow||[[on_rez]]|Eseguito quando l'oggetto viene rezzato}}
{{LSL DefineRow||[[state_exit]]|Eseguito quando si esce da uno stato a un cambio di stato}}
|also_functions={{LSL DefineRow||[[llResetScript]]|Azzera lo script}}
{{LSL DefineRow||[[llResetOtherScript]]|Azzera un altro script nel prim}}
{{LSL DefineRow||[[llGetStartParameter]]|Il parametro [[on_rez]] (o il parametro [[llRemoteLoadScriptPin]])}}
|also_articles
|also_footer
|notes
|mode
|deprecated
|cat1=Script
|cat2=State
|cat3
|cat4
}}

State entry/it

2012-01-15T13:12:33Z

Violet Hammerer: Created page with "{{Issues/SVC-3379}}{{LSL_Event |event_id=0|event_delay|event=state_entry |event_desc=Eseguito ad ogni transizione di stato e avvio |constants |spec= === Esecuzione === #Salvatagg…"

{{Issues/SVC-3379}}{{LSL_Event
|event_id=0|event_delay|event=state_entry
|event_desc=Eseguito ad ogni transizione di stato e avvio
|constants
|spec=
=== Esecuzione ===
#Salvataggio dello script o aggiunta ad un oggetto
#Cambio di stato
#*Viene eseguito uno [[state_exit]] nel vecchio stato e lo [[state_entry]] viene avviato nel nuovo stato. Come risultato del cambio di stato, tutti gli altri eventi in coda sono persi.
#All'azzeramento dello script, sia tramite client che [[llResetScript]]/[[llResetOtherScript]]
#Quando l'oggetto viene rezzato ''senza'' uno stato script salvato
#*Se era una copia presa da SL
#*Se l'evento non è stato eseguito a causa di un terreno in cui gli script erano disabilitati.

=== Non esecuzione ===
#Quando l'oggetto viene rezzato ''con'' uno stato script salvato
#*In cuesta situazione usate l'evento [[on_rez]]
|caveats
|examples=<lsl>default
{
state_entry()
{
llSay(0, "Ciao, Avatar!");
}
}</lsl>
|helpers
|also_header
|also_events={{LSL DefineRow||[[on_rez]]|Eseguito quando l'oggetto viene rezzato}}
{{LSL DefineRow||[[state_exit]]|Eseguito quando si esce da uno stato a un cambio di stato}}
|also_functions={{LSL DefineRow||[[llResetScript]]|Azzera lo script}}
{{LSL DefineRow||[[llResetOtherScript]]|Azzera un altro script nel prim}}
{{LSL DefineRow||[[llGetStartParameter]]|Il parametro [[on_rez]] (o il parametro [[llRemoteLoadScriptPin]])}}
|also_articles
|also_footer
|notes
|mode
|deprecated
|cat1=Script
|cat2=State
|cat3
|cat4
}}

LlResetScript/it

2012-01-15T12:58:27Z

Violet Hammerer: Created page with "{{LSL_Function |func_id=163|func_sleep=0.0|func_energy=10.0 |func=llResetScript |func_footnote=All'azzeramento dello script... *Si esce dall'evento/la funzione corrente senza ese…"

{{LSL_Function
|func_id=163|func_sleep=0.0|func_energy=10.0
|func=llResetScript
|func_footnote=All'azzeramento dello script...
*Si esce dall'evento/la funzione corrente senza esecuzioni o ritorno ulteriori.
*Tutte le variabili globali vengono impostate ai loro valori predefiniti
*La coda degli eventi viene svuotata.
*Viene impostato come stato attivo lo stato [[default]]
**Se questo possiede un evento [[state_entry]], allora viene messo in coda.
|func_desc=Azzera lo script.
|return_text
|spec
|caveats
|constants
|examples=
<lsl>
default
{
state_entry()
{
// Qui vanno i comandi di inizializzazione dello script
}

on_rez(integer start_param)
{
// Azzera lo script quando l'oggetto viene rezzato
llResetScript();
}
}
</lsl>
|helpers
|also_functions=*{{LSLG|llResetOtherScript}}
|also_events
|also_tests
|also_articles
|notes
|permission
|negative_index
|sort=ResetScript
|cat1=Script
|cat2
|cat3
|cat4
}}

Template:LSL Function/prim-desc/it

2012-01-12T18:49:05Z

Violet Hammerer:

{{#if:
{{LSL Function/limits}}
{{#vardefine:caveats|{{#var:caveats}}
*La descrizione di un prim è [[limit]]ata a 127 [[bytes]], qualunque stringa vada oltre quel limite verrà troncata. Questo troncamento non sempre accade quando l'attributo viene impostato o letto.
*Il carattere barretta '|' e la combinazione di caratteri per una nuova linea '\n' non sono legali nella descrizione di un prim, verranno sostituiti con '?'{{Footnote|Il carattere barretta storicamente è stato usato per separare i campi nella versione serializzata dell'inventario. Il campo non è multiriga, perciò la combinazione per una nuova linea non ha senso in questo contesto.}}.
*Si noti che quando le persone selezionano "Mostrare i suggerimenti per tutti gli oggetti." nel menù "Mostrare" del proprio visualizzatore, vedono al di sotto del loro cursore il pop-up descrittivo per qualsiasi oggetto. Per tale ragione, è una buona abitudine impostare solamente informazioni umanamente comprensibili nel campo della descrizione (es., chiavi e simili).
*Quando un oggetto indossato viene tolto, i cambiamenti effettuati dallo script a nome e descrizione (del prim radice) dell'oggetto indossato verranno persi. Mentre l'oggetto viene indossato, nome e descrizione possono essere cambiati, ma ciò non si rifletterà nell'inventario. Questo avvertimento ''non'' si applica ai prim collegati.
}}
}}<noinclude>
{| {{Prettytable}}
|-{{Hl2}}
! #var
! value
|-
{{VarPairTable|also_articles}}
|-
{{VarPair|caveats}}
|}
{{Footnotes}}
</noinclude>

Template:LSL Function/prim-desc/it

2012-01-12T18:41:36Z

Violet Hammerer:

{{#if:
{{LSL Function/limits}}
{{#vardefine:caveats|{{#var:caveats}}
*La descrizione di un prim è [[limit]]ata a 127 [[bytes]], qualunque stringa vada oltre quel limite verrà troncata. Questo troncamento non sempre accade quando l'attributo viene impostato o letto.
*Il carattere barretta '|' la combinazione di caratteri per una nuova linea '\n' non sono legali nella descrizione di un prim, verranno sostituiti con '?'{{Footnote|Il carattere barretta storicamente è stato usato per separare i campi nella versione serializzata dell'inventario. Il campo non è multiriga, perciò la combinazione per una nuova linea non ha senso in questo contesto.}}.
*Note that when people have "Hover Tips on All Objects" selected in the viewer's "View" menu, they'll see the object description pop-up for any object under their mouse pointer. For that reason, it is good practice to only set human-friendly information in the description (e.g. keys and such).
*When an attached object is detached, changes made by script to the name and description (of the root prim) of the attachment will be lost. While the object is attached the name and description can be changed but it will not be reflected in inventory. This caveat does ''not'' apply to child prims.
}}
}}<noinclude>
{| {{Prettytable}}
|-{{Hl2}}
! #var
! value
|-
{{VarPairTable|also_articles}}
|-
{{VarPair|caveats}}
|}
{{Footnotes}}
</noinclude>

Template:LSL Function/prim-desc/it

2012-01-12T18:35:57Z

Violet Hammerer: Created page with "{{#if: {{LSL Function/limits}} {{#vardefine:caveats|{{#var:caveats}} *The prim description is limited to 127 bytes, any string longer then that will be truncated. This tr…"

{{#if:
{{LSL Function/limits}}
{{#vardefine:caveats|{{#var:caveats}}
*The prim description is [[limit]]ed to 127 [[bytes]], any string longer then that will be truncated. This truncation does not always happen when the attribute is set or read.
*The pipe character '|' and the newline character '\n' are not legal in a prim's description, they will be replaced by with '?'{{Footnote|The pipe character historically has been used to separate fields in the serialized version of inventory. The field is not multi-line so the newline character holds no meaning in this context.}}.
*Note that when people have "Hover Tips on All Objects" selected in the viewer's "View" menu, they'll see the object description pop-up for any object under their mouse pointer. For that reason, it is good practice to only set human-friendly information in the description (e.g. keys and such).
*When an attached object is detached, changes made by script to the name and description (of the root prim) of the attachment will be lost. While the object is attached the name and description can be changed but it will not be reflected in inventory. This caveat does ''not'' apply to child prims.
}}
}}<noinclude>
{| {{Prettytable}}
|-{{Hl2}}
! #var
! value
|-
{{VarPairTable|also_articles}}
|-
{{VarPair|caveats}}
|}
{{Footnotes}}
</noinclude>

LlGetObjectDesc/it

2012-01-12T18:34:30Z

Violet Hammerer:

{{LSL_Function/prim-desc}}{{LSL_Function
|func_id=270|func_sleep=0.0|func_energy=10.0
|func=llGetObjectDesc
|return_type=string
|func_footnote
|func_desc
|return_text=che è la descrizione del prim in cui sta lo script.
|spec
|caveats
|constants
|examples=<lsl>default
{
state_entry()
{
llSay(PUBLIC_CHANNEL, llGetObjectDesc() );
}
}</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llSetObjectDesc]]|Imposta la descrizione del prim in cui sta lo script.}}
{{LSL DefineRow||[[llGetObjectName]]|Ottiene il nome del prim.}}
{{LSL DefineRow||[[llSetObjectName]]|Imposta il nome del prim.}}
{{LSL DefineRow||[[llGetObjectDetails]]|Restituisce una serie di dati sul prim in cui sta lo script.}}
|also_events
|also_articles=
{{LSL DefineRow||[[Prim Attribute Overloading]]}}
|notes
|cat1=Prim
|cat2
|cat3
|cat4
}}

LlGetObjectDesc/it

2012-01-12T18:21:14Z

Violet Hammerer:

{{LSL_Function/prim-desc}}{{LSL_Function
|func_id=270|func_sleep=0.0|func_energy=10.0
|func=llGetObjectDesc
|return_type=string
|func_footnote
|func_desc
|return_text=che è la descrizione del prim in cui sta lo script.
|spec
|caveats
|constants
|examples=<lsl>default
{
state_entry()
{
llSay(PUBLIC_CHANNEL, llGetObjectDesc() );
}
}</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llSetObjectDesc]]|Sets the prim description.}}
{{LSL DefineRow||[[llGetObjectName]]|Gets the prim name.}}
{{LSL DefineRow||[[llSetObjectName]]|Sets the prim name.}}
{{LSL DefineRow||[[llGetObjectDetails]]}}
|also_events
|also_articles=
{{LSL DefineRow||[[Prim Attribute Overloading]]}}
|notes
|cat1=Prim
|cat2
|cat3
|cat4
}}

LlGetObjectDesc/it

2012-01-12T18:14:05Z

Violet Hammerer:

{{LSL_Function/prim-desc}}{{LSL_Function
|func_id=270|func_sleep=0.0|func_energy=10.0
|func=llGetObjectDesc
|return_type=string
|func_footnote
|func_desc
|REstituisce una stringa che è la descrizione del prim in cui sta lo script.
|spec
|caveats
|constants
|examples=<lsl>default
{
state_entry()
{
llSay(PUBLIC_CHANNEL, llGetObjectDesc() );
}
}</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llSetObjectDesc]]|Sets the prim description.}}
{{LSL DefineRow||[[llGetObjectName]]|Gets the prim name.}}
{{LSL DefineRow||[[llSetObjectName]]|Sets the prim name.}}
{{LSL DefineRow||[[llGetObjectDetails]]}}
|also_events
|also_articles=
{{LSL DefineRow||[[Prim Attribute Overloading]]}}
|notes
|cat1=Prim
|cat2
|cat3
|cat4
}}

LlGetObjectDesc/it

2012-01-12T18:12:39Z

Violet Hammerer: Created page with "{{LSL_Function/prim-desc}}{{LSL_Function |func_id=270|func_sleep=0.0|func_energy=10.0 |func=llGetObjectDesc |return_type=string |func_footnote |func_desc |return_text=that is the…"

{{LSL_Function/prim-desc}}{{LSL_Function
|func_id=270|func_sleep=0.0|func_energy=10.0
|func=llGetObjectDesc
|return_type=string
|func_footnote
|func_desc
|return_text=that is the description of the prim the script is attached to.
|spec
|caveats
|constants
|examples=<lsl>default
{
state_entry()
{
llSay(PUBLIC_CHANNEL, llGetObjectDesc() );
}
}</lsl>
|helpers
|also_functions=
{{LSL DefineRow||[[llSetObjectDesc]]|Sets the prim description.}}
{{LSL DefineRow||[[llGetObjectName]]|Gets the prim name.}}
{{LSL DefineRow||[[llSetObjectName]]|Sets the prim name.}}
{{LSL DefineRow||[[llGetObjectDetails]]}}
|also_events
|also_articles=
{{LSL DefineRow||[[Prim Attribute Overloading]]}}
|notes
|cat1=Prim
|cat2
|cat3
|cat4
}}

Link message/it

2012-01-12T14:05:30Z

Violet Hammerer:

{{LSL_Event|event_id=29|event_delay|event=link_message
|p1_type=integer|p1_name=sender_num|p1_desc=Il numero di collegamento del prim che contiene lo script che ha chiamato [[llMessageLinked]].
|p2_type=integer|p2_name=num|p2_desc=Secondo parametro della chiamata llMessageLinked.
|p3_type=string|p3_name=str|p3_desc=Terzo parametro della chiamata llMessageLinked.
|p4_type=key|p4_name=id|p4_desc=Quarto parametro della chiamata llMessageLinked.
|event_desc=Lanciato quando lo script riceva un messaggio collegato che è stato mandato da una chiamata a [[llMessageLinked]]. llMessageLinked viene usato per inviare messaggi da uno script a un altro.
|event_footnote='''id''' viene usato spesso come secondo campo stringa (in LSL il tipo [[key]] è implementato come una [[string]] con operatori personalizzati). [[typecast|La trasformazione]] tra i tipi [[string]] e [[key]] non ha effetti sui dati in essi contenuti. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|spec
|caveats=*Si possono accodare 64 eventi link_message, superati i quali, vengono scartati silenziosamente! Non fate troppe cose nell'evento se questi potrebbero arrivare velocemente.
*'''sender_num''' non rispecchia il modo in cui è stato mandato un messaggio, non c'è modo di sapere se è stato inviato col flag LINK_* o il [[llGetLinkNumber|numero specifico di collegamento]].
*Se '''str''' e '''id''' sono più grandi della memoria disponibile, lo script crasherà silenziosamente con una Collisione Stack-Heap.
|examples=
<lsl>
// Questo è solo uno script di esempio, non dovreste gestire il tocco in questo modo all'interno di un unico script.

default
{
touch_start(integer c)
{
llMessageLinked(LINK_THIS, 0, llDetectedName(0), llDetectedKey(0));
}
link_message(integer source, integer num, string str, key id)
{
llWhisper(0, str + " (" + (string)id + ") mi ha toccato!");
}
}
</lsl>
|helpers=
<lsl>
// Questo è solo uno script di esempio, non dovreste gestire i messaggi collegati in questo modo all'interno di un unico script.

default
{
// Per diffondere un numero illimitato di argomenti di qualsiasi tipo.
// Presupposto, la stringa separatrice non viene utilizzata in nessuna stringa sorgente!
state_entry()
{
list mia_lista = [1, 2.0, "una stringa", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string parametro_lista = llDumpList2String(mia_lista, "|"); // Converte la lista in una stringa
llMessageLinked(LINK_THIS, 0, parametro_lista, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list ri_elenca = llParseString2List(parametro_lista, ["|"], []); // elabora nuovamente la stringa in una lista
}
}
</lsl>
|also_header
|also_events
|also_functions={{LSL DefineRow||[[llMessageLinked]]}}
|also_articles
|also_footer
|notes=Uno script può ascoltare i propri messaggi.
|mode
|cat1=Link
|cat2=Communications
|cat3=Link Message
|cat4
}}

Link message/it

2012-01-12T13:53:54Z

Violet Hammerer: Created page with "{{LSL_Event|event_id=29|event_delay|event=link_message |p1_type=integer|p1_name=sender_num|p1_desc=The link number of the prim that contained the script that called [[llMessageLi…"

{{LSL_Event|event_id=29|event_delay|event=link_message
|p1_type=integer|p1_name=sender_num|p1_desc=The link number of the prim that contained the script that called [[llMessageLinked]].
|p2_type=integer|p2_name=num|p2_desc=Second parameter of the llMessageLinked call.
|p3_type=string|p3_name=str|p3_desc=Third parameter of the llMessageLinked call.
|p4_type=key|p4_name=id|p4_desc=Fourth parameter of the llMessageLinked call.
|event_desc=Triggered when the script receives a link message that was sent by a call to [[llMessageLinked]]. llMessageLinked is used to send messages from one script to another.
|event_footnote='''id''' is often used as a second string field (in LSL the [[key]] type is implemented as a [[string]] with just custom operators). [[typecast|Typecasting]] between [[string]] and [[key]] types has no effect on the data contained. The sizes of '''str''' and '''id''' are only limited by available script memory.
|constants
|spec
|caveats=*64 link_message events can queue, past that, they are silently dropped! Don't do too much in the event if they might be coming in fast.
*'''sender_num''' does not reflect how a message was sent, there is no way to know if it was sent with a LINK_* flag or the [[llGetLinkNumber|specific link number]].
*If '''str''' and '''id''' are bigger than available memory the script will crash with a Stack-Heap Collision.
|examples=
<lsl>
//This is just an example script, you shouldn't handle touches within single script this way.

default
{
touch_start(integer c)
{
llMessageLinked(LINK_THIS, 0, llDetectedName(0), llDetectedKey(0));
}
link_message(integer source, integer num, string str, key id)
{
llWhisper(0, str + " (" + (string)id + ") touched me!");
}
}
</lsl>
|helpers=
<lsl>
// This is just an example script, you shouldn't handle link message within single script this way.

default
{ // To propagate an unlimited number of arguments of any type.
// Presumed, the separator string isn't used in any source string!
state_entry()
{
list my_list = [1, 2.0, "a string", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string list_parameter = llDumpList2String(my_list, "|"); // Typecast list to a string
llMessageLinked(LINK_THIS, 0, list_parameter, NULL_KEY)
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list re_list = llParseString2List(list_argument, ["|"], [""]); // Typecast string back to a list
}
}
</lsl>
|also_header
|also_events
|also_functions={{LSL DefineRow||[[llMessageLinked]]}}
|also_articles
|also_footer
|notes=A script can hear its own link messages.
|mode
|cat1=Link
|cat2=Communications
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T22:06:20Z

Violet Hammerer:

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controlla quale/i prim riceve/ono il link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Valore del secondo parametro dell'evento link_message risultante.
|p3_type=string|p3_name=str|p3_desc=Valore del terzo parametro dell'evento link_message risultante.
|p4_type=key|p4_name=id|p4_desc=Valore del quarto parametro dell'evento link_message risultante.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=Potete utilizzare '''id''' come campo stringa secondario{{Footnote|In LSL il tipo [[key]] è implementato come una [[string]] (ma con operatori e restrizioni differenti). [[typecast|La conversione]] tra tipi stringa e chiave non ha effetto sui dati contenuti.}}. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|func_footnote
|return_text
|spec
|caveats=*Uno script può ascoltare i suoi stessi link_messages se '''linknum''' ha come obiettivo il prim in cui è lo script{{Footnote|Uno script ha quattro modi per avere sé stesso come obiettivo: [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] e [[LINK_ALL_CHILDREN]] (se il prim è un prim collegato).}}. Ciò crea la possibilità di un circolo vizioso infinito (cosa cattiva); state molto attenti a come i messaggi vengono gestiti e passati.
* I messaggi inviati tramite llMessageLinked a uno script che è in [[llSleep|sonno]], [[LSL Delay|è rinviato]], o [[lag|laggato]], sono messi in coda fino al termine del rinvio. La coda eventi può contenere 64 eventi.
** Se la coda è piena e si riceve un evento, questo viene scartato in modo silenzioso.
** Evitate di inviare simultaneamente link_messages a grandi quantità di script poiché ciò può causare picchi di lag. Questo generalmente accade mentre si usano i flag multi-prim LINK_* e può causare l'esecuzione lenta dello script o portare ad arresti.
** Evitate di inviare link_messages a un obiettivo più velocemente di quanto questi possano essere gestiti. Farlo significa rischiare di riempire la coda eventi e di portare allo scarto silenzioso dei messaggi seguenti.
* Quando cambia lo [[state]] di uno script, tutti gli eventi in coda vengono cancellati, compresi i link_messages accodati.
* Se '''link_num''' è un numero non valido allora la funzione fallisce in modo silenzioso.
* Se '''str''' e '''id''' eccedono la memoria disponibile di uno script che prende l'evento link_message risultante, quello script crasherà con una [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Collisione Stack-Heap]].
|examples=<lsl>default
{
// presupposti // nome oggetto: LSLWiki // nome script: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// il proprietario dell'oggetto sentirà
// LSLWiki:_lslwiki
}
}</lsl>

=== Circolo infinito ===

<lsl>Controllo_Messaggio(integer l, integer n) // Mancanza_Assoluta_di_Controllo_del_Messaggio
{
integer r = (++n); // Aumenta il valore di n.
llMessageLinked( l, r, "", ""); // Invia il risultato a l
}

default
{
state_entry()
{
Controllo_Messaggio(LINK_SET, 0); // Comunica a tutti gli script nell'oggetto che siamo entrati nello stato.
}

link_message(integer Mittente, integer Numero, string Stringa, key Chiave) // Anche questo script è nell'oggetto.
{
Controllo_Messaggio(Mittente, Numero); // Non esistono condizioni filtranti.
llOwnerSay(((string)Numero)); // Guardate tutti quei bei numeri!
}
}</lsl>
|helpers=<lsl>default
{
// Correzione veloce e sporca dei link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// Questo è solo uno script di esempio, non dovreste gestire i messaggi collegati all'interno del medesimo script in questo modo.

default
{
// Per diffondere un numero illimitato di argomenti di qualsiasi tipo.
// Presupposto, la stringa separatrice non viene utilizzata in nessuna stringa sorgente!
state_entry()
{
list mia_lista = [1, 2.0, "una stringa", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string parametro_lista = llDumpList2String(mia_lista, "|"); // Converte la lista in una stringa
llMessageLinked(LINK_THIS, 0, parametro_lista, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list ri_elenca = llParseString2List(parametro_lista, ["|"], []); // elabora nuovamente la stringa in una lista
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Utilizzare llMessageLinked in un unico oggetto permette agli sviluppatori di alleviare alcuni limiti del LSL spartendo le funzionalità tra script cooperanti e sincronizzando le azioni. Quando lo fate, siate estremamente attenti a non creare circoli infiniti come descritto prima.
*Alcuni utenti hanno osservato un ritardo di .25-.50 tra la ricezione e l'invio di llLinkedMessage
*Alcuni utenti hanno notato fallimenti sporadici di messaggi collegati quando si invia un messaggio a grandi quantità di script riceventi in prim differenti usando [[LINK_SET]], [[LINK_ALL_OTHERS]], e [[LINK_ALL_CHILDREN]]. Se incontrate questo problema, un trucco è mettere tutti gli script dei prim collegati in un singolo prim, e usare funzioni mirate come [[llSetLinkPrimitiveParams]] per modificare il prim in cui lo script stava precedentemente. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T21:59:23Z

Violet Hammerer:

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controlla quale/i prim riceve/ono il link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Valore del secondo parametro dell'evento link_message risultante.
|p3_type=string|p3_name=str|p3_desc=Valore del terzo parametro dell'evento link_message risultante.
|p4_type=key|p4_name=id|p4_desc=Valore del quarto parametro dell'evento link_message risultante.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=Potete utilizzare '''id''' come campo stringa secondario{{Footnote|In LSL il tipo [[key]] è implementato come una [[string]] (ma con operatori e restrizioni differenti). [[typecast|La conversione]] tra tipi stringa e chiave non ha effetto sui dati contenuti.}}. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|func_footnote
|return_text
|spec
|caveats=*Uno script può ascoltare i suoi stessi link_messages se '''linknum''' ha come obiettivo il prim in cui è lo script{{Footnote|Uno script ha quattro modi per avere sé stesso come obiettivo: [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] e [[LINK_ALL_CHILDREN]] (se il prim è un prim collegato).}}. Ciò crea la possibilità di un circolo vizioso infinito (cosa cattiva); state molto attenti a come i messaggi vengono gestiti e passati.
* I messaggi inviati tramite llMessageLinked a uno script che è in [[llSleep|sonno]], [[LSL Delay|è rinviato]], o [[lag|laggato]], sono messi in coda fino al termine del rinvio. La coda eventi può contenere 64 eventi.
** Se la coda è piena e si riceve un evento, questo viene scartato in modo silenzioso.
** Evitate di inviare simultaneamente link_messages a grandi quantità di script poiché ciò può causare picchi di lag. Questo generalmente accade mentre si usano i flag multi-prim LINK_* e può causare l'esecuzione lenta dello script o portare ad arresti.
** Evitate di inviare link_messages a un obiettivo più velocemente di quanto questi possano essere gestiti. Farlo significa rischiare di riempire la coda eventi e di portare allo scarto silenzioso dei messaggi seguenti.
* Quando cambia lo [[state]] di uno script, tutti gli eventi in coda vengono cancellati, compresi i link_messages accodati.
* Se '''link_num''' è un numero non valido allora la funzione fallisce in modo silenzioso.
* Se '''str''' e '''id''' eccedono la memoria disponibile di uno script che prende l'evento link_message risultante, quello script crasherà con una [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Collisione Stack-Heap]].
|examples=<lsl>default
{
// presupposti // nome oggetto: LSLWiki // nome script: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// il proprietario dell'oggetto sentirà
// LSLWiki:_lslwiki
}
}</lsl>

=== Circolo infinito ===

<lsl>Controllo_Messaggio(integer l, integer n) // Mancanza_Assoluta_di_Controllo_del_Messaggio
{
integer r = (++n); // Aumenta il valore di n.
llMessageLinked( l, r, "", ""); // Invia il risultato a l
}

default
{
state_entry()
{
Controllo_Messaggio(LINK_SET, 0); // Comunica a tutti gli script nell'oggetto che siamo entrati nello stato.
}

link_message(integer Mittente, integer Numero, string Stringa, key Chiave) // Anche questo script è nell'oggetto.
{
Controllo_Messaggio(Mittente, Numero); // Non esistono condizioni filtranti.
llOwnerSay(((string)Numero)); // Guardate tutti quei bei numeri!
}
}</lsl>
|helpers=<lsl>default
{
// Correzione veloce e sporca dei link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// Questo è solo uno script di esempio, non dovreste gestire i messaggi collegati all'interno del medesimo script in questo modo.

default
{
// Per diffondere un numero illimitato di argomenti di qualsiasi tipo.
// Presupposto, la stringa separatrice non viene utilizzata in nessuna stringa sorgente!
state_entry()
{
list mia_lista = [1, 2.0, "una stringa", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string parametro_lista = llDumpList2String(mia_lista, "|"); // Converte la lista in una stringa
llMessageLinked(LINK_THIS, 0, parametro_lista, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list ri_elenca = llParseString2List(parametro_lista, ["|"], []); // elabora nuovamente la stringa in una lista
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Utilizzare llMessageLinked in un unico oggetto permette agli sviluppatori di alleviare alcuni limiti del LSL spartendo le funzionalità tra script cooperanti e sincronizzando le azioni. Quando lo fate, siate estremamente attenti a non creare circoli infiniti come descritto prima.
*Alcuni utenti hanno osservato un ritardo di .25-.50 tra la ricezione e l'invio di llLinkedMessage
*Some users have noted occasional failures of linked messages when sending a message to a large number of receiving scripts in different prims using [[LINK_SET]], [[LINK_ALL_OTHERS]], & [[LINK_ALL_CHILDREN]]. If you encounter this problem, a workaround is to place all child prim scripts in a single prim, using targeted functions like [[llSetLinkPrimitiveParams]] to modify the prim in which the script previously resided. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T21:49:14Z

Violet Hammerer:

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controlla quale/i prim riceve/ono il link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Valore del secondo parametro dell'evento link_message risultante.
|p3_type=string|p3_name=str|p3_desc=Valore del terzo parametro dell'evento link_message risultante.
|p4_type=key|p4_name=id|p4_desc=Valore del quarto parametro dell'evento link_message risultante.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=Potete utilizzare '''id''' come campo stringa secondario{{Footnote|In LSL il tipo [[key]] è implementato come una [[string]] (ma con operatori e restrizioni differenti). [[typecast|La conversione]] tra tipi stringa e chiave non ha effetto sui dati contenuti.}}. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|func_footnote
|return_text
|spec
|caveats=*Uno script può ascoltare i suoi stessi link_messages se '''linknum''' ha come obiettivo il prim in cui è lo script{{Footnote|Uno script ha quattro modi per avere sé stesso come obiettivo: [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] e [[LINK_ALL_CHILDREN]] (se il prim è un prim collegato).}}. Ciò crea la possibilità di un circolo vizioso infinito (cosa cattiva); state molto attenti a come i messaggi vengono gestiti e passati.
* I messaggi inviati tramite llMessageLinked a uno script che è in [[llSleep|sonno]], [[LSL Delay|è rinviato]], o [[lag|laggato]], sono messi in coda fino al termine del rinvio. La coda eventi può contenere 64 eventi.
** Se la coda è piena e si riceve un evento, questo viene scartato in modo silenzioso.
** Evitate di inviare simultaneamente link_messages a grandi quantità di script poiché ciò può causare picchi di lag. Questo generalmente accade mentre si usano i flag multi-prim LINK_* e può causare l'esecuzione lenta dello script o portare ad arresti.
** Evitate di inviare link_messages a un obiettivo più velocemente di quanto questi possano essere gestiti. Farlo significa rischiare di riempire la coda eventi e di portare allo scarto silenzioso dei messaggi seguenti.
* Quando cambia lo [[state]] di uno script, tutti gli eventi in coda vengono cancellati, compresi i link_messages accodati.
* Se '''link_num''' è un numero non valido allora la funzione fallisce in modo silenzioso.
* Se '''str''' e '''id''' eccedono la memoria disponibile di uno script che prende l'evento link_message risultante, quello script crasherà con una [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Collisione Stack-Heap]].
|examples=<lsl>default
{
// presupposti // nome oggetto: LSLWiki // nome script: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// il proprietario dell'oggetto sentirà
// LSLWiki:_lslwiki
}
}</lsl>

=== Circolo infinito ===

<lsl>Controllo_Messaggio(integer l, integer n) // Mancanza_Assoluta_di_Controllo_del_Messaggio
{
integer r = (++n); // Aumenta il valore di.
llMessageLinked( l, r, "", ""); // Invia il risultato a l
}

default
{
state_entry()
{
Controllo_Messaggio(LINK_SET, 0); // Comunica a tutti gli script nell'oggetto che siamo entrati nello stato.
}
link_message(integer Mittente, integer Numero, string Stringa, key Chiave) // Anche questo script è nell'oggetto.
{
Controllo_Messaggio(Mittente, Numero); // Non esistono condizioni filtranti.
llOwnerSay(((string)Numero)); // Guarda tutti quei bei numeri!
}
}</lsl>
|helpers=<lsl>default
{
// Quick and dirty debugging link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// This is just an example script, you shouldn't handle link message within single script this way.

default
{
// To propagate an unlimted number of arguments of any type.
// Presumed, the separator string isn't used in any source string!
state_entry()
{
list my_list = [1, 2.0, "a string", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string list_parameter = llDumpList2String(my_list, "|"); // Convert the list to a string
llMessageLinked(LINK_THIS, 0, list_parameter, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list re_list = llParseString2List(list_argument, ["|"], []); // Parse the string back to a list
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Using llMessageLinked in a single prim object allows developers to mitigate some LSL limits by breaking up functionality between cooperating scripts and synchronizing actions. When you do this, be extremely careful not to create infinite loops as mentioned above.
*Estimated .25-.50 delay between receiving and sending of llLinkedMessage has been observed by some users
*Some users have noted occasional failures of linked messages when sending a message to a large number of receiving scripts in different prims using [[LINK_SET]], [[LINK_ALL_OTHERS]], & [[LINK_ALL_CHILDREN]]. If you encounter this problem, a workaround is to place all child prim scripts in a single prim, using targeted functions like [[llSetLinkPrimitiveParams]] to modify the prim in which the script previously resided. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T21:41:00Z

Violet Hammerer:

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controlla quale/i prim riceve/ono il link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Valore del secondo parametro dell'evento link_message risultante.
|p3_type=string|p3_name=str|p3_desc=Valore del terzo parametro dell'evento link_message risultante.
|p4_type=key|p4_name=id|p4_desc=Valore del quarto parametro dell'evento link_message risultante.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=Potete utilizzare '''id''' come campo stringa secondario{{Footnote|In LSL il tipo [[key]] è implementato come una [[string]] (ma con operatori e restrizioni differenti). [[typecast|La conversione]] tra tipi stringa e chiave non ha effetto sui dati contenuti.}}. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|func_footnote
|return_text
|spec
|caveats=*Uno script può ascoltare i suoi stessi link_messages se '''linknum''' ha come obiettivo il prim in cui è lo script{{Footnote|Uno script ha quattro modi per avere sé stesso come obiettivo: [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] e [[LINK_ALL_CHILDREN]] (se il prim è un prim collegato).}}. Ciò crea la possibilità di un circolo vizioso infinito (cosa cattiva); state molto attenti a come i messaggi vengono gestiti e passati.
* I messaggi inviati tramite llMessageLinked a uno script che è in [[llSleep|sonno]], [[LSL Delay|è rinviato]], o [[lag|laggato]], sono messi in coda fino al termine del rinvio. La coda eventi può contenere 64 eventi.
** Se la coda è piena e si riceve un evento, questo viene scartato in modo silenzioso.
** Evitate di inviare simultaneamente link_messages a grandi quantità di script poiché ciò può causare picchi di lag. Questo generalmente accade mentre si usano i flag multi-prim LINK_* e può causare l'esecuzione lenta dello script o portare ad arresti.
** Evitate di inviare link_messages a un obiettivo più velocemente di quanto questi possano essere gestiti. Farlo significa rischiare di riempire la coda eventi e di portare allo scarto silenzioso dei messaggi seguenti.
* Quando cambia lo [[state]] di uno script, tutti gli eventi in codavengono cancellati, compresi i link_messages accodati.
* Se '''link_num''' è un numero non valido allora la funzione fallisce in modo silenzioso.
* Se '''str''' e '''id''' eccedono la memoria disponibile di uno script che prende l'evento link_message risultante, quello script crasherà con una [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Collisione Stack-Heap]].
|examples=<lsl>default
{
// presupposti // nome oggetto: LSLWiki // nome script: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// il proprietario dell'oggetto sentirà
// LSLWiki:_lslwiki
}
}</lsl>

=== Infinite Loop ===

<lsl>Message_Control(integer l, integer n) // Message_Total_Lack_Of_Control
{
integer r = (++n); // Increment the value of n.
llMessageLinked( l, r, "", ""); // Send the result to l
}

default
{
state_entry()
{
Message_Control(LINK_SET, 0); // Tell all the scripts in the object that we have state_entered.
}
link_message(integer Sender, integer Number, string String, key Key) // This script is in the object too.
{
Message_Control(Sender, Number); // No filtering condition exists.
llOwnerSay(((string)Number)); // Look at all the pretty numbers!
}
}</lsl>
|helpers=<lsl>default
{
// Quick and dirty debugging link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// This is just an example script, you shouldn't handle link message within single script this way.

default
{
// To propagate an unlimted number of arguments of any type.
// Presumed, the separator string isn't used in any source string!
state_entry()
{
list my_list = [1, 2.0, "a string", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string list_parameter = llDumpList2String(my_list, "|"); // Convert the list to a string
llMessageLinked(LINK_THIS, 0, list_parameter, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list re_list = llParseString2List(list_argument, ["|"], []); // Parse the string back to a list
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Using llMessageLinked in a single prim object allows developers to mitigate some LSL limits by breaking up functionality between cooperating scripts and synchronizing actions. When you do this, be extremely careful not to create infinite loops as mentioned above.
*Estimated .25-.50 delay between receiving and sending of llLinkedMessage has been observed by some users
*Some users have noted occasional failures of linked messages when sending a message to a large number of receiving scripts in different prims using [[LINK_SET]], [[LINK_ALL_OTHERS]], & [[LINK_ALL_CHILDREN]]. If you encounter this problem, a workaround is to place all child prim scripts in a single prim, using targeted functions like [[llSetLinkPrimitiveParams]] to modify the prim in which the script previously resided. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T21:38:39Z

Violet Hammerer:

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controlla quale/i prim riceve/ono il link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Valore del secondo parametro dell'evento link_message risultante.
|p3_type=string|p3_name=str|p3_desc=Valore del terzo parametro dell'evento link_message risultante.
|p4_type=key|p4_name=id|p4_desc=Valore del quarto parametro dell'evento link_message risultante.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=Potete utilizzare '''id''' come campo stringa secondario{{Footnote|In LSL il tipo [[key]] è implementato come una [[string]] (ma con operatori e restrizioni differenti). [[typecast|La conversione]] tra tipi stringa e chiave non ha effetto sui dati contenuti.}}. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|func_footnote
|return_text
|spec
|avvertimenti=*Uno script può ascoltare i suoi stessi link_messages se '''linknum''' ha come obiettivo il prim in cui è lo script{{Footnote|Uno script ha quattro modi per avere sé stesso come obiettivo: [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] e [[LINK_ALL_CHILDREN]] (se il prim è un prim collegato).}}. Ciò crea la possibilità di un circolo vizioso infinito (cosa cattiva); state molto attenti a come i messaggi vengono gestiti e passati.
* I messaggi inviati tramite llMessageLinked a uno script che è in [[llSleep|sonno]], [[LSL Delay|è rinviato]], o [[lag|laggato]], sono messi in coda fino al termine del rinvio. La coda eventi può contenere 64 eventi.
** Se la coda è piena e si riceve un evento, questo viene scartato in modo silenzioso.
** Evitate di inviare simultaneamente link_messages a grandi quantità di script poiché ciò può causare picchi di lag. Questo generalmente accade mentre si usano i flag multi-prim LINK_* e può causare l'esecuzione lenta dello script o portare ad arresti.
** Evitate di inviare link_messages a un obiettivo più velocemente di quanto questi possano essere gestiti. Farlo significa rischiare di riempire la coda eventi e di portare allo scarto silenzioso dei messaggi seguenti.
* Quando cambia lo [[state]] di uno script, tutti gli eventi in codavengono cancellati, compresi i link_messages accodati.
* Se '''link_num''' è un numero non valido allora la funzione fallisce in modo silenzioso.
* Se '''str''' e '''id''' eccedono la memoria disponibile di uno script che prende l'evento link_message risultante, quello script crasherà con una [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Collisione Stack-Heap]].
|examples=<lsl>default
{
// presupposti // nome oggetto: LSLWiki // nome script: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// il proprietario dell'oggetto sentirà
// LSLWiki:_lslwiki
}
}</lsl>

=== Infinite Loop ===

<lsl>Message_Control(integer l, integer n) // Message_Total_Lack_Of_Control
{
integer r = (++n); // Increment the value of n.
llMessageLinked( l, r, "", ""); // Send the result to l
}

default
{
state_entry()
{
Message_Control(LINK_SET, 0); // Tell all the scripts in the object that we have state_entered.
}
link_message(integer Sender, integer Number, string String, key Key) // This script is in the object too.
{
Message_Control(Sender, Number); // No filtering condition exists.
llOwnerSay(((string)Number)); // Look at all the pretty numbers!
}
}</lsl>
|helpers=<lsl>default
{
// Quick and dirty debugging link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// This is just an example script, you shouldn't handle link message within single script this way.

default
{
// To propagate an unlimted number of arguments of any type.
// Presumed, the separator string isn't used in any source string!
state_entry()
{
list my_list = [1, 2.0, "a string", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string list_parameter = llDumpList2String(my_list, "|"); // Convert the list to a string
llMessageLinked(LINK_THIS, 0, list_parameter, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list re_list = llParseString2List(list_argument, ["|"], []); // Parse the string back to a list
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Using llMessageLinked in a single prim object allows developers to mitigate some LSL limits by breaking up functionality between cooperating scripts and synchronizing actions. When you do this, be extremely careful not to create infinite loops as mentioned above.
*Estimated .25-.50 delay between receiving and sending of llLinkedMessage has been observed by some users
*Some users have noted occasional failures of linked messages when sending a message to a large number of receiving scripts in different prims using [[LINK_SET]], [[LINK_ALL_OTHERS]], & [[LINK_ALL_CHILDREN]]. If you encounter this problem, a workaround is to place all child prim scripts in a single prim, using targeted functions like [[llSetLinkPrimitiveParams]] to modify the prim in which the script previously resided. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T20:56:47Z

Violet Hammerer:

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controlla quale/i prim riceve/ono il link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Valore del secondo parametro dell'evento link_message risultante.
|p3_type=string|p3_name=str|p3_desc=Valore del terzo parametro dell'evento link_message risultante.
|p4_type=key|p4_name=id|p4_desc=Valore del quarto parametro dell'evento link_message risultante.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=Potete utilizzare '''id''' come campo stringa secondario{{Footnote|In LSL il tipo [[key]] è implementato come una [[string]] (ma con operatori e restrizioni differenti). [[typecast|La conversione]] tra tipi stringa e chiave non hanno effetto sui dati contenuti.}}. Le dimensioni di '''str''' e '''id''' sono limitate solamente dalla memoria script disponibile.
|constants
|func_footnote
|return_text
|spec
|caveats=*A script can hear its own linked messages if '''linknum''' targets the prim it is in{{Footnote|There are four ways for a script to target itself: by [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] and [[LINK_ALL_CHILDREN]] (if the prim is a child prim).}}. This creates the possibility of an infinite loop (a bad thing); be very careful about how messages are handled and passed along.
* Messages sent via llMessageLinked to a script that is [[llSleep|sleeping]], [[LSL Delay|delayed]], or [[lag|lagged]], are queued until the end of the delay. The event queue can hold 64 events.
** If an event is received and the queue is full the event is silently dropped.
** Avoid sending link_messages to large numbers of scripts simultaneously as it can cause lag spike. This most often happens when using the multi-prim LINK_* flags and can cause script execution to slow or halts.
** Avoid sending link_messages to a target faster than they can be handled. Doing so risks filling the event queue and subsequent messages being silently discarded.
* When a script [[state]] changes, all pending events are deleted, including queued link_messages.
* If '''link_num''' is an invalid link number then the function silently fails.
* If '''str''' & '''id''' exceed the available memory of a script that catches the resulting link_message event, that script will crash with a [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Stack-Heap Collision]].
|examples=<lsl>default
{
// assumptions // object name: LSLWiki // script name: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// the owner of object LSLWiki will hear
// LSLWiki:_lslwiki
}
}</lsl>

=== Infinite Loop ===

<lsl>Message_Control(integer l, integer n) // Message_Total_Lack_Of_Control
{
integer r = (++n); // Increment the value of n.
llMessageLinked( l, r, "", ""); // Send the result to l
}

default
{
state_entry()
{
Message_Control(LINK_SET, 0); // Tell all the scripts in the object that we have state_entered.
}
link_message(integer Sender, integer Number, string String, key Key) // This script is in the object too.
{
Message_Control(Sender, Number); // No filtering condition exists.
llOwnerSay(((string)Number)); // Look at all the pretty numbers!
}
}</lsl>
|helpers=<lsl>default
{
// Quick and dirty debugging link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// This is just an example script, you shouldn't handle link message within single script this way.

default
{
// To propagate an unlimted number of arguments of any type.
// Presumed, the separator string isn't used in any source string!
state_entry()
{
list my_list = [1, 2.0, "a string", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string list_parameter = llDumpList2String(my_list, "|"); // Convert the list to a string
llMessageLinked(LINK_THIS, 0, list_parameter, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list re_list = llParseString2List(list_argument, ["|"], []); // Parse the string back to a list
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Using llMessageLinked in a single prim object allows developers to mitigate some LSL limits by breaking up functionality between cooperating scripts and synchronizing actions. When you do this, be extremely careful not to create infinite loops as mentioned above.
*Estimated .25-.50 delay between receiving and sending of llLinkedMessage has been observed by some users
*Some users have noted occasional failures of linked messages when sending a message to a large number of receiving scripts in different prims using [[LINK_SET]], [[LINK_ALL_OTHERS]], & [[LINK_ALL_CHILDREN]]. If you encounter this problem, a workaround is to place all child prim scripts in a single prim, using targeted functions like [[llSetLinkPrimitiveParams]] to modify the prim in which the script previously resided. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T20:47:26Z

Violet Hammerer:

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controls which prim(s) receive the link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Value of the second parameter of the resulting link_message event.
|p3_type=string|p3_name=str|p3_desc=Value of the third parameter of the resulting link_message event.
|p4_type=key|p4_name=id|p4_desc=Value of the fourth parameter of the resulting link_message event.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', e '''id''' in tutti gli script nel/i prim definito/i da '''linknum'''.
|func_footer=You can use '''id''' as a second string field{{Footnote|In LSL the [[key]] type is implemented as a [[string]] (but with different operators and restrictions). [[typecast|Typecasting]] between string and key types has no effect on the data contained.}}. The sizes of '''str''' and '''id''' are only limited by available script memory.
|constants
|func_footnote
|return_text
|spec
|caveats=*A script can hear its own linked messages if '''linknum''' targets the prim it is in{{Footnote|There are four ways for a script to target itself: by [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] and [[LINK_ALL_CHILDREN]] (if the prim is a child prim).}}. This creates the possibility of an infinite loop (a bad thing); be very careful about how messages are handled and passed along.
* Messages sent via llMessageLinked to a script that is [[llSleep|sleeping]], [[LSL Delay|delayed]], or [[lag|lagged]], are queued until the end of the delay. The event queue can hold 64 events.
** If an event is received and the queue is full the event is silently dropped.
** Avoid sending link_messages to large numbers of scripts simultaneously as it can cause lag spike. This most often happens when using the multi-prim LINK_* flags and can cause script execution to slow or halts.
** Avoid sending link_messages to a target faster than they can be handled. Doing so risks filling the event queue and subsequent messages being silently discarded.
* When a script [[state]] changes, all pending events are deleted, including queued link_messages.
* If '''link_num''' is an invalid link number then the function silently fails.
* If '''str''' & '''id''' exceed the available memory of a script that catches the resulting link_message event, that script will crash with a [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Stack-Heap Collision]].
|examples=<lsl>default
{
// assumptions // object name: LSLWiki // script name: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// the owner of object LSLWiki will hear
// LSLWiki:_lslwiki
}
}</lsl>

=== Infinite Loop ===

<lsl>Message_Control(integer l, integer n) // Message_Total_Lack_Of_Control
{
integer r = (++n); // Increment the value of n.
llMessageLinked( l, r, "", ""); // Send the result to l
}

default
{
state_entry()
{
Message_Control(LINK_SET, 0); // Tell all the scripts in the object that we have state_entered.
}
link_message(integer Sender, integer Number, string String, key Key) // This script is in the object too.
{
Message_Control(Sender, Number); // No filtering condition exists.
llOwnerSay(((string)Number)); // Look at all the pretty numbers!
}
}</lsl>
|helpers=<lsl>default
{
// Quick and dirty debugging link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// This is just an example script, you shouldn't handle link message within single script this way.

default
{
// To propagate an unlimted number of arguments of any type.
// Presumed, the separator string isn't used in any source string!
state_entry()
{
list my_list = [1, 2.0, "a string", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string list_parameter = llDumpList2String(my_list, "|"); // Convert the list to a string
llMessageLinked(LINK_THIS, 0, list_parameter, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list re_list = llParseString2List(list_argument, ["|"], []); // Parse the string back to a list
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Using llMessageLinked in a single prim object allows developers to mitigate some LSL limits by breaking up functionality between cooperating scripts and synchronizing actions. When you do this, be extremely careful not to create infinite loops as mentioned above.
*Estimated .25-.50 delay between receiving and sending of llLinkedMessage has been observed by some users
*Some users have noted occasional failures of linked messages when sending a message to a large number of receiving scripts in different prims using [[LINK_SET]], [[LINK_ALL_OTHERS]], & [[LINK_ALL_CHILDREN]]. If you encounter this problem, a workaround is to place all child prim scripts in a single prim, using targeted functions like [[llSetLinkPrimitiveParams]] to modify the prim in which the script previously resided. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T20:44:59Z

Violet Hammerer:

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controls which prim(s) receive the link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Value of the second parameter of the resulting link_message event.
|p3_type=string|p3_name=str|p3_desc=Value of the third parameter of the resulting link_message event.
|p4_type=key|p4_name=id|p4_desc=Value of the fourth parameter of the resulting link_message event.
|func_desc=Lo scopo di questa funzione è di permettere la comunicazione tra gli script in uno stesso oggetto. Fà scattare un evento [[link_message]] con i medesimi parametri '''num''', '''str''', and '''id''' The purpose of this function is to allow scripts in the same object to communicate. It triggers a [[link_message]] event with the same parameters '''num''', '''str''', and '''id''' in all scripts in the prim(s) described by '''linknum'''.
|func_footer=You can use '''id''' as a second string field{{Footnote|In LSL the [[key]] type is implemented as a [[string]] (but with different operators and restrictions). [[typecast|Typecasting]] between string and key types has no effect on the data contained.}}. The sizes of '''str''' and '''id''' are only limited by available script memory.
|constants
|func_footnote
|return_text
|spec
|caveats=*A script can hear its own linked messages if '''linknum''' targets the prim it is in{{Footnote|There are four ways for a script to target itself: by [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] and [[LINK_ALL_CHILDREN]] (if the prim is a child prim).}}. This creates the possibility of an infinite loop (a bad thing); be very careful about how messages are handled and passed along.
* Messages sent via llMessageLinked to a script that is [[llSleep|sleeping]], [[LSL Delay|delayed]], or [[lag|lagged]], are queued until the end of the delay. The event queue can hold 64 events.
** If an event is received and the queue is full the event is silently dropped.
** Avoid sending link_messages to large numbers of scripts simultaneously as it can cause lag spike. This most often happens when using the multi-prim LINK_* flags and can cause script execution to slow or halts.
** Avoid sending link_messages to a target faster than they can be handled. Doing so risks filling the event queue and subsequent messages being silently discarded.
* When a script [[state]] changes, all pending events are deleted, including queued link_messages.
* If '''link_num''' is an invalid link number then the function silently fails.
* If '''str''' & '''id''' exceed the available memory of a script that catches the resulting link_message event, that script will crash with a [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Stack-Heap Collision]].
|examples=<lsl>default
{
// assumptions // object name: LSLWiki // script name: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// the owner of object LSLWiki will hear
// LSLWiki:_lslwiki
}
}</lsl>

=== Infinite Loop ===

<lsl>Message_Control(integer l, integer n) // Message_Total_Lack_Of_Control
{
integer r = (++n); // Increment the value of n.
llMessageLinked( l, r, "", ""); // Send the result to l
}

default
{
state_entry()
{
Message_Control(LINK_SET, 0); // Tell all the scripts in the object that we have state_entered.
}
link_message(integer Sender, integer Number, string String, key Key) // This script is in the object too.
{
Message_Control(Sender, Number); // No filtering condition exists.
llOwnerSay(((string)Number)); // Look at all the pretty numbers!
}
}</lsl>
|helpers=<lsl>default
{
// Quick and dirty debugging link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// This is just an example script, you shouldn't handle link message within single script this way.

default
{
// To propagate an unlimted number of arguments of any type.
// Presumed, the separator string isn't used in any source string!
state_entry()
{
list my_list = [1, 2.0, "a string", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string list_parameter = llDumpList2String(my_list, "|"); // Convert the list to a string
llMessageLinked(LINK_THIS, 0, list_parameter, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list re_list = llParseString2List(list_argument, ["|"], []); // Parse the string back to a list
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Using llMessageLinked in a single prim object allows developers to mitigate some LSL limits by breaking up functionality between cooperating scripts and synchronizing actions. When you do this, be extremely careful not to create infinite loops as mentioned above.
*Estimated .25-.50 delay between receiving and sending of llLinkedMessage has been observed by some users
*Some users have noted occasional failures of linked messages when sending a message to a large number of receiving scripts in different prims using [[LINK_SET]], [[LINK_ALL_OTHERS]], & [[LINK_ALL_CHILDREN]]. If you encounter this problem, a workaround is to place all child prim scripts in a single prim, using targeted functions like [[llSetLinkPrimitiveParams]] to modify the prim in which the script previously resided. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

LlMessageLinked/it

2012-01-11T14:43:09Z

Violet Hammerer: Created page with "{{LSL_Function |inject-2={{LSL Function/link|linknum|, controls which prim(s) receive the link_message.}} |func_id=164|func_sleep=0.0|func_energy=10.0 |func=llMessageLinked|sort=…"

{{LSL_Function
|inject-2={{LSL Function/link|linknum|, controls which prim(s) receive the link_message.}}
|func_id=164|func_sleep=0.0|func_energy=10.0
|func=llMessageLinked|sort=MessageLinked
|p1_type=integer|p1_name=linknum|p1_desc
|p2_type=integer|p2_name=num|p2_desc=Value of the second parameter of the resulting link_message event.
|p3_type=string|p3_name=str|p3_desc=Value of the third parameter of the resulting link_message event.
|p4_type=key|p4_name=id|p4_desc=Value of the fourth parameter of the resulting link_message event.
|func_desc=The purpose of this function is to allow scripts in the same object to communicate. It triggers a [[link_message]] event with the same parameters '''num''', '''str''', and '''id''' in all scripts in the prim(s) described by '''linknum'''.
|func_footer=You can use '''id''' as a second string field{{Footnote|In LSL the [[key]] type is implemented as a [[string]] (but with different operators and restrictions). [[typecast|Typecasting]] between string and key types has no effect on the data contained.}}. The sizes of '''str''' and '''id''' are only limited by available script memory.
|constants
|func_footnote
|return_text
|spec
|caveats=*A script can hear its own linked messages if '''linknum''' targets the prim it is in{{Footnote|There are four ways for a script to target itself: by [[llGetLinkNumber|precise link number]], [[LINK_THIS]], [[LINK_SET]] and [[LINK_ALL_CHILDREN]] (if the prim is a child prim).}}. This creates the possibility of an infinite loop (a bad thing); be very careful about how messages are handled and passed along.
* Messages sent via llMessageLinked to a script that is [[llSleep|sleeping]], [[LSL Delay|delayed]], or [[lag|lagged]], are queued until the end of the delay. The event queue can hold 64 events.
** If an event is received and the queue is full the event is silently dropped.
** Avoid sending link_messages to large numbers of scripts simultaneously as it can cause lag spike. This most often happens when using the multi-prim LINK_* flags and can cause script execution to slow or halts.
** Avoid sending link_messages to a target faster than they can be handled. Doing so risks filling the event queue and subsequent messages being silently discarded.
* When a script [[state]] changes, all pending events are deleted, including queued link_messages.
* If '''link_num''' is an invalid link number then the function silently fails.
* If '''str''' & '''id''' exceed the available memory of a script that catches the resulting link_message event, that script will crash with a [[LSL_Errors#Script_run-time_error:_Stack-Heap_Collision|Stack-Heap Collision]].
|examples=<lsl>default
{
// assumptions // object name: LSLWiki // script name: _lslwiki
state_entry()
{
llMessageLinked(LINK_THIS, 0, llGetScriptName(), "");
}

link_message(integer sender_num, integer num, string msg, key id)
{
llOwnerSay(msg);
// the owner of object LSLWiki will hear
// LSLWiki:_lslwiki
}
}</lsl>

=== Infinite Loop ===

<lsl>Message_Control(integer l, integer n) // Message_Total_Lack_Of_Control
{
integer r = (++n); // Increment the value of n.
llMessageLinked( l, r, "", ""); // Send the result to l
}

default
{
state_entry()
{
Message_Control(LINK_SET, 0); // Tell all the scripts in the object that we have state_entered.
}
link_message(integer Sender, integer Number, string String, key Key) // This script is in the object too.
{
Message_Control(Sender, Number); // No filtering condition exists.
llOwnerSay(((string)Number)); // Look at all the pretty numbers!
}
}</lsl>
|helpers=<lsl>default
{
// Quick and dirty debugging link_messages
link_message(integer sender_num, integer num, string msg, key id)
{
llSay(DEBUG_CHANNEL, llList2CSV([sender_num, num, msg, id]));
}
}</lsl>
<lsl>// This is just an example script, you shouldn't handle link message within single script this way.

default
{
// To propagate an unlimted number of arguments of any type.
// Presumed, the separator string isn't used in any source string!
state_entry()
{
list my_list = [1, 2.0, "a string", <1, 2, 3>, <1, 2, 3, 4>, llGetOwner()];
string list_parameter = llDumpList2String(my_list, "|"); // Convert the list to a string
llMessageLinked(LINK_THIS, 0, list_parameter, "")
}

link_message(integer sender_num, integer num, string list_argument, key id)
{
list re_list = llParseString2List(list_argument, ["|"], []); // Parse the string back to a list
}
}</lsl>
|also_header
|also_events={{LSL DefineRow||[[link_message]]|}}
|also_functions
|also_articles
|also_footer
|notes=*Using llMessageLinked in a single prim object allows developers to mitigate some LSL limits by breaking up functionality between cooperating scripts and synchronizing actions. When you do this, be extremely careful not to create infinite loops as mentioned above.
*Estimated .25-.50 delay between receiving and sending of llLinkedMessage has been observed by some users
*Some users have noted occasional failures of linked messages when sending a message to a large number of receiving scripts in different prims using [[LINK_SET]], [[LINK_ALL_OTHERS]], & [[LINK_ALL_CHILDREN]]. If you encounter this problem, a workaround is to place all child prim scripts in a single prim, using targeted functions like [[llSetLinkPrimitiveParams]] to modify the prim in which the script previously resided. -- [[User:Void Singer|Void Singer]]
|cat1=Communications
|cat2=Link
|cat3=Link Message
|cat4
}}

Category:LSL List/it

2012-01-05T14:24:02Z

Violet Hammerer: /* Extended List Operations */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Aggiungere un elemento a una lista====

Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
# miaLista = miaLista + [nuovo_oggetto];
# miaLista += [nuovo_oggetto];
# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
# miaLista = miaLista + miaLista;
# miaLista += nuovo_oggetto;
# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

=====Note=====
* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
** Uno script di prova col settimo metodo, una volta compilato ha avuto una memoria iniziale di 15878, mentre col quarto metodo ha avuto una memoria di 15871. Come risultato, il settimo metodo ha avuto più memoria libera del quarto alla fine dell'operazione di prova.
* I metodi 2 e 3 compilano nella stessa cosa.
* I metodi 5 e 6 compilano nella stessa cosa.
* I metodi 5, 6 e 7 consentono un risparmio bytecode rispetto ai metodi 2, 3 e 4 rispettivamente, sebbene esista un bug VM LSO-LSL che provoca un malfunzionamento nelle trasformazioni in stringhe e chiavi: {{Jira|SVC-1710}}.
* I metodi 4 e 7 possono portare a considerevoli risparmi di memoria in LSO-LSL rispetto ai metodi 2, 3, 5 e 6 (aiutano a ridurre la frammentazione cumulativa, che altrimenti risulterebbe in blocchi inutilizzabili di memoria cumulativa){{Footnote|Questo metodo è stato inventato e reso popolare da {{User|Strife Onizuka}}|Questo metodo è stato inventato e reso popolare da Strife Onizuka}}. In Mono-LSL non fornisce vantaggi o svantaggi significativi di memoria.
** Dipendentemente dalla situazione (in LSO-LSL) questo metodo potrebbe non fornire alcun vantaggio. Se siete in dubbio, sagomate lo script usando e non usando questo metodo.

====Unire le liste (ossia la concatenazione)====

Le liste possono essere unite semplicemente usando il segno + :

<lsl>nuovalista = lista01 + lista02;

nuovalista = lista01 + ["rosso","marrone",<0,0,0>];</lsl>

Nota: l'esempio di cui sopra, nei fatti crea 3 liste nella memoria mentre il comando viene eseguito, sebbene ne venga restituita soltanto una. Ciò potrebbe influire sull'uso della memoria.

====Svuotare una lista====

Per svuotare una lista, impostatela per essere uguale a due parentesi quadre vuote, in questo modo:

<lsl>miaLista = [];</lsl>

====Passare una lista in una funzione====

Passare una lista in una funzione è un po' differente dal passare qualunque altro tipo di dato, comunque, ci sono alcuni casi utili di cui essere al corrente:

<lsl>miaLista = llListReplaceList(miaLista, ["miaStringa"], 2, 2);</lsl>

Nel codice qui sopra, chiamiamo [[llListReplaceList]](), un'operazione abbastanza innocente, comunque, a causa del modo in cui si passano le liste, e di come funzionano le funzioni come llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() e [[llListSortList()]] (e altre), potete finire con l'usare due, tre o persino quattro volte l'ammontare di memoria richiesto per immagazzinare la vostra lista, solo chiamando quella funzione! Per evitare questo problema, possiamo utilizzare un po' di ottimizzazione; se sapete che la lista che state passando in questa funzione non verrà mai più letta (ad esempio se il risultato della funzione sovrascriverà la lista) allora possiamo fare questo:

<lsl>miaLista = llListReplaceList((miaLista = []) + miaLista, ["miaStringa"], 2, 2);</lsl>

L'effetto di ciò è di ridurre enormemente l'utilizzo della memoria, in entrambe le VM LSO-LSL e Mono, e ridurrà anche la frammentazione della memoria. Questo funziona anche in altri casi che non siano chiamate a funzioni, per esempio quando si concatenano le liste (vedi sopra), potreste scoprire che questo sistema elimina quasi completamente qualsiasi problema di memoria:

<lsl>list lista1 = ["a", "b", "c"];
lista2 = ["d", "e", "f"];
lista3 = (lista1 = lista2 = []) + lista1 + lista2;</lsl>

====Elaborare una lista in un'altra lista====

Un caso più complesso, ma a volte quando elaborerete una grande lista potreste scoprire che come risultato ne starete producendo un'altra di dimensioni simili. In questi casi, si corre un rischio elevato di esaurire la memoria. Come risultato, in ogni caso in cui sapete che vi succederà, o potrebbe succedervi, di lavorare su liste particolarmente grandi, varrà spesso la pena di manipolarle in modo simile a questo:

<lsl>list mioRisultato = [];

integer i = 0; integer x = miaLista != [];
for (; i < x; ++i) {
if (i > 10) { // Pota la lista ogni 10 elementi
miaLista = llDeleteSubList((miaLista = []) + miaLista, 0, i - 1);
x -= i;
i = 0;
}

// Qui esegue lo stesso lavoro:
mioRisultato += llList2List(miaLista, i, i); // Un lavoro esemplificativo un po' futile
}</lsl>

Questo metodo (cancellare ogni tot di elementi o passaggi) è preferibile al cancellare un elemento ciascun giro, perché il costo di chiamare llDeleteSubList() è molto elevato. Sta allo scripter decidere qual'è la dimensione ottimale per potare una lista di dati immessi, poiché potreste dover bilanciare l'utilizzo della memoria col costo dell'eliminazione.

== Liste raggruppate ==

Un utilizzo comune per le liste è di copiare la funzionalità delle collezioni strutturate di dati. Tali collezioni (chiamate anche <i>struct</i>), disponibili in molti linguaggi di programmazione, mancano dal LSL.

Nel mondo di SL, (perlomeno nel luglio 2008), una lista raggruppata è quanto più si avvicini all'immagazzinare quantità limitate di dati in qualche tipo di struttura a cui potete accedere e che potete manipolare in alcuni modi limitati.

Le liste raggruppate vi permettono di immagazzinare parti di dati correlati in gruppi. Potete determinare quante parti di dati debbano esserci in ciascun "raggruppamento".

A questo punto è meglio fare un esempio. Potreste usare una lista raggruppata per tenere traccia dei nomi, del sesso e delle date di nascita in SL di un gruppo di avatar:

<lsl>list anagrafica = ["Mario Rossi", "maschio", "2007-06-22", "Maria Bianchi", "femmina", "2005-11-02", "Tizio Caio", "maschio", "2008-05-19"];</lsl>

Questo esempio ha un <i>gruppo</i> di tre, perché ciascun raggruppamento possiede tre elementi di dati. L'indice 0 ("Mario Rossi") è l'inizio della prima istanza (poiché il conteggio di una lista parte da 0), l'indice 3 ("Maria Bianchi") è l'inizio della seconda istanza, e così via.

E' importante che i pezzi di informazione in ciascun gruppo vengano inseriti sempre nella stessa sequenza per ciascuna istanza del raggruppamento nella lista! Nell'esempio qui sopra, ciò significa che il nome deve essere sempre il primo dei tre elementi correlati. Dovreste riflettere attentamente sull'ordine in cui registrate le informazioni poiché la funzione per ordinare una lista, [[llListSort]], potrà ordinare solamente a partire dal <i>primo elemento</i> delle istanze. In altre parole, se la data di nascita in SL dell'avatar fosse stata l'attributo più importante per il vostro script, allora avreste dovuto registrarlo per primo, e il nome per secondo. Se volete avere la possibilità di ordinare per cognome piuttosto che per nome, il nominativo dovrebbe essere aggiunto alla lista nel cormato Cognome Nome (evitando la virgola, a meno che, ovviamente, non vogliate che Cognome e Nome siano trattati come elementi separati nella lista).

Per aggiungere un'altra persona alla lista qui sopra, dovreste fare così:

<lsl>anagrafica += ["Maria Rossi", "femmina", "2010-01-22"];</lsl>

Non potete svolgere alcun tipo elegante di analisi dei dati o di manipolazione con le liste raggruppate, come si usa fare nelle banche dati o nei fogli elettronici al di fuori di SL, ma esse possono soddisfare alcune necessità limitate in SL, se non avete le risorse per appoggiarvi a strumenti esterni. Andrebbe evidenziato che quando si manipolano liste raggruppate estremamente grandi, se volete modificare le liste potreste volere usare una lista per ciascuna "colonna", così facendo potrebbe essere più complicato ma ridurrebbe significativamente il quantitativo di memoria richiesta durante la manipolazione delle liste, sebbene ci saranno molte più difficolta nell'ordinare.

Ecco gli strumenti a nostra disposizione per le liste raggruppate:

Le funzioni native LSL (nel luglio 2008) seguenti possono essere utilizzate con le liste raggruppate:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Ecco alcune funzioni aggiuntive create dagli utenti per lavorare con le liste raggruppate:

{|{{Prettytable}}
|+
|-{{Hl2}}
!funzione
!scopo
|-
|| [[ListStridedMove]] || Sposta qualcosa in una lista raggruppata in un altro posto nella lista.
|-
|| [[ListStridedRemove]] || Rimuove parte di una lista raggruppata.
|-
|| [[ListStridedUpdate]] || Aggiorna parte di una lista raggruppata.
|-
|}

== Operazioni estese con le liste ==

Queste funzioni sono state create e fornite da utenti del LSL per eseguire operazioni non contemplate dalle funzioni LSL ufficiali.

{|{{Prettytable}}
|+
|-{{Hl2}}
!funzione
!scopo
|-
|| [[ListCast]] || Elabora una lista così che i suoi contenuti siano di un tipo singolo.
|-
|| [[List_cast]] || Elabora una lista così che i suoi contenuti siano convertiti da stringa a stringa nei loro tipi rispettivi.
|-
|| [[ListCompare]] || Compara due liste per l'uguaglianza.
|-
|| [[ListItemDelete]] || Rimuove un elemento da una lista.
|-
|| [[ListKeyCase]] || Cambia i valori dell'intera lista in maiuscolo o minuscolo basandosi sui dati in entrata
|-
|| [[ListToWholeNumbers]] || Data una lista di numeri frazionari, li converte tutti in numeri interi.
|-
|| [[ListXorY]] || Unisce due liste per creare una nuova lista combinata, eliminando nel frattempo ciascun dato duplicato dalla nuova lista.
|-
|| [[ListXandY]] || Questa funzione esamina due liste, e restituisce una nuova lista composta dagli elementi che entrambe le liste hanno in comune.
|-
|| [[ListXnotY]] || Mostra ciò che la lista x possiede che alla lista y manca.
|-
|| [[ListXxorY]] || Restituisce una nuova lista, composta dagli elementi che erano in ciascuno script originario, ma non entrambi. Nota: ciò non è come sbarazzarsi dei duplicati conservando solo uno degli elementi copiati. Va oltre, e rimuove entrambi gli elementi.
|-
|| [[ListXequY]] || Risponde alla domanda: la lista X è identica alla lista Y?
|-
|| [[ListXneqY]] || Risponde alla domanda: la lista X è diversa dalla lista Y?
|-
|| [[ListItemReplace|Replace]] || Sostituisce una singola istanza di qualcosa in una lista con qualcos'altro specificato da voi.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Sostituisce tutte le istanze di 'lista in entrata' con quelle di 'lista in uscita' in 'lista di ricerca'. Non è concisa come la funzione qui sopra ma gestisce più oggetti nello stesso tempo.
|-
|| [[ListUnique ]] || Data una lista di elementi, restituisce solo gli elementi unici di quella lista.
|-
|| [[ccFixListDatatypes ]] || Scorre una lista, ne trasforma gli elementi nelle tipologie appropriate, e restituisce una lista corretta. Utile per cose tipo [[llSetPrimitiveParams]] quando avete elaborato i vostri dati estraendoli da una stringa.
|-
|| [[2D Pseudo-Array]] || Un metodo per emulare il comportamento di un assortimento (orig. "array", ndT) bidimensionale.
|}

Category:LSL List/it

2012-01-05T14:00:01Z

Violet Hammerer: /* Strided lists */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Aggiungere un elemento a una lista====

Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
# miaLista = miaLista + [nuovo_oggetto];
# miaLista += [nuovo_oggetto];
# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
# miaLista = miaLista + miaLista;
# miaLista += nuovo_oggetto;
# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

=====Note=====
* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
** Uno script di prova col settimo metodo, una volta compilato ha avuto una memoria iniziale di 15878, mentre col quarto metodo ha avuto una memoria di 15871. Come risultato, il settimo metodo ha avuto più memoria libera del quarto alla fine dell'operazione di prova.
* I metodi 2 e 3 compilano nella stessa cosa.
* I metodi 5 e 6 compilano nella stessa cosa.
* I metodi 5, 6 e 7 consentono un risparmio bytecode rispetto ai metodi 2, 3 e 4 rispettivamente, sebbene esista un bug VM LSO-LSL che provoca un malfunzionamento nelle trasformazioni in stringhe e chiavi: {{Jira|SVC-1710}}.
* I metodi 4 e 7 possono portare a considerevoli risparmi di memoria in LSO-LSL rispetto ai metodi 2, 3, 5 e 6 (aiutano a ridurre la frammentazione cumulativa, che altrimenti risulterebbe in blocchi inutilizzabili di memoria cumulativa){{Footnote|Questo metodo è stato inventato e reso popolare da {{User|Strife Onizuka}}|Questo metodo è stato inventato e reso popolare da Strife Onizuka}}. In Mono-LSL non fornisce vantaggi o svantaggi significativi di memoria.
** Dipendentemente dalla situazione (in LSO-LSL) questo metodo potrebbe non fornire alcun vantaggio. Se siete in dubbio, sagomate lo script usando e non usando questo metodo.

====Unire le liste (ossia la concatenazione)====

Le liste possono essere unite semplicemente usando il segno + :

<lsl>nuovalista = lista01 + lista02;

nuovalista = lista01 + ["rosso","marrone",<0,0,0>];</lsl>

Nota: l'esempio di cui sopra, nei fatti crea 3 liste nella memoria mentre il comando viene eseguito, sebbene ne venga restituita soltanto una. Ciò potrebbe influire sull'uso della memoria.

====Svuotare una lista====

Per svuotare una lista, impostatela per essere uguale a due parentesi quadre vuote, in questo modo:

<lsl>miaLista = [];</lsl>

====Passare una lista in una funzione====

Passare una lista in una funzione è un po' differente dal passare qualunque altro tipo di dato, comunque, ci sono alcuni casi utili di cui essere al corrente:

<lsl>miaLista = llListReplaceList(miaLista, ["miaStringa"], 2, 2);</lsl>

Nel codice qui sopra, chiamiamo [[llListReplaceList]](), un'operazione abbastanza innocente, comunque, a causa del modo in cui si passano le liste, e di come funzionano le funzioni come llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() e [[llListSortList()]] (e altre), potete finire con l'usare due, tre o persino quattro volte l'ammontare di memoria richiesto per immagazzinare la vostra lista, solo chiamando quella funzione! Per evitare questo problema, possiamo utilizzare un po' di ottimizzazione; se sapete che la lista che state passando in questa funzione non verrà mai più letta (ad esempio se il risultato della funzione sovrascriverà la lista) allora possiamo fare questo:

<lsl>miaLista = llListReplaceList((miaLista = []) + miaLista, ["miaStringa"], 2, 2);</lsl>

L'effetto di ciò è di ridurre enormemente l'utilizzo della memoria, in entrambe le VM LSO-LSL e Mono, e ridurrà anche la frammentazione della memoria. Questo funziona anche in altri casi che non siano chiamate a funzioni, per esempio quando si concatenano le liste (vedi sopra), potreste scoprire che questo sistema elimina quasi completamente qualsiasi problema di memoria:

<lsl>list lista1 = ["a", "b", "c"];
lista2 = ["d", "e", "f"];
lista3 = (lista1 = lista2 = []) + lista1 + lista2;</lsl>

====Elaborare una lista in un'altra lista====

Un caso più complesso, ma a volte quando elaborerete una grande lista potreste scoprire che come risultato ne starete producendo un'altra di dimensioni simili. In questi casi, si corre un rischio elevato di esaurire la memoria. Come risultato, in ogni caso in cui sapete che vi succederà, o potrebbe succedervi, di lavorare su liste particolarmente grandi, varrà spesso la pena di manipolarle in modo simile a questo:

<lsl>list mioRisultato = [];

integer i = 0; integer x = miaLista != [];
for (; i < x; ++i) {
if (i > 10) { // Pota la lista ogni 10 elementi
miaLista = llDeleteSubList((miaLista = []) + miaLista, 0, i - 1);
x -= i;
i = 0;
}

// Qui esegue lo stesso lavoro:
mioRisultato += llList2List(miaLista, i, i); // Un lavoro esemplificativo un po' futile
}</lsl>

Questo metodo (cancellare ogni tot di elementi o passaggi) è preferibile al cancellare un elemento ciascun giro, perché il costo di chiamare llDeleteSubList() è molto elevato. Sta allo scripter decidere qual'è la dimensione ottimale per potare una lista di dati immessi, poiché potreste dover bilanciare l'utilizzo della memoria col costo dell'eliminazione.

== Liste raggruppate ==

Un utilizzo comune per le liste è di copiare la funzionalità delle collezioni strutturate di dati. Tali collezioni (chiamate anche <i>struct</i>), disponibili in molti linguaggi di programmazione, mancano dal LSL.

Nel mondo di SL, (perlomeno nel luglio 2008), una lista raggruppata è quanto più si avvicini all'immagazzinare quantità limitate di dati in qualche tipo di struttura a cui potete accedere e che potete manipolare in alcuni modi limitati.

Le liste raggruppate vi permettono di immagazzinare parti di dati correlati in gruppi. Potete determinare quante parti di dati debbano esserci in ciascun "raggruppamento".

A questo punto è meglio fare un esempio. Potreste usare una lista raggruppata per tenere traccia dei nomi, del sesso e delle date di nascita in SL di un gruppo di avatar:

<lsl>list anagrafica = ["Mario Rossi", "maschio", "2007-06-22", "Maria Bianchi", "femmina", "2005-11-02", "Tizio Caio", "maschio", "2008-05-19"];</lsl>

Questo esempio ha un <i>gruppo</i> di tre, perché ciascun raggruppamento possiede tre elementi di dati. L'indice 0 ("Mario Rossi") è l'inizio della prima istanza (poiché il conteggio di una lista parte da 0), l'indice 3 ("Maria Bianchi") è l'inizio della seconda istanza, e così via.

E' importante che i pezzi di informazione in ciascun gruppo vengano inseriti sempre nella stessa sequenza per ciascuna istanza del raggruppamento nella lista! Nell'esempio qui sopra, ciò significa che il nome deve essere sempre il primo dei tre elementi correlati. Dovreste riflettere attentamente sull'ordine in cui registrate le informazioni poiché la funzione per ordinare una lista, [[llListSort]], potrà ordinare solamente a partire dal <i>primo elemento</i> delle istanze. In altre parole, se la data di nascita in SL dell'avatar fosse stata l'attributo più importante per il vostro script, allora avreste dovuto registrarlo per primo, e il nome per secondo. Se volete avere la possibilità di ordinare per cognome piuttosto che per nome, il nominativo dovrebbe essere aggiunto alla lista nel cormato Cognome Nome (evitando la virgola, a meno che, ovviamente, non vogliate che Cognome e Nome siano trattati come elementi separati nella lista).

Per aggiungere un'altra persona alla lista qui sopra, dovreste fare così:

<lsl>anagrafica += ["Maria Rossi", "femmina", "2010-01-22"];</lsl>

Non potete svolgere alcun tipo elegante di analisi dei dati o di manipolazione con le liste raggruppate, come si usa fare nelle banche dati o nei fogli elettronici al di fuori di SL, ma esse possono soddisfare alcune necessità limitate in SL, se non avete le risorse per appoggiarvi a strumenti esterni. Andrebbe evidenziato che quando si manipolano liste raggruppate estremamente grandi, se volete modificare le liste potreste volere usare una lista per ciascuna "colonna", così facendo potrebbe essere più complicato ma ridurrebbe significativamente il quantitativo di memoria richiesta durante la manipolazione delle liste, sebbene ci saranno molte più difficolta nell'ordinare.

Ecco gli strumenti a nostra disposizione per le liste raggruppate:

Le funzioni native LSL (nel luglio 2008) seguenti possono essere utilizzate con le liste raggruppate:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Ecco alcune funzioni aggiuntive create dagli utenti per lavorare con le liste raggruppate:

{|{{Prettytable}}
|+
|-{{Hl2}}
!funzione
!scopo
|-
|| [[ListStridedMove]] || Sposta qualcosa in una lista raggruppata in un altro posto nella lista.
|-
|| [[ListStridedRemove]] || Rimuove parte di una lista raggruppata.
|-
|| [[ListStridedUpdate]] || Aggiorna parte di una lista raggruppata.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}

Category:LSL List/it

2011-12-31T14:48:39Z

Violet Hammerer: /* Elaborare una lista in un'altra lista */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Aggiungere un elemento a una lista====

Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
# miaLista = miaLista + [nuovo_oggetto];
# miaLista += [nuovo_oggetto];
# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
# miaLista = miaLista + miaLista;
# miaLista += nuovo_oggetto;
# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

=====Note=====
* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
** Uno script di prova col settimo metodo, una volta compilato ha avuto una memoria iniziale di 15878, mentre col quarto metodo ha avuto una memoria di 15871. Come risultato, il settimo metodo ha avuto più memoria libera del quarto alla fine dell'operazione di prova.
* I metodi 2 e 3 compilano nella stessa cosa.
* I metodi 5 e 6 compilano nella stessa cosa.
* I metodi 5, 6 e 7 consentono un risparmio bytecode rispetto ai metodi 2, 3 e 4 rispettivamente, sebbene esista un bug VM LSO-LSL che provoca un malfunzionamento nelle trasformazioni in stringhe e chiavi: {{Jira|SVC-1710}}.
* I metodi 4 e 7 possono portare a considerevoli risparmi di memoria in LSO-LSL rispetto ai metodi 2, 3, 5 e 6 (aiutano a ridurre la frammentazione cumulativa, che altrimenti risulterebbe in blocchi inutilizzabili di memoria cumulativa){{Footnote|Questo metodo è stato inventato e reso popolare da {{User|Strife Onizuka}}|Questo metodo è stato inventato e reso popolare da Strife Onizuka}}. In Mono-LSL non fornisce vantaggi o svantaggi significativi di memoria.
** Dipendentemente dalla situazione (in LSO-LSL) questo metodo potrebbe non fornire alcun vantaggio. Se siete in dubbio, sagomate lo script usando e non usando questo metodo.

====Unire le liste (ossia la concatenazione)====

Le liste possono essere unite semplicemente usando il segno + :

<lsl>nuovalista = lista01 + lista02;

nuovalista = lista01 + ["rosso","marrone",<0,0,0>];</lsl>

Nota: l'esempio di cui sopra, nei fatti crea 3 liste nella memoria mentre il comando viene eseguito, sebbene ne venga restituita soltanto una. Ciò potrebbe influire sull'uso della memoria.

====Svuotare una lista====

Per svuotare una lista, impostatela per essere uguale a due parentesi quadre vuote, in questo modo:

<lsl>miaLista = [];</lsl>

====Passare una lista in una funzione====

Passare una lista in una funzione è un po' differente dal passare qualunque altro tipo di dato, comunque, ci sono alcuni casi utili di cui essere al corrente:

<lsl>miaLista = llListReplaceList(miaLista, ["miaStringa"], 2, 2);</lsl>

Nel codice qui sopra, chiamiamo [[llListReplaceList]](), un'operazione abbastanza innocente, comunque, a causa del modo in cui si passano le liste, e di come funzionano le funzioni come llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() e [[llListSortList()]] (e altre), potete finire con l'usare due, tre o persino quattro volte l'ammontare di memoria richiesto per immagazzinare la vostra lista, solo chiamando quella funzione! Per evitare questo problema, possiamo utilizzare un po' di ottimizzazione; se sapete che la lista che state passando in questa funzione non verrà mai più letta (ad esempio se il risultato della funzione sovrascriverà la lista) allora possiamo fare questo:

<lsl>miaLista = llListReplaceList((miaLista = []) + miaLista, ["miaStringa"], 2, 2);</lsl>

L'effetto di ciò è di ridurre enormemente l'utilizzo della memoria, in entrambe le VM LSO-LSL e Mono, e ridurrà anche la frammentazione della memoria. Questo funziona anche in altri casi che non siano chiamate a funzioni, per esempio quando si concatenano le liste (vedi sopra), potreste scoprire che questo sistema elimina quasi completamente qualsiasi problema di memoria:

<lsl>list lista1 = ["a", "b", "c"];
lista2 = ["d", "e", "f"];
lista3 = (lista1 = lista2 = []) + lista1 + lista2;</lsl>

====Elaborare una lista in un'altra lista====

Un caso più complesso, ma a volte quando elaborerete una grande lista potreste scoprire che come risultato ne starete producendo un'altra di dimensioni simili. In questi casi, si corre un rischio elevato di esaurire la memoria. Come risultato, in ogni caso in cui sapete che vi succederà, o potrebbe succedervi, di lavorare su liste particolarmente grandi, varrà spesso la pena di manipolarle in modo simile a questo:

<lsl>list mioRisultato = [];

integer i = 0; integer x = miaLista != [];
for (; i < x; ++i) {
if (i > 10) { // Pota la lista ogni 10 elementi
miaLista = llDeleteSubList((miaLista = []) + miaLista, 0, i - 1);
x -= i;
i = 0;
}

// Qui esegue lo stesso lavoro:
mioRisultato += llList2List(miaLista, i, i); // Un lavoro esemplificativo un po' futile
}</lsl>

Questo metodo (cancellare ogni tot di elementi o passaggi) è preferibile al cancellare un elemento ciascun giro, perché il costo di chiamare llDeleteSubList() è molto elevato. Sta allo scripter decidere qual'è la dimensione ottimale per potare una lista di dati immessi, poiché potreste dover bilanciare l'utilizzo della memoria col costo dell'eliminazione.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}

Category:LSL List/it

2011-12-31T14:47:24Z

Violet Hammerer: /* Processing a List Into Another List */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Aggiungere un elemento a una lista====

Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
# miaLista = miaLista + [nuovo_oggetto];
# miaLista += [nuovo_oggetto];
# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
# miaLista = miaLista + miaLista;
# miaLista += nuovo_oggetto;
# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

=====Note=====
* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
** Uno script di prova col settimo metodo, una volta compilato ha avuto una memoria iniziale di 15878, mentre col quarto metodo ha avuto una memoria di 15871. Come risultato, il settimo metodo ha avuto più memoria libera del quarto alla fine dell'operazione di prova.
* I metodi 2 e 3 compilano nella stessa cosa.
* I metodi 5 e 6 compilano nella stessa cosa.
* I metodi 5, 6 e 7 consentono un risparmio bytecode rispetto ai metodi 2, 3 e 4 rispettivamente, sebbene esista un bug VM LSO-LSL che provoca un malfunzionamento nelle trasformazioni in stringhe e chiavi: {{Jira|SVC-1710}}.
* I metodi 4 e 7 possono portare a considerevoli risparmi di memoria in LSO-LSL rispetto ai metodi 2, 3, 5 e 6 (aiutano a ridurre la frammentazione cumulativa, che altrimenti risulterebbe in blocchi inutilizzabili di memoria cumulativa){{Footnote|Questo metodo è stato inventato e reso popolare da {{User|Strife Onizuka}}|Questo metodo è stato inventato e reso popolare da Strife Onizuka}}. In Mono-LSL non fornisce vantaggi o svantaggi significativi di memoria.
** Dipendentemente dalla situazione (in LSO-LSL) questo metodo potrebbe non fornire alcun vantaggio. Se siete in dubbio, sagomate lo script usando e non usando questo metodo.

====Unire le liste (ossia la concatenazione)====

Le liste possono essere unite semplicemente usando il segno + :

<lsl>nuovalista = lista01 + lista02;

nuovalista = lista01 + ["rosso","marrone",<0,0,0>];</lsl>

Nota: l'esempio di cui sopra, nei fatti crea 3 liste nella memoria mentre il comando viene eseguito, sebbene ne venga restituita soltanto una. Ciò potrebbe influire sull'uso della memoria.

====Svuotare una lista====

Per svuotare una lista, impostatela per essere uguale a due parentesi quadre vuote, in questo modo:

<lsl>miaLista = [];</lsl>

====Passare una lista in una funzione====

Passare una lista in una funzione è un po' differente dal passare qualunque altro tipo di dato, comunque, ci sono alcuni casi utili di cui essere al corrente:

<lsl>miaLista = llListReplaceList(miaLista, ["miaStringa"], 2, 2);</lsl>

Nel codice qui sopra, chiamiamo [[llListReplaceList]](), un'operazione abbastanza innocente, comunque, a causa del modo in cui si passano le liste, e di come funzionano le funzioni come llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() e [[llListSortList()]] (e altre), potete finire con l'usare due, tre o persino quattro volte l'ammontare di memoria richiesto per immagazzinare la vostra lista, solo chiamando quella funzione! Per evitare questo problema, possiamo utilizzare un po' di ottimizzazione; se sapete che la lista che state passando in questa funzione non verrà mai più letta (ad esempio se il risultato della funzione sovrascriverà la lista) allora possiamo fare questo:

<lsl>miaLista = llListReplaceList((miaLista = []) + miaLista, ["miaStringa"], 2, 2);</lsl>

L'effetto di ciò è di ridurre enormemente l'utilizzo della memoria, in entrambe le VM LSO-LSL e Mono, e ridurrà anche la frammentazione della memoria. Questo funziona anche in altri casi che non siano chiamate a funzioni, per esempio quando si concatenano le liste (vedi sopra), potreste scoprire che questo sistema elimina quasi completamente qualsiasi problema di memoria:

<lsl>list lista1 = ["a", "b", "c"];
lista2 = ["d", "e", "f"];
lista3 = (lista1 = lista2 = []) + lista1 + lista2;</lsl>

====Elaborare una lista in un'altra lista====

Un caso più complesso, ma a volte quando elaborerete una grande lista potreste scoprire che come risultato ne starete producendo un'altra di dimensioni simili. In questi casi, si corre un rischio elevato di esaurire la memoria. Come risultato, in ogni caso in cui sapete che vi succederà, o potrebbe succedervi, di lavorare su liste particolarmente grandi, varrà spesso la pena di manipolarle in modo simile a questo:

<lsl>list mioRisultato = [];

integer i = 0; integer x = miaLista != [];
for (; i < x; ++i) {
if (i > 10) { // Pota la lista ogni 10 elementi
miaLista = llDeleteSubList((miaLista = []) + miaLista, 0, i - 1);
x -= i;
i = 0;
}

// Qui esegue lo stesso lavoro:
mioRisultato += llList2List(miaLista, i, i); // A silly bit of example work
}</lsl>

Questo metodo (cancellare ogni tot di elementi o passaggi) è preferibile al cancellare un elemento ciascun giro, perché il costo di chiamare llDeleteSubList() è molto elevato. Sta allo scripter decidere qual'è la dimensione ottimale per potare una lista di dati immessi, poiché potreste dover bilanciare l'utilizzo della memoria col costo dell'eliminazione.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}

Category:LSL List/it

2011-12-31T14:35:04Z

Violet Hammerer: /* Passing a List Into a Function */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Aggiungere un elemento a una lista====

Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
# miaLista = miaLista + [nuovo_oggetto];
# miaLista += [nuovo_oggetto];
# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
# miaLista = miaLista + miaLista;
# miaLista += nuovo_oggetto;
# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

=====Note=====
* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
** Uno script di prova col settimo metodo, una volta compilato ha avuto una memoria iniziale di 15878, mentre col quarto metodo ha avuto una memoria di 15871. Come risultato, il settimo metodo ha avuto più memoria libera del quarto alla fine dell'operazione di prova.
* I metodi 2 e 3 compilano nella stessa cosa.
* I metodi 5 e 6 compilano nella stessa cosa.
* I metodi 5, 6 e 7 consentono un risparmio bytecode rispetto ai metodi 2, 3 e 4 rispettivamente, sebbene esista un bug VM LSO-LSL che provoca un malfunzionamento nelle trasformazioni in stringhe e chiavi: {{Jira|SVC-1710}}.
* I metodi 4 e 7 possono portare a considerevoli risparmi di memoria in LSO-LSL rispetto ai metodi 2, 3, 5 e 6 (aiutano a ridurre la frammentazione cumulativa, che altrimenti risulterebbe in blocchi inutilizzabili di memoria cumulativa){{Footnote|Questo metodo è stato inventato e reso popolare da {{User|Strife Onizuka}}|Questo metodo è stato inventato e reso popolare da Strife Onizuka}}. In Mono-LSL non fornisce vantaggi o svantaggi significativi di memoria.
** Dipendentemente dalla situazione (in LSO-LSL) questo metodo potrebbe non fornire alcun vantaggio. Se siete in dubbio, sagomate lo script usando e non usando questo metodo.

====Unire le liste (ossia la concatenazione)====

Le liste possono essere unite semplicemente usando il segno + :

<lsl>nuovalista = lista01 + lista02;

nuovalista = lista01 + ["rosso","marrone",<0,0,0>];</lsl>

Nota: l'esempio di cui sopra, nei fatti crea 3 liste nella memoria mentre il comando viene eseguito, sebbene ne venga restituita soltanto una. Ciò potrebbe influire sull'uso della memoria.

====Svuotare una lista====

Per svuotare una lista, impostatela per essere uguale a due parentesi quadre vuote, in questo modo:

<lsl>miaLista = [];</lsl>

====Passare una lista in una funzione====

Passare una lista in una funzione è un po' differente dal passare qualunque altro tipo di dato, comunque, ci sono alcuni casi utili di cui essere al corrente:

<lsl>miaLista = llListReplaceList(miaLista, ["miaStringa"], 2, 2);</lsl>

Nel codice qui sopra, chiamiamo [[llListReplaceList]](), un'operazione abbastanza innocente, comunque, a causa del modo in cui si passano le liste, e di come funzionano le funzioni come llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() e [[llListSortList()]] (e altre), potete finire con l'usare due, tre o persino quattro volte l'ammontare di memoria richiesto per immagazzinare la vostra lista, solo chiamando quella funzione! Per evitare questo problema, possiamo utilizzare un po' di ottimizzazione; se sapete che la lista che state passando in questa funzione non verrà mai più letta (ad esempio se il risultato della funzione sovrascriverà la lista) allora possiamo fare questo:

<lsl>miaLista = llListReplaceList((miaLista = []) + miaLista, ["miaStringa"], 2, 2);</lsl>

L'effetto di ciò è di ridurre enormemente l'utilizzo della memoria, in entrambe le VM LSO-LSL e Mono, e ridurrà anche la frammentazione della memoria. Questo funziona anche in altri casi che non siano chiamate a funzioni, per esempio quando si concatenano le liste (vedi sopra), potreste scoprire che questo sistema elimina quasi completamente qualsiasi problema di memoria:

<lsl>list lista1 = ["a", "b", "c"];
lista2 = ["d", "e", "f"];
lista3 = (lista1 = lista2 = []) + lista1 + lista2;</lsl>

====Processing a List Into Another List====

A more complex case, but sometimes when processing a large list you may find that you are producing a similarly large list as a result. In such cases there is a very large risk of running out of memory. As a result, in any case where you know you will, or might, be working on a particularly large list, it will often be worth manipulating them similarly to:

<lsl>list myOutput = [];

integer i = 0; integer x = myList != [];
for (; i < x; ++i) {
if (i > 10) { // Prune list every 10 elements
myList = llDeleteSubList((myList = []) + myList, 0, i - 1);
x -= i;
i = 0;
}

// Do some work here:
myOutput += llList2List(myList, i, i); // A silly bit of example work
}</lsl>

This method (deleting every few list entries or strides) is preferable to deleting an entry every loop, as the cost of calling llDeleteSubList() is very high. It is up to the scripter to decide what their optimal chunk-size is for pruning an input list, as you will need to balance memory use with delete cost.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}

Category:LSL List/it

2011-12-31T14:22:55Z

Violet Hammerer: /* Clearing a List */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Aggiungere un elemento a una lista====

Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
# miaLista = miaLista + [nuovo_oggetto];
# miaLista += [nuovo_oggetto];
# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
# miaLista = miaLista + miaLista;
# miaLista += nuovo_oggetto;
# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

=====Note=====
* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
** Uno script di prova col settimo metodo, una volta compilato ha avuto una memoria iniziale di 15878, mentre col quarto metodo ha avuto una memoria di 15871. Come risultato, il settimo metodo ha avuto più memoria libera del quarto alla fine dell'operazione di prova.
* I metodi 2 e 3 compilano nella stessa cosa.
* I metodi 5 e 6 compilano nella stessa cosa.
* I metodi 5, 6 e 7 consentono un risparmio bytecode rispetto ai metodi 2, 3 e 4 rispettivamente, sebbene esista un bug VM LSO-LSL che provoca un malfunzionamento nelle trasformazioni in stringhe e chiavi: {{Jira|SVC-1710}}.
* I metodi 4 e 7 possono portare a considerevoli risparmi di memoria in LSO-LSL rispetto ai metodi 2, 3, 5 e 6 (aiutano a ridurre la frammentazione cumulativa, che altrimenti risulterebbe in blocchi inutilizzabili di memoria cumulativa){{Footnote|Questo metodo è stato inventato e reso popolare da {{User|Strife Onizuka}}|Questo metodo è stato inventato e reso popolare da Strife Onizuka}}. In Mono-LSL non fornisce vantaggi o svantaggi significativi di memoria.
** Dipendentemente dalla situazione (in LSO-LSL) questo metodo potrebbe non fornire alcun vantaggio. Se siete in dubbio, sagomate lo script usando e non usando questo metodo.

====Unire le liste (ossia la concatenazione)====

Le liste possono essere unite semplicemente usando il segno + :

<lsl>nuovalista = lista01 + lista02;

nuovalista = lista01 + ["rosso","marrone",<0,0,0>];</lsl>

Nota: l'esempio di cui sopra, nei fatti crea 3 liste nella memoria mentre il comando viene eseguito, sebbene ne venga restituita soltanto una. Ciò potrebbe influire sull'uso della memoria.

====Svuotare una lista====

Per svuotare una lista, impostatela per essere uguale a due parentesi quadre vuote, in questo modo:

<lsl>miaLista = [];</lsl>

====Passing a List Into a Function====

Passing a list into a function is little different than passing any other data type, however, there are some useful cases to be aware of:

<lsl>myList = llListReplaceList(myList, ["myString"], 2, 2);</lsl>

In the above code, we call [[llListReplaceList]](), an innocent enough operation, however, due to the way passing of lists, and functions such as llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() and [[llListSortList()]] (and others), work, you can end up using two, three, or even four times the amount of memory required to store your list, just by calling that function! To avoid this problem, we can use a small piece of optimisation; if you know that the list you're passing into such a function will never be read again (for example if the result of the function will overwrite the list) then we can do this:

<lsl>myList = llListReplaceList((myList = []) + myList, ["myString"], 2, 2);</lsl>

The effect of this is to greatly reduce the memory usage, in both LSO-LSL and Mono VMs, and also reduce the fragmentation of memory. This can also work for other cases other than function-calls, for example when concatenating lists (above), you may find that this nearly eliminates any memory problem:

<lsl>list list1 = ["a", "b", "c"];
list2 = ["d", "e", "f"];
list3 = (list1 = list2 = []) + list1 + list2;</lsl>

====Processing a List Into Another List====

A more complex case, but sometimes when processing a large list you may find that you are producing a similarly large list as a result. In such cases there is a very large risk of running out of memory. As a result, in any case where you know you will, or might, be working on a particularly large list, it will often be worth manipulating them similarly to:

<lsl>list myOutput = [];

integer i = 0; integer x = myList != [];
for (; i < x; ++i) {
if (i > 10) { // Prune list every 10 elements
myList = llDeleteSubList((myList = []) + myList, 0, i - 1);
x -= i;
i = 0;
}

// Do some work here:
myOutput += llList2List(myList, i, i); // A silly bit of example work
}</lsl>

This method (deleting every few list entries or strides) is preferable to deleting an entry every loop, as the cost of calling llDeleteSubList() is very high. It is up to the scripter to decide what their optimal chunk-size is for pruning an input list, as you will need to balance memory use with delete cost.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}

Category:LSL List/it

2011-12-31T14:20:55Z

Violet Hammerer: /* Joining Lists (aka Concatenation) */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Aggiungere un elemento a una lista====

Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
# miaLista = miaLista + [nuovo_oggetto];
# miaLista += [nuovo_oggetto];
# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
# miaLista = miaLista + miaLista;
# miaLista += nuovo_oggetto;
# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

=====Note=====
* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
** Uno script di prova col settimo metodo, una volta compilato ha avuto una memoria iniziale di 15878, mentre col quarto metodo ha avuto una memoria di 15871. Come risultato, il settimo metodo ha avuto più memoria libera del quarto alla fine dell'operazione di prova.
* I metodi 2 e 3 compilano nella stessa cosa.
* I metodi 5 e 6 compilano nella stessa cosa.
* I metodi 5, 6 e 7 consentono un risparmio bytecode rispetto ai metodi 2, 3 e 4 rispettivamente, sebbene esista un bug VM LSO-LSL che provoca un malfunzionamento nelle trasformazioni in stringhe e chiavi: {{Jira|SVC-1710}}.
* I metodi 4 e 7 possono portare a considerevoli risparmi di memoria in LSO-LSL rispetto ai metodi 2, 3, 5 e 6 (aiutano a ridurre la frammentazione cumulativa, che altrimenti risulterebbe in blocchi inutilizzabili di memoria cumulativa){{Footnote|Questo metodo è stato inventato e reso popolare da {{User|Strife Onizuka}}|Questo metodo è stato inventato e reso popolare da Strife Onizuka}}. In Mono-LSL non fornisce vantaggi o svantaggi significativi di memoria.
** Dipendentemente dalla situazione (in LSO-LSL) questo metodo potrebbe non fornire alcun vantaggio. Se siete in dubbio, sagomate lo script usando e non usando questo metodo.

====Unire le liste (ossia la concatenazione)====

Le liste possono essere unite semplicemente usando il segno + :

<lsl>nuovalista = lista01 + lista02;

nuovalista = lista01 + ["rosso","marrone",<0,0,0>];</lsl>

Nota: l'esempio di cui sopra, nei fatti crea 3 liste nella memoria mentre il comando viene eseguito, sebbene ne venga restituita soltanto una. Ciò potrebbe influire sull'uso della memoria.

====Clearing a List====

To clear a list, set it equal to two square, empty brackets like this:

<lsl>myList = [];</lsl>

====Passing a List Into a Function====

Passing a list into a function is little different than passing any other data type, however, there are some useful cases to be aware of:

<lsl>myList = llListReplaceList(myList, ["myString"], 2, 2);</lsl>

In the above code, we call [[llListReplaceList]](), an innocent enough operation, however, due to the way passing of lists, and functions such as llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() and [[llListSortList()]] (and others), work, you can end up using two, three, or even four times the amount of memory required to store your list, just by calling that function! To avoid this problem, we can use a small piece of optimisation; if you know that the list you're passing into such a function will never be read again (for example if the result of the function will overwrite the list) then we can do this:

<lsl>myList = llListReplaceList((myList = []) + myList, ["myString"], 2, 2);</lsl>

The effect of this is to greatly reduce the memory usage, in both LSO-LSL and Mono VMs, and also reduce the fragmentation of memory. This can also work for other cases other than function-calls, for example when concatenating lists (above), you may find that this nearly eliminates any memory problem:

<lsl>list list1 = ["a", "b", "c"];
list2 = ["d", "e", "f"];
list3 = (list1 = list2 = []) + list1 + list2;</lsl>

====Processing a List Into Another List====

A more complex case, but sometimes when processing a large list you may find that you are producing a similarly large list as a result. In such cases there is a very large risk of running out of memory. As a result, in any case where you know you will, or might, be working on a particularly large list, it will often be worth manipulating them similarly to:

<lsl>list myOutput = [];

integer i = 0; integer x = myList != [];
for (; i < x; ++i) {
if (i > 10) { // Prune list every 10 elements
myList = llDeleteSubList((myList = []) + myList, 0, i - 1);
x -= i;
i = 0;
}

// Do some work here:
myOutput += llList2List(myList, i, i); // A silly bit of example work
}</lsl>

This method (deleting every few list entries or strides) is preferable to deleting an entry every loop, as the cost of calling llDeleteSubList() is very high. It is up to the scripter to decide what their optimal chunk-size is for pruning an input list, as you will need to balance memory use with delete cost.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}

Category:LSL List/it

2011-12-31T14:15:50Z

Violet Hammerer: /* Adding an Element to a list */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Aggiungere un elemento a una lista====

Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
# miaLista = miaLista + [nuovo_oggetto];
# miaLista += [nuovo_oggetto];
# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
# miaLista = miaLista + miaLista;
# miaLista += nuovo_oggetto;
# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

=====Note=====
* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
** Uno script di prova col settimo metodo, una volta compilato ha avuto una memoria iniziale di 15878, mentre col quarto metodo ha avuto una memoria di 15871. Come risultato, il settimo metodo ha avuto più memoria libera del quarto alla fine dell'operazione di prova.
* I metodi 2 e 3 compilano nella stessa cosa.
* I metodi 5 e 6 compilano nella stessa cosa.
* I metodi 5, 6 e 7 consentono un risparmio bytecode rispetto ai metodi 2, 3 e 4 rispettivamente, sebbene esista un bug VM LSO-LSL che provoca un malfunzionamento nelle trasformazioni in stringhe e chiavi: {{Jira|SVC-1710}}.
* I metodi 4 e 7 possono portare a considerevoli risparmi di memoria in LSO-LSL rispetto ai metodi 2, 3, 5 e 6 (aiutano a ridurre la frammentazione cumulativa, che altrimenti risulterebbe in blocchi inutilizzabili di memoria cumulativa){{Footnote|Questo metodo è stato inventato e reso popolare da {{User|Strife Onizuka}}|Questo metodo è stato inventato e reso popolare da Strife Onizuka}}. In Mono-LSL non fornisce vantaggi o svantaggi significativi di memoria.
** Dipendentemente dalla situazione (in LSO-LSL) questo metodo potrebbe non fornire alcun vantaggio. Se siete in dubbio, sagomate lo script usando e non usando questo metodo.

====Joining Lists (aka Concatenation)====

Lists can be joined simply by using the + sign:

<lsl>newlist = list01 + list02;

newlist = list01 + ["red","brown",<0,0,0>];</lsl>

Note: The above example actually creates 3 lists in memory while the command runs, even though just one is returned. This can affect memory usage.

====Clearing a List====

To clear a list, set it equal to two square, empty brackets like this:

<lsl>myList = [];</lsl>

====Passing a List Into a Function====

Passing a list into a function is little different than passing any other data type, however, there are some useful cases to be aware of:

<lsl>myList = llListReplaceList(myList, ["myString"], 2, 2);</lsl>

In the above code, we call [[llListReplaceList]](), an innocent enough operation, however, due to the way passing of lists, and functions such as llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() and [[llListSortList()]] (and others), work, you can end up using two, three, or even four times the amount of memory required to store your list, just by calling that function! To avoid this problem, we can use a small piece of optimisation; if you know that the list you're passing into such a function will never be read again (for example if the result of the function will overwrite the list) then we can do this:

<lsl>myList = llListReplaceList((myList = []) + myList, ["myString"], 2, 2);</lsl>

The effect of this is to greatly reduce the memory usage, in both LSO-LSL and Mono VMs, and also reduce the fragmentation of memory. This can also work for other cases other than function-calls, for example when concatenating lists (above), you may find that this nearly eliminates any memory problem:

<lsl>list list1 = ["a", "b", "c"];
list2 = ["d", "e", "f"];
list3 = (list1 = list2 = []) + list1 + list2;</lsl>

====Processing a List Into Another List====

A more complex case, but sometimes when processing a large list you may find that you are producing a similarly large list as a result. In such cases there is a very large risk of running out of memory. As a result, in any case where you know you will, or might, be working on a particularly large list, it will often be worth manipulating them similarly to:

<lsl>list myOutput = [];

integer i = 0; integer x = myList != [];
for (; i < x; ++i) {
if (i > 10) { // Prune list every 10 elements
myList = llDeleteSubList((myList = []) + myList, 0, i - 1);
x -= i;
i = 0;
}

// Do some work here:
myOutput += llList2List(myList, i, i); // A silly bit of example work
}</lsl>

This method (deleting every few list entries or strides) is preferable to deleting an entry every loop, as the cost of calling llDeleteSubList() is very high. It is up to the scripter to decide what their optimal chunk-size is for pruning an input list, as you will need to balance memory use with delete cost.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}

Category:LSL List/it

2011-12-31T13:45:50Z

Violet Hammerer: /* Limiti delle liste */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script. Tali lunghe liste predefinite sono comuni, per esempio, quando qualcuno offre all'utente una pletora di colori tra cui scegliere.

Suggerimento! Se davvero vi servono 72 o più di queste scelte in una lista predefinita, create 2 (o più) liste che non turbano il compilatore, e unitele nello state_entry() o dovunque sia appropriato:

<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

====Adding an Element to a list====

There are several ways used to add an element to an existing list via prepending/appending:

# myList = '''['''new_item''']''' + myList; '''Best method for Mono-LSL'''
# myList = myList + [new_item];
# myList += [new_item];
# myList = (myList=[]) + myList + [new_item];
# myList = myList + new_item;
# myList += new_item;
# myList = (myList=[]) + myList + new_item; '''Best method for LSO-LSL'''

=====Notes=====
* As of 8/8/2009 Method 1 gives significant savings over any other method used in Mono-LSL.
** Note that prepending the new_item '''without''' brackets '''negates''' any memory savings in Mono-LSL.
** Method 1 will consume more memory than other methods in LSO-LSL.
* As of 8/8/2009 Method 7 returns the best value for savings in LSO-LSL.
** Method 7 is better than Method 4 due to the fact that Method 7 takes up less script overhead.
** Method 7 test script compiled to have a start memory of 15878, while Method 4 compiled to have a start memory of 15871. As a result Method 7 had more free memory than Method 4 at the end of the test operation.
* Methods 2 & 3 compile to the same thing.
* Methods 5 & 6 compile to the same thing.
* Methods 5, 6 & 7 have a bytecode savings over methods 2, 3 & 4 respectively, though there is an LSO-LSL VM bug that causes the string & key typecasts to not stick properly: {{Jira|SVC-1710}}.
* Methods 4 & 7 can result in a considerable memory savings in LSO-LSL over methods 2, 3, 5 & 6 (it helps reduce heap fragmentation, which would otherwise result in unusable blocks of heap memory){{Footnote|This method was invented and popularized by {{User|Strife Onizuka}}|This method was invented and popularized by Strife Onizuka}}. In Mono-LSL it provides no significant memory advantage or disadvantage.
** Depending upon the situation (in LSO-LSL) this method may not provide any advantage what so ever. If in doubt profile the script with and without using this method.

====Joining Lists (aka Concatenation)====

Lists can be joined simply by using the + sign:

<lsl>newlist = list01 + list02;

newlist = list01 + ["red","brown",<0,0,0>];</lsl>

Note: The above example actually creates 3 lists in memory while the command runs, even though just one is returned. This can affect memory usage.

====Clearing a List====

To clear a list, set it equal to two square, empty brackets like this:

<lsl>myList = [];</lsl>

====Passing a List Into a Function====

Passing a list into a function is little different than passing any other data type, however, there are some useful cases to be aware of:

<lsl>myList = llListReplaceList(myList, ["myString"], 2, 2);</lsl>

In the above code, we call [[llListReplaceList]](), an innocent enough operation, however, due to the way passing of lists, and functions such as llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() and [[llListSortList()]] (and others), work, you can end up using two, three, or even four times the amount of memory required to store your list, just by calling that function! To avoid this problem, we can use a small piece of optimisation; if you know that the list you're passing into such a function will never be read again (for example if the result of the function will overwrite the list) then we can do this:

<lsl>myList = llListReplaceList((myList = []) + myList, ["myString"], 2, 2);</lsl>

The effect of this is to greatly reduce the memory usage, in both LSO-LSL and Mono VMs, and also reduce the fragmentation of memory. This can also work for other cases other than function-calls, for example when concatenating lists (above), you may find that this nearly eliminates any memory problem:

<lsl>list list1 = ["a", "b", "c"];
list2 = ["d", "e", "f"];
list3 = (list1 = list2 = []) + list1 + list2;</lsl>

====Processing a List Into Another List====

A more complex case, but sometimes when processing a large list you may find that you are producing a similarly large list as a result. In such cases there is a very large risk of running out of memory. As a result, in any case where you know you will, or might, be working on a particularly large list, it will often be worth manipulating them similarly to:

<lsl>list myOutput = [];

integer i = 0; integer x = myList != [];
for (; i < x; ++i) {
if (i > 10) { // Prune list every 10 elements
myList = llDeleteSubList((myList = []) + myList, 0, i - 1);
x -= i;
i = 0;
}

// Do some work here:
myOutput += llList2List(myList, i, i); // A silly bit of example work
}</lsl>

This method (deleting every few list entries or strides) is preferable to deleting an entry every loop, as the cost of calling llDeleteSubList() is very high. It is up to the scripter to decide what their optimal chunk-size is for pruning an input list, as you will need to balance memory use with delete cost.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}

Category:LSL List/it

2011-12-30T20:59:48Z

Violet Hammerer: /* Limiti delle liste */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Le liste vengono espresse tra parentesi quadre che ne racchiudono gli elementi; gli elementi al loro interno vengono separati da virgole.

Esempi:
<lsl>[0,1,2,3,4]

["Sì","No","Magari"]</lsl>

(Nota: per essere chiari con coloro che hanno altri precedenti in programmazione, non esistono array nel LSL: solo liste.)

====Tipi di dati differenti====

Non tutti gli elementi in una lista devono essere lo stesso tipo di elemento. Nella stessa lista, potete immagazzinare stringhe, numeri interi, numeri frazionari, vettori, ecc. proprio fianco a fianco.

Esempio:
<lsl>//una lista con un numero intero, un numero frazionario, una stringa e un vettore.
[1,14.154,"Non è divertente?",<0,0,0>]</lsl>

Comunque, una lista non può contenere un'altra lista (es. non potete nidificarle).

<lsl>[1, "uno", 2, "due"] + [3, "tre"] restituisce [1, "uno", 2, "due", 3, "tre"]</lsl>
non
<lsl>[1, "uno", 2, "due", [3, "tre"]]</lsl>

Quando aggiungete un elemento a una lista, questa ricorda automaticamente che tipo di dato era quel valore.

Generalmente, poiché state aggiungendo qualcosa a una lista, sapete che tipo di dato sta in un determinato posto della lista, e lo estraete dalla lista con l'apposita funzione llList2<tipo> come ad esempio [[llList2String]], [[llList2Vector]], ecc. (più tardi ne diremo dell'altro).

Se per qualche motivo, però, dovete provare che tipo di dato sia un elemento in una lista, potete usare la funzione [[llGetListEntryType]].

Suggerimento! Quando aggiungete un numero [[float]] (frazionario) a una lista, aggiungetelo sempre con un punto decimale (es. 1.0 invece di 1) per essere sicuri che sia conservato come frazionario.

Le liste possono essere tramutate direttamente in stringhe
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // risultato: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

oppure potete usare una condizione [[do while]] per pronunciare separatamente ciascun elemento della lista
<lsl>default
{
touch_start(integer numero_totale)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Operazioni comuni con le liste ===
====Contare la posizione in una lista Vs. lunghezza della lista====

All'inizio è importante notare quanto segue (ciò potrebbe far inciampare persino le menti esperte quando sono stanche per la battaglia):

<lsl>["Sì","No","Magari"]</lsl>

La lunghezza di questa lista è 3, perché contiene 3 elementi. La lunghezza di una lista è restituita dalla funzione [[llGetListLength]]() :

<lsl>integer lunghezza = llGetListLength(miaLista);</lsl>

MA, il conteggio per determinare la posizione di un elemento nella sua lista (ovvero "indicizzazione") parte da 0 -- NON da 1.

La posizione di "Sì" nella lista precedente è 0, "No" è alla posizione 1, e "Magari" è alla posizione 2.

Conseguentemente, se avete 7 elementi in una lista, l'ultimo oggetto nella lista sarà alla posizione 6.

Perciò per ritrovare l'ultimo elemento in una lista, senza dover conoscere in anticipo in quale posizione sia, potete fare così:

<lsl>integer lunghezza = llGetListLength(miaLista);
string oggetto = llList2String(miaLista,lunghezza - 1);</lsl>

====Limiti delle liste====

''(Dal 20 febbraio 2011 questi limiti non sembrano essere in vigore sia per LSL che per Mono.)''

Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.

Comunque, al momento di compilare (ovvero salvare), c'è un limite di 72 elementi per le liste predefinite incorporate nello script.

XXXXXXXXXXX Traduzione da terminare. XXXXXXXXXXX

However, at compile (aka save) time, there is a 72 element limit to pre-defined lists hardcoded in the script. Such long, predefined lists are common, for example, when someone is offering the user a plethora of colour choices.

Tip! If you really need 72 or more such choices in a pre-defined list, just make 2 (or more) lists that don't upset the compiler, and join them together in state_entry() or wherever appropriate:

<lsl>biggerlist = biglist01 + biglist02;</lsl>

====Adding an Element to a list====

There are several ways used to add an element to an existing list via prepending/appending:

# myList = '''['''new_item''']''' + myList; '''Best method for Mono-LSL'''
# myList = myList + [new_item];
# myList += [new_item];
# myList = (myList=[]) + myList + [new_item];
# myList = myList + new_item;
# myList += new_item;
# myList = (myList=[]) + myList + new_item; '''Best method for LSO-LSL'''

=====Notes=====
* As of 8/8/2009 Method 1 gives significant savings over any other method used in Mono-LSL.
** Note that prepending the new_item '''without''' brackets '''negates''' any memory savings in Mono-LSL.
** Method 1 will consume more memory than other methods in LSO-LSL.
* As of 8/8/2009 Method 7 returns the best value for savings in LSO-LSL.
** Method 7 is better than Method 4 due to the fact that Method 7 takes up less script overhead.
** Method 7 test script compiled to have a start memory of 15878, while Method 4 compiled to have a start memory of 15871. As a result Method 7 had more free memory than Method 4 at the end of the test operation.
* Methods 2 & 3 compile to the same thing.
* Methods 5 & 6 compile to the same thing.
* Methods 5, 6 & 7 have a bytecode savings over methods 2, 3 & 4 respectively, though there is an LSO-LSL VM bug that causes the string & key typecasts to not stick properly: {{Jira|SVC-1710}}.
* Methods 4 & 7 can result in a considerable memory savings in LSO-LSL over methods 2, 3, 5 & 6 (it helps reduce heap fragmentation, which would otherwise result in unusable blocks of heap memory){{Footnote|This method was invented and popularized by {{User|Strife Onizuka}}|This method was invented and popularized by Strife Onizuka}}. In Mono-LSL it provides no significant memory advantage or disadvantage.
** Depending upon the situation (in LSO-LSL) this method may not provide any advantage what so ever. If in doubt profile the script with and without using this method.

====Joining Lists (aka Concatenation)====

Lists can be joined simply by using the + sign:

<lsl>newlist = list01 + list02;

newlist = list01 + ["red","brown",<0,0,0>];</lsl>

Note: The above example actually creates 3 lists in memory while the command runs, even though just one is returned. This can affect memory usage.

====Clearing a List====

To clear a list, set it equal to two square, empty brackets like this:

<lsl>myList = [];</lsl>

====Passing a List Into a Function====

Passing a list into a function is little different than passing any other data type, however, there are some useful cases to be aware of:

<lsl>myList = llListReplaceList(myList, ["myString"], 2, 2);</lsl>

In the above code, we call [[llListReplaceList]](), an innocent enough operation, however, due to the way passing of lists, and functions such as llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() and [[llListSortList()]] (and others), work, you can end up using two, three, or even four times the amount of memory required to store your list, just by calling that function! To avoid this problem, we can use a small piece of optimisation; if you know that the list you're passing into such a function will never be read again (for example if the result of the function will overwrite the list) then we can do this:

<lsl>myList = llListReplaceList((myList = []) + myList, ["myString"], 2, 2);</lsl>

The effect of this is to greatly reduce the memory usage, in both LSO-LSL and Mono VMs, and also reduce the fragmentation of memory. This can also work for other cases other than function-calls, for example when concatenating lists (above), you may find that this nearly eliminates any memory problem:

<lsl>list list1 = ["a", "b", "c"];
list2 = ["d", "e", "f"];
list3 = (list1 = list2 = []) + list1 + list2;</lsl>

====Processing a List Into Another List====

A more complex case, but sometimes when processing a large list you may find that you are producing a similarly large list as a result. In such cases there is a very large risk of running out of memory. As a result, in any case where you know you will, or might, be working on a particularly large list, it will often be worth manipulating them similarly to:

<lsl>list myOutput = [];

integer i = 0; integer x = myList != [];
for (; i < x; ++i) {
if (i > 10) { // Prune list every 10 elements
myList = llDeleteSubList((myList = []) + myList, 0, i - 1);
x -= i;
i = 0;
}

// Do some work here:
myOutput += llList2List(myList, i, i); // A silly bit of example work
}</lsl>

This method (deleting every few list entries or strides) is preferable to deleting an entry every loop, as the cost of calling llDeleteSubList() is very high. It is up to the scripter to decide what their optimal chunk-size is for pruning an input list, as you will need to balance memory use with delete cost.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}