Costruttori Table

Costruttori sono espressioni che creare e inizializzare le tabelle. Essi sono una caratteristica distintiva di Lua e uno dei suoi meccanismi più utili e versatili.

Il costruttore più semplice è il costruttore vuoto, {}, che crea un tavolo vuoto; abbiamo visto prima. Costruttori inizializzare anche array (chiamati anche sequenze o liste). Per esempio, l'istruzione

giorni = {"Domenica", "Lunedi", "Martedì", "Mercoledì",
"Giovedi", "Venerdì", "Sabato"}
inizializzare giorni [1] con la stringa "Domenica" (il primo elemento è sempre indice 1, non 0), giorni [2] con "Lunedi", e così via:
stampa (giorni [4]) -> Mercoledì

Costruttori non hanno bisogno di usare espressioni solo costanti. Possiamo usare qualsiasi tipo di espressione per il valore di ogni elemento. Ad esempio, possiamo costruire una breve tabella di seno come

tab = {sin (1), il peccato (2), il peccato (3), il peccato (4),
sin (5), il peccato (6), il peccato (7), il peccato (8)}

Per inizializzare una tabella da utilizzare come record, Lua offre la seguente sintassi:

a = {x = 0, y = 0}
che è equivalente a
a = {}; ax = 0; y = 0
Non importa quale costruttore usiamo per creare una tabella, possiamo sempre aggiungere e rimuovere altri campi di qualsiasi tipo ad esso:

w = {x = 0, y = 0, label = "console"}
x = {sin (0), il peccato (1), il peccato (2)}
w [1] = "un altro campo"
xf = w
stampa (w ["x"]) -> 0
stampa (w [1]) -> un altro campo
stampa (xf [1]) -> un altro campo
wx = nil - rimuovere campo "x"

Cioè, tutti i tavoli sono creati uguali; costruttori riguardano solo loro inizializzazione.
Ogni volta che Lua valuta un costruttore, crea e inizializza una nuova tabella. Di conseguenza, siamo in grado di utilizzare le tabelle per implementare liste collegate:

list = nil
per la linea in io.lines () fare
list = {prossimo = lista, valore = linea}
fine

Questo codice legge linee dallo standard input e li memorizza in una lista collegata, in ordine inverso. Ogni nodo della lista è una tabella con due campi: valore, con i contenuti di linea, e prossimi, con un riferimento al nodo successivo. Il seguente codice stampa il contenuto della lista:

l = lista
mentre l do
stampa (l.value)
l = l.next
fine

(Perché abbiamo implementato la nostra lista come una pila, le linee verranno stampate in ordine inverso.) Anche se istruttivo, quasi non utilizziamo il sopra attuazione nei programmi reali Lua; liste sono meglio implementate come array, come vedremo nel Capitolo 11.
Possiamo mescolare record di stile e l'elenco in stile inizializzazioni nello stesso costruttore:

polyline = {color = "blue", spessore = 2, NPOINTS = 4,
{x = 0, y = 0},
{x = -10, y = 0},
{x = -10, y = 1},
{x = 0, y = 1}
}
L'esempio precedente illustra anche come possiamo costruttori nido per rappresentare strutture di dati più complesse. Ciascuno degli elementi polilinea [1], , polyline [4] è una tabella che rappresenta un record:

stampa (polyline [2] .x) -> -10

Queste due forme costruttori hanno i loro limiti. Ad esempio, non è possibile inizializzare i campi con gli indici negativi, o con gli indici di stringa che non sono gli identificatori adeguati. Per tali esigenze, c'è un altro più generale, il formato. In questo formato, scriviamo esplicitamente l'indice da inizializzare come espressione, tra parentesi quadre:

opnames = {["+"] = "add", ["-"] = "sub",
["*"] = "Mul" ["/"] = "div"}

i = 20; s = "-"
a = {[i + 0] = s, [i + 1] = s..s, [i + 2] = s..s..s}

stampa (opnames [s]) -> sub
stampa (un [22]) -> ---
Che la sintassi è più ingombrante, ma più flessibile anche: Sia il list-style e le forme record stile sono casi speciali di questo più generale. Il costruttore
{x = 0, y = 0}
è equivalente a
{["x"] = 0, ["y"] = 0}
e il costruttore
{"rosso", "verde", "blu"}
è equivalente a
{[1] = "red", [2] = "verde", [3] = "blue"}
Per coloro che veramente vogliono che i loro array a partire da 0, non è difficile scrivere il seguente:

giorni = {[0] = "Domenica", "Lunedi", "Martedì", "Mercoledì",
"Giovedi", "Venerdì", "Sabato"}

Ora, il primo valore, "Domenica", è indice 0. Questo lo zero non influisce gli altri campi, ma "Lunedi" va naturalmente a indice 1, perché è il primo valore lista nel costruttore; gli altri valori seguono. Nonostante questa struttura, non mi consiglia l'uso di array a partire da 0 a Lua. Ricordate che la maggior parte delle funzioni presuppongono che gli array partono indice 1, e quindi non gestire correttamente tali matrici.
Si può sempre mettere una virgola dopo l'ultima voce. Queste le virgole finali sono opzionali, ma sono sempre vali

a = {[1] = "red", [2] = "verde", [3] = "blu",}

Tale flessibilità rende più facile scrivere programmi che generano tabelle Lua, perché non hanno bisogno per gestire l'ultimo elemento come un caso speciale.
Infine, è sempre possibile utilizzare un punto e virgola al posto di una virgola in un costruttore. Noi di solito riserviamo il punto e virgola per delimitare le diverse sezioni in un costruttore, ad esempio per separare la parte lista dalla sua parte verbale:

{x = 10, y = 45; "uno due tre"}