No more maintained.
Now just a test in a lab.
Variabili, operatori e condizioni
Variabili, condizioni, costanti e sintassi generale del codice.
Introduzione alle variabili in PHP
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
Il PHP ha una libertà di utilizzo delle variabili non comune nella maggior parte linguaggi di programmazione. Infatti non è necessaria al fine del corretto funzionamento dello script la dichiarazione della variabile stessa o la definizione del tipo di variabile. E' però necessario che ogni variabile venga sempre preceduta dal carattere $.
E' corretto scrivere in un qualsiasi punto dello script:
$pippoPluto=20;
Tuttavia è permessa una dichiarazione tramite la sintassi:
var $pippoPluto;
anche con un assegnamento immediato al momento della dichiarazione (diretto, indiretto o come risultato di una funzione/espressione):
var $pippoPluto=0;
var $pippoPluto2=true;
var $pippoPluto3="hello, how are you?";
var $pippoPluto4=explode($pippoPluto3,",");
var $pippoPluto5=sqrt(2);
etc...
Per motivi di leggibilità è utile utilizzare la dichiarazione come in linguaggi meno evoluti e più restrittivi.
Ogni variabile dichiarata o meno può in ogni momento cambiare tipo a seconda dell'assegnamento che viene effettuato, quindi se si era dichiarata la variabile pippoPluto come in precedenza:
var $pippoPluto=0;
in una qualsiasi parte dello script si può effettuare un cambio di tipo semplicemente assegnando il nuovo dato (descritto in modo diretto, indiretto o come risultato di una funzione/espressione) alla variabile. Quindi sarà corretto assegnare alla variabile pippoPluto dichiarata in precedenza una stringa, un oggetto, un numero razionale, etc. anche come risultato di un operazione che utilizza il precedente valore della variabile:
var $pippoPluto=$pippoPluto + "ciao";
var $pippoPluto=new TObject;
var $pippoPluto=1,34567;
var $pippoPluto=log(3)*sin(5);
La considerazione più importante legata alle variabili è la visibilità. Una variabile dichiarata in un certo blocco (come blocco s'intende una certa parte di codice compresa tra '{' e relativa '}' ) sarà presente unicamente in esso, la variabile viene distrutta alla riga di chiusura definita con '}'. Una variabile non dichiarata sarà presente in tutto lo script anche se viene definita per la prima volta in una funzione o in un blocco interno. Per migliorare la leggibilità esistono, come in altri linguaggi, le variabili globali e si definiscono come le normali variabili ma con la keyword global. Anche queste variabili hanno lo stesso modo di dichiarazione, assegnamento e proprietà dele normali variabili con il vantaggio di essere sicuramente visibili in ogni parte del codice.
global $PIPPOPLUTO;
Tipi di variabili
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
Abbiamo diversi tipi di variabili a seconda del loro contenuto:
Integer, cioè tutti i numeri interi, positivi e negativi.
L'intervallo di questi numeri varia a seconda della piattaforma,ma solitamente è compreso tra -2.000.000.000 e +2.000.000.000.
Esempio $var = 4;
Per verificare che un valore sia un integer, si può usare la funzione is_int().
Float, cioè tutti i numeri in virgola mobile, quindi tutti i valori reali.
Rispetto agli integer ha un intervallo molto più grande che cambia anch'esso a seconda della piattaforma.
Esempio $var = 8.3;
Per verificare che un valore sia un numero in virgola mobile, si può usare la funzione is_float().
Boolean, cioè i valori true(vero,o anche 1) e falso(false, o anche 0).
Una variabile booleana, può per esempio, essere utilizzata come risultato di una condizioni, che per l'appunto restituirà vero,nel caso in cui la condizione sarà verificata o falso,nel caso in cui non lo sarà.
Esempio $var = true;
Per verificare che un valore sia un booleano, si può usare la funzione is_bool().
Stringa, cioè una sequenza di caratteri racchiusa tra apici o doppi apici.
Tutto quello che racchiuso in una stringa viene considerato testo,anche se si tratta di un numero.
Esempio $var = “Stringa di caratteri”;
Per verificare che un valore sia una stringa, si può usare la funzione is_string().
Array, cioè contiene al suo interno un gruppo di valori, non necessariamente dello stesso tipo. Ogni valore è identificabile univocamente da un indice che potra essere numerico o testuale.
Esempio $var = array(3,'ciao',2);
Per verificare che un valore sia un array, si può usare la funzione is_array().
Oggetti, per ora li definiremo come istanze di una classe, più avanti approfondiremo meglio il concetto.
Esempio $var = $this->numero;
Per verificare che un valore sia un oggetto, si può usare la funzione is_object().
Risorse, sono state introdotte a partire da PHP4, hanno al loro interno un riferimento a una risorsa esterna. Per esempio una connessione ad un DB o una query.
Esempio $var = mysql_connect($host,$login,$pwd);
Per verificare che un valore sia una risorsa , si può usare la funzione is_resource().
NULL, è un parola not-sensitive,che indica quelle variabili senza un valore.
Esempio $var = NULL;
Per verificare che un valore sia NULL, si può usare la funzione is_null().
Di array e oggetti parleremo meglio più avanti.
Operatori nel linguaggio PHP
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
Di seguito vedremo i diversi operatori utilizzabili nel linguaggio PHP.
ARITMETICA BASE
$a + $b esegue la somma di $a e $b.
$a - $b esegue la differenza di $a e $b.
$a * $b esegue il prodotto di $a e $b.
$a / $b esegue il quoziente di $a e $b.
$a % $b esegue $a diviso da $b e restituisce il resto.
CONFRONTARE DUE VARIABILI / VALORI
$a == $b Uguale. Restituisce TRUE (vero) se $a è uguale a $b.
$a === $b Identico. Restituisce TRUE se $a è uguale a $b e se sono dello stesso tipo.
$a != $b Diversi. Restituisce TRUE se $a è diverso da $b.
$a $b Diversi. Restituisce TRUE se $a è diverso da $b.
$a !== $b Non identici. Restituisce TRUE se $a è diverso da $b, o se non sono dello stesso tipo.
$a < $bMinore. Restituisce TRUE se $a è strettamente minore di $b.
$a > $b Maggiore. Restituisce TRUE se $a è strettamente maggiore di $b.
$a <= $b Minore o uguale. Restituisce TRUE se $a è minore o uguale a $b.
$a >= $b Maggiore o uguale. Restituisce TRUE se $a è maggiore o uguale a $b
OPERATORI D'ESECUZIONE
PHP supporta un operatore di esecuzione: backticks (``). PHP cercherà di eseguire il contenuto dei backticks come comando di shell; sarà restituito l'output, che potrà anche essere assegnato ad una variabile.
$output = `ps xa`;
esegue il comando ps xa e assegna l'output alla variabile $output
echo "<.pre>$output";
visualizza il contenuto formattato (con spazi e a capo) della variabile $output, utilizzando il tag PRE
ATTENZIONE: i backticks non sono apostrofi!
OPERATORI D'INCREMENTO
Operatori di pre e post incremento, come nel linguaggio C.
++$a Pre-incremento. Prima incrementa $a di una unità e poi restituisce $a.
$a++ Post-incremento. Prima restituisce $a e poi incrementa $a di una unità.
--$a Pre-decremento. Prima decrementa $a di una unità e poi restituisce $a.
$a-- Post-decremento. Prima restituisce $a e poi decrementa $a di una unità.
OPERATORI LOGICI
$a and $b And. Restituisce TRUE se sia $a che $b sono TRUE. Al posto di and si può anche usare &&.
$a or $b Or. Restituisce TRUE se uno dei due operatori è TRUE. Al posto di or si può anche usare ||.
$a xor $b Xor. Restituisce TRUE se uno dei due operatori è TRUE, ma non entrambi.
!$a Not. Restituisce TRUE se $a non è TRUE.
OPERATORI DI STRINGA
Ci sono due operatori di stringa: l'operatore di concatenazione e quello di assegnazione concatenata.
L'operatore di concatenazione ('.') restituisce la concatenazione dei suoi argomenti a destra e a sinistra.
$a = "Ciao ";
$b = $a . "a tutti!";
Ora la variabile $b contiene il valore "Ciao a tutti"
L'operatore di assegnazione concatenata ('.=') aggiunge alla fine dell'argomento sul lato destro l'argomento sul lato sinistro.
$a = "Ciao ";
$a .= "a tutti";
Ora la variabile $a contiene il valore "Ciao a tutti"
OPERATORI DI CONTROLLO ERRORE
Il carattere @ (at) anteposto ad un espressione permette di ignorare l'errore che potrebbe essere generato nel caso in cui l'espressione non sia corretta.
/*in questo caso se non avessimo messo “@” prima del comando,sarebbe stato segnalato l'errore.*/
$testo = “testo della query”;
$query = @mysql_query($testo);
Se nel file di configurazione “php.ini” la caratterista track_errors è abilitata, quindi a 1, ogni messaggio di errore generato sarà salvato nella variabile globale $php_errormsg, sovrascrivendosi ogni volta.
OPERATORI DI BITWISE
Gli operatori bitwise permettono di modificare specifici bit a 0 o a 1.
Converte automaticamente il numero in binario(o se si tratta di una stringa in caratteri ASCII e da ASCII in binario) e ne confronta bit per bit.
“&” - ($x & $y) - sono impostati a 1 i bit che sono a 1 sia in $x che inr $y
“|” - ($x | $y) – sono impostati a 1 i bit che sono a 1 in $x o in $y
“^” - ($x ^ $y) – sono impostati a 1 i bit che sono a 1 in $x oppure in $y,ma non quelli che sono entrambi a 1
“~” - (~$x) – inverte tutti i bit,quindi quelli che sono a 1 diventeranno 0 e vicevesa
“>>” - ($x>>$y) – fà slittare a destra i bit di $x di $y volte
“<<” - ($x<<$y) - fà slittare a sinistra i bit di $x di $y volte
Esempio:
//setto il valore di $x e $y in base decimale
$x = 34;
$y = 12;
//------------------------------------ & ------------------------------------//
/*
In binario saranno
00100010 $x
00001100 $y
-------------
00000000 0
restituisce 0 perchè nessun bit che è a 1 in $x è a 1 in $y
*/
echo $x & $y;
//------------------------------------ | ------------------------------------//
/*
In binario saranno
00100010 = $x
00001100 = $y
-------------
00101110 = 46
restituisce 46 perchè setta a 1 i bit che sono a 1 in $x o in $y
*/
echo $x | $y;
//------------------------------------ ^ ------------------------------------//
//setto il valore di $x e $y in base decimale
$x = 118;
$y = 43;
/*
In binario saranno
01110110 = $x
00101011 = $y
-------------
01011101 = 93
restituisce 93 perchè setta a 1 i bit che sono a 1 in $x o in $y,ma non quelli che sono entrambi a 1
*/
echo $x ^ $y;
//------------------------------------ ~ ------------------------------------//
//setto il valore di $x in base decimale
$x = 34;
/*
In binario saranno
00100010 = $x
-------------
11011101 = -35
restituisce -35 perchè inverte i bit.
Nel linguaggio binario questa operazione viene chiama complemento a 2
*/
echo ~$x;
//------------------------------------ >> ------------------------------------//
//setto il valore di $x e $y in base decimale
$x = 100;
$y = 4;
/*
In binario saranno
01100100 = $x
00000100 = $y
-------------
00000110 = 6
Restitusce 6 perchè fà shiftare verso destra i bit di 4 volte.
Facendo ciò i bit restanti sarano 00000110,che corrisponde a 6.
*/
echo $x >> $y;
//------------------------------------ << ------------------------------------//
//setto il valore di $x e $y in base decimale
$x = 10;
$y = 3;
/*
In binario saranno
00001010 = $x
00000011 = $y
-------------
01010000 = 80
Restitusce 80 perchè fà shiftare verso sinistra i bit di 3 volte.
Facendo ciò i bit restanti sarano 01010000,che corrisponde a 80.
*/
echo $x << $y;
Per le stringhe converte i carattere in ASCII e poi da ASCII a binario.
Array in PHP
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
In PHP, così come in molti altri linguaggi di programmazione, con il termine array si identifica una struttura in cui i dati sono mantenuti tramite una associazione chiave --> valore.
Questa particolare struttura permette di gestire liste, tabelle hash, stack, code. Inoltre, il fatto che un valore possa esso stesso essere un array permette di gestire molte altre implementazioni di strutture dati ordinate che vengono utilizzate come basi dei più conosciuti algoritmi.
La creazione di un array avviene tramite il costrutto array e la definizione delle coppie di valori, si noti come l'indicazione delle chiavi (cioè degli indici del vettore) non è obbligatoria, si vedrà di seguito come PHP gestisce l'indicizzazione automatica dei valori per i quali non si è specificato l'indice.
$mioarray = array("chiave1" =>"valore1", 2 => "valore2", "chiave3" => "valore3", "valore4")
Utilissima, al solito, le funzioni print_r e var_dump che ci permettono di ispezionare il contenuto delle nostre strutture dati. Per il nostro esempio otterremo:
Array
(
[chiave1] => valore1
[2] => valore2
[chiave3] => valore3
[3] => valore4
)
Come si può vedere, l'interprete PHP si è occupato di assegnare l'indice 3 al valore4, il criterio utilizzato è quello di cercare il massimo intero utilizzato come indice e sommargli 1, nel caso non ci sia nessun indice numerico allora il primo sarà 0. Si presti attenzione al fatto che una chiave viene considerata un intero anche quando essa sia una rappresentazione standard dello stesso, quindi stringhe del tipo "3" verranno considerate indici numerici mentre non lo saranno le stringhe come "003".
I contenuti (valori indicizzati) dell'array sono accessibili inidicando la chiave (indice) associata all'interno di parentesi quadre, sempre dal nostro esempio:
print $mioarray[2]; che stamperà valore2
oppure
print $mioarray["chiave1"]; che avrà come output valore1
si noti come
print $mioarray; non mostra tutti i valori ma l'indicazione che si sta cercando di stampare un array: array.
L'inserimento di nuovi valori all'interno dell'array può avvenire in modo esplicito cioè assegnando un valore ad una particolare chiave:
$mioarray["nuovachiave"]="nuovovalore";
oppure implicitamente delegando all'interprete la generazione dell'inidice in base alla regole presentate sopra:
$mioarray[]="nuovovalore";.
La rimozione di elementi di un array avviene tramite la funzione unset, ad esempio:
unset($mioarray["nuovachiave"])
rimuovrà dall'array l'elemento con indice nuovachiave.
Il fatto che un valore può essere a sua volta definito come un array offre la possibilità di utilizzare array multidimensionali, vediamo un esempio:
$multiarray= array("itemA" => array("campo1" => "valore1A",
"campo2" => "valore2A",
"campo3" => "valore3A"),
"itemB" => array("campo1" => "valore1B",
"campo2" => "valore2B",
"campo3" => "valore3B")
);
l'accesso alla particolare componente dell'array avviene, al solito, utilizzando gli indici all'interno di parentesi quadre, in questo caso scendendo tra i livelli fino a quello desiderato:
print $multiarray["itemB"]["campo2"];
risulterà in valore2B
Variabili d'ambiente in PHP >=4.1.0
Tipo Infobox: TIPS - Skill: 3- INTERMEDIATE
Nelle versioni di php dopo la 4.1.0 sono state ridefinite le variabili d'ambiente che andranno a sostituire i vecchi array. Dato il loro largo e importante utilizzo le elenchiamo:
$_SERVER al posto di $HTTP_SERVER_VARS
$_GET al posto di $HTTP_GET_VARS
$_POST al posto di $HTTP_POST_VARS
$_COOKIE al posto di $HTTP_COOKIE_VARS
$_FILES al posto di $HTTP_POST_FILES
$_ENV al posto di $HTTP_ENV_VARS
$_REQUEST (non ha equivalenti nelle vecchie versioni)
$_SESSION[] per $HTTP_SERVER_VARS[]
Il funzionamento è molto simile ai vecchi array, quindi se in uno script fate riferimento alle variabili in input con gli appositi array non si deve far altro che cambiare i nomi.
Decisamente diverso invece se per riferirsi alle variabili in input si usava il nome della variabile e non il suo array (es. $var invece di $HTTP_GET_VARS[var]).
Questo perchè nelle versioni dalla 4.2.0 in poi per default il php.ini contiente questa riga
register_globals = 'Off'
mentre in quelle precedenti la configurazione di default era:
register_globals = 'On'
Cambiando questa configurazione non vengono create in modo automatico le variabili di GET e POST ma sono presenti solo nelle rispettive variabili d'ambiente.
E' consigliabile mantenere la riga su Off, ma è sempre possibile impostarla su On (anche se ciò è deprecato per motivi di sicurezza).
Un'altra novità che può tornare utile è il fatto che queste variabili sono automaticamente globali, se in una funzione si inseriva:
global $HTTP_GET_VARS;
per rendere le variabili get visibili, ora tutto ciò non sarà necessario.
Un ultimo consiglio...
in questo momento di transizione è consigliabile scrivere gli script riferendosi alle variabili con i nuovi array ed inserire in cima allo script righe di questo tipo:
if(!isset($_GET)) $_GET = $HTTP_GET_VARS;
oppure
if(!isset($_POST)) $_GET = $HTTP_POST_VARS;
(ovviamente una per ogni array usato)
Importante
Usare questa soluzione può comportare alcuni problemi di sicurezza:
qualche utente malizioso potrebbe richiamare la pagina con pagina.php?_GET['var']=53 e $_GET sarebbe settato.
Una soluzione proposta è questa:
if(!isset($_SERVER) OR !$_SERVER OR !is_array($_SERVER) OR count(array_diff($_SERVER, $HTTP_SERVER_VARS))){
$_GET = &$HTTP_GET_VARS;
$_POST = &$HTTP_POST_VARS;
$_SERVER = &$HTTP_SERVER_VARS;
$_ENV = &$HTTP_ENV_VARS;
$_COOKIE = &$HTTP_COOKIE_VARS;
$_FILES = &$HTTP_POST_FILES;
$_SESSION = &$HTTP_SESSION_VARS;
}
Autore originario: "Chris" dal forum di html.it
Dichiarare costanti e variabili
Tipo Infobox: TIPS - Skill:
Tutti i dati che vengono utilizzati in un programma Pascal devono essere dichiarati prima di poterli usare.
Tutti i dati che vengono utilizzati in un programma Pascal devono essere dichiarati prima di poterli usare.
La sezione delle dichiarazioni è posta subito dopo l'intestazione del programma, prima del blocco delle istruzioni, ed è composta nell'ordine da:
- la dichiarazione delle costanti;
- la dichiarazione delle variabili.
Le costanti sono quei dati che non vengono modificati durante l'esecuzione del programma. Considera, ad esempio, un programma che, acquista il prezzo netto di un bene, ne calcoli il prezzo di vendita, compresivo di IVA, e lo comunichi.
Dobbiamo considerare tre dati: il prezzo netto, il prezzo lordo e l'aliquota (percentuale) dell'IVA. I primi due vengono modificati l'esecuzione del programma (il prezzo netto è acquisito dall'esterno, il prezzo è calcolato) e perciò devono essere rappresentati da variabili, l'aliquota, cioè l'aumento percentuale del prezzo, rimane invariata e quindi rappresenta una costante. La dichiarazione delle costanti si effettua scrivendo la parola chiave Const e quindi specificando per ogni costante il nome seguito dal simbolo "=" e dal valore della costante. Nel nostro esempio la costante ALIQUOTA si dichiara nel modo seguente:
const ALIQUOTA = 20;
Se vi sono più costanti, le dichiarazioni vanno separate da un punto e virgola ";":
Const PI_GREGO = 3.1415;
INTESTAZIONE = 'Area del cerchio';
Nella sezione precedente vengono dichiarate due costanti PI_GREGO corrisponde al numero decimale 3,1415 e INTESTAZIONE corrisponde alla stringa "Area del cerchio".
La dichiarazione delle variabili si effetua, dopo quella delle costanti, scrivendo la parola chiave Var seguita dalla lista delle variabili, raggruppate per tipo. Le variabili dello stesso tipo devono essere separate da un virgola "," e alla fine della lista, dopo il simbolo due punti ":", va posto il nome del tipo:
Var a,b,c : Real;
n, i : Integer;
nome : String[30];
Nella sezione precedente vengono dichiarate tre variabili di tipo Real (a,b,c), due di tipo integer (n, i) e una di tipo stringa di lunghezza massimo 30 (nome).
I nomi usati in un programma Pascal, per definire le variabili, le costanti e il programma stesso, sono detti identificatori e devono essere costruiti secondo le seguenti regole, altrimenti non saranno riconosciuti.
Regola:
1. Ogni identificatore deve iniziare con una lettere;
2. Gli altri caratteri possono essere solamente lettere, cifre o il simbolo "_" (underscore);
3. Un identificatore non può contenere spazi.
Le procedure (pascal)
Tipo Infobox: TIPS - Skill:
Le funzione non sono adatte a risolvere tutti i problemi che si possono incontrare nella scrittura di un programma.
Le funzione non sono adatte a risolvere tutti i problemi che si possono incontrare nella scrittura di un programma.
Ad esempio, potrebbe essere necessario ritornare più di un parametro. Per questo il linguaggio Pascal mette a
disposizione un'altra struttura: la procedura.
Per comprendere come funziona una procedura vediamo un semplice esempio.
Nel costruire gli algoritmi può capitare di dover scambiare il contenuto di due variabili. Questo processo richiede
sempre l'uso di una variabile di appoggio, come hai visto nel tutorial precedente :)
Possiamo immaginare di allestire una procedura che realizzi quest'operazione e possa essere utilizzata in un
programma tutte le volte che è necessario.
In Pascal, la procedura che realizza lo scopo va scritta in questo modo:
Procedure Scambia(var A,B : integer);
var appoggio : integer;
Begin
appoggio:=B;
B:=A;
A:=appoggio
End;
nella prima riga, dopo la parola Procedure, viene dichiarato il nome della procedura, seguito dalle variabili
scambiate con il programma principale, poste tra parentesi.
Nel programma principale la procedura:
- deve essere dichiarata subito dopo la dichiarazione delle variabili e prima delle eventuali funzioni;
- in seguito, può essere chiamata (cioè eseguita) in un punto qualunque del programma principale, scrivendo
semplicemente il suo nome e specificando, tra parentes, le variabili che vengono passate
Scambia(Uno,Due);
Un programma che utilizza la procedura scambio può essere il seguente:
Program ScambiaEricorda;
var primoNumero, secondoNumero: Integer
Procedure Scambia(var A,B : integer);
var appoggio : integer;
Begin
appoggio:=B;
B:=A;
A:=appoggio;
Writeln('è stata applicata la procedura Scambia')
End;
Begin
primoNumero := 5;
secondoNumero := 3;
Scambia(primoNumero, secondoNumero);
Writeln(' La variabile primo Numero ha ora valore ',primo Numero);
Writeln(' La variabile secondoNumero ha ora valore ',secondoNumero);
End.
A prima vista sembra che la procedura non restituisca alcun valore, infatti non troviamo dopo Scambia( var
A,B : integer ) alcuna indicazione del tipo. La modifica e la restituzione dei valori delle variabili passate alla
procedura viene realizzata premettendo alla dichiarazione delle variabili di scambio, A e B, la parola riservata
var. Le modifiche effettuate in una procedure su variabili dichiarate di tipo var, come A e B, hanno effetto anche
nel programma principale.
Nel programma precedente l'effetto della procedura Scambia è il seguente:
- vengono passati alla procedura le variabili primoNumero, il cui valore, 5, è assegnato ad A e secondoNumero,
il cui valore, 3, è assegnato a B;
- la procedura viene eseguita e si scambiano i valori di A e B;
- i nuovi valori di A e B vengono assegnati a primoNumero e secondoNumero.
Alla fine, la variabile primoNumero ha valore 3 e la variabile secondoNumero ha valore 5.
Le variabili passate come var sono passate per indirizzo: cioè viene passato alla procedura l'indirizzo della locazione
di memoria in cui è memorizzato il valore della variabile. Eventuali modifiche verranno effettuate in quella locazione
e pertanto permangono anche al termine della procedura.
Le altre variabili vengono invece passate per valore: cioè viene creata una copia del valore della variabile in una
nuova locazione di memoria e le modifiche sono applicate a tale copia. Il valore originario non viene quindi cambiato.
- Per suggerimenti o delucidazioni <[email protected]> ciao! ;)
Le Funzioni (Pascal)
Tipo Infobox: TIPS - Skill:
Come abbiamo visto nel mio precedente tutorial, la costruzione di un programma per quanto semplice richiede molte istruzioni. Nasce, quindi, l'esigenza di scomporre i problemi in sottoproblemi al fine di garantire un più facile controllo della correttezza delle singole parti.
Come abbiamo visto nel mio precedente tutorial, la costruzione di un programma per quanto semplice richiede molte istruzioni. Nasce, quindi, l'esigenza di scomporre i problemi in sottoproblemi al fine di garantire un più facile controllo della correttezza delle singole parti. Questi sottoproblemi vengono tradotti in sottoprogramma, che sono
detti, in Pascal, funzioni e procedure, oggi parleremo soltanto delle funzioni.. Esse possono essere utilizzate
più volte nel programma principale.
Per introdurre il concetto di funzione in Pascal supponiamo di dover calcolare a[n] + b[m] ( con a, b, n ed m
numeri naturali non nulli ). Poichè gia conosciamo il programma per calcolare la potenza, scriviamo il seguente
listato che permette di risolvere il problema ( le righe tra parentesi graffe sono commentati al programma che
che vengono saltate dal compilatore e servono invece al programmatore per chiarire il significato del codice ):
Program SommaPotenze;
Var a,b,n,m ; integer;
Var p,i : integer
Begin
writeln('Inserisci la prima base:');
readln(a);
writeln('Inserisci la seconda base:');
readln(b);
writeln('Inserisci il primo esponente:');
readln(b);
writeln('Inserisci il secondo esponente:');
readln(b);
{ nelle istruzioni seguenti si calcola a^n e si inserisce il risultato in an }
p:= 1;
For i:= 1 to n Do
p := p * a;
an :=p;
{ segue il listato relativo all'elevamento a potenza; si calcola b^m e si inserisce il risultato in bm }
p := 1;
For i:= 1 to m Do
p := p * b;
bm := p;
writeln(an+bm)
End.
La ripetizione del listato dell'elevamento a potenza può essere superata costruendo una funzione il cui scopo
sarà quello di svolgere l'operazione richiesta:
Function Eleva(base, esponente : integer) : integer;
Var potenza,i : integer;
Begin
potenza := 1;
For i:= 1 to esponente Do
potenza := potenza * base;
Eleva := potenza
End.
Questa parte di programma, cioè la dichiarazione della funzione, va inserita prima del Begin del programma
principale, il quale potrà richiamare la funzione ( cioè far eseguire il calcolo ), inserendo l'assegnazione:
...
an := Eleva(a,n);
...
L'istruzione precedente opera nel modo seguente:
- i valori di a e di n vengono "passati" alla funzione Eleva: cioè diventano i valori delle variabili corrispondenti
nella dichiarazione della funzione, cioè base ed esponente, che sono dette variabili di scambio;
- si esegue la sequenza di istruzioni comprese nel blocco Begin ... End della funzione ( nelle quali si calcola
il valore di a[n] e lo si memorizza nella variabile potenza, interna alla funzione );
- l'ultima istruzione del blocco
Eleva := potenza
assegna a Eleva il valore che la funzione "ritorna" al programma principale;
- riprende l'esecuzione del programma principale con l'assegnazione del valore ritornato dalla funzione an.
Guarda nella riga iniziale della dichiarazione della funzione:
Function Eleva(base, esponente : integer) : integer;
abbiamo specificato, dopo il nome della funzione:
- la lista delle variabili di scambio e il loro tipo, poste tra parentesi;
- il tipo di dato associato alla funzione (integer).
Dal momento che ogni funzione restituisce un dato, è sempre necessario specificare di quale tipo sia.
Osserva, inoltre, che la funzione Eleva si comporta proprio come le funzioni studiate in matematica o per lo
meno che avreste dovuto studiare =)
- Per suggerimenti o delucidazioni <[email protected]> ciao! ;)
Il calcolo numerico (Derive)
Tipo Infobox: TIPS - Skill:
Derive è un software studiato appositamente per risolvere problemi matematici, anche complessi.
- INTRODUZIONE -
Derive è un software studiato appositamente per risolvere problemi matematici, anche complessi. Può essere di
valido aiuto per svolgere il lavoro assegnato e per controllare la correttezza dei risultati ottenuti.
Normalmente, al momento dell'installazione, Derive viene inserito nel sotto-menù Programmi del menù Start (avvio),
quindi per avviarlo si può partire da questo stesso menù; oppure, se il collegamento è presente sul desktop, si
può fare doppio clic sull'icona.
Apparirà la finestra, nella quale, sotto la barra del titolo, si trovano la barra del menù e quella degli strumenti:
Il primo menù File è molto simile agli analoghi menù delle applicazioni per Windows e consente di creare un nuovo
documento, apriren uno già esistente, chiudere un documento aperto, salvarlo oppure effettuarne una stampa.
Anche gli ultimi due - Finestra e? - compiono le stesse funzioni svolte nelle altre applicazioni e servono rispettivamente
a gestire più finestre e ad attivare l'help del programma. Gli altri menù, che sono specifici di Derive, verranno
presentati quando si useranno le loro funzioni.
- L' inserimento e la cancellazione delle espressioni -
Derive è in grado di semplificare esperessioni algebriche numeriche e letterali. Per creare una nuova espressione
si può procedere in due modi:
- si seleziona nel menù Crea la voce Espressione;
- si preme il pulsante (matita) nella barra degli strumenti.
Comparirà una nuova finestra.
Nella casella a sfondo bianco si potrà digitare l'espressione e quindi premere il tasto OK per confermala. Nella parte
alta della finestra sono elencati alcuni tasti indicanti caratteri che non si trovano sulla tastiera (ad es. il simbolo di radice quadrata,
i simboli di disuguaglianza oppure le lettere dell'alfabeto greco). Essi possono essere inseriti semplicemente cliccandovi sopra.
Nello scrivere le espressioni si devono usare correttamente le parentesi.
L'espressione viene inserita nel documento e le è assegnata un numero progressivo:
Per cancellare, invece un'espressione basta selezionarla con il mouse e quindi scegliere il comando Varia / Taglia.
- La semplificazione e la fattorizzazione di espressioni numeriche -
Se ora vogliamo svolgere i calcoli contenuti nell'espressione è sufficiente selezionare il menù Semplifica e la voce Base. Dopo aver
confermato la scelta con il tasto OK, apparirà il risultato dell'espressione sotto forma di frazione.
Il comando Semplifica / Base può essere attivato anche facendo clic sul tasto "=" nella barra degli strumenti.
Se vogliamo semplificare l'espressione, ma ottenere il risultato in forma di numero decimale, è sufficiente selezionare l'espressione,
cliccando sull'etichetta numerica (#1) che la individua, e, poi utilizzare il comando Semplifica / Approssima.
Appare a questo punto una finestra nella quale viene richiesto il numero di cifre decimali da assegnare; impostato il valore desiderato, si seleziona
Approssima e si ottiene il risultato.
Se viene premuto il tasto OK non appare il risultato, ma il comando corrispondente nel linguaggio Derive; semplificando successivamente questa
espressione con Semplifica / Base si ottiene il risultato dell'espressione.
Il comando Semplifica / Approssima può essere attivato anche usando il tasto = nella barra degli strumenti.
- Per suggerimenti o delucidazioni <[email protected]> ciao! ;)
Come utilizzare Windows Media Encoder per la RADIO
Tipo Infobox: TIPS - Skill: 1- NOVICE
Stanco della solita Radio trasmessa con Winamp, questo tutorial spiega come sostituirla con "Windows Media Encoder" ?
1) Trasmetti evento
2) Selezionare solo audio e mettere (periferica audio predefinita)
3) Selezionare la seconda casella alla voce (Pull da codificatore)
4) Cliccare su "cerca porta disponibile" per trovare una porta (Sotto esce la url che servirà per fare collegare le persone alla vostra radio, quindi segnatevi da qualche parte (http://vostroindirizzoip:portatrovata)
5) Cambiare solo la velocità di Bit, deselezionate 135Kbps e selezionate 24Kbps
6) Ci siamo quasi..ora fate "fine" :)
7) Ora vi trovate davanti la schermata del prog, sopra ci sta il simbolo di play (avvia codifica) cliccate!!!
9) Dopo aver cliccato il play si dovrebbe aprire un volume alla vostra sinistra, sotto il volume ci sta il tasto
"mixer" cliccate e vi si apriranno vari volumi. Il vostro compito è trovare il volume della voce "Missaggio
Stereo" e selezionarlo
10) Ora aprite il Windows Media Player e fate partire la vostra musica :)...siete in onda :P
12) Per fare ascoltare la radio ad altre persone, è inutile dirlo (ma lo dico lo stesso) dovete dare la url del
vostro ip + la porta scelta - es. http://81.57.49.185:1353 da inserire ovviamente nel windows media
player dell'ascoltatore.
# uhm, un ultima cosa, per vedere le persone connesse alla vostra radio, andate alla linguetta "connessioni"
del programma, li troverete la scritta - client - seguita dagli ip delle persone connesse :)
- Per suggerimenti o delucidazioni <[email protected]> ciao! ;)
Dal linguaggio macchina ai linguaggi ad alto livello
Tipo Infobox: TIPS - Skill:
Ogni CPU ( Central Processing Unit, cioè Unità Centrale di Elaborazione ) di un computer è in grado di eseguire quella CPU.
Ogni CPU ( Central Processing Unit, cioè Unità Centrale di Elaborazione ) di un computer è in grado di eseguire quella CPU. Operazioni elementari sono,
ad esempio:
- copiare il contenuto di una locazione di memoria in un registro della CPU;
- copiare il contenuto di un registro in una locazione di memoria;
- effettuare un'operazione aritmetica o logica fra i contenuti di due registri.
Il linguaggio macchina è un linguaggio binario, questo significa che ogni istruzione è rappresentata da un numero binario, cioè da una sequenza di 1 e 0.
L'intero programma in linguaggio macchina è quindi una lunga sequenza da 1 e 0.
Scrivere un programma in questo modo è ovviamente molto difficile perchè non è immediato per il programmatore comprendere il significato di quello
che sta scrivendo. Il primo passaggio ad un livello di maggiore comprensibilità è costituito dal linguaggio assembly, nel quale ogni istruzione elementare è
codificata con simboli, che prevedono l'uso dei caratteri dell'alfabeto oltre alle cifre, e sono detti alfanumerici. Ad esempio, l'istruzione che aggiunge al registro A
della CPU il numero contenuto nella locazione 100, in un linguaggio macchina potrebbe essere codificata nel modo seguente:
101 10001 01100100
In questa scrittura, i caratteri 101 10001 formano il codice dell'istruzione "aggiungi ad A il contenuto della locazione che segue", mentre 01100100 è il
numero 100 scritto in base 2. In linguaggio assembly potrebbe essere scritta:
ADDA MEM
Nella quale ADDA è il codice alfanumerico dell'istruzione e MEM è un simbolo che rappresenta la locazione di memoria ( il cui valore viene definito all'inizio
del programma assembly).
Un programma scritto in assembly, per poter essere eseguito, deve essere tradotto in linguaggio macchina, sostituendo ai codici alfanumerici i corrispondenti
valori binari. I programmi che effettuano questa traduzione vengono detti assemblatori.
Scrivere programmi in assembly per risolvere problemi complessi richiede un tempo molto lungo, senza contare la difficoltà per trovarne gli errori o per
effettuare delle modifiche. Fin dagli anni '50 furono creati dei linguaggi, detti ad alto livello, che mettevano a disposizione del programmatore istruzioni più vicine
al suo mondo di pensare e di costruire gli algoritmi. I primi furono il FORTRAN (Formula Translation) ed il COBOL (Common Business Oriented Language),
destinati, rispettivamente, a programmi di tipo scientifico-matematico ed ad applicazioni riguardanti la gestione di archivi.
Successivamente vennero sviluppati molti linguaggio, tra i più noti ricordiamo il BASIC ( Begginers All Purpose Symbolic Instructional Code) un linguaggio
semplice destinato a chi iniziava ad apprendere la programmazione. Nel 1971 N. Wirth definì il linguaggio Pascal nel quale venivano applicati rigorosamente
i principi della programmazione strutturata e che si impose ben presto come linguaggio didattico. Negli anni '70 venne anche sviluppato il linguaggio C,
che si diffuse nella programmazione professionale, per le possibilità che offriva al programmatore esperto.
Dagli anni '80 in poi si è diffusa la programmazione orientata agli oggetti, per la quale si usano linguaggio quali Smalltalk, C++, Java, VisualBasic. In questi
linguaggi si raggiunge un livello di astrazione ancora maggiore, consentendo al programmatore di definire nuovi oggetti e le procedure con le quali è possibile
manipolarli, in modo tale che i dati del programma possano adattarsi alla rappresentazione più opportuna del problema.
I programmi scritti in linguaggio ad alto livello vengono tradotti in linguaggio macchina da altri programmi chiamati compilatori.
- Per suggerimenti o delucidazioni <[email protected]> ciao! ;)
Operatori
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
Gli operatori del PHP e la loro gerarchia sono comuni a quelli della maggior parte degli altri linguaggi di programmazione.
= : Assegnamento
+,-,*,/ : Operazioni fondamentali
+=,-=,*=,/= : Assegnamento con variabile destinazione anche come sorgente. Per esempio se esiste una variabile pippoPluto=5 e si utilizza uno di questi operatori per una nuova assegnazione, per esempio:
$pippoPluto+=11
pippoPluto dopo questa riga di codice conterrà il valore 16
++, -- : Incremento, decremento (di + o - 1). E' possibile utilizzare in 2 diversi modi l'operatore incremento-decremnento: prima o dopo la variabile cambiando il momento in cui l'operazione viene effettuata. Per esempio in un espressione con due variabili, $pippoPluto=3 e $inc=4 si potrebbero avere due casi:
$terza=$pippoPluto*(++$inc);
oppure
$terza=$pippoPluto*($inc++);
nel primo caso prima di eseguire o valutare l'espressione (nel caso di confronti) viene eseguito l'incremento della variabile $inc che dal valore 4 passa al valore 5. Il valore di terza sarà quindi $pippoPluto*5 cioè 3*5=15.
Nel secondo caso, con l'operatore posticipato alla variabile, viene prima eseguita o valutata l'espressione, solo dopo aver ottenuto il risultato verrà incrementata la variabile $inc, quindi $terza assumerà il valore di $pippopluto * 4 ovvero 3*4=12, solo dopo l'assegnamento di 12 alla variabile destinazione si andrà a incrementare $inc che assumerà il valore di 5.
&,|,! : Bitwise operation rispettivamente and, or, not. Queste operazioni possono essere eseguite tra variabili e vengono utilizzate per espressioni di tipo logico.
&&,||,!=,==,>,<,>=,<= : Operatori di confronto rispettivamente: and, or, diverso, uguale, maggiore, minore, maggiore o uguale, minore o uguale. Questi operatori si utilizzano tra 2 operandi, principalemente per il controllo del flusso (if, for, while,do-while, for etc...) o in espressioni comunque booleane. Nulla vieta di poterli utilizzare in espressioni numeriche facendo però attenzione ai risultati che provocano.
Il risultato di un confronto è un valore booleano, true oppure false. Nel linguaggio ANSI C che non era stato predisposto per valori di tipo bool perciò veniva considerato 1=true e 0=false. Tuttora anche in altri linguaggi come il PHP si può utilizzare anche il valore numerico 0=falso o NULL=falso o >0=vero o !NULL=vero per indicare verità o meno.
Le istruzioni di input/output
Tipo Infobox: TIPS - Skill:
I programmi non avrebbero alcuna utilità se non potessero acquisire informazioni dall'esterno (input di un dato) o fornire informazioni all'esterno (output di un dato).
I programmi non avrebbero alcuna utilità se non potessero acquisire informazioni dall'esterno (input di un dato) o fornire informazioni all'esterno (output di un dato). Nel linguaggio di progetto si sono definite queste operazioni come acquisisci il valore di una variabile e come comunica il valore di una variabile.
Nel linguaggio Pascal la più importante istruzione di input è:
Readln(nomevariabile)
Che acquisisce il valore digitato sulla tastiera e lo memorizza nella variabile il cui nome è scritto tra le parentesi. Ad esempio l'istruzione:
Readln(baseMaggiore);
Che ho introdotto nel programma "areaTrapezio" acquisisce il valore dalla tastiera e lo memorizza nella variabile di nome baseMaggiore.
A proposito dell'istruzione Readln va ancora notato che:
- Il valore scritto sulla tastiera, che è visualizzato sul monitor mentre viene scritto, è acquisito solamente dopo che si è premuto il tasto Invio;
- Una volta acquisito il dato il cursore si posiziona all'inizio della riga successiva;
- Se il dato digitato non è compatibile con il tipo della variabile viene generato un errore.
La principale istruzione di output del Pascal è:
Writeln(nomevariabile);
Il suo significato è "scrivi sul monitor il valore contenuto nella variabile il cui nome è posto tra le parentesi e sposta il cursore all'inizio della riga successiva".
Ad esempio, la sequenza di istruzioni,
Prezzo := 5000;
Writeln(prezzo);
Ha l'effetto di visualizzare sullo schermo il numero 5000.
Con la stessa istruzione possono essere scritti valori di più variabili, basta porre i nomi tra parentesi, separati da virgole. Mi fermo qua, penso di essere stato chiaro, alla prossima.