Soluţii - PC Magazine Romania, Iulie 2002
Soluţii web client-side cu JavaScript
Iulian Radu
Scrierea corectă a unei bucăţi de cod în JavaScript
În acest articol vor fi prezentate modurile în care se scrie corect un cod JavaScript
în cadrul paginilor web. Pentru început, o variantă care afişează un mesaj în
navigatoarele care nu ştiu de existenţa tag-urilor <SCRIPT>:
1. <SCRIPT LANGUAGE="JavaScript">
2. <! Mesajul care urmează va fi afişat doar de navigatoarele care nu înţeleg
JavaScript >->
3. <! > <HR><H1>Această pagină necesită JavaScript</H1>1>
4. <! > Navigatorul dumneavoastră web nu este capabil să execute programe
în JavaScript,t,
5. <! > astfel încât nu puteţi să folosiţi această pagină. Vă rugăm
să luaţi în considerare folosireaea
6. <! > ultimei versiuni a navigatorului Netscape Navigator sau Microsoft
Internet Explorer.r.
7. <! > <HR> >
8. <! începem comentariul HTML care ascunde script-ull
9. Codul JavaScript este introdus aici -.
10. // terminarea comentariului HTML care ascunde script-ul >>
11. </SCRIPT>
Liniile 1 şi 11 delimitează scriptul nostru în JavaScript. Deoarece JavaScript
recunoaşte succesiunile de caractere "<!-" şi "//" ca începutul unui comentariu
ce se termină la sfârşitul liniei, ne vom folosi de acest lucru. JavaScript
va considera că în liniile 2-8 şi 10 avem comentarii şi le va ignora. În schimb,
navigatorul va considera comentariu doar ce se află între "<!-" şi ">>".
Astfel, el va afişa codul HTML aflat în liniile 3-7, dar va considera comentariu
tot ce se află în liniile 2 şi 8-10. Atenţie, nu fiţi tentaţi în baza exemplelor
următoare să puneţi cod JavaScript după "<!-". Tot ce va apărea după aceste
caractere va fi ignorat (vezi mai sus explicaţiile).
Dacă o pagină de web conţine cod JavaScript, înseamnă că are nevoie de el şi
dacă pagina trebuie să fie funcţională pentru vizitator, atunci singura soluţie
este să creăm o variantă a paginii în format HTML pur şi să facem apel la scripturile
CGI. În continuare este dată varianta în care pagina ce foloseşte JavaScript
este diferită de cea cu HTML pur. Vizitatorul trebuie să acceseze în mod implicit
pagina cu HTML pur care va conţine la începutul ei următorul cod:
1. <HEAD>
2. <SCRIPT LANGUAGE="JavaScript"> <! încep ascunderea script-ull
3. window.location = "my_js_home_page.html";
// termin ascunderea script-ului >>
4. </SCRIPT>
5. <TITLE>Pagina mea de intrare
(Versiunea care nu înţelege JavaScript)</TITLE>
6. </HEAD>
7. <BODY>
8. Pagina în format HTML
pur este introdusă aici -.
9. </BODY>
În linia 3 indicăm navigatorului că dorim să accesăm o nouă pagină denumită
"my_js_home_page.html" şi care este echivalentul paginii curente, doar că include
şi cod JavaScript. Trebuie remarcat că dacă utilizatorul foloseşte butonul BACK
al navigatorului, se va întoarce la această pagină care îl va retrimite în cea
care conţine cod JavaScript. În acest fel este creată o buclă. Soluţia constă
în folosirea funcţiei "location.replace". Un exemplu de utilizare a acestei
funcţii apare în unul din exemplele următoare.
Dacă avem multe pagini ce conţin scripturi JavaScript, atunci este indicat
ca denumirile paginilor cu cod JavaScript să fie asemănătoare cu cele ce conţin
doar cod HTML pur. Să presupunem că paginile cu cod JavaScript au prefixul js_.
În acest caz se poate folosi scriptul următor (în realitate scriptul este mai
complex pentru că trebuie să se ţină cont de separatorul folosit de sistemul
de operare de pe serverul de web pentru separarea numelor de directoare şi fişiere
în cadrul definirii căilor) în locul celui precedent:
1. <SCRIPT> <! încep ascunderea script-ull
2. var path = window.location.path;
3. var filename = path.substring(path.lastIndexOf("/") + 1, path.length);
4. window.location = path.substring
(0, path.lastIndexOf("/")) + "/js_" + filename;
5. // termin ascunderea script-ului
>> </SCRIPT>
În linia 2 obţin URL-ul paginii curente, din care obţin în linia 3 în variabila
filename numele paginii curente. În linia 4 îi indic navigatorului numele noii
pagini pe care doresc să o încarce şi să o afişeze.
Soluţiile prezentate până acum afişau un mesaj care indica lipsa facilităţilor
de script în navigatoarele care înţeleg doar HTML.
În continuare este prezentată o soluţie pentru cazul în care sunt necesare facilităţile
oferite de JavaScript 1.1, dar navigatorul recunoaşte doar JavaScript 1.0:
1. <SCRIPT LANGUAGE="JavaScript"> <!-
2. _version = 10; // >> </SCRIPT>
3. <SCRIPT LANGUAGE="JavaScript1.1"> <!-
4. _version = 11; // >> </SCRIPT>
5. <SCRIPT LANGUAGE="JavaScript"> <!-
6. if (_version < 11) {
7. document.write('<HR><H1>
Această pagină necesită JavaScript 1.1</H1>');
8. document.write('Navigatorul
dumneavoastră acceptă doar JavaScript 1.0<HR>');
9. }
10. // >> </SCRIPT>
11. <SCRIPT LANGUAGE="JavaScript1.1">
12. <! Mesajul care urmează va fi afişat doar de navigatoarele care nu înţeleg
JavaScript >->
13. <! > <HR><H1>Această pagină necesită JavaScript 1.1</H1>1>
14. <! > Navigatorul dumneavoastră nu poate executa script-uri JavaScript.<HR>R>
15. <! încep ascunderea script-ull
16. Codul JavaScript 1.1 este introdus aici -.
17. // termin ascunderea script-ului >>
18. </SCRIPT>
În liniile 2 şi 4 atribuim variabilei _version un cod ce ne indică numărul
celei mai noi versiuni de JavaScript înţeleasă de către navigator. În liniile
6-9 afişăm mesajul de avertizare dacă nu este suportat JavaScript 1.1, dar este
suportat JavaScript 1.0. În liniile 13 şi 14 afişăm mesajul în navigatoarele
care nu înţeleg scripturi.
Dacă dorim să încărcăm o nouă pagină atunci codul va arăta aşa:
1. <SCRIPT LANGUAGE="JavaScript1.1"> <!-
2. location.replace(unescape(location.search.substring(1)));
3. self.loading = true;
4. // >> </SCRIPT>
5. <SCRIPT LANGUAGE="JavaScript">
6. <! > <HR><H1> Această pagină necesită JavaScript 1.1</H1>1>
7. <! > Navigatorul dumneavoastră nu poate executa script-uri JavaScript.<HR>R>
8. <!
9. if (!self.loading) {
10. document.write('<HR><H1> această pagină necesită JavaScript
1.1</H1>');
11. document.write('Navigatorul dumneavoastră acceptă doar JavaScript 1.0<HR>');
12. }
13. // >>
14. </SCRIPT>
Avantajul acestui script este că obţine adresa paginii ce conţine codul JavaScript
1.1 direct din URL-ul paginii curente; se presupune că aceasta a fost apelată
în genul:
http://site/path/html_js1.0.html?path2/html_js11.html
În linia 2 observăm folosirea funcţiei "replace" a obiectului Location (aminteam
la începutul articolului). Apelarea acestei funcţii va conduce la înlocuirea
paginii curente cu cea specificată, atât pe ecran cât şi în lista history a
navigatorului (lista cu URL-urile vizitate). Citirea din "location.search" ne
întoarce şirul care apare după semnul întrebării în URL-ul paginii curente (inclusiv
semnul întrebării). De aceea vom extrage din acest şir toate caracterele cu
excepţia primului (aplicarea funcţiei "substring" cu argumentul 1). Definim
şi o proprietate atribuită ferestrei curente ("self" este identic cu "window")
denumită "loading" şi care să ne indice dacă este în curs de încărcare pagina
în format JavaScript 1.1.
Se observă că în liniile 8 şi 13 nu am mai pus şi comentariul care indica rolul
acelor linii. Acest lucru nu este bun, deoarece în cadrul unor script-uri mari
este posibil să nu mai fie evident rolul lor.
Dacă navigatorul dumneavoastră ştie JavaScript, dar în cadrul tag-ului <SCRIPT>
nu recunoaşte atributul SRC, se poate utiliza următoarea variantă:
1. <SCRIPT SRC="utils.js"> <!-
2. var path = location.path;
3. location = path.substring(0, path.lastIndexOf("/")) +"utils.html";
4. // >></SCRIPT>
În linia 3 apelăm o pagină web care are inclusă în ea codul scriptului JavaScript
aflat în fişierul de sine stătător "utils.js".
Obţinerea de date despre navigatorul web
1. <SCRIPT LANGUAGE="JavaScript">
2. function _get_version() {
3. return Math.round(parseFloat(navigator.appVersion) * 1000);
4. }
5. function _get_os() {
6. if (navigator.appVersion.indexOf("Win95") > 0) return "WIN95";
7. else if (navigator.appVersion.indexOf("Win16") > 0) return "WIN31";
8. else if (navigator.appVersion.indexOf("Win") > 0) return "WIN";
9. else if (navigator.appVersion.indexOf("Mac") > 0) return "MAC";
10. else if (navigator.appVersion.indexOf("X11") > 0) return "UNIX";
11. else return "UNKNOWN";
12. }
13. var browser = new Object();
14. if (navigator.appName.substring(0,8) == "Netscape") {
15. browser.name = "NN"; }
16. else if (navigator.appName.substring(0,9) == "Microsoft") {
17. browser.name = "MSIE"; }
18. else {
19. browser.name = navigator.appName; }
20. browser.version = _get_version();
21. browser.os = _get_os();
22. browser.langlevel = 1000;
23. </SCRIPT>
24. <SCRIPT LANGUAGE="JavaScript1.1">
25. browser.langlevel = 1100;
26. </SCRIPT>
27. <SCRIPT LANGUAGE="JavaScript1.2">
28. browser.langlevel = 1200;
29. </SCRIPT>
În liniile 2-4 definim o funcţie denumită "_get_version" care extrage versiunea
şi o prelucrează. De exemplu, va întoarce 3000 pentru Internet Explorer 3.0.
Funcţia "_get_os" definită în liniile 5-12 încearcă să identifice sistemul de
operare. În linia 13 creăm un obiect denumit "browser" şi care nu are nici o
proprietate. În liniile 14-19 definim o proprietate denumită "name", în care
memorăm un cod ce identifică numele firmei care a creat navigatorul. În liniile
20 şi 21 creăm alte două proprietăţi (denumite "version" şi "os") care memorează
ce versiune de navigator afişează pagina şi pe ce sistem de operare. În liniile
22 şi 24-29 identificăm versiunea cea mai recentă de JavaScript pe care o înţelege
acest navigator.
Afişarea unei ferestre de erori mai detaliată
De multe ori constatăm că avem o eroare în codul nostru JavaScript, dar nu primim
nici o informaţie din partea navigatorului ca să identificăm unde anume este
ea. De aceea, cea mai bună metodă este de a ne crea propria funcţie de afişare
în caz de eroare.
Iată o astfel de soluţie:
<SCRIPT LANGUAGE="JavaScript">
function report_error(msg, url, line) {
var w = window.open("","error_javascript","resizable,status,width=600,height=400");
var d = w.document;
d.write('<DIV align=center>');
d.write('<H1><B>Eroare JavaScript detectată !</B></H1>');
d.write('<HR SIZE=4 WIDTH="80%">');
d.write('<INPUT TYPE="button" VALUE="Dismiss" onClick="self.close()">');
d.write('</DIV><DIV align=right>');
d.write('<BR>Mesaj de eroare: ' + msg);
d.write('<BR>Document: ' + url);
d.write('<BR>Număr line: ' + line);
d.write('<BR>Versiune navigator: ' + navigator.userAgent);
d.write('</DIV>');
d.close();
return true;
}
self.onerror = report_error;
</SCRIPT>
Pentru a testa funcţionarea, puteţi introduce ulterior următoarea comandă JavaScript
care va activa apelarea funcţiei "report_error":
</SCRIPT>
self=null;
</SCRIPT>
Se observă că funcţia va afişa în cadrul aceleiaşi ferestre toate mesajele
de anunţare a erorilor JavaScript. Astfel, la sfârşit va fi afişată practic
ultima eroare întâlnită. Dacă se doreşte ca pentru fiecare eroare să fie afişată
o fereastră diferită se poate implementa o variabilă care să memoreze a câta
eroare este şi care să fie adăugată la numele ferestrei care se deschide.
Afişarea unei liste cu proprietăţile unui obiect
Acest script va afişa toate proprietăţile obiectului specificat:
1. <SCRIPT LANGUAGE="JavaScript">
2. function display_prop(obj, pad) {
3. for(i in obj){
4. the_obj=obj[i];
5. the_type=typeof(the_obj);
6. the_pad=pad+"."+i;
7. str=" <b>"+the_pad+":</b> "+the_obj+" <i>("+the_type+")</i>";
8. document.write(str+"<br>"); }
9. }
10. display_prop(self,"self",1);
11. </SCRIPT>
În liniile 2-9 definim funcţia care va afişa proprietăţile obiectului respectiv.
Argumentul "obj" va primi obiectul ale cărui proprietăţi dorim să le vizualizăm
şi "pad" va conţine un şir care va fi afişat în faţa proprietăţilor obiectului
(cel mai indicat este să fie chiar numele obiectului). În cazul nostru, afişăm
toate proprietăţile ferestrei curente (obiectul referit prin "self"; vezi linia
10). Deoarece în JavaScript proprietăţile unui obiect pot fi accesate ca şi
cum am avea o listă asociativă, în linia 3 ne folosim de bucla de tip for/in
pentru a extrage numele proprietăţilor obiectului. Creăm o nouă scurtătură denumită
"the_obj" spre proprietatea obiectului (care poate fi la rândul lui un obiect).
Folosim funcţia "typeof" pentru a obţine un şir ce descrie de ce tip este argumentul
trimis ei la apelare. Şirul întors va aparţine unuia dintre următoarele tipuri:
"boolean", "function", "number", "object", "string" sau "undefined". În variabila
"str" asamblăm şirul care va fi introdus în document folosind funcţia "document.write".
Afişarea datei la care a fost modificată pagina
<SCRIPT LANGUAGE="JavaScript">
document.write(document.lastModified);
</SCRIPT>
Pur şi simplu afişăm şirul întors de citirea proprietăţii "lastModified" a
obiectului ce reprezintă documentul curent. Pentru a vedea ce alte proprietăţi
mai sunt asociate obiectului Document, folosiţi scriptul dat în cadrul exemplului
"Afişarea unei liste cu proprietăţile unui obiect", apelând funcţia astfel "display_prop(self.document,'
self.document')".
AfiŞarea unui ceas în linia de stare
1. <SCRIPT LANGUAGE="JavaScript">
2. function display_time_in_status_line(){
3. var d = new Date();
4. var h = d.getHours();
5. var m = d.getMinutes();
6. var ampm = (h >= 12)?"PM":"AM";
7. if (h > 12) h -= 12;
8. if (h == 0) h = 12;
9. if (m < 10) m = "0" + m;
10. defaultStatus = h + ':' + m + ' ' + ampm;
11. setTimeout("display_time_in_status_line()", 60000);
12. }
13. </SCRIPT>
14. <BODY onLoad="display_time_in_status_line();">
15. -.
16. </BODY>
În liniile 2-13 definim o funcţie care va afişa în linia de status a navigatorului
(cea de la baza ferestrei acestuia) timpul curent. În linia 3 creăm o variabilă
denumită "d", care va conţine ora curentă. În liniile 4 şi 5 extragem ora şi
minutele în variabilele "h" şi respectiv "m". Atribuim lui ampm, în linia 6,
un şir care identifică în care jumătate a zilei ne aflăm. În liniile 7-9 facem
pregătirile pentru o afişare frumoasă a timpului curent. În linia 10 stabilim
ca valoare implicită a textului afişat în linia de status timpul curent (el
va fi modificat temporar când se va atribui o valoare proprietăţii "status"
a ferestrei curente). În linia 11 instruim navigatorul să apeleze în mod automat
această funcţie după un minut (un minute conţine 60000 ms). Această funcţie
va fi prima dată apelată după ce întreaga pagină a fost încărcată (pentru aceasta
folosim evenimentul "onLoad" al ferestrei curente).
Afişarea unei liste cu cookie-urile care se aplică documentului curent
1. <SCRIPT LANGUAGE="JavaScript">
2. function display_cookies(){
3. var cookies=document.cookie.split(";");
4. str="Cookie-urile documentului curent:\n\n";
5. for(i=0; i<cookies.length; i++){
6. str += unescape(cookies[i]) + "\n";}
7. alert(str);
8. }
9. </SCRIPT>
Deoarece citirea din "document.cookie" întoarce un şir ce conţine subşiruri
de tipul "nume=valoare" despărţite prin virgulă, apelăm la funcţia "split" care
va crea o listă cu aceste subşiruri. Fiecare element al acestei liste va fi
de forma: nume_cookie=valori
Apelarea unui URL pe baza unei liste
1. <SCRIPT LANGUAGE="JavaScript">
2. function go_there(){
3. var f=document.the_form.the_select.options;
4. for(i=0; i<f.length; i++) {
5. if( f[i].selected ) {
6. location = f[i].value;
7. break; }
8. }
9. }
10. </SCRIPT>
11. </HEAD>
12. <BODY>
13. <FORM NAME="the_form" onSubmit="go_there(); return false;">
14. <INPUT TYPE=submit VALUE="Vizualizare">
15. <SELECT NAME="the_select" SIZE=10>
16. <OPTION VALUE="content.html" SELECTED>Cuprins
17. -.
18. <OPTION VALUE="index-example.html">Index exemple
19. </SELECT>
20. </FORM>
21. </BODY>
Acest script ne permite să afişăm o listă de URL-uri şi după alegerea descrierii
unuia dintre ele şi apelarea butonului "Vizualizare" să vedem pagina corespunzătoare.
Pentru aceasta folosim handler-ul de evenimente "onSubmit" asociat tag-ului
"FORM" (vezi linia 13) din care apelăm funcţia definită în liniile 2-9. Întoarcem
"false" ca să nu încerce şi navigatorul apelarea URL-ului asociat form-ului.
În cadrul funcţiei, în linia 3, creăm o scurtătură definind variabila f ce conţine
referinţa la opţiunile tag-ului "SELECT" denumit "the_select". În liniile 4-8
căutăm acea opţiune care este selectată şi folosim valoarea câmpului "VALUE"
a acelei opţiuni pentru a apela noua pagină. Deoarece am solicitat deja afişarea
noului URL, nu mai are rost să continuăm ciclul. Dacă modificaţi numele form-ului
sau al select-ului, nu uitaţi să modificaţi şi în script numele asociat lor.
Animaţie de imagini
1. <IMG SRC="frame0.gif" NAME=animation>
2. <SCRIPT LANGUAGE="JavaScript1.1">
3. var max_frame = 10;
4. var num_loaded_images = 0;
5. var frame = 0;
6. var timeout_id = null;
7. function count_images() {
8. num_loaded_images++;
9. if (num_loaded_images == max_frame){
10. animate();}
11. }
12. images = new Array(max_frame);
13. for(var i = 0; i < max_frame; i++) {
14. images[i] = new Image();
15. images[i].onload = count_images;
16. images[i].src = "frame" + i + ".gif";
17. }
18. function animate(){
19. document.animation.src = images[frame].src;
20. frame = (frame + 1)%max_frame;
21. timeout_id = setTimeout("animate()", 250);
22. }
23. </SCRIPT>
24. <FORM>
25. <INPUT TYPE=button VALUE="Start" onClick="if (timeout_id==null &&
num_loaded_images==max_frame) animate()">
26. <INPUT TYPE=button VALUE="Stop" onClick="if (timeout_id) clearTimeout(timeout_id);
timeout_id=null;">
27. </FORM>
În linia 1 afişăm prima imagine din animaţie; restul de imagini trebuie să
aibă exact aceleaşi dimensiuni ca şi aceasta. Îi dăm şi un nume pentru a ne
putea referi uşor la ea când trebuie să o înlocuim. În liniile 3-6 definim variabile
în care memorăm câte frame-uri are animaţia, numărul de imagini off-screen deja
încărcate, numărul frame-ului care trebuie să fie afişat (0-max_frame-1) şi,
respectiv, o variabilă a cărei valoare să ne indice dacă trebuie să acceptăm
pornirea/oprirea animaţiei. Funcţia "count_images", definită în liniile 7-11,
înregistrează câte imagini au fost încărcate. În momentul când au fost toate
aduse în cache-ul local se porneşte în mod automat animaţia (vezi liniile 9
şi 10). În linia 12 definim variabila de tip listă care va conţine toate imaginile
off-screen. În liniile 14-16 aducem imaginile şi ne folosim de handler-ul de
evenimente "onload" al obiectului Image pentru a putea înregistra câte imagini
au fost aduse. Atenţie, ordinea liniilor 15 şi 16 nu poate fi schimbată, existând
altfel riscul ca o imagine să fie luată din cache-ul navigatorului şi să nu
fie înregistrată ca adusă. Funcţia "animate" realizează animaţia propriu-zisă.
De remarcat că tot ce avem de făcut este să modificăm valoarea proprietăţii
"src" a imaginii deja afişate pentru a afişa noua imagine. În linia 21 instruim
navigatorul să apeleze din nou această funcţie după 1/4 minute (creăm o animaţie
de 4 fps). În liniile 24-27 construim două butoane care ne permit să pornim/oprim
animaţia.
Verificarea câmpurilor unui form
1. <SCRIPT LANGUAGE="JavaScript1.1">
2. function isblank(s) {
3. for(var i = 0; i < s.length; i++) {
4. var c = s.charAt(i);
5. if ((c != ' ') && (c != '\n') && (c != '\t')) {
6. return false; }
7. }
8. return true;
9. }
10. function verify(f) {
11. var msg, empty_fields = "", errors = "";
12. for(var i = 0; i < f.length; i++) {
13. var e = f.elements[i];
14. if (((e.type == "text") || (e.type == "textarea")) && !e.optional)
{
15. if ((e.value == null) || (e.value == "") || isblank(e.value)) {
16. empty_fields += "\n " + e.name;
17. continue; }
18. if (e.numeric || (e.min != null) || (e.max != null)) {
19. var v = parseFloat(e.value);
20. if (isNaN(v) || ((e.min != null) && (v < e.min)) || ((e.max !=
null) && (v > e.max))) {
21. errors += "- The field " + e.name + " must be a number";
22. if (e.min != null) {
23. errors += " that is greater than " + e.min; }
24. if (e.max != null && e.min != null) {
25. errors += " and less than " + e.max; }
26. else if (e.max != null) {
27. errors += " that is less than " + e.max; }
28. errors += ".\n"; }
29. }
30. }
31. }
32. if (!empty_fields && !errors) return true;
33. msg += "Form-ul nu poate fi trimis deoarece are următoarele erori.\n____\n\n"
34. if (empty_fields) {
35. msg += "- The following required field(s) are empty:" + empty_fields + "\n";
36. if (errors) {
37. msg += "\n"; }
38. }
39. msg += errors;
40. alert(msg);
41. return false;
42. }
43. </SCRIPT>
44. <FORM onSubmit="
45. this.firstname.optional = true;
46. this.phonenumber.optional = true;
47. this.zip.min = 0;
48. this.zip.max = 99999;
49. return verify(this);">
50. Nume: <INPUT TYPE=text NAME="firstname">
51. Prenume: <INPUT TYPE=text NAME="lastname"><BR>
52. Adresă:<BR><TEXTAREA NAME="address" ROWS=4 COLS=40></TEXTAREA><BR>
53. Cod poştal: <INPUT TYPE=text NAME="zip"><BR>
54. Număr de telefon: <INPUT TYPE=text NAME="phonenumber"><BR>
55. <INPUT TYPE=submit>
56. </FORM>
În liniile 2-9 definim o funcţie denumită "isblank" care întoarce "true" dacă
şirul trimis ca argument este gol sau conţine doar caractere spaţii. În liniile
10-42 definim funcţia "verify" care primeşte ca argument form-ul ce trebuie
verificat. Această funcţie va fi apelată din handler-ul de evenimente "onSubmit"
al form-ului (vezi liniile 44-49). În linia 13 definim variabila "e" care va
conţine pe rând fiecare element al form-ului. Ne interesează doar elementele
de tip "text" şi "textarea" care nu sunt opţionale (vezi linia 14). Dacă avem
un astfel de câmp şi este gol atunci îl adăugăm la lista de câmpuri goale, denumită
"empty_fields" (vezi liniile 15-17). Apoi verificăm dacă câmpurile trebuie să
fie de tip numeric (au una din următoarele proprietăţi: "numeric", "min" sau
"max") şi dacă se încadrează în limitele stabilite (vezi liniile 18-29). Dacă
totul este în regulă, în linia 32 terminăm executarea funcţiei intorcând valoarea
"true". În liniile 33-40 pregătim mesajul şi îl afişăm, iar în linia 41 terminăm
funcţia întorcând valoarea "false", care la rândul ei este întoarsă navigatorului
şi care îi indică faptul că form-ul nu trebuie să fie trimis. Liniile 50-54
conţin câmpurile form-ului, iar în linia 55 definim butonul de trimitere a form-ului.
|
