Array in Visual dBASE 
parte prima 
ultima modifica : 21 marzo 1999 
Ken Mayer, 
dBASE, Inc. 
Traduzione in Italiano di Antonio Campagna - Ottobre 2001

Gli obiettivi di questo documento sono: 

• un tutorial sull'uso degli array in Visual dBASE, dando uno sguardo alle basi di quello che è un array  e come usarne uno; 

• un'introduzione sulla gestione degli array tramite le funzioni predefinite di Visual dBASE (solo le basi).

Se volete maggiori informazioni rispetto a quelle fornite da questo documento esaminate ARRAY2.HTM.  In più, il manuale  di riferimento al linguaggio  e la guida in linea di Visual dBASE possono essere piuttosto utili. 

Che cosa é un Array? 

Un array in Visual dBASE è un oggetto usato per memorizzare dati. In alcuni casi si può usare un array per emulare una tabella in memoria. Un array usa un singolo "nome" (identificatore), per riferirsi a locazioni di memoria multiple. Un semplice array contiene una "dimensione" o colonna di informazioni. 

In Visual dBASE un array è detto "irregolare", perché in esso potete memorizzare diversi tipi di dati. 
È probabile che in un elemento si memorizzi una data, in un altro un numero e in un terzo un valore carattere - dBASE non se ne cura... 
... almeno finché non tentate di ordinare i dati o effettuate operazioni di ricerca, in tal caso potreste avere dei problemi. 
In un  array di dBASE si possono memorizzare anche altri array. Ci sono due modi per fare questo: 

• il primo consiste nel memorizzare un array come "elemento" in un altro array; 

• il secondo é definire un array multi-dimensionale, cioè un array di array. 

Come dicevamo prima è molto importante comprendere che un array in Visual dBASE è un oggetto.   

Gli sviluppatori di Visual dBASE nel implementazione del linguaggio di programmazione, hanno ampliato le capacità degli array rispetto ai giorni di dBASE IV. 

Parti di un Array
 
Un array deve avere le seguenti caratteristiche: 

Un Nome: in questo documento userò una convenzione (detta notazione dBASE ungherese; in onore del leggendario programmatore Charles Simonyi) la quale  specifica che i nomi degli array siano preceduti da un prefisso che ne indica il tipo di dato, nel caso specifico la lettera "a" (ad esempio, aMioArray).
La maggior parte delle volte, un array richiede un nome. C'è una struttura speciale in Visual dBASE chiamata "Array Letterale" che qui sarà esaminata brevemente (si approfondirà il discorso nel documento ARRAY2.HTM), che non richiede un nome. 

Elementi: gli elementi sono i contenitori, o forse direste le 'celle', usate per memorizzare i dati in un array.

Dimensioni: gli array possono avere una singola dimensione (solo righe (una colonna)), due dimensioni (righe e colonne) o anche tre o più dimensioni. Potete pensare ad un array tridimensionale come il "cubo magico". Un altro modo di pensare ad un array a tre (o più) dimensioni, è un "array di array" . Non c'è un modo facile di visualizzare qualsiasi array oltre la "terza dimensione". Per gli scopi di questi documenti (Array?. HTM) non utilizzeremo array con più di due dimensioni. 

Righe: tutti gli array hanno righe. Una riga può contenere qualsiasi tipo di dato supportato da Visual dBASE, incluso un altro array (array irregolari). 

Colonne: tutti gli array hanno almeno una colonna. Se l'array ha solamente una colonna, di solito si considera che sia un array uni-dimensionale. Se l'array ha due o più colonne, è almeno un array bi-dimensionale. Un array bi-dimensionale è paragonabile ad una tabella, ogni colonna è comparabile ad un campo, ed ogni riga è comparabile ad un record. 

Subscripts: I subscripts sono indici agli elementi contenuti nell'array. Se abbiamo un array formato da una singola colonna, con cinque righe, tramite il subscript puntiamo a ciascuna riga. Se abbiamo un array con più colonne, un subscript si riferisce alla riga, l'altro alla colonna. Quindi tramite i subscript accediamo ad ogni elemento dell'array. Per differenziare un array da una funzione, usiamo le parentesi quadrate (chiamate nel guida "riferimento al linguaggio": Operatori Indice) intorno il subscript(s). 

Esempio 1.

Array a singola colonna

Per riferirsi alla riga 3 di un array come quello precedente, dovremmo usare la seguente sintassi:

aCity[3] 

Array con 2 colonne

In un array a due (o più ) colonne, per accedere ad uno specifico elemento abbiamo bisogno di riferirci sia alla riga, sia alla colonna, così per puntare alla popolazione di New York, useremo la seguente sintassi: 

aCity[3,2] 

Il primo subscript (3) punta alla riga, il secondo (2) alla colonna. 

L'utilità degli Array 

Come detto precedentemente, tramite l'uso di un array avete un singolo "nome" che fa riferimento ad un elenco. Altra cosa di notevole importanza è che un array può essere "dinamico", cioè  potete aggiungere o rimuovere facilmente elementi nell'array, potete ordinare i dati contenuti dell'array  e potete scorrere un array, per vedere se contiene un determinato valore. Provate a fare tutto questo con l'elenco di variabili di memoria seguente: 

City1 = "San Francisco" 
City2 = "Los Angeles" 
City3 = "New York" 
City4 = "Miami" 
City5 = "Sydney" 

Le seguenti tre linee di codice possono visualizzare tutti i nomi di città da un array, osservate che il codice è molto più efficiente e compatto:

for i = 1 to ( aCity.size / aCity.dimensions )

? aCity[ i, 1 ]

next 

Se usassimo una variabile per ogni nome di città, dovremmo avere una linea di codice per stampare ogni nome di città, le tre istruzioni precedenti sono sicuramente molto meglio. 
In più, immagazzinando i valori in memoria, processare una lista è una operazione molto più veloce  rispetto alla stessa utilizzando una tabella. 

Potete usare anche un array per emulare una tabella. Se usate un array bi-dimensionale, le righe possono essere equivalenti ai record e le colonne ai campi. Pensate che un array sia simile ad un foglio di calcolo elettronico, questa similitudine potrebbe aiutarvi maggiormente. La parte divertente è che con il moderno software di foglio elettronico, potete creare fogli di calcolo elettronico tridimensionali (pagine multiple) ciò può essere fatto molto bene anche con gli array in Visual dBase. 

Come definisco un Array? 

Avete bisogno di dire a dBase che userete un array. Questo vuol dire che dovete:

• dare un nome;

• istanziare un array. 

In Visual dBase, un array è un oggetto. Questo è piuttosto utile se utilizzate la sintassi OOP per definire un array. Ci sono almeno un paio di modi di definire un array. Il metodo di programmazione procedurale standard è: 

DECLARE nomearray [righe,colonne] 

Il  nomearray  è l'identificatore tramite il quale farete riferimento a tutti  gli elementi memorizzati nell'array. Il numero di righe è richiesto, il numero di colonne si richiede solamente se state definendo un array con colonne multiple. Notate che questo metodo da alcuni è considerato obsoleto e voi probabilmente dovreste usare la nuova sintassi, mostrata sotto. La sintassi DECLARE eventualmente può essere abbandonata dirigendosi verso una mentalità OOP. 

Voi dovreste usare la sintassi OOP con dBase, la quale fra le altre cose vi dà un array dinamico: 

nomearray = NEW ARRAY() 

Se volete l'array può essere dichiarato con una specifica dimensione ad es.: 

aCity = NEW ARRAY(5,2) 

L'istruzione precedente stabilisce che l'array conterrà 10 elementi, 5 righe e 2 colonne. 
C'è un altro modo di definire  un array uni-dimensionale, ma questo già presume che sappiate a priori ciò che l'array dovrà contenere. Usando questo modo state creando  un "Array Letterale" (maggiori informazioni in ARRAY2.HTM): 

aCity = {"San Francisco","Los Angeles","New York","Miami","Sydney"} 

Un array letterale usa le parentesi graffe e ciascun elemento dell'array è separato da una virgola. 
 
Adesso che abbiamo definito l'Array, come fare ad inserire dati? 

Un array è inutile senza dati. Una cosa interessante è che se non "popolate" l'array, dBase automaticamente immette un valore logico "falso", in ogni elemento a cui non è assegnato un altro valore, almeno questo è quello che sembra. In realtà questa è una cella vuota e se usate la funzione dBase Empty(), essa restituirà un valore vero, per ogni cella a cui non è stata assegnata un valore. Ciò può essere utile, ma  alle volte può anche essere un po' noioso, quando state tentando di compiere specifici compiti (come ordinare un array). Per esempio, se tentate di ordinare su valori carattere, numerico o data e ad alcuni degli elementi non sono stati assegnati valori o sono stati cancellati (vedete sotto), otterrete un messaggio di errore "Data type mismatch". 

Per gli obiettivi di questo documento ci sono allegati due piccoli programmi nel file .zip: SHOW1.PRG e SHOW2.PRG. Lo scopo di questi programmi è mostrare i contenuti dell'array su cui state attualmente lavorando, così che potete vedere l'effetto dei comandi che  state utilizzando. Il primo prg è utile per array uni-dimensionali, il secondo è per array a colonne multiple. 
Per usare i suddetti programmi usate la seguente sintassi

do show1 with "aCity" 
oppure 
do show2 with "aCity" 

Dove "aCity" è il nome dell'array che state esaminando. 

Assegnare valori ad un array può essere abbastanza semplice, ad esempio: 

aCity[1] = "San Francisco" // richiede che teniate conto del subscript 
oppure 
aCity.Add("San Francisco") // usa il metodo Add() 
oppure 
aCity = {"San Francisco","Los Angeles","New York","Miami","Sydney"} 

oppure abbastanza interessante, potete estrarre le informazioni da una tabella: 

COPY TO ARRAY aCity FIELDS NomeTabella->City 

Il comando precedente richiede che: 

• l'array sia definito; 
• la tabella sia aperta. 

Per maggiori informazioni su COPY TO ARRAY, vedete nel manuale di riferimento al linguaggio oppure nella guida in linea (HELP COPY TO ARRAY). Argomenti correlati: APPEND FROM ARRAY (memorizza il contenuto di un array in una tabella) e REPLACE FROM ARRAY (sostituisce il contenuto di un record con il contenuto di un array) 
NOTA: I comandi COPY TO ARRAY (e correlati ) non hanno equivalenti in OODML di Visual dBASE 7 ... 
 
Ci sono altri modi di riempire un array. Molto dipende dalle vostre necessità. Per esempio, se voleste memorizzare in un array due campi: "nome" e "cognome", potete memorizzarli sia come array con due colonne, sia come array uni-dimensionale (una colonna). Per quest'ultimo array potreste memorizzare i dati come  "Cognome,Nome" (per esempio "Campagna,Antonio). 
Ci sono due modi di fare quanto suddetto, il primo è un po' più complesso e non è veramente necessario... è qui per mostrare l'eleganza del secondo modo: 

1. Modo

q = new Query() // Istanza oggetto query
q.sql = "select * from miatabella" // seleziono tutti i campi della tabella
q.active=true  // attivo la query
r = q.rowset  // assegno alla variabile r il rowset
nMax = r.count() // restituisce il numero di record nella tabella 
declare aNames[nMax] // definisco l'array 
for nRow = 1 to nMax // scansione della tabella record per record

// inserisco l'informazione  nell'array  
aNames[nRow] = trim( r.fields["last"].value )+; 
r.fields["first"].value 
r.next() // vado alla riga successiva 

next // fine del ciclo for  

Il codice precedente  svolgerà egregiamente il suo compito, ma  verificate il più semplice e più elegante codice mostrato sotto: 

2. modo

q = new Query() // Istanza oggetto query
q.sql = "select * from miatabella" // seleziono tutti i campi della tabella
q.active=true  // attivo la query
r = q.rowset  // assegno alla variabile r il rowset
aNames = new Array() // Istanza Oggetto Array
r.first() // primo record della tabella
do while not r.endOfSet // Scansione della tabella... 

// inserisco l'informazione  nell'array  
aNames.add( trim( r.fields["last"].value )+; 
r.fields["first"].value ) 
r.next() //  record/riga successiva 

enddo // fine ciclo do While

Non c'è nessun bisogno di preoccuparsi del  subscript o di determinare la dimensione dell'array prima aggiungere elementi. Questo è molto più semplice.  
Come potete vedere, gli array sono piuttosto flessibili e la confusione che si genera dal loro uso in dBase deriva proprio da questa flessibilità! 

Cancellare dati da un array 

Ci sono volte quando usiamo un array che abbiamo la necessità di cancellare un elemento, o una riga,  o una colonna.  C'è un trucco per questa operazione. Quando usate le funzioni dBase che gestiscono la cancellazione (elemento, riga o colonna), dBase trasporta l'elemento/riga /colonna alla fine dell'array e sostituisce il valore contenuto negli elementi con il valore logico "falso" (in realtà, "vuoto" vedete sotto). Se usate le funzioni/metodi array di ordinamento in dBase, su un array nel quale avete cancellato un elemento/riga/colonna, vi sarà restituito un errore. Alla fine di questa sezione vi mostrerò come evitare il suddetto errore se utilizzate  il metodo resize() o la funzione aResize(). 

Cancellare un elemento in un array uni-dimensionale 

nomearray.Delete(elemento) 
oppure 
aDel(nomearray,elemento) 

Per esempio, nell'array aCity simile al seguente: 

se volete cancellare il secondo elemento: 

aCity.delete(2) 
oppure 
aDel(aCity,2) 

L'array conterrà i valori seguenti dopo avere eseguito uno di questi due comandi: 

Cancellare una riga (array a una o più dimensioni ): 

nomearray.Delete(nRow,1) // secondo parametro = riga (1) oppure colonna (2) 
oppure 
aDel(nomearray,nRow,1) // terzo parametro = riga (1) o colonna (2) 

Presumendo una versione dell'array aCity simile al seguente: 

Per cancellare la seconda riga di questo array possiamo usare: 

aCity.Delete(2,1) 
oppure 
aDel(aCity,2,1) 

Dopo la cancellazione l'array sarà simile al seguente: 

Cancellare una colonna (array a colonna multipla) 

nomearray.Delete(nColumn,2) // secondo parametro = riga (1) oppure colonna (2) 
oppure 
aDel(nomearray,nColumn,2) // terzo parametro = riga (1) oppure colonna (2) 

presumiamo che l'array aCity sia simile al seguente: 

il comando per cancellare la seconda colonna sarà: 

aCity.Delete(2,2) //il primo 2 è la colonna, il secondo dice a dBASE la colonna da cancellare 
oppure
aDel(aCity,2,2) 

Il quale ci restituirà un array simile al seguente: 

Rimuovere gli elementi/righe/colonne cancellati dall'array: 

In tutti i tre casi mostrati, il problema è come notato, che l'elemento/la riga/la colonna cancellata  esisterà ancora nell'array.  Quindi, per rimuovere ciò che è stato cancellato dovete usare il metodo Resize o la funzione aResize

 nomearray.Resize(nNumRows,nNumCols)  
oppure  
aResize(nomearray,nNumRows,nNumCols) 

Gli esempi sottostanti sono stati realizzati in funzione del codice utilizzato per gli esempi precedenti: 

Rimuovere un elemento da un array di uni-dimensionale: 

Rimuovere una riga di un array multi-dimensionale (il quale rimuove tutti gli elementi nella riga): 

Rimuovere una colonna da un array multi-dimensionale

   
Riferimento/Visualizzazione dei dati in un Array 

Ci sono molti modi di lavorare con gli array. Una volta che avete "popolato"  l'array è di solito necessario fare qualche cosa con i dati, ad es. usarli per operazioni di lookups, ordinamento ecc. Quindi la domanda nasce spontanea: 
"Come faccio a riferirmi ai dati contenuti in un array ? " 
La cosa più importante da ricordare è che avete bisogno di un subscript che punti ai singoli elementi. Se state lavorando con un array multi-colonna,  potete usare le vostre specifiche convenzioni  per i nomi dei vostri subscript, come "nRow" e "nColumn". Così voi probabilmente non confonderete i vostri subscript. Se "mescolate" i vostri subscript, è molto probabile incorrere in errore ( "subscript out of range") o puntare o utilizzare dati sbagliati!  

In un array a singola colonna, per puntare alla riga, potete usare qualsiasi riferimento al subscript che vi piace, ma per questo documento, tenterò di essere coerente e userò "nRow" per il subscript di riga e per un array a colonne multiple, userò "nColumn" per il subscript di colonna. 

Quindi, come visualizzare il contenuto di un array? 

Se conoscete lo specifico elemento a cui accedere, potete fare riferimento tramite il subscript. Presumendo un array simile al seguente: 

il comando:

? aCity[2] 

Visualizzerà "Los Angeles" 

Se l'array aCity contiene più di una colonna, ovviamente avete bisogno di usare un altro subscript che specifichi la colonna. Presumendo il seguente array: 

il comando

? aCity[2,2] // Visualizzerà il contenuto dell'elemento inserito seconda  riga e seconda colonna 

Verrà visualizzato 10,000,000. 

Potete fare un "loop"  che vi permetterà di visualizzare il contenuto dell'array: 

for nRow = 1 to aLen( aCity, 1) // aLen() è una funzione che restituisce il numero degli
                                            // elementi di un array 

? aCity[nRow] // visualizza il contenuto dell'elemento corrispondente 

next 

Il precedente frammento di codice visualizzerà  il contenuto dell'array:

San Francisco 
Los Angeles 
New York 
Miami 
Sydney 
 

La Funzione ALEN() 

Questa utile funzione usa due parametri - il nome dell'array e un operatore numerico opzionale:1 per le righe, 2 per le colonne e 0 per il numero di elementi nell'array (0 per default). E' molto comodo sapere l'esatta dimensione di un array  e il codice di esempio di questi documenti (questo che state leggendo e ARRAY2.HTM) ne fa largo uso. 
 
Se avete un array con più colonne, ovviamente avete bisogno di fare riferimento alla colonna. Ad es. se il vostro array ha tre colonne e volete visualizzarne semplicemente il contenuto delle tre colonne, riga per riga, potete fare  un "loop innestato" come mostrato sotto: 

for nRow = 1 to aLen(aCity,1) 

for nColumn = 1 to aLen(aCity,2) 

? aCity[nRow,nColumn] // visualizza l'elemento corrispondente 

next // nColumn 

next // nRow 

Se facciamo riferimento all'esempio su mostrato (array con tre colonne) il precedente frammento di codice visualizzerà: 

San Francisco 
4.000.000 
678 
Los Angeles 
10.000.000 
123 
New York 
25.000.000 
456 
Miami 
8.000.000 
678 
Sydney 
1.000.000 
1234 

Non molto bello, ma gli elementi contenuti nell'array sono visualizzati. (Per rendere "elegante" quanto precedentemente mostrato date un'occhiata a SHOW2.PRG.) 
 
Ordinare il contenuto di un array 

Qualche volta i dati immessi in un array non sono ordinati in modo specifico e  molto probabilmente avete necessità di ordinarli (sia per visualizzarli in ordine, sia per altri ragioni ). Ci sono due modi in dBase per fare questa operazione: il primo utilizza una funzione, il secondo utilizza un metodo legato ad un oggetto array. 

aCity.Sort() //metodo 
oppure 
aSort(aCity) //funzione

il comando precedente ordina l'array aCity sulla prima colonna. Se ci sono più colonne, le righe saranno tutte spostate con gli elementi nella prima colonna. 

Assumiamo di avere il seguente array prima dell'ordinamento: 

  dopo: 

Ordinare sulla seconda colonna: 

aCity.Sort(2) 
oppure 
aSort(aCity,2) 

Otterremo:

Un paio di Funzioni che sono molto utili quando si lavora con gli Array 

Le seguenti due funzioni sono piuttosto utili quando voi state programmando con array, ma non sono specifiche per gli array 

Type() 

Con la funzione Type()  potete determinare se un oggetto in Visual dBase è definito: se non è definito, questa funzione ritorna il  valore  "U", se è un oggetto ritorna un "O". Se l'oggetto che voi state esaminando è un array, la funzione ritorna un "A" (quindi l'array è un oggetto "speciale") ad esempio: 

?Type("aCity") 

Se questo è un array, vi sarà restituito: 

A 

Se questo è un "normale" oggetto di dBase, vi sarà restituito: 

O 

Se l'array (od oggetto) non è stato definito, vi sarà restituito: 

U 

Bisogna aggiungere che questa  funzione può restituire il tipo di dato contenuto in un elemento di un array. Ad esempio: 

?Type("aCity[1]") 

Restituisce: "C" per Carattere, "N" per Numerico, ecc. (Vedete il manuale di riferimento al linguaggio per maggiori informazioni ).

EMPTY() 

Questa funzione può essere usata sugli elementi di un array per determinare se loro sono veramente vuoti (indefinito), o contengono il valore logico "falso". 

Perché questo é importante? 

Visual dBase mostra falso sia ovviamente, se l'elemento contiene il valore logico falso, sia se all'elemento non è stato assegnato alcun valore. Vi rendete conto che questa situazione può confondere un po'. Quindi, per vedere se un elemento dell'array contiene effettivamente il valore falso oppure non contiene nulla possiamo utilizzare: 

//controlla se l'elemento dell'array non è vuoto e contiene il valore falso 
if aCity[1] == false and not empty(aCity[1]) 

Per vedere se l'elemento è vuoto 

if empty(aCity[1]) 

Ok, Adesso ho le basi, dove posso ottenere maggiori informazioni? 

Provate a leggere ARRAY2.HTM (nello stesso file .zip). Controllate anche nella guida in linea e nel manuale di riferimento al linguaggio. Oltre a quello che è trattato in questi documenti .HTM (ARRAY1 ed ARRAY2) esistono: gli  Array sparsi e gli Array Associativi. Non sono stati trattati per motivi di spazio, probabilmente in un secondo tempo dedicheremo un How To specifico, comunque, potete trovare maggiori informazioni su questi argomenti nella guida in linea  nel manuale di riferimento al linguaggio. 

AVVISO: l'autore è un membro del dBVIPS (dBASE Volunteer Internet Peer Support). Un gruppo di volontari che offrono assistenza tecnica per dBase, Inc. sul newsgroups di Visual dBase (news.dbase2000.com). Se avete domande che riguardano questo documento, o su Visual dBase potete comunicare direttamente con l'autore e i dBVIPS nel newsgroups.   Attualmente non è offerta assistenza tecnica "privata" tramite E-mail privato dai membri del dBVIPS. 
I file How sono creati come servizio gratuito dai membri del dBVIPS per aiutare gli utenti ad imparare ad usare più efficacemente Visual dBase. Questi documenti sono redatti dai membri del dBVIPS e dall'Assistenza Tecnica di dBase Inc. (per assicurare qualità). Questo file How To  non può essere affisso altrove senza il permesso esplicito dell'autore che trattiene tutti i diritti sul documento. 

Copyright 1999, Kenneth J. Mayer. All rights reserved. 

EoHT: ARRAY1.HTM -- 10/28/1998 -- KJM