Difference between revisions of "Category:LSL List/it"

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:

1. miaLista = [nuovo_oggetto] + miaLista; Metodo migliore per Mono-LSL
2. miaLista = miaLista + [nuovo_oggetto];
3. miaLista += [nuovo_oggetto];
4. miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
5. miaLista = miaLista + miaLista;
6. miaLista += nuovo_oggetto;
7. 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: 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)^[1]. 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 struct), 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 gruppo 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 primo elemento 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:

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.