Fundamentele programării (XIII) - Scala

de Claudiu Soroiu · 22 august 2015

Am văzut până acum că avem șiruri de caractere (string-uri) și acestea sunt foarte utile pentru a reprezenta texte. Dar, poate avem nevoie și de alte tipuri de șiruri... De exemplu, am putea avea nevoie de șiruri de numere.

Șiruri

Putem spune că un șir este o colecție de valori, puse împreună, care au o denumire. Sunt întâlnite diverse denumiri pentru acest concept: șir, vector, listă sau englezescul array. În Scala, termenul folosit este, de obicei, array.

Pentru a lucra cu șiruri va trebui să le declarăm, să le dăm valori și să dăm valori și elementelor care fac parte din șir.

În Scala, șirurile trebuie să conțină elemente de același tip. Pentru a declara un șir va trebui să specificăm tipul elementelor din șir, să precizăm că de fapt vrem să avem un șir, nu o simplă variabilă și să alegem o denumire. Pentru a declara și inițializa un șir de numere întregi care poate fi format din 10 elemente, declarația folosită ar putea fi:

var a = new Array[Int](10)

1	var a = new Array[Int](10)

După cum observăm, inițializarea este puțin mai ciudată. Folosim cuvântul new pentru a preciza că este vorba de un nou șir, urmat de cuvântul Array; între paranteze drepte punem tipul elementelor din șir și apoi numărul elementelor cuprins între paranteze rotunde.

Accesarea elementelor

Șirurile sunt excelente pentru a lucra cu date care au sens să fie grupate. Putem evita să declarăm câte o variabilă pentru fiecare. Putem avea zeci, sute sau mii de valori care sunt păstrate împreună și avem o singură variabilă. Dar, cum lucrăm cu valorile individuale? Cum vedem care este primul element al șirului, care este al doilea și așa mai departe?

Într-un array, elementele sunt numerotate (începând cu 0). Numărul de ordine al unui element în șir poartă denumirea de indice. Pentru a accesa un anumit element, trebuie să folosim variabila care reprezintă șirul, urmată de indicele respectiv, cuprins între paranteze drepte.

De exemplu, pentru a da o valoare celui de-a șaselea element al șirului nostru, am putea scrie:

a(5) = 47

a(5) = 47

Observați că am scris a(5), nu a(6), fiindcă numerotarea începe de la 0. În acest mod putem da valori tuturor elementelor șirului.

Dar, dorim și să accesăm valorile acestor elemente. Acest lucru se realizează în același fel. Pentru a scrie valoarea celui de-a șaselea element al șirului, am putea folosi instrucțiunea:

println(a(5))

1	println(a(5))

Inițializare mai simplă

Am văzut că trebuie să inițializăm șirul și apoi să precizăm valorile tuturor elementelor. De exemplu, dacă am dori să avem un șir care să conțină numărul zilelor din lunile anului, am putea avea o secvență de genul:

var zile = new Array[Int](12)
zile(0) = 31
zile(1) = 28
zile(2) = 31
zile(3) = 30
zile(4) = 31
zile(5) = 30
zile(6) = 31
zile(7) = 31
zile(8) = 30
zile(9) = 31
zile(10) = 30
zile(11) = 31

var zile = new Array[Int](12)

zile(0) = 31

zile(1) = 28

zile(2) = 31

zile(3) = 30

zile(4) = 31

zile(5) = 30

zile(6) = 31

zile(7) = 31

zile(8) = 30

zile(9) = 31

zile(10) = 30

zile(11) = 31

Am presupus că nu avem de-a face cu un an bisect...

Pare complicat și ne-ar plăcea să putem face mai simplu. Din fericire, ni se oferă o prescurtare:

var zile = Array[Int](31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

1	var zile = Array[Int](31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

Putem specifica șirul cuprins între acolade, elementele sale fiind separate prin virgule. Nu mai este necesar să precizăm câte elemente are șirul; numărul elementelor va fi egal cu numărul valorilor dintre acolade.

Șiruri ca parametri

Putem folosi șiruri cam peste tot unde am folosit un tip simplu. De exemplu, putem crea funcții ale căror parametri să fie șiruri; am putea avea o funcție care are doi parametri; primul este numărul zilelor din lunile anului; al doilea este numărul de ordine al unei luni (numerotarea începe cu 0); funcția va afișa numărul zilelor din luna respectivă. Un program ar putea fi:

object Zile extends App {
  def zile(an: Array[Int], luna: Int) = {
    println(an(luna))
  }

  var anBisect = Array[Int](31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
  var anNebisect = Array[Int](31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
  zile(anBisect, 7)
  zile(anNebisect, 7)
  zile(anBisect, 1)
  zile(anNebisect, 1)
}

object Zile extends App {

def zile(an: Array[Int], luna: Int) = {

println(an(luna))

}

var anBisect = Array[Int](31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

var anNebisect = Array[Int](31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

zile(anBisect, 7)

zile(anNebisect, 7)

zile(anBisect, 1)

zile(anNebisect, 1)

}

Observăm câteva aspecte interesante:

indicele nu trebuie să fie un număr întreg precizat ca atare; putem folosi o variabilă (în acest caz un parametru al funcției) care are ca valoare un număr întreg;
pentru fiecare apel am ales șirul pe care să îl transmitem ca argument al funcției; două apeluri folosesc zilele din anii bisecți și două zilele din anii nebisecți.

Limbajul Scala ne permite și o construcție utilă uneori:

zile((31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31), 1)

1	zile((31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31), 1)

Va urma

Până acum am folosit șirurile doar pentru a simplifica puțin codul și a reduce numărul variabilelor declarate. Vom vedea în episodul următor că șirurile aduc numeroase alte beneficii.