{"id":180,"date":"2010-03-25T15:15:00","date_gmt":"2010-03-25T15:15:00","guid":{"rendered":"http:\/\/e-ware.org\/blog\/?p=180"},"modified":"2010-03-25T15:15:00","modified_gmt":"2010-03-25T15:15:00","slug":"gambas-passaggio-parametri-variabili-ad-una-funzione","status":"publish","type":"post","link":"http:\/\/e-ware.org\/blog\/gambas-passaggio-parametri-variabili-ad-una-funzione\/","title":{"rendered":"Gambas: Passaggio parametri variabili ad una funzione"},"content":{"rendered":"

<\/span><\/div>\n
Quando si programmano software un p\u00f2 pi\u00f9 avanzati si deve tener conto che non tutto nella vita pu\u00f2 essere definito a priori.<\/span><\/div>\n
Basti immaginare a chi sviluppa una semplice calcolatrice da riga di comando. Molte volte ho visto questo esempio ma l’errore sempre ricorrente era quello di accettare sempre e solo due parametri numerici ai quali applicare l’operazione prescelta. La cosa \u00e8 molto utile dal lato sviluppo ma davvero poco professionale dal lato utenza.<\/span><\/div>\n

<\/span><\/div>\n
Qualsiasi linguaggio che si rispetti da la possibilit\u00e0 a chi programma di scrivere funzioni che accettano anche parametri senza prima definirne l’esatte numero, semplicemente scrivendo un prototipo che indichi al sistema che tale funzione accetta parametri ma ne accetta tanti quanti l’utente ne inserisce.<\/span><\/div>\n

<\/span><\/div>\n
Questo modo di programmare \u00e8 davvero utile e flessibile e toglie dall’imbarazzo di dover specificare nei propri programmi che una certa operazione pu\u00f2 essere eseguita solo tra due dati alla volta.<\/span><\/div>\n

<\/span><\/div>\n
In Gambas, svolgere tale compito \u00e8 davvero semplice e vedremo ora come fare.<\/span><\/div>\n

<\/span><\/div>\n
Il passaggio indefinito di parametri prevede una struttura della funzione uguale a quelle a cui siamo abituati con una differenza nella dichiarazione dei parametri da passare in fase di esecuzione. Immaginiamo di avere la nostra funzione di nome FAddizione che deve sommare tutti i numeri interi passati come parametri (di cui ovviamente non sappiamo il numero a priori) e ne deve restituire la somma intera. Il prototipo di tale funzione sara quindi:<\/span><\/div>\n

<\/span><\/div>\n
FAddizione (Numero1 AS Integer, Numero2 AS Integer, …) AS Integer<\/span><\/i><\/div>\n

<\/span><\/div>\n
Innanzitutto vediamo che la definizione prevede un costrutto del tutto simile ad una normale funzione, con la differenza che il terzo parametro viene definito come una serie di tre punti ( <\/span>…<\/span><\/b> ) che sta ad indicare al linguaggio che dopo Numero2 non si sa quanti altri parametri verranno sottoposti ad operazione.<\/span><\/div>\n
Si noti che i primi due parametri, ovvero <\/span>Numero1<\/span><\/i> e <\/span>Numero2<\/span><\/i>, vengono definiti esplicitamente per il semplice fatto che non ha senso effettuare una somma se non ci sono almeno due numeri su cui effettuare l’operazione.<\/span><\/div>\n

<\/span><\/div>\n
Il codice che eseguir\u00e0 il lavoro voluto \u00e8 il seguente:<\/span><\/div>\n

<\/span><\/div>\n
FAddizione (Numero1 AS Integer, Numero2 AS Integer, …) AS Integer<\/span><\/i><\/div>\n

<\/span><\/i><\/div>\n
DIM Elemento AS Integer<\/span><\/i><\/div>\n
DIM Risultato AS Integer<\/span><\/i><\/div>\n

<\/span><\/i><\/div>\n
Risultato = Numero1 + Numero2<\/span><\/i><\/div>\n

<\/span><\/i><\/div>\n
FOR EACH Elemento IN Param<\/span><\/i><\/div>\n
Risultato = Risultato + Elemento<\/span><\/i><\/div>\n
NEXT<\/span><\/i><\/div>\n

<\/span><\/i><\/div>\n
RETURN Risultato<\/span><\/i><\/div>\n

<\/span><\/i><\/div>\n
END<\/span><\/i><\/div>\n

<\/span><\/div>\n
Dunque, come si vede la funzione, come primo passo, somma i due numeri passati esplicitamente alla funzione mediante l’operazione<\/span><\/div>\n

<\/span><\/div>\n
Risultato = Numero1 + Numero2<\/span><\/i><\/div>\n

<\/span><\/div>\n
Fatto ci\u00f2 scorre tutti gli altri elementi passati alla funzione, non definiti, mediante il ciclo <\/span>FOR EACH<\/span><\/b>. Si vede infatti che \u00e8 stato definito un intero all’interno della funzione di nome <\/span>Elemento<\/span><\/b> che indica di volta in volta nel ciclo un nuovo elemento presente in <\/span>Param<\/span><\/b>. Elemento viene sommato a Risultato che aggiorna, di volta in volta, il suo valore con il proprio valore precedente sommato al nuovo parametro.<\/span><\/div>\n

<\/span><\/div>\n
Apriamo una parentesi. <\/span>Param<\/span><\/b> \u00e8 una classe statica, di sola lettura, interna di Gambas che prevede la gestione di tutti gli extra-parametri di una funzione. Essa gode di alcune propriet\u00e0 che agevolano il trattamento di questa particolare situazione.<\/span><\/div>\n
Nel nostro caso sfruttiamo la particolarit\u00e0 della classe di essere enumerabile mediante il ciclo FOR EACH e di scorrerla quindi finch\u00e8 c’\u00e8 un dato da leggere.<\/span><\/div>\n

<\/span><\/div>\n
Tornando al codice si pu\u00f2 vedere come con l’istruzione:<\/span><\/div>\n

<\/span><\/div>\n
RETURN Risultato<\/span><\/i><\/div>\n

<\/span><\/div>\n
Restituisce alla fine di tutto il dato voluto.<\/span><\/div>\n

<\/span><\/div>\n
CONSIDERAZIONI<\/span><\/b><\/div>\n

<\/span><\/div>\n
L’uso di questo tipo di struttura e del suo costrutto deve diventare una prassi per i codici che richiedono la risoluzione di questi tipi di situazioni poich\u00e8 pu\u00f2 accadere che all’utente serva passare un grosso numero di parametri e si costringerebbe chi opera sul nostro software a creare numerosi cicli, dispendiosi in termini di tempo, per effettuare semplici operazioni.<\/span><\/div>\n

<\/span><\/div>\n
Ovviamente rimango a vostra disposizione per chiarimenti in merito a questo articolo.<\/span><\/div>\n
<\/div>\n","protected":false},"excerpt":{"rendered":"

Quando si programmano software un p\u00f2 pi\u00f9 avanzati si deve tener conto che non tutto nella vita pu\u00f2 essere definito a priori. Basti immaginare a chi sviluppa una semplice calcolatrice da riga di comando. Molte volte ho visto questo esempio ma l’errore sempre ricorrente era quello di accettare sempre e solo due parametri numerici ai […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[52,23,2,4],"tags":[],"class_list":["post-180","post","type-post","status-publish","format-standard","hentry","category-didattica","category-gambas","category-gnulinux","category-opencode"],"views":1090,"_links":{"self":[{"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/posts\/180","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/comments?post=180"}],"version-history":[{"count":0,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/posts\/180\/revisions"}],"wp:attachment":[{"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/media?parent=180"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/categories?post=180"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/tags?post=180"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}