Joan Soler-Adillon || Tutorial de Processing
Despatx 52.803 (Campus de la comunicació, UPF) || 93 542 1238
----------------------------------------------------------------
----------------------------------------------------------------
TUTORIAL DE PROCESSING || Secció 3: Variables i constants
1. Variables
2. Constants
3. Declaració de variables i constants
4. Tipus de dades
5. Variables de sistema
Una variable és un espai en la memòria on guardem un valor. Cada variable té un nom únic (i fixe) que ens serveix per referir-nos-hi, i un valor que pot variar.
Dit d'una altra manera, és un contenidor d'un valor. Per exemple, d'un número enter. Quan programem, ens referim al contenidor (la variable) pel seu nom, i mai directament pel valor. No parlem de tres, o dos-cents tretze, sinó de "puntuacio" o "distanciaRespecteObjectiu", "edat", etc. El valor el podem conèixer, canviar i podem realitzar operacions amb ell. El nom no canvia mai.
Un exemple: Imagineu-vos que tenim un robot al costat de la porta capaz de fer copets (molt suaus!) de benvinguda al cap de la gent que entra a l'aula. Aquest robot realitza una sèrie de funcions (preparar el braç i la mà, aixecar-lo, fer els copets, replegar el braç...) que son sempre els mateixos. El que canvia és l'alçada a la que fa els copets. A vegades serà a 180 (cms), altres a 159, 175, etc.
Això seria el qeu entenem com a variable. Podriem dir-li "altura", i sería un valor que canvia cada cop que entra algú. Així, al robot només li hauriem de dir que fes les accions a una alçada nova i no caldria canviar res més de la programació:
En pseudocódi:
- estira el braç fins a "altura"
- fés els copets exactament a "altura"
- replega el braç
- estira el braç fins a "altura"
- fés els copets exactament a "altura"
- replega el braç
Un altre exemple: Una variable podria ser, dins l'aula, la distancia entre jo i la porta, anomenada "distanciaPorta", que és un valor enter expressat en centímetres. Si m'acosto a la porta, el valor de "distanciaPorta" disminueix. També puc multiplicar "distanciaPorta" per un altre número, o la puc comparar amb la distància d'algú altre, el qual em pot servir per a prendre decisions.
Així, si cal tancar la porta, podria comparar "distanciaPorta" amb la distancia de cert alumne amb la mateixa (diguem-li "distanciaAlumne"), per tal de decidir si la tanco jo mateix o li demano a l'alumne.
Aquest raonament, que quotidianament fem sense plantejar-nos-el, cal explicitar-lo pas a pas (és a dir, cal generar l'algorisme) quan estem treballant amb codi. El paragraf anterior, en pseudocodi, quedaria així:
[Pseudocodi]:
-Si "distanciaPorta" és menor a "distanciaAlumne"
-llavors l'obro jo mateix
-Si no, li demano a l'alumne
-Si "distanciaPorta" és menor a "distanciaAlumne"
-llavors l'obro jo mateix
-Si no, li demano a l'alumne
L'important és que, gràcies a les variables, si jo o l'alumne ens movem i les recalculem, podem executar el mateix codi que ens serveix per prendre la decisió. Si ens posem a córrer per l'aula i l'anem executant, cada vegada ens donaria un resultat diferent.
Les constants són exactament com les variables, però amb una característica que les fa diferents. Com es pot endevinar pel nom, les constants no canvien (no varien) sinó que mantenen sempre el mateix valor dins el programa.
Imagineu que estem definint un progama que definirà persones. Les variables serien doncs aquelles coses que canvien: Edat, pes, alçada, diners al compte bancari, etc. Les constants, en canvi, serien coses com el sexe, el color d'ulls o el número de cames.
3.- Declaració de variables i constants
Com en gairebé tots els llenguatges de programació, i en tots els seriosos, a Processing cal declarar les variables.
Això vol dir que abans de donar-li a la variable un nom i valor inicial (o nom i valor a seques en una constant), cal dir de quin tipus de dades constarà. Així, per una variable que té per valor un número enter
int distanciaAlumne = 445;
declara una variable anomenada "distanciAlumne", amb el valor 445, i del tipus de dades "enter" (integer). Ni el nom ni el tipus de dades d'una variable es poden canviar. Sempre es pot declarar una altra variable i convertir-la, però això ja és un altre tema...
Un com declarada una variable, la podem utilitzar:
int distanciaAlumne = 445;
print(distanciaAlumne);
print(distanciaAlumne);
El que es canvia, doncs, és el valor.
int a = 78;
println(a);
a = 99;
println(a);
println(a);
a = 99;
println(a);
o es poden fer operacions entre variables:
int a = 78;
float b = 13.46;
println(a*b);
float b = 13.46;
println(a*b);
Per sort, això tant abstracte te també la seva aplicació visual. Si dibuixo un quadrat, puc tenir com a variables la seva posició i mides:
int x = 78;
int y = 121;
int mida = 50;
rect(x,y,mida,mida);
int y = 121;
int mida = 50;
rect(x,y,mida,mida);
Fixeu-vos que en els primers exemples he utilitzat noms de variables que ténen a veure amb allò que contindrà la variable: distanciaAlumne, distanciaPorta... Això és una bona pràctica a adquirir des del principi, ja que és extremadament útil quan es multiplica el nombre de variables que utilitzem en els nostres projectes.
Fixeu-vos també amb la sintaxi de palaulesEncadenadesAmbMajuscules. Es tracta d'una convenció. Com que els noms de variables no poden contenir espais, cal utilitzar això, o_bé_separar_per_guions, si es vol utilitzar més d'una paraula i nosequiereunacadenaininteligible. La primera pràctica és molt més estesa. Això sí, una vegada la utilitzeu, recordeu que Processing és sensible a les majúscules i minúscules (case sensitive). És a dir, Processing no entendrà que aquestaVariable sigui igual a aquestavariable. És un aspecte a cuidar. Una bona pràctica pot ser utilitzar SEMPRE la sintaxi de les majúscules quan el nom d'una variable (o funció) consta de més d'una paraula.
Pel que fa a constants, la convenció és utilitzar noms en majúscules (SEXE, COLOR_ULLS...).
També és molt recomanable no utilitzar mai accents ni altres caràcters no anglesos ("ç", "ñ"...) en els noms de variables. No és lloc aquí de criticar l'imperialisme anglosaxó, però va per aquí. Al cap i a la fi són ells els qui han inventat els llenguatges de programació. Com a curiositat, programar és molt més còmode en un teclat americà que en el nostre.
El valor d’una variable ha de correspondre a un dels tipus de dades amb què el programa pot treballar. En concret, ha de correspondre al tipus de dades de la variable en qüestió. Els més utilitzats en Processing són int (números enters), float (número amb decimals), boolean (cert o fals), color i string (cadena de caràcters).
Com tot en Processing, són a la referència del programa, una eina excel·lent a tenir sempre en compte:
Aquests i altres tipus de dades es poden utilitzar com es veu en l'exemple següent:
boolean a; // true or false
byte b; // -128 to 127
char c; //carácter
color d;
float e; //número amb decimals
int f; // enter
String g; //cadena de caràcters
byte b; // -128 to 127
char c; //carácter
color d;
float e; //número amb decimals
int f; // enter
String g; //cadena de caràcters
a = false;
println(a);
b = -32;
println(b);
c = 'f';
println(c);
d = color(233,127,23);
println(d);
e = 983.243812;
println(e);
f = 78;
println(f);
g = "ceci nest pas une pipe";
println(g);
Les variables de sistema no deixen de ser variables. És a dir, ens hi referim pel seu nom i contenen un valor.
La seva característica especial és que no les podem declarar ni canviar-ne el valor ja que, d'una banda, al ser de sistema és aquest (el sistema, Processing) qui les calcula per nosaltres i, de l'altra, són accessibles des de qualsevol lloc del codi (les podem utilitzar en qualsevol punt del programa).
Ara per ara, ens interessen aquestes:
width : L'ample de la finestra (segons l'hem declarat a size())
height : L'alçada de la finestra (segons l'hem declarat a size())
mouseX : posición del ratolí a l'eix X dins la finestra de Processing
mouseY : posición del ratolí a l'eix Y dins la finestra de Processing
Amb width i height, ens estalviem d'anar mirant constantment size() per recordar quina mida de finestra estem utilitzant. I més important: Amb l'ús de width y height podem canviar la mida de la finestra en un sketch de Processing sense alterar la posició i mida relativa dels objectes:
size(300,300);
ellipse(width/2,height/2,width-20,height-20);
Si canviem la primera línia del codi, no cal tocar la segona:
size(120,120);
ellipse(width/2,height/2,width-20,height-20);
---------------------------------------------------------------------------------------