Am văzut în cadrul episodului anterior cum putem transmite anumite valori unei funcții și funcția poate opera cu ele. Dar, este posibil și o comunicare în sens invers; în urma executării unei funcții, apelantul poate primi o valoare. Se spune că funcția returnează acea valoare.
Să presupunem că vrem să determinăm ultima cifră a unui număr. Am putea scrie următoarea funcție:
|
1 2 3 |
def ultima(n: Int): Int = { return n % 10 } |
Vedem două lucruri diferite față de situația in care nu returnăm nimic.
Prima diferență este aceea că, pe linia 1, înainte de semnul = apare semnul :, urmat de un tip de dată, în cazul nostru Int. În Scala, trebuie să specificăm tipul valorii returnate.
Ca și precizare, o funcție care nu returnează nimic are tipul Unit. Când o funcție nu returnează nimic, tipul poate lipsi. Mai există o excepție, când nu suntem obligați să precizăm tipul, dar nu este importantă acum.
A doua diferentă este cuvântul return care apare pe linia 2. Acesta este folosit în cadrul unei instrucțiuni care precizează valoarea care trebuie returnată de funcție. În cazul nostru returnăm ultima cifră, adică restul împărțirii la 10 a parametrului. Nu va funcționa corect pentru numere negative, dar acest lucru nu este relevant acum.
Putem face ce vrem cu valoarea returnată de o funcție. De exemplu, o putem atribui unei variabile. Funcția noastră ar putea fi apelată astfel:
|
1 |
var c = ultima(2457) |
Valoarea variabilei c va fi 7. Probabil v-ați dat seama deja, funcția poate fi utilizată în cadrul expresiilor. De exemplu, am putea avea:
|
1 |
var v = ultima(2457) + ultima(47) |
În această situație, valoarea variabilei v va fi 14.
Mai trebuie să precizăm faptul că, în Scala, după executarea instrucțiunii care returnează o valoare, nicio altă instrucțiune din cadrul funcției nu se mai execută. Evident, avem excepții, dar nu sunt importante acum.
Putem avea mai multe instrucțiuni return în cadrul unei funcții, dacă ambele au șanse să fie apelate. De exemplu, următoarea funcție este corectă:
|
1 2 3 4 5 6 7 |
def paritate(nr: Int): String = { if (nr % 2 == 0) { return "Număr par" } else { return "Număr impar" } } |
În funcție de valoarea variabilei nr, una dintre cele două instrucțiuni return se va executa.
Dar, următoarea variantă nu mai este corectă (cea de-a treia instrucțiune return nu are șanse să se execute):
|
1 2 3 4 5 6 7 8 |
def paritate(nr: Int): String = { if (nr % 2 == 0) { return "Număr par" } else { return "Număr impar" } return "Altceva" } |
Este obligatoriu ca o funcție să returneze o valoare. Așadar, oricâte ramificații am avea, este obligatoriu ca, la un moment dat, să fie întâlnită o instrucțiune care returnează o valoare (cu excepția cazului când tipul funcției este Unit). Varianta care urmează nu este corectă:
|
1 2 3 4 5 |
def paritate(nr: Int): String = { if (nr % 2 == 0) { return "Număr par" } } |
Dacă parametrul nu este par, nu este întâlnită nicio instrucțiune de returnare. În schimb, am putea scrie următoarea funcție:
|
1 2 3 4 5 6 7 8 9 |
def paritate(nr: Int): String = { var a = 0 if (nr % 2 == 0) { return "Număr par" } else { a += 1 } return "Altceva" } |
Cam ciudat codul, dar este valid. Până la urmă este întâlnită o instrucțiune de returnare, indiferent dacă parametrul este par sau nu.
Să revenim puțin la funcțiile fără tip (sau cu tip Unit). Putem folosi instrucțiunea return și în cadrul lor; nu precizăm și o valoare returnată; efectul este întreruperea execuției funcției.
Ca și regulă generală, atunci când folosim instrucțiunea return este obligatoriu să specificăm faptul că funcția returnează Unit(adică nici o valoare).
Să presupunem că am dori să scriem o funcție care afișează un număr pe care îl primește ca parametru, dar numai dacă acesta este par. Una dintre variantele prin care aceasta ar putea fi implementată este:
|
1 2 3 4 5 6 |
def paritate(nr: Int): Unit = { if (nr % 2 != 0) { return } println(nr) } |
Se poate evita întreruperea execuției (pentru acest exemplu adăugând un simplu else), dar de multe ori este mult mai simplu să întrerupem execuția în anumite cazuri, evitând scrierea de condiții din ce în ce mai complicate.
Va urma
În cadrul episodului următor vom vedea în ce condiții putem folosi o variabilă. Vom vedea ce se întâmplă cu variabilele declarate în interiorul funcțiilor, precum și ce se întâmplă cu modificările aduse parametrilor funcțiilor.
