Sunteți pe pagina 1din 16

Curs Programare WEB

Curs 7

OPERATORI LA NIVEL DE BIT


La nivelul cel mai de jos stocarea in memorie se face la nivel de biti . Aceasta stocare
se face folosind sistemul binar de numeratie , cu cifrele 0 si 1 . De exemplu numarul
intreg 12 este reprezentat binar de 1100 si are nevoie de 4 biti pentru a fi stocat in
memorie . Pornind de la dreapta la stanga , 1100 poate fi calculat folosind expresia :
0*20 + 0*21 + 1*22 + 1*23 = 12
Atunci cand JS stocheaza numere intregi in memorie el rezerva cate 32 de biti pentru
fiecare . Indiferent daca vom introduce numere in sistemul zecimal , octal sau
hexazecimal JavaScript le va trasnforma in forma binara .
Pentru valorile negative , bitul cel mai din stanga , de nivelul cel mai ridicat ,
reprezinta o valoare negativa egala cu (231) . Folosindu-l , putem incepe cu (231) si
sa-i adaugam valori pozitive ( reprezentate de ceilalti 31 de biti ) , pentru a genera
orice numar negativ mai mare sau egal cu (231) .
JavaScript ne ofera acces la reprezentarea binara a unui numar intreg prin intermediul
operatorilor la nivel de bit . Cel mai simplu operator la acest nivel este operatorul unar
pentru complementar , simbolizat prin tilda "~" . Functia sa este de a inversa totii bitii
operandului sau . El este clasificat ca operator de negare , deoarece neaga fiecare bit.
Daca un bit are valoarea 1 va deveni 0 iar valoarea 0 va deveni 1 .
Gasirea complementarului poate fi descrisa astfel :
x=~12
x=~1100
x=0011
x=3
OPERATORI LOGICI LA NIVEL DE BIT
Cand folosim operatori logici la nivel de bit in JavaScript se cupleaza operanzii bit cu
bit , apoi se executa operatia asupra fiecarei perechi de biti . De exemplu , folosind
operatorul la nivel de bit AND asupra numerelor 01111 si 11011 vom obtine 01011 .
Echivalentele lor binare sunt aliniate de la dreapta la stanga , formand cinci perechi de
biti . Perechile sunt dupa aceea operate in mod independent si este generat un numar
nou .
Pentru a exemplifica cele de mai sus urmariti tabelul de mai jos :
EXPRESIE
0&1
1&1
1&0

REZULTATUL EXPRESIEI
0
1
0

1&1
1&1
&
|
^

1
1
operatorul la nivel de bit AND intoarce 1 daca ambii operanzi
sunt 1 , altfel intoarce 0
operatorul la nivel de bit OR intoarce 1 daca cel putin unul
dintre operanzi este 1 , altfel intoarce 0
operatorul la nivel de bit OR exclusiv intoarce 1 daca unul si
numai unul dintre operanzi este 1 , altfel intoarce 0

OPERATORI DE DEPLASARE LA NIVEL DE BIT


Acest tip de operatori folosesc doi operanzi . Operandul din stanga este un numar
intreg ai carui biti trebuie deplasati . Operandul din dreapta este numarul de biti cu
care trebuie deplasata reprezentarea binara a numarului intreg .
In continuare vom expune acesti operatori impreuna cu cate un exemplu de folosire ,
totul cadrat intr-un tabel :
OPERATOR
<<

>>

>>>

DESCRIERE
operatorul de deplasare spre stanga intoarce valoarea unui
numar intreg daca bitii sai au fost deplasati cu un numar de
locuri spre stanga . Totii bitii vacanti din dreapta sunt
completati cu zerouri . Exemplul de mai jos deplaseaza numarul
15 spre stanga cu 1 :
15<<1 --> intoarce 30 ( 1111<<1 intoarce 11110 )
In practica deplasarea spre stanga a unui numar intreg pozitiv
echivaleaza cu dublarea valorii sale de un numar de ori
corespunzator numarului de biti deplasati . Aceasta operatie
este executata de calculatoare mai rapid decat inmultirea
explicita cu 2 .
operatorul de deplasare spre dreapta intoarce valoarea unui
numar intreg daca bitii sai au fost deplasati cu un numar de
locuri spre dreapta . Toti bitii vacanti sunt completati cu copia
bitului cel mai din stanga ( bitul de semn ) . Copierea bitului cel
mai din stanga asigura ca numarul intreg va ramane fie pozitiv
fie negatic . Aceasta este de asemenea o modalitate de a imparti
un numar intreg pozitiv par de un numar de ori la 2 . In cazul
unui numar intreg pozitiv impar efectul este de impartire la 2 si
ignorarea restului . Mai jos avem si un exemplu :
15>>1 intoarce 7 ( 1111>>1 intoarce 0111 )
operatorul de deplasare spre dreapta si completare cu zerouri
intoarce valoarea unui numar intreg daca bitii sai au fost
deplasati cu un numar de zerouri spre dreapta . Toti bitii vacanti
la nivel mai mare sunt completati cu zerouri . Cand opereaza
asupra numerelor intregi pozitive acest operator produce acelasi
efect ca si cand s-ar folosi operatorul de deplasare spre dreapta
care transmite semnul .
Acest lucru se datoreaza faptului ca bitul de semn care este
copiat e totdeauna zero pentru numerele intregi pozitive . In
cazul numerelor intregi negative orice deplasare spre dreapta si

completare cu zerouri va modifica bitul de nivel cel mai ridicat


din 1 in 0 . Rezultatul va fi totdeauna un numar intreg mai mare
sau egal cu 0 . Mai jos avem si unele exemple :
15>>>1 intoarce 7 ( 1111>>>1 intoarce 0111 )
-15>>>1 intoarce 2147483640
( 11111111111111111111111111110001>>>1 intoarce
11111111111111111111111111111000 )
Trebuie sa mentionez ca lucrul propriu-zis cu biti sau la nivel de bit apare foarte
rar in JS . Este posibil ca niciodata in cadrul dezvoltarii de scripturi sa nu folosim
acesti operatori . Exista totusi unele cazuri speciale cand tratarea datelor in acest mod
devine necesara .
Un exemplu de astfel de situatie este atunci cand sunt necesari operatori la nivel de bit
pentru a transforma un numar din baza 10 in baza 16 . Acest lucru este necesar
deoarece JS ne permite sa afisam doar reprezentarea binara a unui numar aflat in
memorie . Nu vom dezvolta subiectul la acest moment dar atrag atentia ca exista
totusi cazuri desi extrem de rare cand va trebui sa utilizam acest tip de operatori la
nivel de bit .
PRECEDENTA OPERATORILOR
In cazul utilizarii expresiilor care folosesc mai mult de un operator JS nu evalueaza
expresia de la dreapta la stanga totdeauna , el tine seama de precedenta predefinita a
fiecarui operator . In cazul in care apar mai multi operatori cu aceeasi precedenta JS ii
va evalua de la stanga spre dreapta .
In tabelul de mai jos se prezinta operatorii in ordinea precedentei lor , cu operatorii
din partea de jos a tabelului avand precedenta maxima :
OPERATOR
,
= += -= *= /= %= <<= >>= >>>= &= ^= |=
?;
||
&&
|
^
&
== !=
< <= > >=
<< >> >>>
+ * / %
! ~ - ++ -() [] .

NUME OPERATOR
virgula
de atribuire
conditional
SAU logic
SI logic
SAU pe biti
XOR pe biti
SI pe biti
de egalitate
de comparatie
de deplasare be biti
de adunare/scadere
de inmultire/impartire
de negare/incrementare
de apelare , pentru structuri de
date

1.1 Structuri de control si cicluri ale limbajului


INSTRUCTIUNI CONDITIONALE
a. if
Aceasta este una dintre instructiunile cele mai des utilizate . Fiecare limbaj de
programare o detine intr-o forma sau alta si utilizarea ei nu poate fi evitata . Sintaxa ei
este :
in (conditie) {
instructiuni
}
"conditie" poate fi orice expresie logica . Daca rezultatul sau este true sunt executate
instructiunile din blocul if-ului , daca este false se trece peste bloc .
Ca o forma de a mentine scriptul cat mai lizibil se foloseste foarte des indentarea
instructiunilor blocului IF , dintre acolade . Acest lucru este de mare ajutor mai ales in
cazul imbricarii mai multor instructiuni IF .
b. if..else
In cazul in care nu putem utiliza un IF simplu trebuie sa apelam la o versiune a sa ,
instructiunea IF..ELSE , care executa un bloc de instructiuni in cazul in care conditia
are valoare true si alt bloc in cazul false . Sintaxa instructiunii apare mai jos :
if (conditie) {
instructiuni1
}
else {
instructiuni2
}
Exista posibilitatea imbricarii unui alt set IF..ELSE chiar pe una dintre ramurile
instructiunii initiale , creand astfel o metoda de a evalua mai multe scenarii posibile .
Mai jos avem un exemplu de utilizare a acestei instructiuni :
<html>
<head><title>JS</title></head>
<body>
<script type="text/javascript">
<!-var suma;
suma=10;
if (suma>500.00) {

document.write("Multumim !");
} else {
document.writeln("Multumim dar mai puteti cumpara ");
}
// -->
</script>
</body>
</html>
In acest exemplu utilizatorul va primi doua mesaje diferite , in functie de valoarea
variabilei "suma" .
INSTRUCTIUNI DE CICLARE
a. for
Pentru a incepe un ciclu intr-un script utilizam instructiunea FOR . Sintaxa generala a
instructiunii este urmatoarea :
for ( initializare ; conditie ; ciclu) {
instructiuni
}
Cele trei expresii dintre parantezele rotunde sunt optionale dar daca omitem una dintre
ele semnul punct si virgula trebuie sa ramana , in acest mod fiecare expresie ramanand
in locul in care trebuia sa apara .
De obicei folosim "initializare" pentru a da o valoare initiala si de multe ori chiar
pentru a declara unei variabile pe care o vom folosi drept index sau contor al
ciclului . Apoi "conditie" este evaluata la true inainte de fiecare executie a
instructiunilor dintre acolade . . "ciclu" incrementeaza sau decrementeaza variabila
folosita drept contor al ciclului .
In exemplul de mai jos vom folosi o instrucitune FOR pentru a afisa numerele intre 0
si 50 :
<script type="text/javascript">
<!-document.write("Numere intre 0 si 50 ");
document.write('<hr size=0 width=25%>');
for (var i=0;i<51;i++) {
document.write(i+" , ");
}
// -->
</script>
Ca si in cazul instructiunii IF si la FOR poate apare imbricarea instructiunilor .
Deoarece nu suntem limitati la un singur ciclu imbricat putem creste numarul FORurilor imbricate la oricate dorim .

b. for..in
Aceasta instructiune necesita cunostinte despre obiectele JS asa ca in mod normal va
trebui sa reveniti asupra ei dupa introducerea acestor elemente in cadrul lucrarii - in
capitolele urmatoare .
Cu FOR..IN putem executa cate un set de instructiuni pentru fiecare proprietate dintrun obiect . Putem folosi ciclul cu orice obiect JS , indiferent daca are sau nu
proprietati . Pentru fiecare proprietate se executa cate o iteratie , asa ca daca obiectul
nu are nici o proprietate nu se desfasoara nici un ciclu . FOR..IN lucreaza si cu
obiectele particularizate ; o variabila a unui astfel de obiect JS este considerata o
proprietate si astfel se executa cate un ciclu pentru fiecare . Sintaxa comenzii este :
for ( proprietate in obiect ) {
instructiuni
}
"proprietate" este un literal de tip sir generat de JS . Pentru fiecare ciclu lui
"proprietate" i se atribuie urmatorul nume de proprietate continut in "obiect" , pana ce
sunt folosite toate .
Exemplul de mai jos foloseste aceasta functie pentru a afisa fiecare nume de
proprietate din obiectul Document , alaturi de toate valorile proprietatilor :
<script type="text/javascript">
<!-var obiect=document;
var info="";
for (var numeProprietate in obiect) {
info=numeProprietate+" = "+obiect[numeProprietate];
document.write(info+"<br>");
}
//-->
</script>
c. while
Aceasta comanda actioneaza asemanator cu un ciclu FOR , dar nu include si functia
de initializare sau incrementare a variabilelor . Trebuie sa declaram variabilele inainte
si sa le incrementam sau decrementam in blocul de instructiuni . Sintaxa sa este :
while (conditie) {
instructiuni
}
In exemplul de mai jos vom prezenta o variabila logica drept indicator pentru a
determina daca mai continuam sau nu ciclul . Aceasta variabila , status , este stabilita
la false si ciclul se intrerupe :

<script type="text/javascript">
<!-var i=0;
var rezultat=0;
var status=true;
document.write("0");
while(status) {
rezultat+=++i;
document.write(" + "+i);
if (i==10) {
status=false;
}}
document.writeln(" = "+rezultat);
//-->
</script>
d. do..while
Aceasta instructiunie a fost introdusa incepand cu versiunea 1.2 a JavaScript .
Diferenta fata de instructiunea "while" consta in executarea totdeauna cel putin o data
a setului de instructiuni aferent lui "do..while" ; acest lucru este posibil datorita
faptului ca expresia conditionala este verificata dupa prima iteratie a comenzii .
Sintaxa sa apare sub forma :
do {
instructiuni}
while (conditie);
e. break si continue
Atunci cand folosim un ciclu acesta , in mod predefinit , continua sa se execute pana
ce conditia specificata devine falsa . Uneori insa exista cazuri cand avem nevoie sa
putem iesi dintr-un ciclu inainte de a fi ajuns la finalul sau . Acest lucru se face
adaugand fie "break" fie "continue" in blocul de instructiuni al ciclului .
Instructiunea "break" intrerupe definitiv ciclul , in timp ce "continue" sare peste
instructiunile ramase din iteratia curenta , evalueaza expresia ciclului ( daca exista ) si
trece la urmatoarea iteratie .
In scriptul de mai jos puteti vedea in actiune aceste doua instructiuni . Programul
calculeaza prin incercari succesive radacina patrata a numarului "n" .
Se porneste cu i=0 , ciclul "for" incepe afisand valoarea lui i . Apoi , scriptul verifica
daca n nu este negativ ; in caz ca este ciclul este intrerupt definitiv . Daca n este
pozitiv atunci i este inmultit cu propria valoare si rezultatul este comparat cu n . Daca
rezultatul este mai mic decat n atunci i este stocat ca fiind - pentru moment - cel mai
mare numar care este egal sau mai mic decat radacina patrata a lui n . Instructiunea
"continue" sare peste restul ciclului curent si porneste din nou de la inceputul ciclului

dupa incrementarea lui i . In momentul in care i la patrat este mai mare decat n
scriptul trece la instructiunea "break" care opreste complet ciclarea :
<script type="text/javascript">
<!-var maxNumar=-;
var n=101;
document.write("<hr>Numarul a carui radacina o cautam este "+n+"<br>");
for (var i=0;i<n;i++) {
document.write(i+"<br>");
if (n<0) {
document.write("N este negativ !");
break;
}
if (i*i<=n) {
maxNumar=i;
continue;
}
document.write("<br>Terminat");
break;
}
document.write("<br>Numarul gasit : "+maxNumar);
//-->
</script>
f. label
Tot incepand cu versiunea JavaScript 1.2 limbajul ne ofera si modalitati de a fi mai
specifici atunci cand folosim "break" sau "continue" . Instructiunea "label" poate fi
plasata inaintea oricarei structuri de control care poate imbrica alte instructiuni , ceea
ce ne permite sa iesim dintr-o instructiune conditionala sau dintr-un ciclu la o locatie
specifica din script .
Pentru a da un exemplu practic al utilizarii acestei instructiuni executati scriptul care
urmeaza :
<script type="text/javascript">
<!-var stopX=3;
var stopY=8;
document.write("Toate perechile x,y dintre (0,0) si (");
document.write(stopX+" , "+stopY+"):<br>");
loopX:
for (var x=0;x<10;++x) {
for (var y=0;y<10;++y) {
document.write("("+x+" , "+y+") ");
if ((x==stopX) && (y==stopY)) {
break loopX;
}

}
document.write("<br>");
}
document.write("<br>Dupa terminarea loopului , x este : "+x);
document.writeln("<br>Dupa terminarea loopului , y este : "+y);
//-->
</script>
In programul nostru avem un ciclu "for" etichetat cu "loopX" , ceea ce ne permite sa
intrerupem sau sa continuam acest ciclu indiferent cat de imbricat este programul la
momentul respectiv . "loopX" este adaugata la instructiunea "break" pentru a opri
ambele cicluri "for" . Fara eticheta instructiunea "break" ar fi intrerupt numai ciclul
care genera valori pentru y .
g. with
Aceasta comanda este folosita pentru a evita specificarea in mod repetat referirea la
obiect , atunci cand ii accesam proprietatile sau metodele . Orice proprietate sau
metoda dintr-un bloc "with" pe care JS nu o recunoaste este asociata cu obiectul
specificat pentru acel bloc .
Sintaxa instructiunii apare in cele ce irmeaza :
with (obiect) {
instructiuni
}
"obiect" specifica referirea la obiect care trebuie folosita , daca aceasta nu exista in
blocul "instructiuni" . Este foarte util cand folosim functii matematice avansate ,
disponibile prin intermediul obiectului "Math" . Acest obiect va fi si el detalia mai
tarziu asa ca nu va faceti probleme despre el deocamdata .
Pentru a exemplifica folosirea acestei instructiuni sa introducem scriptul de mai jos :
<script type="text/javascript">
<!-with(document){
write("hello");
write("<br>Acum putem evita folosirea obiectului ca prefix al functiei");
}
//-->
</script>
In mod normal atunci cand folosim metodele "write()" sau "writeln()" asociate cu
obiectul "Document" apelarea lor se face sub forma :
document.write("Text");
Folosind instructiunea "with" putem scurta codul sursa , utilizand direct numele
metodelor fara prefixul cu numele obiectului .

h. switch
Aceasta instructiune este folosita pentru a compara o valoare cu altele dintr-o lista .
Exista si posibilitatea folosirii instructiunii "if" pentru a obtine acelasi rezultat dar
aplicarea acestuia in cazul unei liste de valori mai mari devine extrem de greoaie si
duce la aparitia de numeroase erori legate de sintaxa si lizibilitate .
Pentru a introduce sintaxa instructiunii sa analizam direct scriptul de mai jos :
<script type="text/javascript">
<!-var cerere="Nume";
switch(cerere) {
case "Logo": document.write('<img src="logo.jpg" alt="logo"><br>');
break;
case "Nume": document.write('Software SRL.');
break;
case "Produse": document.write('Produse');
break;
default: document.write('www.site.ro');
break;
}
//-->
</script>
Sintaxa instructiunii este identica cu cea din limbajele C sau Java , prezentarea ei
teoretica fiind :
switch(variabila) {
case valoare1_variabila : instructiuni ; break ;
case valoare2_variabila : instructiuni ; break ;
...
default : instructiuni ; break ;
}
Valoarea variabilei este comparata pe rand cu valorile din instructiunile "case" ; in
cazul in care nu este gasita nici o egalitate se executa automat instructiunile din cadrul
etichetei "default" .
In cazul in care ar lipsi instructiunile "break" functionarea "switch"-ului ar fi
modificata . De la momentul la care valoarea variabilei s-a "potrivit" cu cea a unei
etichete "case" se vor executa in continuare toate instructiunile din fiecare eticheta
"case" care eventual mai exista .
1.2 Functii JavaScript
O functie JS este de fapt un script care este desprins ca o sectiune separata de cod si
careia i se da un nume . Folosind acest nume un alt script poate apela executarea

acelei sectiuni de oricate ori are nevoie de el . Aceasta posibilitate exista in marea
majoritate a limbajelor de programare chiar daca denumirea specifica este functie ,
metoda , procedura sau subrutina .
Cand sunt apelate functii acestea pot primi si unele valori , numite argumente . Aceste
argumente pot fi folosite ca variabile in cadrul functiei respective . Dupa ce date sunt
atribuite unei variabile putem sa le prelucram sau sa le folosim in calcule si ,
eventual , sa returnam un rezultat .
CREAREA FUNCTIILOR
Sintaxa folosita pentru a crea o functie este :
function numeFunctie ( argument1 , argument2 , .. ) {
instructiuni
}
Cuvantul cheie care specifica existenta functiei este "function" ; in cazul in care nu
dorim sa introducem nici un argument este totusi obligatorie folosirea parantezelor
dupa nume functiei .
DECLARAREA FUNCTIILOR
O functie poate fi declarata in orice pozitie in cadrul unui script . Singura restrictie
este legata de imposibilitatea declararii unei functii in cadrul altei functii sau in
interiorul unei structuri de control .
Exista insa inca un element de care trebuie sa tinem seama in practica . Asa cum unele
blocuri diferite ale unui document HTML saunt incarcate inaintea altora acelasi lucru
este valabil si pentru scripturile inglobate in aceste blocuri . Din aceasta cauza este de
preferat ca functiile sa fie declarate in sectiunea <head> a documentului HTML ; acest
lucru asigura disponibilitatea lor in cazul in care un alt script trebuie sa le utilizeze
imediat .
<head>
<script type="text/javascript">
<!-function culori() {
document.fgColor="red";
document.bgColor="blue";
}
//-->
</script>
</head>
<body>
<script type="text/javascript">
<!-culori();
document.writeln("OK");
//-->

</script>
Scriptul de mai sus are ca efect modificarea culorilor de fundal si principale ale
paginii web . In cazul in care functia "culori()" ar fi declarata dupa scriptul din
sectiunea <body> atunci ea nu ar realiza nimic deoarece apelul scriptului anterior ei ar
cauta o functie care la momentul acela nu a fost incarcata .
APELAREA FUNCTIILOR
Dupa cum ati putut vedea si in exemplul anterior de script apelarea unei functii se face
prin numele ei urmat de paranteze rotunde ; in cazul in care functia trebuie sa preia si
un numar de parametri acestia sunt introdusi in interiorul parantezelor rotunde .
ARGUMENTE TRIMISE FUNCTIILOR
Definirea unei functii cu parametri ( argumente ) da posibilitatea utilizarii ei in mai
multe moduri .
Spre a da un exemplu sa consideram problematica realizarii unei functii care este
refolosita de mai multe ori in program dar una dintre valorile din interiorul ei trebuie
sa se modifice la fiecare apelare a functiei .
Aceasta problema in particular poate fi solutionata si prin folosirea de variabile
globale dar pentru moment vom folosi solutia unei functii cu argumente .
<head>
<script type="text/javascript">
<!-function daBinar(intreg) {
var rezultat="";
var rezultatScurt="";
for (var i=1;i<32;i++) {
if (intreg & 1 == 1) {
rezultat="1"+rezultat;
rezultatScurt=rezultat;
} else {
rezultat="0"+rezultat;
}
intreg=intreg>>1;
}
return(rezultatScurt);
}
//-->
</script>
</head>
<body>
<script type="text/javascript">
<!-var sirBinar="";

x=9;
document.write(x);<head>
<script type="text/javascript">
<!-function binar(intreg) {
var rezultat="";
var rezultatScurt="";
for (var i=1;i<32;i++) {
if (intreg & 1 ==1) {
rezultat="1"+rezultat;
rezultatScurt=rezultat;
} else {
rezultat="0"+rezultat;
}
intreg=intreg>>1;
}
return(rezultatScurt);
}
//-->
</script>
</head>
<body>
<script type="text/javascript">
<!-var sirBinar="";
x=9;
sirBinar=daBinar(x);
document.write("Numarul "+x+" in binar este :");
document.write(sirBinar);
document.writeln("Variabila x este egala cu : "+x);
x=255;
sirBinar=daBinar(x);
document.write("Numarul "+x+" in binar este :");
document.write(sirBinar);
document.writeln("Variabila x este egala cu : "+x);
//-->
</script>
</body>
Cand apelam functia "daBinar()" aceasta primeste o copie a valorii care este stocata in
"x" . Acest proces se numeste transfer prin valoare . Valoarea este apoi atribuita
variabilei "intreg" iar aceasta poate fi folosita ca variabila locala a functiei . Daca
"intreg" isi modifica valoarea in cadrul functiei aceasta nu va afecta valoarea lui "x"
Observati si folosirea cuvantului cheie "return" . Acesta face ca functia sa returneze o
valoare spre locatia din program care a apelat-o .
Putem folosi functii care intorc valori oriunde folosim o expresie normala . Unele
functii intorc rezultatul unui set de calcule in timp ce altele intorc o valoare logica
pentru a anunta starea desfasurarii unei operatii ( cu succes sau nu ) .

MODIFICAREA NUMARULUI DE ARGUMENTE


O functie accepta un anumit numar de argumente - specificare care apare in momentul
declararii ei . Apar insa cazuri in care dorim sa transmitem functiei un numar diferit
de argumente ; aceasta se obisnuieste atunci cand se apeleaza o functie care foloseste
acelasi parametru de fiecare data , dar este construita pentru a trata cazuri speciale .
Intr-un astfel de caz putem folosi o valoare prestabilita in interiorul functiei daca nu
sunt transferate argumente .
In cele ce urmeaza introducem un script care afiseaza un mesaj de salut atunci cand
utilizatorul ajunge la o pagina web . Programul afiseaza unul dintre mesaje dupa cum
cunoaste sau nu numele vizitatorului . Daca "numeUser" nu este null variabila a fost
definita . Acest lucru este posibil numai daca o valoare , ca "Presedinte" , a fost
transferata functiei . Daca functia este egala cu null atunci scriptul evita folosirea
variabilei in mesajul de salut .
<head>
<script type="text/javascript">
function mesaj(numeUser) {
if (numeUser!=null) {
document.writeln("Salut " +numeUser); }
else {
document.writeln("\"Bine ati venit in siteul nostru!\"");
}
}
//-->
</script>
<body>
<script type="text/javascript">
<!-document.writeln("Primul apel al functiei mesaj()<br>");
mesaj("Presedinte");
document.writeln("<br><br>Al doilea apel al functiei<br>");
mesaj();
//-->
</script>
O alta posibilitate este ca unei functii sa-i fie transferate mai multe argumente decat au
fost specificate la declararea ei . Valorile suplimentare nu sunt pierdute ci se stocheaza
intr-un tablou numit "arguments" , care exista implicit pentru orice functie . Toate
argumentele sunt stocate in acest tablou si pot fi extrase in interiorul blocului de
instructiuni al functiei . De exemplu , pentru a extrage primul argument transferat
functiei "mesaj()" din exemplul anterior folosim instructiunea :
primulArgument = mesaj.arguments[0]
Toate tablourile JS sunt indexate pornind de la 0 . Ca sa gasim numarul total de
argumente transferate putem folosi o instructiune speciala care ne returneaza lungimea
unui tablou :

numarArgumente = mesaj.arguments.length
Implementand instructiunile de mai sus s-a creat o noua versiune a scripturilor
anterioare pentru a raspunde mai corect in functie de faptul cunoasterii sau nu a
numelui vizitatorului :
<head>
<script type="text/javascript">
function mesaj(numeUser) {
if (numeUser!=null) {
document.writeln("Salut din nou "+numeUser);
} else {
document.writeln("Bine ati venit la site-ul nostru");
}
numarArgumente=mesaj.arguments.length;
if(numarArgumente>1) {
for (var i=1;i<numarArgumente;i++) {
document.writeln(mesaj.arguments[i]);
}}}
</script>
</head>
<body>
<script type="text/javascript">
var numeUser="Alex", extraMesaj="Nu ne-am vazut de mult";
var numeUser2=null;
var extraMesaj1="Vrei sa devii membru ?";var extraMesaj2="Te poti inscrie online";
mesaj(numeUser,extraMesaj);
document.writeln("<hr>");
mesaj(numeUser2,extraMesaj1,extraMesaj2);
</script>
</body>
TRANSFERUL OBIECTELOR PRIN REFERINTA
Desi problematica obiectelor JS o vom detalia in capitolul urmator e bine de stiut inca
de acum ce se intampla cand folosim obiectele in conjunctie cu functiile - mai exact
ce se intampla atunci cand folosim ca argument pentru o functie un obiect .
Cand se transfera unei functii , ca argument , un tip de date simplu - ca sir , numar sau
boolean - acest transfer se face prin valoare , acest lucru insemnand ca functia uzeaza
practic de o copie a variabilei , orice modificari aduse de functie neafectand originalul
.
Atunci cand transferam unei functii un argument obiect acesta este transferat prin
referinta . Acest lucru inseamna ca functia are dreptul - si chiar o face - sa modifice
direct originalul obiectului . Luand in considerare acest fapt JS aduce si posibilitatea
de a "impacheta" un tip simplu de date in interiorul unui obiect , in cazul in care
prefeream transferul prin referinta al unei variabile de un tip simplu .

FUNCTII RECURSIVE
O functie JS poate fi recursiva , adica se poate autoapela . Cea mai des intalnita
modalitate de a demonstra aceasta capacitate este rezolvarea ecuatiilor factoriale .
In continuare vom vedea un exemplu de functie JS recursiva care afla factorialul unui
numar dat "n" .
function factorial(n) {
var rezultat;
if (n>0) {
rezultat=n*factorial(n-1);
} else if (n==0) {
rezultat=1;
} else {
rezultat =null;
}
return(rezultat)
}
Acest model de functie cred ca nu mai necesita explicatii foarte laborioase , ea
verificand intai daca "n" este mai mare decat 0 , apoi in caz afirmativ "n" se
inmulteste cu rezultatul intors de apelarea functiei cu argumentul "n-1" . In momentul
in care "n" ajunge 0 aparitia cea mai imbricata a functiei se incheie si intoarce prima
valoare . JS se retrage si incheie fiecare functie imbricata pana ce ajunge la apelarea
initiala a functiei "factorial" , apoi intoarce rezultatul final .