Pc Magazine Romania - Ţara de dincolo de negură

AgoraNews

PC Magazine Ro

NET Report

Ginfo

agora ON line

PC Concrete

Liste de discuţii

Cartea de oaspeţi

Mesaje

Agora

Clic aici

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.