Category:LSL List/it - Revision history

Strife Onizuka at 18:47, 27 April 2012

2012-04-27T18:47:45Z

← Older revision		Revision as of 11:47, 27 April 2012
Line 1:		Line 1:
	{{LSL Header\|ml=*}}{{LSLC\|}}{{LSLC\|Types}}		{{LSL Header\|ml=*}}{{LSLC/it\|}}{{LSLC/it\|Types}}
	{{RightToc}}		{{RightToc}}
	Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.		Una lista è un tipo speciale di dati che può contenere nessuno o più elementi.

Violet Hammerer: /* Extended List Operations */

2012-01-05T14:24:02Z

Extended List Operations

← Older revision		Revision as of 07:24, 5 January 2012
Line 220:		Line 220:
	\|}		\|}

	== ~~Extended List Operations~~ ==		== Operazioni estese con le liste ==

	~~These functions have been created and contributed by~~ LSL ~~users to perform operations not covered by built-in~~ LSL ~~functions~~.		Queste funzioni sono state create e fornite da utenti del LSL per eseguire operazioni non contemplate dalle funzioni LSL ufficiali.


Line 228:		Line 228:
	\|+		\|+
	\|-{{Hl2}}		\|-{{Hl2}}
	!~~function~~		!funzione
	!~~purpose~~		!scopo
	\|-		\|-
	\|\| [[ListCast]] \|\| ~~Processes a list so that its contents are of a single-type~~.		\|\| [[ListCast]] \|\| Elabora una lista così che i suoi contenuti siano di un tipo singolo.
	\|-		\|-
	\|\| [[List_cast]] \|\| ~~Processes~~ a ~~list so that its contents are converted from strings to their respective types~~.		\|\| [[List_cast]] \|\| Elabora una lista così che i suoi contenuti siano convertiti da stringa a stringa nei loro tipi rispettivi.
	\|-		\|-
	\|\| [[ListCompare]] \|\| ~~Compares two lists for equality~~		\|\| [[ListCompare]] \|\| Compara due liste per l'uguaglianza.
	\|-		\|-
	\|\| [[ListItemDelete]] \|\| ~~Removes one element from a list~~.		\|\| [[ListItemDelete]] \|\| Rimuove un elemento da una lista.
	\|-		\|-
	\|\| [[ListKeyCase]] \|\| ~~Changes the values of the whole list into uppercase or lowercase based on input~~		\|\| [[ListKeyCase]] \|\| Cambia i valori dell'intera lista in maiuscolo o minuscolo basandosi sui dati in entrata
	\|-		\|-
	\|\| [[ListToWholeNumbers]] \|\| ~~Given a list of floats~~, ~~converts them all to whole numbers (aka integers~~.)		\|\| [[ListToWholeNumbers]] \|\| Data una lista di numeri frazionari, li converte tutti in numeri interi.
	\|-		\|-
	\|\| [[ListXorY]] \|\| ~~Join two lists to make one new combined list~~, ~~while also eliminating any resulting duplicates in the new list~~.		\|\| [[ListXorY]] \|\| Unisce due liste per creare una nuova lista combinata, eliminando nel frattempo ciascun dato duplicato dalla nuova lista.
	\|-		\|-
	\|\| [[ListXandY]] \|\| ~~This function examines two lists~~, ~~and returns a new list composed of the elements that both lists have~~ in ~~common~~.		\|\| [[ListXandY]] \|\| Questa funzione esamina due liste, e restituisce una nuova lista composta dagli elementi che entrambe le liste hanno in comune.
	\|-		\|-
	\|\| [[ListXnotY]] \|\| ~~Show what~~ x ~~list has that~~ y ~~list is missing~~.		\|\| [[ListXnotY]] \|\| Mostra ciò che la lista x possiede che alla lista y manca.
	\|-		\|-
	\|\| [[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~~.		\|\| [[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]] \|\| ~~Answers the question~~: ~~is list~~ X ~~identical to list~~ Y?		\|\| [[ListXequY]] \|\| Risponde alla domanda: la lista X è identica alla lista Y?
	\|-		\|-
	\|\| [[ListXneqY]] \|\| ~~Answers the question~~: ~~is list~~ X ~~different from list~~ Y?		\|\| [[ListXneqY]] \|\| Risponde alla domanda: la lista X è diversa dalla lista Y?
	\|-		\|-
	\|\| [[ListItemReplace\|Replace]] \|\| ~~Replaces a single occurrence of something~~ in ~~a list with something else that you specify~~.		\|\| [[ListItemReplace\|Replace]] \|\| Sostituisce una singola istanza di qualcosa in una lista con qualcos'altro specificato da voi.
	\|-		\|-
	\|\| [[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~~.		\|\| [[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 ]] \|\| ~~Given a list of elements~~, ~~returns a list of only the unique individual elements in that list~~.		\|\| [[ListUnique ]] \|\| Data una lista di elementi, restituisce solo gli elementi unici di quella lista.
	\|-		\|-
	\|\| [[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~~.		\|\| [[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]] \|\| ~~A way to emulate the behavior of a 2 dimensional~~ array.		\|\| [[2D Pseudo-Array]] \|\| Un metodo per emulare il comportamento di un assortimento (orig. "array", ndT) bidimensionale.
	\|}		\|}

Violet Hammerer: /* Strided lists */

2012-01-05T14:00:01Z

Strided lists

← Older revision		Revision as of 07:00, 5 January 2012
Line 170:		Line 170:
	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.		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~~ ==		== Liste raggruppate ==


	~~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.		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.

	~~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~~.		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.

	~~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~~."		Le liste raggruppate vi permettono di immagazzinare parti di dati correlati in gruppi. Potete determinare quante parti di dati debbano esserci in ciascun "raggruppamento".

	~~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~~:		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 ~~demographics~~ = ["~~John Adams~~", "~~male~~", "2007-06-22", "~~Shirley Bassey~~", "~~female~~", "2005-11-02", "~~Matt Damon~~", "~~male~~", "2008-05-19"];</lsl>		<lsl>list anagrafica = ["Mario Rossi", "maschio", "2007-06-22", "Maria Bianchi", "femmina", "2005-11-02", "Tizio Caio", "maschio", "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~~.		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.

	~~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~~.)		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).

	~~To add another person to the above list~~, ~~you would do this~~:		Per aggiungere un'altra persona alla lista qui sopra, dovreste fare così:

	<lsl>~~demographics~~ += ["~~Dorthy Lamour~~", "~~female~~", "2010-01-22"];</lsl>		<lsl>anagrafica += ["Maria Rossi", "femmina", "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~~.		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.

	~~Here are the tools we do have for strided lists~~:		Ecco gli strumenti a nostra disposizione per le liste raggruppate:


	~~The following three~~ (~~as of July~~ 2008) ~~native LSL functions can be used with strided lists~~:		Le funzioni native LSL (nel luglio 2008) seguenti possono essere utilizzate con le liste raggruppate:

	*[[llList2ListStrided]]		*[[llList2ListStrided]]
Line 204:		Line 204:


	~~Here are some additional, user-created functions for working with strided lists~~:		Ecco alcune funzioni aggiuntive create dagli utenti per lavorare con le liste raggruppate:

	{\|{{Prettytable}}		{\|{{Prettytable}}
	\|+		\|+
	\|-{{Hl2}}		\|-{{Hl2}}
	!~~function~~		!funzione
	!~~purpose~~		!scopo
	\|-		\|-
	\|\| [[ListStridedMove]] \|\| ~~Moves something~~ in ~~a strided list to another place~~ in ~~the strided list~~.		\|\| [[ListStridedMove]] \|\| Sposta qualcosa in una lista raggruppata in un altro posto nella lista.
	\|-		\|-
	\|\| [[ListStridedRemove]] \|\| ~~Removes part of a strided list~~.		\|\| [[ListStridedRemove]] \|\| Rimuove parte di una lista raggruppata.
	\|-		\|-
	\|\| [[ListStridedUpdate]] \|\| ~~Updates part of a strided list~~.		\|\| [[ListStridedUpdate]] \|\| Aggiorna parte di una lista raggruppata.
	\|-		\|-
	\|}		\|}

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

2011-12-31T14:48:39Z

Elaborare una lista in un'altra lista

← Older revision		Revision as of 07:48, 31 December 2011
Line 165:		Line 165:

	// Qui esegue lo stesso lavoro:		// Qui esegue lo stesso lavoro:
	mioRisultato += llList2List(miaLista, i, i); // ~~A silly bit of example work~~		mioRisultato += llList2List(miaLista, i, i); // Un lavoro esemplificativo un po' futile
	}</lsl>		}</lsl>

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

2011-12-31T14:47:24Z

Processing a List Into Another List

← Older revision		Revision as of 07:47, 31 December 2011
Line 150:		Line 150:
	lista3 = (lista1 = lista2 = []) + lista1 + lista2;</lsl>		lista3 = (lista1 = lista2 = []) + lista1 + lista2;</lsl>

	====~~Processing a List Into Another List~~====		====Elaborare una lista in un'altra lista====

	~~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~~:		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 ~~myOutput~~ = [];		<lsl>list mioRisultato = [];

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

	// ~~Do some work here~~:		// Qui esegue lo stesso lavoro:
	~~myOutput~~ += llList2List(~~myList~~, i, i); // A silly bit of example work		mioRisultato += llList2List(miaLista, i, i); // A silly bit of example work
	}</lsl>		}</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~~.		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 ==		== Strided lists ==

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

2011-12-31T14:35:04Z

Passing a List Into a Function

← Older revision		Revision as of 07:35, 31 December 2011
Line 134:		Line 134:
	<lsl>miaLista = [];</lsl>		<lsl>miaLista = [];</lsl>

	====~~Passing a List Into a Function~~====		====Passare una lista in una funzione====

	~~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~~:		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>~~myList~~ = llListReplaceList(~~myList~~, ["~~myString~~"], 2, 2);</lsl>		<lsl>miaLista = llListReplaceList(miaLista, ["miaStringa"], 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~~:		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>~~myList~~ = llListReplaceList((~~myList~~ = []) + ~~myList~~, ["~~myString~~"], 2, 2);</lsl>		<lsl>miaLista = llListReplaceList((miaLista = []) + miaLista, ["miaStringa"], 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~~:		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 ~~list1~~ = ["a", "b", "c"];		<lsl>list lista1 = ["a", "b", "c"];
	~~list2~~ = ["d", "e", "f"];		lista2 = ["d", "e", "f"];
	~~list3~~ = (~~list1~~ = ~~list2~~ = []) + ~~list1~~ + ~~list2~~;</lsl>		lista3 = (lista1 = lista2 = []) + lista1 + lista2;</lsl>

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

Violet Hammerer: /* Clearing a List */

2011-12-31T14:22:55Z

Clearing a List

← Older revision		Revision as of 07:22, 31 December 2011
Line 128:		Line 128:
	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.		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~~====		====Svuotare una lista====

	~~To clear~~ a ~~list, set it equal to two square~~, ~~empty brackets like this~~:		Per svuotare una lista, impostatela per essere uguale a due parentesi quadre vuote, in questo modo:

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

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

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

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

2011-12-31T14:20:55Z

Joining Lists (aka Concatenation)

← Older revision		Revision as of 07:20, 31 December 2011
Line 118:		Line 118:
	** 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.		** 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~~)====		====Unire le liste (ossia la concatenazione)====

	~~Lists can be joined simply by using the~~ + ~~sign~~:		Le liste possono essere unite semplicemente usando il segno + :

	<lsl>~~newlist~~ = ~~list01~~ + ~~list02~~;		<lsl>nuovalista = lista01 + lista02;

	~~newlist~~ = ~~list01~~ + ["~~red~~","~~brown~~",<0,0,0>];</lsl>		nuovalista = lista01 + ["rosso","marrone",<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.~~

			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====		====Clearing a List====

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

2011-12-31T14:15:50Z

Adding an Element to a list

← Older revision		Revision as of 07:15, 31 December 2011
Line 93:		Line 93:
	<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>		<lsl>listapiùgrande = listagrande01 + listagrande02;</lsl>

	====~~Adding an Element to~~ a ~~list~~====		====Aggiungere un elemento a una lista====

	~~There are several ways used to add an element to an existing list via prepending/appending~~:		Esistono svariati modi usati per aggiungere un elemento a una lista esistente tramite l'aggiunta all'inizio o alla fine:

	# ~~myList~~ = '''['''~~new_item~~''']''' + ~~myList~~; '''~~Best method for~~ Mono-LSL'''		# miaLista = '''['''nuovo_oggetto''']''' + miaLista; '''Metodo migliore per Mono-LSL'''
	# ~~myList~~ = ~~myList~~ + [~~new_item~~];		# miaLista = miaLista + [nuovo_oggetto];
	# ~~myList~~ += [~~new_item~~];		# miaLista += [nuovo_oggetto];
	# ~~myList~~ = (~~myList~~=[]) + ~~myList~~ + [~~new_item~~];		# miaLista = (miaLista=[]) + miaLista + [nuovo_oggetto];
	# ~~myList~~ = ~~myList~~ + ~~new_item~~;		# miaLista = miaLista + miaLista;
	# ~~myList~~ += ~~new_item~~;		# miaLista += nuovo_oggetto;
	# ~~myList~~ = (~~myList~~=[]) + ~~myList~~ + ~~new_item~~; '''~~Best method for~~ LSO-LSL'''		# miaLista = (miaLista=[]) + miaLista + nuovo_oggetto; '''Metodo migliore per LSO-LSL'''

	=====~~Notes~~=====		=====Note=====
	* ~~As of 8/~~8/2009 ~~Method 1 gives significant savings over any other method used~~ in Mono-LSL.		* Dall'8 agosto 2009 il primo metodo permette risparmi significativi rispetto a qualunque altro metodo utilizzato in Mono-LSL.
	** ~~Note that prepending the new_item~~ '''~~without~~''' ~~brackets~~ '''~~negates~~''' ~~any memory savings~~ in Mono-LSL.		** Notate che aggiungere all'inizio il nuovo_oggetto '''senza''' parentesi '''nega''' qualsiasi risparmio di memoria in Mono-LSL.
	** ~~Method 1 will consume more memory than other methods~~ in LSO-LSL.		** Il primo metodo consumerà più memoria degli altri metodi in LSO-LSL.
	* ~~As of 8/~~8/2009 ~~Method 7 returns the best value for savings~~ in LSO-LSL.		* Dall'8 agosto 2009 il settimo metodo restituisce il miglior valore per risparmiare in LSO-LSL.
	** ~~Method 7 is better than Method 4 due to the fact that Method 7 takes up less~~ script ~~overhead~~.		** Il settimo metodo è migliore del quarto metodo perché il settimo richiede una minor congestione dello script.
	** ~~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~~.		** 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.
	* ~~Methods~~ 2 & 3 ~~compile to the same thing~~.		* I metodi 2 e 3 compilano nella stessa cosa.
	* ~~Methods~~ 5 & 6 ~~compile to the same thing~~.		* I metodi 5 e 6 compilano nella stessa cosa.
	* ~~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}}.		* 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}}.
	* ~~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~~.		* 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.
	** ~~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~~.		** 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)====		====Joining Lists (aka Concatenation)====

Violet Hammerer: /* Limiti delle liste */

2011-12-31T13:45:50Z

Limiti delle liste

← Older revision		Revision as of 06:45, 31 December 2011
Line 87:		Line 87:
	Mentre uno script è in esecuzione, una lista può diventare crescere dinamicamente tanto larga quanto necessario, limitata solo dal quantitativo di memoria disponibile nello script.		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.		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.

	~~XXXXXXXXXXX Traduzione da terminare. XXXXXXXXXXX~~		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>
	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====		====Adding an Element to a list====