Instalarea programului Perl se face astfel: 4)

1)click pe programul pstudio.exe si aleg yes

2)

next

3) aleg yes

1
 6)

5) next

Finish
si try

2
7)
pentru scripturi windows aleg ca mai sus si open
8)salvarea fisierelor se face astfel:numefisier.pl
PROG
9)executarea se face din meniul PERL ALEG RUN PERL INTERPRETER
RAM
ARE
PERL
ASPE
CTE
TEOR
ETIC
E

3
 Tipuri de date
•Variabilã =zonã (de obicei contiguã)de memorie în care se stocheazã o valoare de un anumit tip, zonei
fiindu-I asociat un nume (identificator al acelei variabile) Scalar
•Aceastã zonã poate fi publicã sau privatã,permanentã sau temporarã pe arcursul e
executiei unui program (simpl
•Numele unei variabile trebuie sã înceapã e)–
cu o literã si poate contine caracterele alfa-numerice si "_". Pentru
• Clasificare gener
–Tipuri scalare (simple) area
•Intregi (cu semn sau nu) unor
•Numere flotante caract
•Siruri de caractere ere
–Tipuri complexe special
•Tablouri indexate e(e.g.,
•Tablouri associative NewLi
• Scalare (simple) ne,
– Intregi cu semn, numere flotante, TAB,
siruri de caractere …) se
– Variabilele de tip scalar au numele precedat de $ vor
– Nu trebuie declarate explicit inainte de a fi utilizate utilize
– Implicit, o variabila numerica are valoarea 0, caract
iar una caracter are valoarea sirul vid "" erele
$nr_studenti++; escap
$pi = 3.14152965; e (ca
$limbaj = "Perl"; in
• Scalare (simple) cazul
– Variabilele de tip sir de caractere au valori incadrate limbaj
intre ghilimele sau apostrofuri ului C)
$prenume = "Hermann"; •
$nume = 'Hesse'; \
# variabilele vor fi expandate n≡Ne
$scriitor = "$prenume $nume"; wLine
# variabilele nu vor fi expandate •
$scriitor2 = '$prenume $nume';

4
\t≡TAB •
• Cheile
\" ≡"$ sau
$salut ="Buna ziua!\nSalut iar!\n"; valoril
e nu
Complexe sunt
– Tablouri indexate ordon
• Liste ordonate de valori scalare (numere, siruri) ate
• Elementele listei sunt disponibile prin intermediul •
unui indice numeric Variab
• Numele unor variabile de tip tablou indexat incepe cu @ ilele
@limbaje = ("Lisp", "C", "Java", "Perl"); de tip
@mix = ("Pink", 1978, "Floyd", $pi); tablou
$primul_limbaj = $limbaje[0]; asocia
@primele_3 = @limbaje[0..2]; # sub-tablou tiv
• Un tablou poate contine elemente eterogene, sunt
de tipuri scalare diferite prefix
• Pentru a adauga si sterge elemente la sfirsitul unui tablou ate de
se vor folosi functiile push() si pop() %
push (@limbaje, "Prolog"); %cure
$eliminat = pop (@limbaje); nte =
• Aflarea lungimii unui tablou ("reali
$nr_limbaje = @limbaje; sm"
$nr_limbaje = scalar (@limbaje); => 4,
• Pot fi utilizate si in partea stinga a unei atribuiri "expre
($primul, $al_doilea) = @limbaje; sionis
($primul, @restul) = @limbaje; m" =>
($studenti, $profesori) = ($absenti, 3); 10,
• Elementele se pot ordona cu functia sort() "mode
• Inversarea unei liste de elemente rnism
se poate face cu reverse() " =>
33);
– Tablouri asociative
• Indicele numeric este substituit de un sir de caractere
• Liste de perechi (cheie, valoare)
5
$romane_moderne = $curente{"modernism"}; $0-
• Intre acolade vor fi precizate doar nume de chei, numel
nu valori ale cheilor e
• Cheile nu pot fi accesate speficind valorile lor progra
intre acolade mului
• O cheie trebuie sa fie unica, care
dar valorile cheilor pot fi duplicate se
• Lista cheilor este furnizata de functia keys() execut
• Lista valorilor este data de functia values() a
• Functia each() furnizeaza o pereche (cheie, valoare) •
@lista_curentelor = keys %curente; $_ -
($curent, $romane) = each (%curente); intrare
• Inserarea unui element intr-un tablou asociativ se face printr-o constructie de genul: a
# 10 romane baroce implici
$curente{"baroc"} = 10; tã sau
spatiul
• Exemplu de parcurgere a unui tablou asociativ de
while (($curent, $romane) = each (%curente)) { cautar
print "Din curentul $curent sunt disponibile e intr-
$romane romane.\n"; un sir
}
•
• Sortarea cheilor – functia sort()
# Lista sortata a curentelor
@curente = sort (keys (%curente));

• Un element se poate elimina cu delete()

• Existenta unui element se verifica prin exists()
if exists ($curente{"baroc"}) {
delete ($curente{"baroc"});
}
Numele $variabila, @variabila si %variabila se refera la tipuri diferite de variabile si se pot utiliza fara a
genera ambiguitati
$studenti ≠%studenti ≠@studenti–
Variabile predefinite
•
6
@ARGV -argumentele furnizate scriptului ($ARGV[0] refera primul argument, nu numele programului) $tobe
• =1;
%ENV -variabilele de mediu $fals
=$tobe
Testarea existentei unei variabile se poate realiza and
cu functia defined() not
– In mod normal, variabilele vor fi disponibile pe tot cuprinsul programului – domeniul de vizibilitate $tobe;
(scopul) este implicit global $adeva
rat
– Pentru a face o variabila locala o vom declara cu my sau local
=(7>
my $scriitor_preferat = "Hermann Hesse";
3) or
Operatori (3<=
• Aritmetici: + - * / % ** $stude
$unu = 1; nti);
$doi = $unu + $unu; –
$patru = $doi * 2; Constr
$doi = $patru / $doi; uctii
$opt = $doi ** 3; # 2 la puterea 3 echiva
$unu = ($opt - $unu) % 2; # restul impartirii lente:
• De incrementare/decrementare: ++ -- and
$unu = 1; ≡&&,
$doi = ++$unu; # $doi = 2, $unu = 1
or ≡||,
$doi = $unu++; # $doi = 1, $unu = 2
not ≡!
$scriitori++; # $scriitori = $scriitori + 1
$fals
=$tobe
• Destinati sirurilor: x . && !
# un rind de 80 de caractere ~@rind = ('~') x 80; $tobe;
# concatenarea a doua siruri $salut = 'Buna' . 'ziua';
•De
• De comparare (relationali):
test: ?
– Comparare numere: <, >, <=, >=, ==, !=
:
– Comparare siruri: lt, gt, le, ge, eq, ne
• De definire a unui interval: ..
print (1 .. 33); # de la 1 la 33
@combinatii = ('aa' .. 'zz');

•Logici: and or not

7
print $nume eq "Hesse" ?"Eel!" :"Nu-iel!"; – –
•De asignare:
$variabila OP= $valoare; #OP – un operator Perl C
$variabila =$variabila OP $valoare; o
n
s
t
Instructiuni r
• Expresii evaluate pentru efectele lor colaterale
u
• Formeaza partea centrala a oricarui program Perl, prelucrind datele stocate in variabile
c
• O secventa de instructiuni formeaza un bloc,delimitat in general intre acolade {}
t
• Fiecare instructiune trebuie terminata de ;
i
• In afara de instructiuni,un program mai poate cuprinde declaratii
a
• Tipuri de instructiuni: de asignare, de test, de control
• De asignare
e
– Ataseaza unei variabile o valoare corespunzatoare unui anumit tip de date
l
– Exemple:
s
$numar_romane_citite = 33;
e
$numar_romane_citite += 3;
$cursuri[1] = ’Programare Perl’;
p
o
• De test – if
a
– Evalueaza o expresie si in functie de valoarea evaluata se va executa un bloc e instructiuni
t
if ($nr_studenti >= 30) {
print ("Multi studenti la curs:)\n"); e
} else {
print ("Cam putini studenti!\n"); l
} i
– Un sir este evaluat ca fals, daca este vid "" sau contine o valoare nula "0" p
– Un numar e evaluat ca fals daca este 0 sau 0.0 s
– Orice valoare nedefinita este considerata falsa i

• De test – unless –
– Complementara lui if unless ($nr_studenti >= 30) { print ("Cam putini studenti!\n"); } else { print
("Multi studenti la curs:)\n"); } A

8
 {
tit if cit si unless pot fi scrise in forma postfixata print "E chiar el" if $nume eq "Hesse" or $nume eq
"Hermann"; print
$nr_studenti-- unless $nr_studenti; "$nota
\n"
• De control unless
– while $nota !
• Evalueaza o expresie si daca valoarea evaluata este adevarata se va executa blocul de instructiuni, dupa = 10;
care se va reevalua expresia si daca valoarea evaluata este adevarata se va executa blocul de instructiuni, }
dupa care se va reevalua expresia si daca… (aproape ad infinitum) print
$studenti = 1; "Gata\
while ($studenti <= 10) { n";
print ("$studenti pe pinza de paianjen...\n"); foreac
$studenti++; h
} $curen
print "Gata!\n"; t (sort
(keys
(%cur
• De control– do ente)))
• Complementara lui while, evaluarea expresiei realizindu-se dupa executia macar o singura data a blocului {
de instructiuni print
do { "$cure
$studenti++; nt are
print "Suntem $studenti\n"; $curen
} until $studenti > 10; te{$cu
– for rent}
• Utilizata de obicei ca instructiune iterativa roman
for ($stud = 1; $stud <= 10; $stud++) { e\n";
print "$stud pe pinza...\n"; •
}

–foreach
•
Utilizata de obicei pentru iterarea tablourilor
@note =(9, 9, 7, 10, 5, 8, 8);
foreach $nota (@note )

9
Variabila de ciclu este o referinþã a listei,nu o copie a acesteia ( elementele listei se pot altera!)
– next
• Permite saltul la finalul blocului de instructiuni si
inceperea urmatoarei iteratii la un while, do, for,
foreach (similar cu continue din C/Java)
for ($grupa = 1 ; $grupa <= 4 ; $grupa++){ next if $grupa == 2; print "Grupa: }
– last
• Va finaliza ciclul de instructiuni si va continua
cu urmatoarea instructiune dupa blocul de
instructiuni al unui while, do, for sau foreach
foreach $grupa (1 .. 4) { if ($grupa == 2) { last }; print "Grupa: $grupa\n"; }print "Gata!\n";

Functii si proceduri
• Grup de instructiuni care poate fi definit de utilizator oriunde in program,cu scopul de a reutiliza
codul-sursa
• Tipuri:
- Proceduri - nu returneaza nimic
- Functii - returneaza o anumita valoare
• Declaratia:
sub nume ( parametri ) {
bloc # grup de instructiuni
• Lista de parametri poate lipsi
sub aduna {
# lista argum. e disponibila in variabila @.
$primul = shift;
$al_doilea = shift;
return $primul + $al_doilea;# se apeleaza subrutina (functia) "aduna print &aduna (2,
7);

10
Pentru returnarea valorilor se pot folosi variabilele $_ sau @_
Subrutinele se pot apela recursiv
Se pune la dispozitie
o paleta larga de subrutine predefinite
Categorii de subrutine predefinite:
- Manipularea valorilor scalare: chomp, chop, chr,
crypt, hex, index, length, ord, reverse, sprintf,
substr, tr,...
- Expresii regulate: pos, split, study,...
- Functii numerice:
abs, cos, exp, int, log, oct, rand, sin, sqrt, srand,..
-Procesarea tablourilor: pop, push, shift, unshift,...
- Procesarea listelor: grep, join, map, sort, unpack,.
- Procesarea tablourilor asociative:
delete, each, exists, keys, values
Categorii de subrutine predefinite:
- Intrari/iesiri: close, closedir, die, eof, fileno, flock,
format, getc, print, printf, read, readdir, seek, tell,
truncate, warn, write,...
- Fisiere & directoare: chdir, chmod, chown, fnctl,
glob, ioctl, link, mkdir, open, opendir, rename,
rmdir, stat, unlink,...
-Controlul fluxului programului: continue, die, do, eval, exit, goto, last, next, redo, return, sub,...
-Controlul vizibilitatii: import, local, my, use,...
- Procese: alarm, exec, fork, kill, pipe, sleep, wait,...
Categorii de subrutine predefinite:
-Acces la retea (socket-w\)\ accept, bind, connect, listen, recv, send, shutdown, socket,...
- Informatii despre retea:
gethostbyaddr, gethostbyname, gethostent,
getnetbyaddr, getnetbyname,...
- Manipularea timpului:
gmtime, localtime, time,...
- Alte functii utile:
defined, dump, scalar, undef,...
Nota: majoritatea subrutinelor predefinitesunt considerate drept operator! Unari (nu trebuie utilizate obligatoriu parantezele)
print (sin (3.14)); print sin 3.14;
Fisiere
11
 Fisier: colectie logic contigua de date, stocata pe un mediu (fizic) de memorare Implicit, se pot utiliza:
- STDIN - intrarea standard (tastatura)
- STDOUT - iesirea standard (ecranul)
- STDERR - iesirea de eroare standard (ecranul)
Citirea datelor se realizeaza cu operatorul < >
Scrierea datelor se poate realize cu functiile obisnuite de afisare (print, printf)
• Exemplu
print STDOUT "Un nume, va rugam: ";
$nume = <STDIN>;
print STDOUT "Salut, $nume";
• In variabila $nume vor fi stocate caracterele
preluate de a intrarea standard,
inclusiv newline care marcheaza finalul introducerii sirului de la terminal
• Pentru eliminarea caracterului newline
se folosesc chopQ sau chompQ
Inainte de a fi utilizat, un fisier trebuie deschis;
open (FIL, "nume_fisier");
Citirea din fisier se va realiza cu operatorul <> Scrierea in fisier se va face cu print/printf La finalul prelucrarii, fisierul trebuie
inchis:
close (FIL);
Toate functiile uzuale din limbajul C destinate manipularii fisierelor sunt suportate: seekQ, tellQ, renameQ, chmodQ, chownQ, IstatQ, linkQ,
symlinkQ, unlinkQ, ioctlQ,... Pentru directoare, se pot utiliza: opendirQ, readdirQ si closedirQ Expandarea continutului unui fisier se
realizeaza cu <> sau globQ
Qpagini = <*.html>; ©director = glob("/tmp/*");

Modul: unitate de cod precompilat,incapsuland diferite functionalitati oferite programatori lorSe stocheaza in fisiere cu extensia
.pm,codul putand fi utilizat ulterior,fara "reinventarea rotii"
Modulele se includ in program prin use Modul;
In mod uzual, fiecare modul are propria lui
documentatie, disponibila prin man sau perldoc Se pun la dispozitie unele module standard (disponibile in orice distributie Perl
actuala):
CGI - pentru scrierea de scripturi CGI
(Common Gateway Interface)
File - pentru prelucrarea facila
a fisierelor/directoarelor
- Math - pentru operatiuni matematice
(e.g., calcule cu numere complexe)

12
 - Socket - pentru programarea in retea (Internet)
Modul: unitate de cod precompilat,
incapsuland diferite functionalitati
oferite programatori lor
Se stocheaza in fisiere cu extensia .pm,
codul putand fi utilizat ulterior,
fara "reinventarea rotii"
Modulele se includ in program prin use Modul;
In mod uzual, fiecare modul are propria lui
documentatie, disponibila prin man sau perldoc
Se pun la dispozitie unele module standard (disponibile in orice distributie Perl actuala):
- CGI - pentru scrierea de scripturi CGI
(Common Gateway Interface)
- File - pentru fisiere/director
- Math - pentru matematica
Socket - pentru programarea in retea (Internet)
Unele module se pot baza pe altele, onstituind ierarhii
Exemple:
- File::Find - traversarea unui arbore de directoare
- HTML::Parser - prelucrarea documentelor HTML
- Math::Complex - lucrul cu numere complexe
- Search:Diet - cautarea unei chei dintr-un dictionar
-XML::Parser - utilizarea analizorului XML prin SAX
- XML: :XSLT - transformari XSL
Expresii regulate
Expresie regulata (regular expression) = gabion (pattern) caruia, pe baza unor reguli precise, i se poate asocia unui text
Variabila implicita in care se realizeaza diferite act;iuni implicand expresii regulate este $_
Specificarea altei variabile se realizeaza prin intermediul operatorului =~
Se poate utiliza si operatorul !~ (echivalent cu negatia lui =~)
Operatorul m//
- Se foloseste pentru a cauta un sablon in cadrul unui text dat (daca nu e pericol de confuzie,litera "m" poate lipsi)
- Se returneaza valoarea logica "adevarat" in cazul in care cautarea se incheie cu succes,
"fals"inrest
while (<STDIN>) {
print "Am gasit subsirul \"Victor\" in $_" if m/Vika/;

Operatorul m// (optiuni uzuale)

13
 - Cautare case-insensitive (majusculele nu difera de minuscule) - i
while (<STDIN>) { print "Am gasit tag-ul \"<b>\" sau \"<B>\" in $_"
Cautarea tuturor secvent;ele care se potrivesc s.ablonului - g
my $sir = "abracadabr a", $num_a = 0;
while ($sir =~ /a/g) { $num_a++; }
print "Am gasit de $num_a ori caracterul \'aV.\n";
Operatorul s///
- Permite cautarea si substitujjia unui sablon cu un text while (<STDIN>) { s/a utmat/Automat/ i; print;

Operatorul qr//
- Precompileaza un sir de caractere ca expresie regulata
- Expresia regulata precompilata poate fi stocata intr-o variabila sj refolosita in constructia altor expresii regulate sau poate fi utilizata direct
my $expr = qr/(autmat|automt)/i;
Delimitarea expresiei regulate si, daca este cazul, a s.irului substituitor se poate realiza cu alte caractere speciale decat"/"
while (<>) { print if m | <pre> | i.. m | </pre> | i;
Identificarea caracterelor
-Cautarea unui caracter se face specificindacel caracter -Pentru cautari complexe, se folosesc meta-caractere = caractere care nu se identified pe
ele Tnsele in cadrul unei expresii regulate
Meta-caracterul.
-Utilizat sa identifice orice caracter, exceptand caracterul newline "\n"
Meta-caracterele [...]
-Reprezinta o clasa de caractere (enumerare): /[a-z]/ /[a-z][ATX][0-7]/
Meta-caracterul ^
-Folosit in cadrul unei secvente de caractere are rol de negare
[^2-5] - toate caracterele exceptind 2, 3, 4, 5
-In alte cazuri, desemneaza inceputul unei linii

14
 ^[2-5] - orice sirincepind cu o cifra cuprinsa intre [255..1]

Meta-caracterul $
-Identifica finalul unei linii: /Hesse$/
Meta-caracterul |
-Alternativa intre doua sau mai multe forme posibile ale unei secvente dintr-un text while (<STDIN>) { p r i n t i f ( / [ 0 - 9 ] | [ A - Z ] [ a - z ] / ) ;

Meta-caracterele ()
-Grupeaza atomi si memoreaza valoarea subsirurilor din text corespunzatoare acestor atomi
-Atom = caracter lipsit de semnificatie ori un meta-caracter de pozitionare (A sau $)

Meta-caracterele ? * + { }
-Au rolul de multiplicatori r ai unui atom -Un atom urmat de ? poate identifica de
zero sau maxim o singura data un atom -Simbolul * poate identifica zero, una
sau mai multe aparp consecutive
ale aceluiasj atom -Un atom urmat de + poate sa identifice
macar o aparitjie a atomului

• Meta-caracterele ? * + { }
while (<STDIN>) {
print "Cel putin o aparitie a cuvintului \'web\' la inceputul liniei\n"
 Meta-caracterele ? * + { }
- atom {m, n} va identifica Tntr-o expresie eel put;in
777 atomi, dar nu mai mul£i de n
- atom {m,} va identifica m sau mai mult;i atomi
- atom {,/?} va identifica n atomi eel mult
- atom {n} va identifica exact n atomi

Constructii predefinite
-\d o cifra: [0-9]
-\w un caracter a Ifa numeric: [0-9_a-zA-Z]
-\s un spatiu alb: [\t\r\n\ \f ]
-\D orice exceptind cifre: [A0-9]
-\W caracter ne-alfanumeric: [A0-9_a-zA-Z]
-\S orice exceptind spatii albe: [A\t\n\r\ \f]

Constructii predefinite
-\b identifica limitele unui cuvint
-\B identifica orice alt context decat limitele
unui cuvant (interiorul unui cuvant) -\A desemneaza inceputul unui sir -\Z identifica sfarsitul unui
sir
-Exemplu: /text\b/ poate identifica " text", "text", "context", dar nu si "textul"

Functia tr///
-Translateaza caracter cu caracter un text
# majusculele devin minuscule
tr/A-Z/a-z/
# http:
devine ftp:
tr/http:/ftp
:/

Functia splitQ
-Imparte un sir de caractere in functie de o expresie regulata si returneaza un tablou contjinand subsirurile
care nu satisfac acea expresie regulata
$data_sistem = localtime (time); ($ziua, $luna, $num, $timp, $an) =
split(/\s+/, $data_sistem);

Functia joinQ
-Reuneste mai multe s.iruri de caractere in unul singur, delimitate de un scalar
Functia evalQ
-Poate fi folosita pentru evaluarea/executiaunei expresii Perl -Valoarea returnata reprezinta valoarea ultimei
expresii evaluate

• Verificarea validitatii unei adrese de e-mail

sub valid_email { $testmail = shift; return 0 if ($testmail =~
/ /);
if ($testmail =~ /(@.*@)|(U.)|(@\.)I(\-@)I(A\-)/ II $testmail !~
/A.+\@(\[?)[a-zA-ZO-9\-\.]+\.([a-zA-Z]{2,4}|[0-9]{1 , return 0;

else { return 1 ; }

Realizarea de scripturi CGI

 Scripturi CGI
(Common Gateway Interface)
-Caracterizare -Variabile de mediu -
I n v o c a r e -GET versus POST
Standard de facto pentru interactiunea programatica a clientilor cu serverele Web:
CGI/1.1
Scop: generarea dinamica pe server de reprezentari ale unor resurse solicitate de un client
Web
- HTML, text obisnuit, imagini JPEG etc.
Un program (script) CGI se invoca pe server, in mod implicit sau explicit (i.e. preluarea
informatiilor dintr-un formular)
Scripturile CGI pot fi concepute in orice limbaj disponibil pe server
-Limbaje interpretate: bash, Perl (modulul CGI), Python, Pike,...
-Limbaje compilate: C, C++,...
Un script CGI scrie datele la iesirea standard
(stdoufy
Un script CGI genereaza/foloseste anteturi HTTP, utilizind standardul MIME -exemplu:
Content-type: text/html
Unui program CGI, datele de procesat i se vor trimite la intrarea standard sau prin
intermediul unor variabile de mediu
Un program CGI are acces la variabilele de
mediu:
-Independente de metoda cererii:
SERVEFLNAME, GATEWAYJNTERFACE
-Specifice cererilor transmise spre script:
SERVER_PROTOCOL, REQUEST_METHOD, QUERY_STRING,REMOTE_HOST,
REMOTE_ADDR,CONTENT_TYPE, CONTENT LENGTH

Variabile suplimentare:
HTTP_ACCEPT, HTTP_USER_AGENT,...

• Afi§area unei imagini aleatoare (cont.)

# alegem imaginea
$imagine = $imagini [rand (@imagini)]; die "eroare la
selectarea imaginii" unless $imagine;
# redirectam navigatorul spre imaginea aleasa
print redirect ("$DIR_IMAGINI/$imagine");

XML in Perl
Utilizarea procesorului Expat si a modelulul DOM pentru
manipularea documentelor XML in Perl
m n cadrul acestui articol vom urmari sa ilustram cateva dintre
facili-I taţile puse la dispoziţie de modulele Perl pentru prelucrarea
facila a I documentelor XML, folosind SAX (Simple API for
XML) si DOM (Document Object Model).
Modulele Perl
Inainte de a discuta despre cum prelucram documentele XML,
este necesar sa prezentam pe scurt conceptele de pachet si de
modul Perl.
Un pachet Perl poate fi considerat drept implementarea unei
clase pe care o putem instanţia in cadrul unui script. Subrutinele
incluse intr-un pachet pot juca, de asemenea, rolul de metode,
existand posi-bilitatea definirii de constructed si destructori. Mai
mult, se ofera su-port pentru derivarea unei metode aparţinand
unui pachet, astfel incat pachetele Perl pot fi ierarhizate. Vom
referi variabilele din alte pachete prefixand identificatorul
variabilei respective cu numele pachetului urmat de „::", dupa
cum se poate observa din urmatorul exemplu:
$intrare = $main::STDIN;
La fel, pentru metode:
$imagine = new GD::Image(174, 333);
Daca nu este specificat numele pachetului, se considera implicit
pa-chetul main. Astfel, construcţia $ :: v a r este echivalenta cu $ m a i
n: :var. Daca dorim sa accesam metode sau date-membru definite
intr-un pachet derivat din altul vom specifica numele ambelor
pachete:
$Pachet::Subpachet::variabila
Un modul reprezinta un pachet public definit intr-un fisier . pm cu
sco-pul de a fi reutilizat ulterior. Modulele Perl vor fi incluse in
program, spre a fi folosite, prin construcţia:
use Modul;
Sunt puse la dispoziţie mai multe module standard (disponibile in
orice distribute Perl actuala), dintre care se pot menţiona:
• Carp (pentru controlul erorilor si avertismentelor);
• Config (pentru acces la opţiunile de configurare);
• CGI (pentru generarea facila de scripturi CGI);
• Env (pentru accesarea variabilelor de mediu);
• ExtUtils::Embed (pentru includerea de cod Perl in programele
C);
• File::Find (pentru traversarea recursiva a unui arbore de
directoare);
• File::Handle (pentru manipularea fisierelor folosind
descriptori de
fisier);
• File::Path (pentru operaţii cu directoare);
• Math::Complex (pentru prelucrarea numerelor complexe);
• POSIX (pentru asigurarea interfeţei cu standardul POSIX
IEEE
1003.1);
• Search::Dict (pentru cautarea unei chei intr-un fisier dicţionar);
• Socket (pentru realizarea de operaţiuni cu socket-van);
• Time::Local (pentru acces la timpul local).
Pentru a gasi toate modulele instalate in sistem (inclusiv cele
care nu au documentaţii sau au fost instalate in afara distribute}
standard) putem folosi urmatoarea linie de comenzi:
find "perl -e 'print "@INC"'~ -name "*.pm" -print
In mod normal, fiecare modul poseda propria lui documentaţie,
accesi-bila prin intermediul comenzii man din UNIX. Se poate
utiliza si co-manda perl doc. De reţinut faptul ca anumite module
pot fi scrise in alte limbaje, in speţa C (cazul modulelor Socket sau
POSIX). CPAN Succesul limbajului Perl rezida, in principal, din
posibilitatea de a extinde limbajul cu noi functionality oferite de
module. In afara modulelor din distribute Perl standard, exista o
colecţie globala a tu-turor materialelor publice referitoare la Perl,
colecţie referita sub denu-mirea CPAN (Comprehensive Perl Archive
Network). CPAN ofera un numa impresionant de module grupate
pe urmatoarele categorii:
• extensii de limbaj si unelte de documentare;
• suport pentru dezvoltare de programe/module;
• interfere (la nivel scazut sau ridicat) cu sistemul de operare;
• comunicarea intre procese, in reţea si controlul dispozitivelor
(e.g.
modemuri);
• tipuri de date si conversii;
• interfere cu bazele de date;
• interfere cu utilizatorul;
• interfere cu alte limbaje de programare;
• procesarea fiserelor si sistemelor de fisiere;
• procesarea caracterelor;
• procesarea fisirelor de configurate si a parametrilor in linia de
comanda
• suport pentru diverse limbi si alfabete (internaţionalizare);
• autentificare, securitate si criptare;
• suport pentru posta electronica si grupurile de stiri;
• suport pentru Web (HTML, HTTP, CGI, XML etc.);
• utilitare pentru daemoni;
• suport pentru arhivarea si compresia datelor;
• procesarea informaţiilor grafice;
• controlul fluxului (excepţii, erori etc.);
• procesarea fluxurilor de date si a fisierelor;
• altele.
Pentru un listing al tuturor locaţiilor Internet referitoare la
CPAN, consultaţi http://www.perl .com/perl /.
Instalarea unui modul In unele cazuri va trebui sa luam un modul
de la CPAN pentru a-1 instala si folosi ulterior in cadrul
scripturilor noas-tre. Pentru a fi instalat pe un sistem
UNIX/Linux, un modul Perl se regaseste fie ca fisier tar arhivat cu
gzip (deci are extensia .tar.gz sau .tgz), fie ca fisier . pm (deja
dezarhivat). Orice modul Perl necesita pentru instalare existenţa
interpretorului Perl in sistem. Dupa dezarhivare (cu tar -xzf
numearhiva.tgz), in directorul in care a fost stocat
modulul dorit a fi instalat se dau urmatoarele comenzi (pentru
a se putea executa ultima linie, utilizatorul trebuie sa aiba drepturi
de root):
perl Makefile.PL
make
make test make
install
In mod uzual, fiecare modul este acompaniat si de documentatia
necesara exploatarii lui. Pentru a avea acces la ea, se foloseste
utilitarul perl doc:
(infoiasi)$ perldoc XML::Parser
Pentru convertirea documentatiei in format text sau HTML se
pot uti-liza comenzile pos2text si, respectiv, pod2html, ca in
exemplul urmator:
(infoiasi)$ pod2text Parser.pm >Parser.txt
(infoiasi)$ pod2html Parser.pm >Parser.html
Prelucrarea documentelor XML
In continuare vom urmari sa prelucram documentele XML via
scrip-turile Perl, in vederea transformarii lor in pagini Web.
Utilizarea analizorului Expat Una dintre cele mai facile modalitati de
a prelucra documentele XML este cea a utilizarii analizorului
Expat dezvoltat de James Clark, a carui functionalitate este
incapsulata de modulul XML::Parser. Acest modul va pune la
dispozitie obiectele XML: : Parser si XML:: Parser: : Expat.
Analiza XML este bazata pe evenimente, fiecare tip de nod al
ar-borelui asociat documentului XML declansandu-se un anumit
eveni-ment care va trebui tratat de o rutina Perl specificata de Dorim sa generam un tabel XHTML cu aceste informatii, prin
programator. Astfel, dupa initializarea analizorului, va trebui sa trans-formarea documentului XML de mai sus. Vom scrie
folosim metoda setHandlers pentru a stabili ce functii vor fi urmatorul script Perl, in care vom substitui fiecare element
apelate pentru fiecare tip de eveniment. XML cu elementele XHTML corespunzatoare (aceste substitutii
Cele mai importante evenimentele generate de procesorul XML vor fi stocate in tablouri asociative):
sunt:
• Start - indica aparitia tag-v&ui de inceput al unui element; #!/usr/bin/perl
• End - desemneaza aparitia tag-ului de sfarsit al unui element; # utilizam modulul XML
• Char - indica aparitia continutului text al unui element use XML: :Parser;
(caracterele de i definim tablourile hash de inlocuire a tag-urilor
text neprocesat dintre tag-\& de inceput si eel de sfarsit); i definim substitutiil e de tag-uri de inceput
• Comment - indica aparitia unui comentariu. %start = (
Intr-un prim exemplu de utilizare a modulului XML::Parser "imprumuturi " => "<table border=\"l\">",
vom asocia pentru evenimentele Start, End si Char cate o "imprumut" => "<tr>",
subrutina care va fi apelata la fiecare aparitie a evenimentului in "carte" => "<td><b>",
cauza. "client" => "<td align=\"center\">"
Documentul XML bi bl i o. xml care urmeaza stocheaza );
informatii despre imprumuturile dintr-o biblioteca: i definim substituti il e de tag-uri de sfirsit
SKsfirsit = (
<?xml version="1.0" ?> "imprumuturi" => "</tabl e>\n",
<imprumuturi > <imprumut> "imprumut" => "</tr>",
<carte autor="H. Hesse" an="1999"> "carte" => "</bX/td>",
Lupul de stepa </carte> <client "client" => "</td>"
adresa="mituc@ac.tuiasi.ro">
Victor Tarhon-Onu
</client> </imprumut> i instantiem analizorul XML
<imprumut> my $parser = new XML: : Parser( ErrorContext => 2);
<carte autor="H. Hesse" an="1998">
i setam functiile de prelucrare
Jocul cu margelele de sticla </carte> # a elementelor si continutului lo r
<client adresa="mihaela@infoiasi.ro"> $parser->setHandlers(
Mihaela Brut
Start => \&procesare_start, # functia de
</client> </imprumut>
procesare tag-uri de inceput End => \
</imprumuturi>
&procesare_sfi rsit, i functia de procesare
tag-uri de sfirsit Char => \
&procesare_continut i functia de procesare a
continutului

i afisam antetul HTTP

print "Content-type: text/html \n\n";

i incarcam fisierul si il analizam

$parser->parsefile("biblio.xml");

# definim subrutinele pentru prelucrarea

# elementelor XML si continutului lor
sub procesare_start
{
my $procesor = shift;
i primul argument este instanta procesorului XML
my $element = shift;

# afisam codul HTML, folosind tabloul hash print

$start{$element);

sub procesare_sfirsit

my $procesor = shift;
i primul argument este instanta procesorului XML
my $element = shift;
# al doilea argument este numele elementului
# corespunzator tag-ului de sfirsit

i afisam codul HTML, folosind tabloul hash

print $sfi rsit{$el ement} ;

# rutina de afisare a continutului sub

procesare_continut
 i am preluat argumentele furnizate concepem o rutina de tratare a fiecarei apariţii a tag-v&ui de sfarsit.
my ($procesor, $data) = @_; Tot in cadrul acestui exemplu vom vedea cum putem accesa
valorile atributelor unui element, prin utilizarea unui tablou
i afisam datele asociativ.
print $data; Codul sursa al scriptului este:

Utilizarea modelului DOM Pentru a beneficia de interfere puse

Funcţiile asociate evenimentelor de procesare XML vor primi drept la dispoziţie de DOM, vom recurge la modulul XML::DOM care
ar-gumente instanta procesorului Expat si numele elementului extinde
curent (pentru evenimentele Start si End) sau conţinutul dintre 0 serie din funcţionalitaţile procesorului Expat. Modulul ofera
tag--urile de inceput si de sfarsit (pentru evenimentul Char). obiectul
lesirea scriptului prezentat mai sus este: XML: :DOM:: Parser care este derivat din XML:: Parser. Vom
putea
Content-type: text/html procesa documentele XML conform specificaţiilor DOM - nivelul
1
<table descrise de Consorţiul Web. Un document va fi regasit in DOM ca
border="l"> in-
<tr> <td><b> stanţa a clasei Document. Un obiect de tip Document va fi compus
Lupul de stepa din
</bX/td> <td obiecte de tipul Node. Un obiect Document va putea include noduri
align="center"> de
Victor Tarhon-Onu tip Element, Text Comment si CDATASection, iar un Element va
</td> </tr> <tr> putea
<td><b> avea noduri de tip Attr, Element, Text, Comment sau CDATASecti
Jocul cu margelele de sticla on.
Alte tipuri de noduri nu vor avea nici un descendent.
<td align="center"> Un exemplu, in care vom afisa toţi autorii carţilor imprumutate
Mihaela Brut </td> din biblioteca (vom folosi pentru exemplificare tot bi bl i o. xml):
</tr> </table>
#!/usr/bin/perl
Analizorul Expat ofera programatorului functionality multiple, use XML::DOM;
denu-mite stiluri de procesare. Stilul implicit a fost utilizat in 1 instantiem analizorul
scriptul precedent. Mai pot fi folosite: my $parser = new XML::DOM::Parser;
• stilul de depanare Debug, # incarcam fisierul XML
• stilul de analiza cu subrutine Subs in care fiecare apariţie a unui my $doc = $parser->parsef il eC'bibl io.xml ");
tag # afisam toate atributele 'autor' a l e elementelor <carte>
distinct va fi tratata de o subrutina purtand acelasi nume cu i preluam lista noduri element <carte>
elemen- my $noduri = $doc->getElementsByTagName("carte"); i
tul corespunzator acelui tag, iar pentru tratarea tag-urilor de numarul de noduri gasite my $nr = $noduri-
sfarsit va invocata o subrutina avand numele elementului urmat >getLength;
de caracterul „_" (vezi mai jos), # pentru fiecare nod gasit,
# stilul de analiza arborescenta Tree, in care procesorul # preluam valoarea atributului
va returna ar- for (my $i = 0; $i < $nr; $i++)
borele de analiza al documentului XML, fiecare nod al arborelui
fiind
de forma (nume de tag, conţinut),
#stilul de analiza cu obiecte Objects care este similar cu stilul Tree,
dar
se vor genera cate un obiect de tip hash pentru fiecare element.
Stabilirea stilului de procesare se va face la iniţializarea
analizoru-lui, prin intermediul opţiunii Styl e. Constructorul
respectiv va putea avea drept argumente si alte atribute de
procesare precum: •protocolul de codificare a documentului
XML: Protocol Encoding (pot fi specificate valori, e.g. UTF-8,
ISO-8859-1 sau UTF-16);
#modalitatea de raportare a erorilor: ErrorContext a carui
valoare este
numarul de linii care vor fi afisate la apariţia unei erori de
analiza
XML (de obicei, se prefera valoarea 2);
#funcţiile asociate evenimentelor generate de procesorul Expat: Handl
ers
(este un tablou asociativ avand drept chei nume de evenimente si
drept
valori referinţe la subrutinele de tratare a evenimentului respectiv);
In continuare vom utiliza stilul de procesare Subs pentru a
putea prelucra comod si valorile atributelor unui element
particular. Folosind bi bl i o. xml ne propunem sa afisam atat titlul
carţilor imprumutate, cat si autorul si data apariţiei (acestea se
regasesc ca atribute ale elementului <carte>). Pentru fiecare
element al documentului, va trebui sa scriem o rutina de tratare a
apariţiei tag-\A\a de inceput al acestuia. La fel, va trebui sa
Dupa cum se observa, datorita faptului ca modulul este derivat
din
XML::Parser, putem utiliza metodele parsefile() sau parse()
pentru
a incarca un document XML in vederea procesarii.
Alte module Comunitatea programatorilor Perl are la
dispoziţie o
sumedenie de module utile pentru diverse procesari asupra
docu-
mentelor XML. In cele ce urmeaza vom descrie cateva dintre
aceste
module:
•XML::Simple ofera o interfaţa foarte simpla pentru citirea si
scrierea
de documente XML (indicat a fi utilizat pentru procesarea
fisierelor
de configurate, a tabelelor de date de mici dimensiuni etc.);
•XML::Twig permite procesarea rapida a documentelor XML de
di
mensiuni considerabile;
• XML::Generator util pentru generarea de documente XML;
•XML::Grove ofera acces la date marcate in SGML, XML
sau
HTML prin intermediul tabelelor asociative;
• XML::XSLT implementeaza funcţionalitaţile specificaţiei
XSLT,
fiind bazat pe XML::DOM;
•XML::XQL ofera posibilitatea de a realiza interogari asupra
documentelor XML;
•XML::Checker verifica validitatea documentelor XML sau a
arbo-rilor DOM;
•XML::RSS permite crearea sau modificarea fisierelor RSS (Rich
Site Summary) bazate pe RDF (aceste documente sunt folosite
pentru crearea de descrieri folosite de Netscape Netcenter sau
Meerkat (O'Reilly), putand fi regasite pe situri precum Slashdot
ori Freshmeat);
•XML::Writer ofera posibilitatea de a crea documente XML,
intr-un
mod asemanator modulului CGI;
•DBIx::XML_RDB exporta date dintr-o baza de date accesata
via
DBI si le reprezinta in XML.

Programare Perl A BAZELOR DE DATE

Conectivitatea cu bazele de date in Perl

Pentru a asigura independenţa de arhitectura internă şi modul de comunicare cu sistemele de gestiune a

bazelor de date relaţionale, în Perl programatorul are la dispoziţie modulul DBI (DataBase Interface) care
oferă o interfaţă abstractă de programare a bazelor de date.
Modulul DBI oferă programatorului trei tipuri de obiecte cu care acesta să interacţioneze, la nivel înalt,
cu bazele de date, aceste obiecte fiind denumite descriptori (handlers). Similar mecanismului de la fişiere,
DBI pune la dispoziţie descriptori de driver, descriptori de bază de date şi descriptori de interogare, după
cum urmează:
 Descriptorul de driver (driver handler) reprezintă, în cadrul programului Perl, driver-ul
iniţializat şi încărcat de DBI pentru manipularea unui sistem de baze de date particular. Pentru
fiecare driver se asociază un descriptor separat. Folosind acest descriptor, vom afla sursele de date
la care putem să ne conectăm prin intermediul unui anumit driver, invocând metoda
data_sources(), şi vom putea, de asemenea, realiza o conexiune efectivă cu o sursă (bază) de
date prin intermediul metodei connect(). Fiecare handler este încapsulat într-un obiect Perl
separat, astfel încât în script-uri pot fi utilizaţi descriptori diferiţi pentru a realiza conexiuni cu mai
multe servere de baze de date simultan. În mod uzual, vom referi acest descriptor de driver prin
$drh.
 Descriptorul de bază de date (database handler) incapsulează o conexiune unică la o bază
de date particulară, stocată de un anumit sistem de baze de date relaţionale. Înainte de a executa
interogări asupra unei baze de date, va trebui să ne conectăm la acea bază de date prin funcţia
connect() care va returna un descriptor de bază de date. Acest descriptor va fi referit prin $dbh. Şi
în acest caz, pot fi realizate conexiuni concurente asupra aceleaşi baze de date, fiecare conexiune
fiind desemnată de un descriptor de bază de date separat.
 Descriptorul de interogare (statement handler) va fi folosit pentru a desemna o interogare
(comandă) SQL care va fi executată asupra bazei de date. Rezultatul interogării va putea fi regăsit via
descriptorul de interogare, DBI permiţând execuţia de comenzi concurente. Descriptorul de
interogare va fi în mod uzual referit prin $sth.
Pentru a asigura în manieră uniformă conectivitatea cu mai multe tipuri de sisteme de baze de date se vor
utiliza anumite convenţii pentru a specifica numele bazei de date sau numele maşinii pe care este stocată
acea bază de date. Aceste informaţii vor fi referite prin intermediul unui nume de sursă de date,
respectându-se o regulă similară sintaxei URI.
Numele unei surse de date va începe obligatoriu cu "dbi:" urmat de numele driver-ului (e.g. Oracle sau
MySQL). Alte sufixe care vor apărea vor fi pasate ca parametri metodei connect() implementate de driver
în vederea realizării conexiunii efective (de exemplu, vor trebui specificate numele simbolic al
calculatorului, numele bazei de date sau portul de conectare).
Ca exemple de surse de date pentru sisteme particulare putem menţiona:
 dbi:Oracle:descriptor pentru Oracle:

 dbi:Oracle:studenti

 dbi:Pg:dbname=baza_de_date;host=calculator pentru PostgreSQL:

 dbi:Pg:dbname=studenti;host=fcs

 dbi:mysql:dbname=baza_de_date;host=calculator pentru MySQL:

 dbi:mysql:dbname=clienti;host=fcs

Exemplu de interogare via Web a unei baze de date MySQL

Vom prezenta un script simplu care poate fi utilizat pentru căutarea unor clienţi ai unei organizaţii sau
companii stocaţi într-o bază de date fcs cu următoarea structură a unicei tabele clients:
CREATE TABLE clients (
# identificator client
id_client int(11) NOT NULL default '0',
# nume client
name varchar(50) NOT NULL default '',
# adresa client
address varchar(100) NOT NULL default '',
# oras
city varchar(30) NOT NULL default '',
# cod postal
zip varchar(10) NOT NULL default '',
# telefon (serviciu tehnic)
tech_phone varchar(20) NOT NULL default '',
# fax (serviciu tehnic)
tech_fax varchar(20) default NULL,
# e-mail (serviciu tehnic)
tech_email varchar(100) NOT NULL default '',
# persoana contact (serviciu tehnic)
tech_contact varchar(50) NOT NULL default '',
# telefon (serviciu comercial)
com_phone varchar(20) NOT NULL default '',
# fax (serviciu comercial)
com_fax varchar(20) default NULL,
# e-mail (serviciu comercial)
com_email varchar(100) NOT NULL default '',
# persoana contact (serviciu comercial)
com_contact varchar(50) NOT NULL default ''
) TYPE=MyISAM PACK_KEYS=1;

Vom putea insera informaţiile de mai jos:

INSERT INTO clients VALUES (
1,
'Tica Bogdan’,
'Str. Berlla, 16',
'TgJIU',
'6600',
'090123456',
'032000000',
'mit@k.ro',
'Tik',
'091999999',
'032111111',
 'tik@k.ro',
'tica bogdan');

Aceste două comenzi SQL le vom putea stoca într-un fişier clients.sql pentru a-l utiliza la crearea şi
popularea cu date a bazei de date.
Sursa script-ului Perl pe care îl vom numi search.pl.cgi este prezentată în continuare (tratarea
erorilor se va realiza exclusiv de către programator, nefiind automată):
#!/usr/bin/perl -w

# Autor principal: Victor Tarhon-Onu (c)2001-2002

# Modificat de: Sabin Corneliu Buraga (c)2002
use strict;

# variabilele referitoare la baza de date

my $DBHOST = "fcs";
my $DBNAME= "fcs";
my $DBUSER = "fcs";
my $DBPASS = "demonstratie";
my $QUERY;

my ($dbh, $sth, $rc);

my ($name, $clientname, $client);

# utilizam modulele CGI

use CGI qw(:standard);
use CGI::Carp qw(fatalsToBrowser);

# preluam numele clientului

$client=param('name');
# scriem antetul paginii Web
print<<"HTML";
Content-type: text/html

<html>
<body bgcolor="white">
<form action="search.pl.cgi" method="post">
<table width="90%" bgcolor="#FFFFFF" border="1" align="center">
<tr><td colspan="5">
HTML

# utilizam modulul DBI

use DBI;
$dbh = DBI->connect("dbi:mysql:dbname=$DBNAME;host=$DBHOST",
"$DBUSER", "$DBPASS",
{ PrintError => 0,
RaiseError => 0,
AutoCommit => 1})
|| die("Cannot connect to $DBNAME: $DBI::errstr");

# ne conectam la baza de date $DBNAME, de pe serverul $DBHOST utilizind

# username-ul $DBUSER si parola $DBPASS, prin driverul mysql.

# in cazul in care conectarea s-a desfasurat fara probleme

# atunci functia de conectare ne va returna un Database Handler nenul

# pregatim de executie interogarea SQL

$sth = $dbh->prepare("SELECT name FROM clients ORDER BY name")
|| die "Cannot prepare : $DBI::errstr\n";
$rc = $sth->execute()
|| die "Cannot execute : $DBI::errstr\n";

# selectam toti clientii din baza de date

# pentru a-i afisa intr-un formular
# de unde vor fi selectati in vederea aflarii
# diferitelor informatii despre ei
print << "HTML";
<center>
<b>Nume client</b>: <select name="name">
HTML
while (($clientname)=$sth->fetchrow_array){
print << "HTML";
<option value="$clientname">$clientname</option>
HTML
}

print << "HTML";

</select>
<input name="enterbutton" type="submit" value="Afiseaza">
</center>
</td>
</tr>
HTML

# acest CGI poate fi apelat fara nici un parametru, caz in care va afisa
# un meniu din care sa se selecteze un eventual client

# daca scriptul primeste un sir in parametrul "name" atunci vor fi

# afisate informatii despre acel client (daca exista)
if (defined($client) && $client ne ""){
$sth = $dbh->prepare("SELECT address, com_contact,
com_email, com_phone,
tech_contact, tech_email,
tech_phone FROM clients WHERE name=?")
|| die "Cannot prepare : $DBI::errstr\n";
$rc = $sth->execute($client)
|| die "Cannot execute : $DBI::errstr\n";

# memoram in variabile datele returnate de server

my ($addres,$persdecizienam,$persdecemail,$persdecphone,
$adminname,$adminemail,$adminphone,
$salesname,$salesemail,$salexphone) = $sth->fetchrow_array;

# verificam daca sunt informatii nule

$addres=" "
if (!defined($addres) || $addres eq "");
$persdecizienam=" "
if (!defined($persdecizienam) || $persdecizienam eq "");
$persdecphone=" "
if (!defined($persdecphone) || $persdecphone eq "");
$persdecemail=" "
if (!defined($persdecemail) || $persdecemail eq "");
$adminname=" "
if (!defined($adminname) || $adminname eq "");
$adminphone=" "
if (!defined($adminphone) || $adminphone eq "");
$adminemail=" "
if (!defined($adminemail) || $adminemail eq "");

print << "HTML";

<tr><td colspan="5" align="center">
<b>
Client: $client<br>
Adresa: $addres
</b>
</td></tr>
<tr>
<th>Departament</th>
<th>Nume Persoana</th>
<th>Numar Telefon</th>
<th>E-mail</th></tr>
<tr>
<td align="left">Serviciul comercial</td>
<td align="center">$persdecizienam</td>
<td align="center">$persdecphone</td>
<td align="center">$persdecemail</td></tr>
<tr>
<td align="left">Servicul tehnic</td>
 <td align="center">$adminname</td>
<td align="center">$adminphone</td>
<td align="center">$adminemail</td></tr>
HTML
}

print << "HTML";

</table></form></body></html>
HTML

# am afisat informatiile, putem iesi din aplicatie

$sth->finish();
$dbh->disconnect;
 Programe PERL
(programele se salveaza in :c:\pxperl\bin
iar fisierele de la programare pe obiecte si baze de date se pun in c:\pxperl\lib
cum ar fi continutul directorului DBI SAU CGI)
print "a2= $a2 \n";
Sa apara un mesaj prin care sa introduce un $a3=$x!=5;
text: print "a3= $a3 \n";
#!C:\PXPERL\SCITE $a4=$x<=>6;
print "numele "; print "a4= $a4 \n";
$input=<STDIN>; $a5=$x<=>5;
($input); print "a5= $a5 \n";
print "salutari ,$input \n"; $a6=$x<=>4;
Sa se tipareasca mesajul scris: print "a6= $a6 \n";
$name="tica"; #operatori de comparare
$message="salutari $name"; $x="aa";
print $message; $y="ac";
 $z="ad";
#operatori de baza #mai mic decat
$x=5; $a=$x lt $y;
$y=15.5; print "a= $a \n";
$z= .05; #mai mare decat
$a=$x+$y; $a=$x gt $y;
print "a este egal cu $a \n"; print "a= $a \n";
$b=$z+5; #mai mic sau egal cu
print "b este egal cu $b \n"; $a=$x le $y;
$c=$x/$z; print "a= $a \n";
print "c este egal cu $c \n"; #mai mare sau egal cu
$d=$x+$y; $a=$x ge $y;
print "d este egal cu $d \n"; print "a= $a \n";
$x=$x+2.5; #egal cu
print " d este egal cu $x \n"; $a=$x eq $y;
 print "a= $a \n";
#operatorii modulo si exponential #diferit de
$x=5; $a=$x ne $y;
$y=15.5; print "a= $a \n";
$z= .05; #operatorul de comparatie
$a=$x % 2; $a1=$x cmp $y;
print "a este egal cu $a \n"; print "a1= $a1 \n";
$b=$y % 2.3; $a2=$y cmp $x;
print "b este egal cu $b \n"; print "a2= $a2 \n";
$c=$x ** $y; $a3=$x cmp $x;
print "c este egal cu $c \n"; print "a3= $a3 \n";
$d=$x ** 3; #operatori complexi
print "d este egal cu $d \n"; $x=12;
#atribuirea $y=3;
$a=5; $z=2;
$c="tica"; $x1=$x+10;
$b=6; $x+=10;
$b=$a; $a=$x==$x1;
print "a= $a \n"; print "a= $a \n";
print "b= $b \n"; $y1=$y*3;
#operatori relationali $y *=3;
$x=5; print "y= $y \n";
$y=15.5; $x=12;
$z= .05; $y=3;
$a=$x<6; $z=2;
print "a= $a \n"; ++$x;
$aa=$x>6; print "x= $x \n";
print "aa= $aa \n"; #se va mari numai variabila z
$a1=$x<=5; $b=$z++;
print "a1= $a1 \n"; print "b= $b \n";
$a2=$x==5; print "z= $z \n";
$x=12; }
-$x; else
print "x= $x \n"; { print "nu este egal cu 15 \n"
#concaternarea sirurilor }
$rezultatul="aaa". " " ."bbbb"; #acum avem evaluarea corecta care percepe
print "rezultatul = $rezultatul \n"; prima conditie ca fiind falsa
$n1="aaa"; unless($a=15)
$n2="bbb"; { print "este egal cu 15 \n"
$n3=$n1 . " " . $n2; }
print "n3= $n3 \n"; else
#tranformare in minuscule { print "nu este egal cu 15 \n"
$n1= lc "AAA"; }
#tranformare in majuscule #instructiune conditionala efectuata corect
$n2= uc "bbb"; $a=25;
if ($a<35)
print "n1= $n1 \n"; { print "este mai mic decat 35 \n"
print "n2= $n2 \n"; }
#operatori logici care functioneaZA SI PE else
SIRURI DE CARACTERE { print "mai mare decat 35 \n"
$x=10; }
$y=0; unless ($a>35)
$c="ab"; { print "este mai mic decat 35 \n"
#eliminarea primului caracter }
$c1=chop $c; #instructiunea repetitiva conditionata
print "$c1 \n"; anterior
#eliminarea caracterului care specifica linia $a=1;
noua while ($a<5)
$c="ab\n"; {
chomp $c; print "$a e mai mic decat 5 \n";
print " c= $c \n"; $a++;
$a=$x || $y; }
print " a= $a \n"; #instructiunea repetitiva conditionata
$a1=$x && $y; posterior
print " a1= $a1 \n"; $a=1;
$a11=$x && $x; until ($a>=5)
print " a11= $a11 \n"; {
$a2=! $y; print "$a e mai mic decat 5 \n";
print " a2= $a2 \n"; $a++;
#operatori pe biti }
$a=3&7; #date introduse de utilizator cu structura
print "3 & 7 = $a \n"; repetitiva conditionata posterior
$a=3 |7; #se executa cel putin odata
print "3 | 7 = $a \n"; $a=5;
$a=3 ^7; do
print "3 ^ 7 = $a \n"; {
$a1=~a; print "$a \n";
print "~a = $a1 \n"; $a++;
$a11=3>>1; }
print "un bit deplasat spre dreapta = $a11 \n"; while $a<3;
$a112=3<<1; #date introduse de utilizator cu structura
print "un bit deplasat spre stanga = $a112 \n"; repetitiva ciclica
#precedenta operatorilor for ($a=1;$a<10;$a++)
#efectuarea operatiilor de la stanga la dreapta {
#inmultirea inaintea adunarii print "$a \n";
#ridicarea la putere inaintea inmultirii }
$a=2*3+10; #date introduse de utilizator cu structura
print "a= $a \n"; repetitiva ciclica
$a1=2**3*10; for ($a=1;$a<10;$a++ ,print "$a \n");
print "a1= $a1 \n"; {
#instructiunea conditionala care ne da print "$a \n";
eronat raspunsul }
$a=25; #parcurgerea iterativa a unei variabile
if ($a=15) tablou
{ print "este egal cu 15 \n" $b=10;
print "initial avem $b \n"; $a++;
@a=(1,3,4,7,9,12); print "a e ste mai mic decat 25 deci tiparesc
foreach $b (@a) valoarea $a \n";
{ $b=1;
print "valoarea lui b in interiorul buclei este while ($b<5)
$b \n"; {
} $c=$a*$b;
print "valoarea lui b in afara buclei este $b \n"; print "$a inmultit cu $b este $c \n";
#variabila implicita $_ care vede valorile $b++;
unui tablou }
@a=(1,3,4,7,9,12); }
foreach (@a) #instructiuni repetitive imbricate cu
{ structuri conditionale
print; $a=1;
print " \n"; while ($a<5)
} {
#instructiuni conditionate pe o linie $a++;
a=15; print "a e ste mai mic decat 25 deci tiparesc
$b=10; valoarea $a \n";
$a++ if ($b<20); $b=1;
print "a= $a \n"; while ($b<5)
print "a a fost marit cu 1 \n" if ($a==16); {
$b++ while ($b<20); if ($b==2 || $b==4)
print " b fost marit mereu pana a ajuns la $b \ {
n" if ($b==20); print " $b este unul din numerele mele
$a-- until ($a==2); preferate \n";
print $a; }
#instructiunea de omitere a unei valori $c=$a*$b;
exepmplu valoarea 20 print "$a inmultit cu $b este $c \n";
$a=15; $b++;
while ($a<25) if ($b==5)
{ {
$a++; print "\n";
next if ($a==20); }
print "a e ste mai mic decat 25 deci tiparesc }
valoarea $a \n"; }
} # sa se scrie o procedura care concaterneaza
print " am iesit \n"; doua siruri de caractere
#instructiunea de afisare pana la o valoare $first="AAAA";
exemplu pana la valoarea 20 $second="bbb";
$a=15; &combine($first,$second);
while ($a<25) sub combine
{ {
$a++; print "\n siruri combinate ".$first.$second."\
last if ($a==20); n";
print "a e ste mai mic decat 25 deci tiparesc }
valoarea $a \n"; # sa se scrie o functie de adunare a doua
} numere
print " am iesit \n"; $first=1;
#instructiunea de de repetare inca odata a $second=2;
blocului de instructiuni $result=combine($first,$second);
$a=15; print "rezutatul este $result \n";
while ($a<25) sub combine
{ {
$a++; $cc=$first+$second;
print "a e ste mai mic decat 25 deci tiparesc print "\n adunarea da: $cc \n";
valoarea $a \n"; }
redo if ($a==25); # sa se scrie o procedura de adunare a doua
} numere
print " am iesit \n"; $first=1;
#instructiuni repetitive imbricate $second=2;
$a=1; &combine($first,$second);
while ($a<5) print "rezutatul este $result \n";
{ sub combine
{ elemente.Valoarea chei a este de fapt
$result=$first+$second; initializata cu valuarea v
print "\n adunarea da:$result \n"; %hash1=(a,1,b,2,c,3,d,4);
} $v=$hash1{c};
#crearea unui tablou si concaternarea a doua print "valoarea memorata la a este $v \n\n";
tablouri #extrag vloarea din cheia c si o pun in variabila
@L1=(5,7,9); v1
print "lista e ; @l1 \n"; $v1=$hash1{c};
@L2=(1,3,@L1,11,13,15,17); print "valoarea memorata la c este $v1 \n\n";
print " lista doi are : @L2 \n"; #adaug la dispersie(vector in care alterneaza
#crearea unui tablou si atribuirea de valori indicele cu valoarea )indicele 3(cheia) care are
unor variabile in ordinea aparitiei lor in lista valoarea 5
@L1=(5,7,9,8); $hash1{e}=5;
print "tabloul e @L1 \n"; $v2=$hash1{e};
($s1,$s2,$s3,$s4,$s5)=@L1; print "valoarea memorata la e este $v2 \n\n";
print " primul e $s1 \n"; $hash2{f}=6;
print " al doilea e $s2 \n"; $v3=$hash2{f};
print " al treilea e $s3 \n"; print "valoarea memorata la f este $v3 \n\n";
print " al patrulea e $s4 \n"; #selectarea tuturor cheilor care vor fi
print " al cincilea e $s5 \n"; memorate intr-un vector
#crearea unui tablou si atribuirea de valori %hash1=(a,1,b,2,c,3,d,4);
unor variabile dar sar peste unele(accesul la @a1=keys(%hash1);
elemente) print "cheile dispersiei sunt @a1 \n";
@L1=(1,2,3,4,5,6,7); foreach $key (keys(%hash1))
print "tabloul e @L1 \n"; {
$s1=$L1[0]; print "cheia curenta este $key \n";
$s2=$L1[1]; print "valoarea corespunzatoare este
$s3=$L1[3]; $hash1{$key} \n";
$s4=$L1[4]; }
$s5=$L1[5]; if (hash1)
print " primul e $s1 \n"; {
print " al doilea e $s2 \n"; print " are macar un element ";
print " al treilea e $s3 \n"; }
print " al patrulea e $s4 \n"; else
print " al cincilea e $s5 \n"; {
$L1[0]=10; print "dispersia nu are elemente \n";
$s1=$L1[0]; }
print " primul e $s1 \n"; #selectarea tuturor valorilor dintr-o
#crearea unui tablou si atribuirea de dispersie(deci nu a cheilor) care vor fi
operatori duali ,incrementare,decrementare memorate intr-un vector
@L1=(1,9,3,4,5,6,7); %hash1=(a,1,b,2,c,3,d,4);
print "tabloul e @L1 \n"; @a1=values(%hash1);
$L1[0]++; print "cheile dispersiei sunt @a1 \n";
$L1[1]--; foreach $value (values(%hash1))
$L1[2]+=5; {
$s1=$L1[0]; print "cheia curenta este $value \n";
$s2=$L1[1]; }
$s3=$L1[2]--; if (values(%hash1))
$s4=$L[3];; {
$s5=$L1[4]; print " are macar un element ";
print " primul e $s1 \n"; }
print " al doilea e $s2 \n"; else
print " al treilea e $s3 \n"; {
print " al patrulea e $s4 \n"; print "dispersia nu are elemente \n";
print " al cincilea e $s5 \n"; }
#punerea elementelor sub forma de interval #sa se stearga elemente dintr -o dispersie
intr-un tablou etapizat
@s1=(1..10); %hash1=(a,1,b,2,c,3,d,4);
for ($i=0;$i<=10;$i++) $i=0;
{ @keys=keys(%hash1);
$e=$s1[$i]; print "cheile dispersiei sunt @keys \n";
print " elementu $i este egal cu $e \n"; while (values(%hash1))
} {
#Sa se creeze o dispersie cu 4 delete $hash1{$keys[$i]};
@a1=values(%hash1); print ("un numar:\n");
print "valorile din dispersie sunt @a1 \n"; $number1 = 17;
$i++; chop ($number1);
if (values(%hash1)) print ("alt numar:\n");
{ $number2 = 18;
print " are macar un element "; chop ($number2);
} if (17 == 18) {
else print ("The two numbers are equal.\n");
{ } elsif ($number1 == $number2 + 1) {
print "dispersia nu are elemente \n"; print ("primule mai mare cu 1.\n");
} } elsif (17 + 1 == 18) {
} print ("al doilea e mai mare cu 1.\n");
#sa se extraga toate valorile si keile dintr-o } else {
dispersie si sa se puna intr-un vector print ("numerele nu sunt egale.\n");
%hash1=(a,1,b,2,c,3,d,4); }
while (@values=each(%hash1)) print ("ultima linie.\n");
{ # sa se incrementeze o variabila pana la o
print "perechea cheie/valoare este @values \n"; valoare dupa care sa iese din ciclu
} $done = 0;
 $count = 1;
#sa se faca conversie din kilometri in mile si print ("linia de start.\n");
invers while ($done == 0) {
$originaldist = 10; print ("acesta valoare este ", $count, "\
n");
chop($originaldist); if ($count == 3) {
$done = 1;
$miles = $originaldist * 0.6214; }
$count = $count + 1;
$kilometers = $originaldist * 1.609; }
print ("am terminat.\n");
print ($originaldist, " kilometri = ", $miles, #sa se delimiteze valorile limita a unui nr
intreg
" miles\n"); $value = 1234567890;
print ("prima valoare ", $value, "\n");
print ($originaldist, " mile = ", $kilometers, $value = 1234567890123456;
print ("a doua valoare ", $value, "\n");
" kilometers\n"); $value = 12345678901234567890;
#sa se determine daca un numar este print ("a treia valoare ", $value, "\n");
negativ sau nu  #sa se exprime in diferite valori
print ("dam un numar:\n"); scalare(numere)in cazul real cu simpla precizie
$number = 10; $value = 34.0;
chop ($number); print ("prima valoare ", $value, "\n");
if ($number) { $value = 114.6e-01;
print ("nenul.\n"); print ("a doua valoare ", $value, "\n");
} $value = 178.263e+19;
print ("ultima linie din program.\n"); print ("a treia valoare ", $value, "\n");
# sa se determine daca doua numere sunt $value =
egale sau nu 123456789000000000000000000000;
print ("un numar:\n"); print ("a patra valoare ", $value, "\n");
$number1 = 10; $value = 1.23e+999;
chop ($number1); print ("a cincea valoare ", $value, "\n");
print ("alt numar:\n"); $value = 1.23e-999;
$number2 = 10; print ("sixth value is ", $value, "\n");
chop ($number2); #sa se prezinte un caz in care numerele
if ($number1 == $number2) { reale sunt afisate eronat(nu se pastreaza
print ("sunt egale.\n"); intervalul posibil)
} value = 9.01e+21 + 0.01 - 9.01e+21;
else print ("prima valoare ", $value, "\n");
{ $value = 9.01e+21 - 9.01e+21 + 0.01;
print (" nu sunt egale.\n"); print ("a doua valoare ", $value, "\n");
} # sa se transforme in majuscule sau
minuscule iar fraza sa inceapa permanent cu
print ("ultima linie din program.\n"); majuscula
#sa se prezinte if -uri imbricate print ("dati un text:\n");
 $inputline = "aceasta este cauza"; $result = ~99;
print ("cu majuscule: \U$inputline\E\n"); print "$result \n";
print ("cu minuscule: \L$inputline\E\n"); $result = 99 >> 1;
print ("prima litera a frazei va fi majuscula: \ print "$result \n";
L\u$inputline\E\n"); $result = 99 << 1;
# sa se determine ce se intampla daca o print "$result \n";
variabila nu e initializata(ia valoarea nula din #sa se prezinte operatorii de incrementare
start) decrementare
$result = $undefined + 2; $result = 99 / 2;
print ("valoarea pt \$result este $result.\n");# sa print "$result \n";
se determine ce se intampla daca o variabila nu $result = 17 * 4;
e initializata(ia valoarea nula din start) print "$result \n";
$result = $undefined + 2; $a=1;
print ("valoarea pt \$result este $result.\n"); $a++;
#sa se prezinte ridicarea la putere print "$a \n";
print ("dau un exponent:\n"); ++$a;
$exponent = 5; print "$a \n";
chop ($exponent); $result = $a++;
print ("ridicarea la putere e $exponent atata print "$result \n";
",2**5, "\n"); $result2 = ++$a;
#sa se prezinte operatorii relationali print "$result \n";
lincvistic stiind ca false nu e afisat iar true e 1 $var1 = 43;
$result = "aaa" lt "bbb"; # result is true $var2 = $var1 += 1;
print "valoare e $result \n"; print "$var1 \n";
$result = "aaa" gt "bbb"; # result is false $var1 = 43;
print "valoare e $result \n"; $var2 = ++$var1;
$result = "aaa" eq "bbb"; # result is false print "$var2 \n";
print "valoare e $result \n"; #sa se foloseasca WHILE in afisarea
$result = "aaa" le "aaa"; # result is true numerelor pana la 5
print "valoare e $result \n"; $value = 0;
$result = "aaa" ge "bbb"; # result is false while (++$value <= 5) {
print "valoare e $result \n"; print("valoarea noua este $value\n");
$result = "aaa" ne "aaa"; # result is false }
print "valoare e $result \n"; print("am terminat\n");
$result = "aaa" cmp "bbb"; # result is -1 #sa se foloseasca WHILE in afisarea
# exprimati de ce cele doua valori sunt numerelor pana la 5
diferite desi numeric sunt egale #daca avem postincrementare se trece si la
$value1 = 14.3; afisarea lui 6
$value2 = 100 + 14.3 - 100; $value = 0;
print("value 1 este $value1, value2 este while ($value++ <= 5) {
$value2\n"); print("valoarea noua este $value\n");
if ($value1 == $value2) { }
print("value 1 e egala cu value 2\n"); print("am terminat\n");
} else { #sa se faca o incrementare de la dreapta la
print("value 1 nu e egala cu value 2\n"); stanga la STRINGURI
#sa se arate ca operatorul de decrementare la
} STRINGURI nu functioaneaza
# sa se prezinte functionarea lui SI ,SAU #cand ultima litera e z se vor incrementa si
$a = 0; celelate litere cu 1 de la dreapta la stanga
$b = 106; #la fel se procedeaza si la combinatii intre
$result = $a && $b; litere si cifre
print " rezultatul lui SI este $result \n"; $stringvar = "abc";
$a = 0; $stringvar++;
$b = 106; print "$stringvar \n";
$result = $a || $b; $stringvar = "abc";
print " rezultatul lui SAU este $result \n"; $stringvar--;
#sa se prezinte functionarea operatorilor la print "$stringvar \n";
nivele de bit $stringvar = "abz";
$result = 124.3 ^ 99; print "$stringvar \n";
print "$result \n"; $stringvar++;
$result = 124.3 | 99; print "$stringvar \n";
print "$result \n"; $stringvar = "AGZZZ";
$result = 124.3 & 99; $stringvar++;
print "$result \n"; print "$stringvar \n";
$stringvar = "bc999"; $result = 4 ** (5 % (8 - 6));
$stringvar++; print "$result \n";
print "$stringvar \n"; # sa se prezinte evaluarea unei expresii
#daca operatorul din sir nu e cifra sau litera se matematice si conditioanale
va testa acest lucru $result = 4 << (2 + 3);
$stringvar = "ab*c"; print "$result \n";
$stringvar++; if ($value == 0 || ($value == 2 && $value2 ==
print "$stringvar \n"; "hello")) {
#avem valoarea 1 daca cifrele apar in interiorul print("operatorul este true\n");
sirului pt ca se considera variavila fiind zero }
$stringvar = "ab5c"; #sa se prezinte un vector mixt cu valori
$stringvar++; numere si stringuri sa se afiseze
print "$stringvar \n"; @array = (1, "chicken", 1.23, "\"Having
#sa se prezinte concaternarea de stringuri fun?\"", 9.33e+23);
$newstring = "potato" . "head"; $count = 1;
print " $newstring \n"; while ($count <= 5) {
$string1 = "potato"; print ("element $count este
$string2 = "head"; $array[$count-1]\n");
$newstring = $string1 . $string2; $count++;
print " $newstring \n"; }
#sa se faca o multiplicare a unei litere de 5 ori  #sa se prezinte generatorul de numere
$newstring = "t" x 5; aleatoare
print " $newstring \n"; $count = 1;
$newstring = "t"; while ($count <= 100) {
$repeats = 5; $randnum = int( rand(10) ) + 1;
$newstring =$newstring x $repeats; $randtotal[$randnum] += 1;
print " $newstring \n"; $count++;
#sa se prezinte folosirea concaternarii ca }
operator odata cu cel de atribuiere $count = 1;
$a = "be"; print ("Totalul este:\n");
$a .= "witched"; while ($count <= 10) {
print" $a \n"; print ("\tnumarul $count:
# sa se opereze de doua ori la o variabila $randtotal[$count]\n");
printr-o comanda $count++;
$val = 26; }
$result = (++$val, $val + 5); #sa se faca o atribuire de doi vectori si sa se
print "$result \n"; afiseze acestia
#aici se va executa ce este inaintea virgulei @array1 = (14, "cheeseburger", 1.23, -7,
restul nu conteaza "toad");
$result = ++$val, $val + 5; @array2 = @array1;
print "$result \n"; $count = 1;
#sa se prezinte operatorul conditional while ($count <= 5) {
$var=0; print("element $count: $array1[$count-
$result = $var == 0 ? 14 : 7; 1] ");
print "$result \n"; print("$array2[$count-1]\n");
$var=1; $count++;
$result = $var == 0 ? 14 : 7; }
print "$result \n"; # se se puna o lista in cadrul altei liste
if ($var == 0) { @innerlist = " unu ";
$result = 14; @outerlist = ("I", @innerlist, "doi!\n");
} else { print @outerlist;
$result = 7; # sa se preia niste valori dintr-un vector si
} sa se puna in variabile
print "$result \n"; @array = (5, 7);
#sa se prezinte prioritatea operatorilor prin ($var1, $var2) = @array;
exemplu(calculul cu oparatori diferiti se face print "$var1,$var2 \n";
de la stanga la dreapta @array = (5, 7, 11);
$result = 11 * 2 + 6 ** 2 << 2; ($var1, $var2) = @array;
print "$result \n"; print "$var1,$var2 \n";
#evaluarea se face de la dreapta la stanga @array = (5, 7);
$result = 2 ** 3 ** 2; ($var1, $var2, $var3) = @array;
print "$result \n"; print "$var1,$var2,$var3 \n";
#paranteza are prioritate mai mare decat ($var1, $var2, $var3) = ("unu", "doi ", "trei");
ridicarea la putere print "$var1,$var2,$var3 \n";
#sa se prei doar ultimul element din vector
@array = (1, 2, 3);
$scalar = @array;
print "$scalar \n";
#sa se afiseze un vector unde <= joca rol de
apartenneta
@array = (14, "cheeseburger", 1.23, -7,
"toad");
$count = 1;
while ($count <= @array) {
print("element $count: $array[$count-1]\
n");
$count++;
} print "tabloul al treilea @a1111 \n\n ";
#preluarea datelor din vector de la dreapta
la stanga
$scalar = (10, 20, 30);
print "$scalar \n";
#sa se arate ca indicierea unui vector incepe
de la zero si sa se preia doar anumite date
dintr-un vector
@array = (1, 2, 3, 4);
@subarray = @array[1,2];
print ("primul element de la subvector e
$subarray[0]\n");
print ("al doilea element de la subvector e
$subarray[1]\n");
#sa se extraga dintr-un vector elementele
care au un anumit indice
@array = ("unu", "doi", "trei", "patru",
"cinci");
@range = (1, 2, 3);
@subarray = @array[@range];
print ("subvectorul este: @subarray\n");
# sa se faca inlocuierea elementelor de un
anumit indice dintr-un vector
@array = ("o1", "o2", "o3", "o4");
@array[1,2] = ("n2", "n3");
print ("@array\n");
<HTML>
<HEAD>
<TITLE>PerlScript Hello World!</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<h2>PerlScript Hello world!</h2>
<SCRIPT LANGUAGE="PerlScript">
$window->document->write('Hello world!');
</SCRIPT>
</BODY>
</HTML>
#sa se afiseze lungimea unui vector
@array=(1,2,4,6,7,8,5,3,2,8);
print "tabloul este @array \n";
$length=@array;
print"dimensiunea tabloului este $length \n";
sa se tipareasca tablul
@array=(2..11);
print "tabloul e : @array \n";
@arrayslice1=@array[0,2,4];
print "tabloul 1 contine @arrayslice1 \n ";
@arrayslice11=@array[1,3,5];
print "tabloul 2 contine @arrayslice11 \n ";
@arrayslice111=@arrayslice1[0,1];
print "tabloul 3 contine @arrayslice111 \n ";
#reprezentarea pe intervale a unui tablou ca
si continut
$index1=14;
$i2=18;
$i3=20;
@array=(11..20);
@a11=@array[0,2,3];
print "tabloul prim @a11 \n\n ";
@arrayslice2=@array[0,2,3];
print "tabloul prim @arrayslice2 \n\n ";
@a111=@array[11..$index1];
print "tabloul al doilea @a111 \n\n ";
@a1111=@array[$index1..$i2];
#sa se inlocuiasca valorile cu indice 3, 4 ,5
cu 10,20,30
@a=qw(tica ion gica piescu john);
print " tablou1 are: @a \n ";
@a[2..4]=(10,20,30,40,50);
print " tablou2 are: @a \n ";
@a[0..5]=(iliescu);
print " tablou3 are: @a \n ";
#sa se creeze un tablou cu 4 elemente
@a1[0..3]=(1..4);
print " tablou4 are: @a1 \n ";
#operatii cu variabile scalare
@a=qw(aceasta nu e o variabila corecta );
print "tabloul 1 este : @a \n ";
$a="salutari ";
print "valoarea scalara a tabloului este : @a \n
";
print "$a[2] world \n";
#nu sunt luate in considerare seminjele de dupa
o variabila scalara ci sunt considerate ca
simbloluri din sir
print "$a\[2] world \n";
print "$a"."[2] world \n";
print "${a}[2] world \n";
#sa se elimine cate o litera(ultima) din
fiecare componenta a unui tablou
@a=("acest\n","tablou\n","este\n","toteauna\
n","unul\n","bun\n");
print ("tabloul la inceput e:@a \n ");
chop(@a);
print("am aplicat functia 1 si obtin :@a \n");
chop(@a);
print("am aplicat functia a doua oara si
obtin :@a \n");
chop(@a);
chop(@a);
print("am aplicat functia a patra oara si
obtin :@a \n");
#sa se elimine cate simbolul "\n" adica
LINIE NOUA din fiecare componenta a unui
tablou
@a=("acest\n","tablou\n","este\n","toteauna\
n","unul\n","bun\n");
print ("tabloul la inceput e:@a \n ");
chomp(@a);
print("am aplicat functia 1 si obtin :@a \n");
chomp(@a);
print("am aplicat functia a doua oara si
obtin :@a \n");
chomp(@a);
chomp(@a); unui vector si sa se atasaseze elemente la
print("am aplicat functia a patra oara si tiparire pe langa vector
obtin :@a \n"); @a=qw(1 2 3 4 5);
#sa se faca operatii de extragere si punere in print "tabloul :@a \n\n";
coada direct sau cu scalari $string=join("-@-",sort(@a));
@a=qw(unu doi trei patru cinci sase sapte opt print ("tablul acesta este $string \n ");
noua zece ); $string=join(":)",@a,6);
print ("tabloul este :@a \n\n "); print "tablul acesta este $string \n ";
pop(@a); $string=join(" ",@a,12,15);
print "fac prima extragere si obtin : @a \n\n "; print "tablul acesta este $string \n ";
$a1=pop(@a); $string=join ("MT",@a);
print "fac a doua extragere si obtin : @a \n\n "; print "tablul acesta este $string \n ";
push(@a,"nou"); #sa se se puna un separator intre elementele
print "fac adaugare in coda si obtin : @a \n\n "; unui vector
pop(@a); $string="1 2 3 4 5";
print "fac extragere si obtin : @a \n\n "; print "tabloul :$string \n\n";
push(@a,$a1); @a=split(" ",$string);
print "fac adaugare in coada si obtin : @a \n\n print ("tablul acesta este @a \n\n ");
"; $string="1 - 2 - 3 - 4 - 5";
#sa se faca operatii de extragere si punere in @a=split(" ",$string);
stiva direct sau cu scalari(la inceputul listei se print ("tablul acesta este @a \n\n ");
face tot) @a=split("-",$string);
@a=qw(unu doi trei patru cinci sase sapte opt print ("tablul acesta este @a \n\n ");
noua zece ); sa se faca conexiunea la o baza de date
print ("tabloul este :@a \n\n "); USE DBI;
shift(@a); $dbh=DBI->connect("c:\perl\bin\LIB\
print "fac prima extragere si obtin : @a \n\n "; DBI","root") or die "\neroare ($DBI::err):
$a1=shift(@a); $dbi:errstr\n";
print "fac a doua extragere si obtin : @a \n\n "; $dbh->disconect;
unshift(@a,"nou"); #sa se descrie o procedura standard(deci
print "fac adaugare in coda si obtin : @a \n\n "; scrisa cu majuscule) si sa se apeleze
shift(@a); print "sal \n";
print "fac extragere si obtin : @a \n\n "; sub begin
unshift(@a,$a1); {
print "fac adaugare in coada si obtin : @a \n\n print "\n \n -----\n";
"; print "BEGIN.pl\n";
#sa se srie care sorteaza un vector si pune }
rezultatul in alt vector begin;
@a=qw(unu doi trei patru cinci sase sapte opt #sa se apeleze o procedura in interiorul
noua zece ); alteia si sa se observe evolutia variabilelor
print ("tabloul este :@a \n\n "); locale si globale
@a1=sort(@a); $c=0;
print "fac sortare si obtin : @a1 \n\n "; print "variabila globala $c \n";
print "fac sortare dar vectorul initial este : @a \ &f1;
n\n "; print "valoarea inainte de functia a doua este" .
@a2=(500,9,2000,-11000,25,-27); ++$c . "\n";
print ("tabloul este :@a2 \n\n "); &f2;
@a11=sort(@a2); print "globala este variabila a doua oara ".++
print "fac sortare si obtin : @a11 \n\n "; $c."\n";
#sa se srie care sorteaza un vector si pune
rezultatul in alt vector(dar sortare e sub f1
descresactoare) {
@a=qw(unu doi trei patru cinci sase sapte opt print "valoarea inainte de functia a doua in f1
noua zece ); este " . ++$c . "\n";
print ("tabloul este :@a \n\n "); local $c=3;
@a1=reverse(@a); print "variabila locala in f1 $c \n";
print "fac sortare si obtin : @a1 \n\n "; print "local este in prima procedura, variabila a
print "fac sortare dar vectorul initial este : @a \ doua oara ".++$c."\n";
n\n "; print " a doua \n";
@a2=(500,9,2000,-11000,25,-27); &f2;
print ("tabloul este :@a2 \n\n "); }
@a11=reverse(@a2);
print "fac sortare si obtin : @a11 \n\n "; sub f2 {
#sa se se puna un separator intre elementele if ($_[0])
 { }
print "in procedura avem $_[0] \n"; @t=<EXAMPLE>;
print "globala este in a doua print " \n @t \n";
procedura, variabila a doua oara ".++$c."\n"; #sa se afiseze primii 10 octeti
local $c=10; print "deschid un fisier \n";
print "local in a doua procedura avem $c \n"; if (open (EXAMPLE,"example.txt"))
} {
if ($_[0]) print "s-a reusit deschiderea \n";
{ }
print "in prima procedura avem $_[0] \n"; else
} {
} print "nu s a deschis \n";
#sa se deschida un fisier }
print "deschid un fisier \n"; read(EXAMPLE,$t,10);
if (open (EXAMPLE,"example.txt")) print "$t \n";
{ read(EXAMPLE,$t,10,10);
print "s-a reusit deschiderea \n"; print "$t \n";
} #la afisare se sare peste primii 10 octeti
else read(EXAMPLE,$t,2000,20);
{ print "$t \n";
print "nu s a deschis \n"; #sa se afiseze un fisier dar sa se sara peste
} un anumit numar de octeti
close(example); print "deschid un fisier \n";
#sa se deschida un fisier si sa se listeze if (open (EXAMPLE,"example.txt"))
prima linie din fisier {
print "deschid un fisier \n"; print "s-a reusit deschiderea \n";
if (open (EXAMPLE,"example.txt")) }
{ else
print "s-a reusit deschiderea \n"; {
} print "nu s a deschis \n";
else }
{ seek(EXAMPLE,10,0);
print "nu s a deschis \n"; $l=tell(EXAMPLE);
} print "ai sarit peste $l octeti \n";
$t=<EXAMPLE>; read(EXAMPLE,$t,10);
print "\n \n $t \n"; print "$t \n";
close(example); read(EXAMPLE,$t,10,10);
#sa se deschida un fisier si sa se listeze print "$t \n";
fiecare linie din fisier $l=tell(EXAMPLE);
print "deschid un fisier \n"; #la afisare se sare peste primii 10 octeti
if (open (EXAMPLE,"example.txt")) read(EXAMPLE,$t,2000,20);
{ print "$t \n";
print "s-a reusit deschiderea \n"; #sa se creeze un fisier sa se puna date in el
} si sa se listeze
else print "deschid un fisier \n";
{ open (EXAMPLE,">example.txt");
print "nu s a deschis \n"; print EXAMPLE ("prima \n");
} print EXAMPLE ("prima \n");
$t=<EXAMPLE>; print EXAMPLE ("prima \n");
while ($t) close(EXAMPLE);
{ open (EXAMPLE,"example.txt");
print " \n $t \n"; read (EXAMPLE,$c,200);
$t=<EXAMPLE>; print "avem \n $c \n";
} close(EXAMPLE);
#sa se deschida un fisier si sa se listeze #sa se creeze un fisier sa se puna date in el
fiecare linie din fisier si sa se listeze
print "deschid un fisier \n"; print "deschid un fisier \n";
if (open (EXAMPLE,"example.txt")) open (EXAMPLE,">example.txt");
{ $t="bine";
print "s-a reusit deschiderea \n"; $t1="bine1";
} print EXAMPLE ("$t \n");
else print EXAMPLE ("$t1 \n");
{ close(EXAMPLE);
print "nu s a deschis \n"; open (EXAMPLE,"example.txt");
read (EXAMPLE,$c,200); if (-z "o.txt")
print "avem \n $c \n"; {
close(EXAMPLE); print "e gol\n"
#sa se deschida un fisier din care preiau }
datele(notat cu i) si unul in care pun datele else
(notat cu e) si sa se listeze destinatarul {
print "deschid un fisier \n"; print "are informatii\n"
open (e,">example.txt"); }
print "deschid un fisier \n"; #sa se creeze un director nou
open (i,"info.txt"); if (mkdir ("nou ",00777))
$copy=<i>; {
while ($copy) print "ai un nou director in c:\perl\bin \n"
{ }
print e ($copy); else
$copy=<i>; {
} print "nu poti crea ";
close(e); }
close(i); #sa se stabileasca daca directorul NOU
open (e,"example.txt"); contine fisierul o.txt
print "deschid un fisier \n"; if (-e "o.txt")
print "noul fisier e \n"; {
$c=<e>; print "am fisier in directorul NOu \n ";
while ($c) }
{ else
print "$c \n"; {
$c=<e>; print "am fisier in directorul NOu \n ";
} }
#sa se deschida un fisier notat cu o.txt in chdir ("c:\perl\bin\nou");
care sa se puna oricare mesaj din comanda if (-e "o.txt")
print in el {
print "deschid un fisier \n"; print "am fisier in directorul NOu \n ";
open (STDOUT,">o.txt"); }
print "deschid un fisier \n"; else
open (e,"info.txt"); {
print "deschid un fisier \n"; print "am fisier in directorul NOu \n ";
print "noul fisier e \n"; }
$c=<e>; #sa se gaseasca un subsir intr-un sir
while ($c) $string1="acesta este un sir de informatii";
{ $s2="il folosesc la cautare";
print "$c \n"; if ($result=$string1=~/sir/ )
$c=<e>; {
} print " l am gasit in $s1 \n ";
close(e); }
close(e1); else
#sa se otina informatii despre un fisier
if (-e "o.txt") {
{ print "nu l am gasit in s1 \n ";
print "este \n" }
} if ($r=$s2=~/str/ )
else {
{ print "l am gasit in s2 \n ";
print "nu este \n"; }
} else
$l=-M "o.txt";
print "cate zile au trecut decand nu a fost {
midificat fisierul $l \n"; print "nu l am gasit in s2 \n ";
if (-r "o.txt") }
{ #sa se gaseasca un subsir intr-un sir cand
print "pot sa l citesc\n" poate sa se repete litera R
} $string1="srt srrt srrt srrrrt";
else if ($result=$string1=~/sr+/ )
{ {
print "nu pot sa l citesc\n" print " l am gasit in s1 \n ";
} }
else cuvantul aa
{ $string1=" fffbeat el este aa" ;
print "nu l am gasit in s1 \n "; if ($result=$string1=~/aa$/ )
} {
#sa se gaseasca un subsir intr-un sir cand print " l am gasit in s1 \n ";
poate sa se repete litera R de minim 3 ori si }
maxim 6 else
$string1="srt srrt srrrrrrrrrt srrrrrrt"; {
if ($result=$string1=~/sr{3,6}/ ) print "nu l am gasit in s1 \n ";
{ }
print " l am gasit in s1 \n "; #sa se determine daca un sir are 4 cifre
} consecutive urmate de un spatiu
else $string1=" fffbeat el 7777 este aa" ;
{ if ($result=$string1=~/\d\d\d\d\s/ )
print "nu l am gasit in s1 \n "; {
} print " l am gasit in s1 \n ";
#sa se gaseasca un subsir intr-un sir astfel }
ca intre A si T poate fi orice caracter in afara else
de \n {
$string1="alt act a!t factor autor"; print "nu l am gasit in s1 \n ";
if ($result=$string1=~/a.t/ ) }
{ #sa se determine o corespondenta si in ce
print " l am gasit in s1 \n "; cuvant apare
} $string1="this is an example string whill nthat-
else shold-tigger-a-match" ;
{ while (string1=~/[a-z]+/gi)
print "nu l am gasit in s1 \n "; {
} print "a fost gasita o componenta cu $& \n ";
#sa se gaseasca un subsir cu ajutorul }
prefixului \b urmat de numele cuvantului (deci #sa se inlocuiasca intr-un sir 7777 cu 8888
cuvantul cautat sa inceapa cu beat) numai o singura data
$string1="aa beatcccc el este" ; $string1=" fffbeat el 7777 este aa" ;
if ($result=$string1=~/\bbeat/ ) if ($result=$string1=~s/7777/8888/ )
{ {
print " l am gasit in s1 \n "; print " l am gasit in s1 \n ";
} print " l am gasit si s a schimbat $string1 \n
else ";
{ }
print "nu l am gasit in s1 \n "; else
} {
#sa se gaseasca un subsir cu ajutorul print "nu l am gasit in s1 \n ";
prefixului \b urmat de numele cuvantului cu }
care sa se termine cuvantul cautat #sa se inlocuiasca intr-un sir 7777 cu 8888
$string1="aa fffbeat el este" ; peste tot pe unde apare 7777
if ($result=$string1=~/beat \b/ ) $string1=" fffbeat el 7777 este 7777 aa" ;
{ while ($string1=~s/7777/8888/g )
print " l am gasit in s1 \n "; {
} print " l am gasit in s1 \n ";
else print " l am gasit si s a schimbat $string1 \n
{ ";
print "nu l am gasit in s1 \n "; }
} #sa se inlocuiasca intr-un sir aaaa sau cu
#sa se determine daca un sir incepe cu majuscule adica AAAA cu bbbb peste tot pe
cuvantul aa unde apare
$string1="aa fffbeat el este" ; $string1=" fffbeat el aaaa este AAAA aaaa" ;
if ($result=$string1=~/^aa / ) while ($string1=~s/aaaa/bbbb/gi )
{ {
print " l am gasit in s1 \n "; print " l am gasit in s1 \n ";
} print " l am gasit si s a schimbat $string1 \n
else ";
{ }
print "nu l am gasit in s1 \n "; #sa se inlocuiasca intr-un sir aaaa cu 9*9
} peste tot pe unde apare
#sa se determine daca un sir incepe cu $string1=" fffbeat el aaaa este AAAA aaaa" ;
while ($string1=~s/aaaa/9*9/g ) print "Location: http:// www.county-line-
{ bbq/clbbq-minus.html.com \n\n";
print " l am gasit in s1 \n "; }
print " l am gasit si s a schimbat $string1 \n #sa se listeze un vectro de stringuri
"; @my_name = ("Eric","C.","Herrmann");
} $myName[0] = "Scott";
#sa se inlocuiasca intr-un sir aaaa cu 81 $myName[1] = "E.";
peste tot pe unde apare ca evaluare a lui 8*8 $myName[2] = "Herrmann";
$string1=" fffbeat el aaaa este AAAA aaaa" ; print "salutari @my_name \n";
while ($string1=~s/aaaa/9*9/ge ) print "Realitatea e: @myName \n";
{ print " $my_name[0] $my_name[1]
print " l am gasit in s1 \n "; $my_name[2] !\n";
print " l am gasit si s a schimbat $string1 \n # sa se faca legatura intre cheie(indice) si
"; valoare(continutul vectorului) in cazul unui
} vector
#sa se inlocuiasca intr-un sir aaaa cu bbbb %names = ("FIRST", "Jessica ", "MIDDLE",
cautarea facandu-se peste tot "Ann ", "LAST", "Herrmann");
$string1=" fffbeat el aaaa este AAAA aaaa" ; $full_name{'first'} = "Steven ";
while ($string1=~tr/aaaa/cccc/) $full_name{'middle'} = "Michael ";
{ $full_name{'last'} = "Herrmann";
print " l am gasit in s1 \n "; print "avem $names{'FIRST'}";
print " l am gasit si s a schimbat $string1 \n print "si ";
"; foreach $name (keys(%full_name)){
} print "$full_name{$name}";
#sa se inlocuiasca intr-un sir tot ce nu e }
litera din intervalul a-z cu un tab adica print "\n";
simbolizat cu \t #sa se testeze operatorul NON
$string1=" fffbeat 5 aaaa este 3 aaaa" ; $question = "acasa";
$string1=~tr/a-z/\t/c; if ($question =~ /please/) {
print " $string1 \n "; print ("multam\n");
#sa se sterga toate spatiile si literele dintr-o } else {
fraza litere din intervalul a-z print ("nu va multumesc!\n");
$string1=" fffbeat 5 aaaa este 3 aaaa" ;
$string1=~tr/a-z//d; }
print " $string1 \n "; #sa se determine tipul variabilei de
#sa se inlocuiasca toate si spatiile dintr-o intrare(string,numar..)
fraza din intervalul a-z cu 9
$string1=" fffbeat 5 aaaa este 3 aaaa" ; $varname = "acasa";
$string1=~tr/a-z/9/;
print " $string1 \n "; chop ($varname);
#sa se inlocuiasca toate si spatiile dintr-o
fraza din intervalul a-z sau grupurile de litere if ($varname =~ /\$[A-Za-z][_0-9a-zA-Z]*/)
cu 9 {
$string1=" fffbeat 55 aaaa este 3 aaaa" ;
$string1=~tr/a-z/9/s; print ("$varname variabila scalara\n");
print " $string1 \n ";
#sa se verifice versiunea de php care } elsif ($varname =~ /@[A-Za-z][_0-9a-zA-
ruleaza Z]*/) {
@user_agent = split(/\//,
$ENV{'HTTP_USER_AGENT'}); print ("$varname e un vector\n");
if ($user_agent[0] eq "Mozilla"){
@version = split(/ /,$user_agent[1]); } elsif ($varname =~ /[A-Za-z][_0-9a-zA-
$version_number = substr($version[0], 0, Z]*/) {
3);
if ($version_number < 1.1){ print ("$varname e un sir de caractere\n");
print "Location: http://www.county-line-
bbq/clbbq-plus.html.com\n\n"; } else {
}
else{ print ("e ciudata $varname is.\n");
print "Location: http:// www.county-line-
bbq/clbbq-minus.html.com \n\n"; }
} #sa se testeze daca o data este buna sau nu
} print ("Enter a date in the format YYYY-MM-
else{ DD:\n");
 $date = 1999-12-12; $temp = 1;
chop ($date); @list = ("This", "is", "a", "list", "of",
$md1 = "(0[13578]|1[02])\\2(0[1-9]|[12]\\d| "words");
3[01])"; print ("tabloul are:: \n");
$md2 = "(0[469]|11)\\2(0[1-9]|[12]\\d|30)"; foreach $temp (@list) {
$md3 = "02\\2(0[1-9]|[12]\\d)"; print ("$temp ");
$match = $date =~ /^(19)?\d\d(.)($md1|$md2| }
$md3)$/; print("\n");
$olddate = $date =~ /^(\d{1,4})(.)($md1| print("The value of temp is now $temp\n");
$md2|$md3)$/; #ultimul cuvant sa devina primul
if ($match) { $line = "linie de test";
print ("$date e buna\n"); $line =~ s/^\s+//;
} elsif ($olddate) { $line =~ s/\s+$//;
print ("$date nu e buna\n"); foreach $word (reverse sort split(/[\t ]+/,
} else { $line)) {
print ("$date nu e valida\n"); print ("$word ");
} }
 #sa se afiseze dac se da cuvantul: balata print ("\n");
# ba #cu repeat sa se listeze elementele pana la 5
#la $count = 1;
#ta do {
while ("balata" =~ /.a/g) { print ("$count\n");
$match = $&; $count++;
print ("$match\n"); } until ($count > 5);
} #sa se adune numere pana la un anumit
#sa se formateze un text numar si pe cele pare
@input = "acasa e foarte FOARTE bine"; $limit =121;
$count = 0; chop ($limit);
while ($input[$count] ne "") { $count = 1;
$input[$count] =~ s/^[ \t]+//; $total = $eventotal = 0;
$input[$count] =~ s/[ \t]+\n$/\n/; for ($count = 1; $count <= $limit; $count++)
$input[$count] =~ s/[ \t]+/ /g; {
$count++; $total += $count;
} if ($count % 2 == 1) {
print ("Formatarea textului:\n"); next;
print (@input); }
#sa se extraga cifrele dintr-o fraza $eventotal += $count;
$string = "acasa 25 acasa"; }
$string =~ tr/0-9//cd; print("suma de la 1 la $limit is $total\n");
print ("$string\n"); print("numere in gemneral $eventotal\n");
#sa se trensfere datele dintr-un fisier in altul # sa se numere cate cuvinte sunt intr-o fraza
sau sa se dea un mesaj de eraoare daca se repeta de 3 ori
die ("nu pot lua datele\n") unless $total = 0;
(open(INFILE, "example.txt")); for ($count = 1; $count <= 3; $count++) {
die ("nu pot sa le pun\n") unless $line = "repede acasa";
(open(OUTFILE, ">o.txt")); last if ($line eq "");
print OUTFILE ($line) while ($line = $line =~ s/^[\t ]*//;
<INFILE>); $line =~ s/[\t ]*\n$//;
close (OUTFILE); redo if ($line eq "");
#sa se afizeze nuere pana la 5 @words = split(/[\t ]+/, $line);
$count = 0;
print ("$count\n") while ($count++ < 5); $total += @words;
#folosind for sa se listeze numere de la 1
pana la 5 }
for ($count=1; $count <= 5; $count++) {
print ("$count\n"); print ("The total number of words is $total\
} n");
#sa se listeze elementele unui vector # sa se dea un exemplu de program care
@words = ("Here", "is", "a", "list."); foloseste etichete si rezultatul da 47
foreach $word (@words) { $total = 0;
print ("$word\n"); $primul = 0;
} DONE: while ($primul < 10) {
 #listarea simpla a elementelor unui tablou $doi = 1;
in timp minim while ($doi <= 10) {
 $total++; #daca un fisier nu e deschis sa se dea mesaj
if ($primul == 4 && $doi == 7) { de eraoare altfel sa se listeze
last DONE; unless (open(MYFILE, "example.txt")) {
} die ("nu e deschis\n");
$doi++; }
} $line = <MYFILE>;
$primul++; while ($line ne "") {
} print ($line);
print ("$total\n"); $line = <MYFILE>;
# sa se apleze o procedura }
$total = 0; # sa se dea un exemplu prin procedurade
&getnumbers; folosire a comenzii AUTILOAD
foreach $number (@numbers) { &nothere("hi", 46);
$total += $number; AUTOLOAD {
} print("subroutina $AUTOLOAD nu e
print ("the total is $total\n"); fondata\n");
sub getnumbers { print("argumentul: @_\n");
$line = "acasa"; }
$line =~ s/^\s+|\s*\n$//g; $rootname = "parent";
@numbers = split(/\s+/, $line); %tree = ("parentleft", "child1",
} "parentright", "child2",
#sa genereze aleator zece numere si sa se
pun aintr-un vector "child1left", "grandchild1",
srand(); "child1right", "grandchild2",
print ("numere aleatoare.\n"); "child2left", "grandchild3",
for ($count = 1; $count <= 100; $count++) { "child2right", "grandchild4");
$randnum[&intrand] += 1; &print_tree($rootname);
} sub print_tree {
print ("Totals for the digits 0 through 9:\n"); local ($nodename) = @_;
print ("@randnum\n"); local ($leftchildname, $rightchildname);
sub intrand { $leftchildname = $nodename . "left";
$num = int(rand(10)); $rightchildname = $nodename . "right";
} if ($tree{$leftchildname} ne "") {
 #sa se tipareasca cu o procedura trei &print_tree($tree{$leftchildname});
numere si sa se sumeze }
$number1 = 1; print ("$nodename\n");
$number2 = 2; if ($tree{$rightchildname} ne "") {
$number3 = 3;
&printnum ($number1, $number2, &print_tree($tree{$rightchildname});
$number3); }
sub printnum { }
my($number1, $number2, $number3) =  # sa se dea o alta varianta de verificare a
@_; deschiderii unui fisier si listarea acestuia
my($total); unless (open(MYFILE, "example.txt")) {
print ("numerele: "); die ("cannot open input file file1\n");
print ("$number1 $number2 $number3\ }
n"); @input = <MYFILE>;
$total = $number1 + $number2 + print (@input);
$number3; # sa se preia datele dintr-un fisier si sa sa se
print (" total: $total\n"); puna in altul notat cu O
} unless (open(INFILE, "example.txt")) {
#sa se scrie un program in care o variabila die ("cannot open input file file1\n");
apare ca scalar si ca vector si sa se afiseze cu o }
procedura unless (open(OUTFILE, ">o.txt")) {
$foo = 26; die ("cannot open output file outfile\n");
@foo = ("here's", "a", "list"); }
&testsub (*foo); $line = <INFILE>;
print ("The value of \$foo is now $foo\n"); while ($line ne "") {
sub testsub {local (*printarray) = @_; print OUTFILE ($line);
foreach $element (@printarray) { $line = <INFILE>;
print ("$element\n"); }
} # sa se listeze asa:prima linie din primul
$printarray = 61; fisier apoi prima din al doilea fisier ...si sa se
} apase CTRL+BREAK pentru intrerupere
open (INFILE1, "e1.txt") || print STDERR ("line 2\n");
die ("Cannot open input file merge1\n"); close (STDOUT);
open (INFILE2, "example.txt") || close (STDERR);
die ("Cannot open input file merge2\n"); #sa se redirectioneze erorile catre un fisier
$line1 = <INFILE1>; prin Buffer
$line2 = <INFILE2>; open (STDOUT, ">e1.txt") || die ("open
while ($line1 || $line2 ) { STDOUT failed");
if ($line1 ) { open (STDERR, ">&STDOUT") || die ("open
print ($line1); STDERR failed");
$line1 = <INFILE1>; $| = 1;
} select (STDERR);
if ($line2) { $| = 1;
print ($line2); print STDOUT ("line 11\n");
} print STDERR ("line 12\n");
} close (STDOUT);
#sa se determine daca un fisier este deschis close (STDERR);
inainte de a fi deschis #sa se tranfere datele dintr-un fisier in altul
if (-e "o.txt") { cu ajutorul unor proceduri
if (!(-w "o.txt")) { &open_file("INFILE", "", "e1.txt");
die ("nu ai drept.\n"); &open_file("OUTFILE", ">", "o.txt");
} while ($line = &read_from_file("INFILE")) {
if (!(-z "o.txt")) { &print_to_file("OUTFILE", $line);
die ("are informatii.\n"); }
sub open_file {
} local ($filevar, $filemode, $filename) =
@_;
} open ($filevar, $filemode . $filename) ||
# sa se determine dimensiunea unui fisier die ("nu l deschid $filename");
$filename = "e.txt"; }
if (!(-e $filename)) { sub read_from_file {
print ("File $filename does not exist.\n"); local ($filevar) = @_;
} else { <$filevar>;
$size = -s $filename; }
print ("File $filename contains $size sub print_to_file {
bytes.\n"); local ($filevar, $line) = @_;
} print $filevar ($line);
#sa se determine cine e conectat acum la }
server # sa se scrie datele dintr-un fisier inainte de
open (WOUT, "w|"); tiparire intr-un fisier temporar
$time = <WOUT>; @array = ("This", "is", "a", "test");
$time =~ s/^ *//; open (TEMPFILE, ">e1.txt");
$time =~ s/ .*//; foreach $element (@array) {
<WOUT>; print TEMPFILE ("$element\n");
@users = <WOUT>; }
close (WOUT); close (TEMPFILE);
open (TEMPFILE, "file1");
foreach $user (@users) { while (1) {
$user =~ s/ .*//; $skipback = tell(TEMPFILE);
} $line = <TEMPFILE>;
print ("la momentu acesta: $time"); last if ($line eq "");
print ("sunt conectati:\n"); print ($line);
$prevuser = ""; $line = <TEMPFILE>; # assume the
foreach $user (sort @users) { second line exists
if ($user ne $prevuser) { print ($line);
print ("\t$user"); seek (TEMPFILE, $skipback, 0);
$prevuser = $user;} $line = <TEMPFILE>;
} print ($line);
 #sa se redirectioneze erori care ar aparea pe $line = <TEMPFILE>;
ecran catre un fisier print ($line);
open (STDOUT, ">e1.txt") || die ("open }
STDOUT failed"); #sa se deschida un director si sa se afiseze
open (STDERR, ">&STDOUT") || die ("open fisierele de acolo
STDERR failed"); opendir(HOMEDIR, "/Pxperl/bin") ||
print STDOUT ("line 1\n"); die ("Unable to open directory");
 while ($filename = readdir(HOMEDIR)) { # sa se numere cate caractere avem pana la
print ("$filename\n"); un cuvant intr-o fraza
} $input = "este the end";
closedir(HOMEDIR); $position = $found = 0;
#sa se listeze subdirectoarele alfabetic si while (1) {
fisierele $position = index($input, "the",
opendir(HOMEDIR, "/pxperl/bin") || $position);
die ("Unable to open directory"); last if ($position == -1);
@files = readdir(HOMEDIR); if ($found == 0) {
closedir(HOMEDIR); $found = 1;
foreach $file (sort @files) { print ("avem atatea caractere pana la
print ("$file\n"); cuvant:");
} }
#sa se evalueze o variabila print (" $position");
$myvar = 1; $position++;
eval ("print (\"sal!\\n\"); \$myvar = 2;"); }
print ("valoarea pt \$myvar e $myvar\n"); if ($found == 0) {
#sa se scrie un program care lasa putin timp print ("nu e bine\n");
dupa o evaluare si apoi trece la urmatoarea } else {
evaluare ignorand EXIT print ("\n");
$procid = fork(); }
if ($procid == 0) { # sa se determine cate caractere are o fraza
# this is the child process $string = "here is a string";
print ("am listat o prima\n"); $_ = $string;
exit(0); $length = tr/a-zA-Z /a-zA-Z /;
} else { print (" $length caractere\n");
waitpid ($procid, 0); #sa se determine cand se repeta litera i pe ce
print ("am listat o dupa\n"); poziti
} string = "Mississippi";
#cu proceduri sa se evalueze sin si cos de while ($string =~ /i/g) {
90 de grade $position = pos($string);
$rad90 = &degrees_to_radians(90); print("am marcat pozitia: $position\n");
$sin90 = sin($rad90); }
$cos90 = cos($rad90); #sa se extraga dintr-un sir de la o anumita
print ("90 degrees:\nsine is $sin90\ncosine is pozitie un numar de caractere sau numai de la
$cos90\n"); o anumita pozitie incolo
sub degrees_to_radians { $string = "This is a sample character string";
local ($degrees) = @_; $sub1 = substr ($string, 10, 6);
local ($radians); $sub2 = substr ($string, 17);
$radians = atan2(1,1) * $degrees / 45;
} print ("\$sub1 is \"$sub1\"\n\$sub2
#sa se calculeze modulul radicalul is \"$sub2\"\n");
exponentiala si logaritmul dintr-un numar #sa se faca inlocuiri intro fraza la anumite
$result = abs(3.5); pozitii
print "$result \n"; $string = "Here is a sample character string";
$result = abs(0); substr($string, 0, 4) = "This";
print "$result \n"; substr($string, 8, 1) = "the";
$value=4; substr($string, 19) = "string";
$result = sqrt ($value); substr($string, -1, 1) = "g.";
print "$result \n"; substr($string, 0, 0) = "Behold! ";
$result = exp ($value); print ("$string\n");
print "$result \n"; #sa se transforme numai prima litera in
$result = log ($value); majuscula respectiv minuscula dar si tot
print "$result \n"; cuvantul
#incepand cu ce pozitie este gasit un subsir $lower = lcfirst("HELLO");
intr-un sir print "$lower \n";
$input = "este the end";; $upper = ucfirst("hello");
$position = index($input, "the"); print "$upper \n";
if ($position >= 0) { $lower = lc("HELLO");
print ("pattern found at position $position\ print "$lower \n";
n"); $upper = uc("hello");
} else { print "$upper \n";
print ("pattern not found\n"); #sa se insereze un simbol intre oricare doua
} cuvinte dintr-un vector
@list = ("Here", "is", "a", "list"); }
$newstr = join ("::", @list); close (OUTFILE);
print "$newstr \n";
# sa se faca conversia din hexazecimal in close (CODEDFILE);
octal #sa se acceseze doar o portiune din
$num = 26; numerele scrise in baza 2 si sa se impacheteze
$outstr = sprintf("%d = %x hexadecimal or $vector = pack ("B*", "11010011");
%o octal\n", $val1 = vec ($vector, 0, 4);
$num, $num, $num); $val2 = vec ($vector, 1, 4);
print ($outstr); print ("high-to-low order values: $val1 si
#sa se sterga caracterul separator dintr-un $val2\n");
sir definit aprioric $vector = pack ("b*", "11010011");
$/ = "::"; $val1 = vec ($vector, 0, 4);
$scalar = "testing::"; $val2 = vec ($vector, 1, 4);
$num = chomp($scalar); print ("low-to-high order values: $val1 si
print ("$scalar $num\n"); $val2\n");
@list = ("test1::", "test2", "test3::"); # sa se determine ce elemente sunt definite
$num = chomp(@list); intr-un vector(AU VALORI)
print ("@list $num\n"); $array[2] = 14;
#sa se transforme in baza 10 din baza 16 $array[4] = "hello";
$myhexstring = "1ff"; for ($i = 0; $i <= 5; $i++) {
$num = hex ($myhexstring); if (defined ($array[$i])) {
print "$num \n"; print ("element ", $i+1, " e definit\
#sa se determine partea intreaga a unui n");
numar }
#sa se determine un numar in baza 10 din octal }
$floatnum = 45.6;  #sa se determine functionarea unei functii
$intnum = int ($floatnum); care elimina o litera dintr-o lista si nu dintr-un
print "$intnum \n"; scalar
$myoctstring = "177"; @array = &mysub();
$num = oct ($myoctstring); $scalar = &mysub();
print "$num \n"; sub mysub {
$num = oct ("07" x 2); if (wantarray()) {
print "$num \n"; print ("true\n");
#sa se determine ce caracter corespunde la } else {
un ordin ASCII si invers print ("false\n");
$slash = sprintf("%c", 47); }
$slash = chr(47);print "$slash \n"; }
$slash = chr(303);print "$slash \n"; #sa se listeze continutul unei variabile si
$slash = chr(559); pointerul(adresa specificat prin \variabila)unde
print "$slash \n"; acsta e memorat
$slash = ord("/"); $variable = 22;
print "$slash \n"; $pointer = \$variable;
#sa se impacheteze in scalar o variabila din print "$pointer \n";
perl $ice = "jello";
$t = pack("i2", 103, 241); print "$ice \n";
$m = pack("a6", "test"); $iceptr = \$ice;
print "$t \n"; print "$iceptr \n";
print "$m \n"; #sa se specifice ce inseamna pointer la
#sa se impacheteze si despacheteze o lista pointer semnificat prin: $$pointer
de intregi $value = 10;
@list_of_integers = (11, 26, 43); $pointer = \$value;
$mystring = pack("i*", @list_of_integers); printf "\n Addresa $pointer la $value \n";
@list_of_integers = unpack("i*", $mystring); printf "\n Pointer *($pointer) poiteaza catre: $
print ("@list_of_integers\n"); $pointer\n";
#sa se codeze un fisier si continutul acestuia #sa se specifice adresa unui vector si
sa se puna in alt fisier continutul sau
open (CODEDFILE, "/pxperl/bin/e.txt") || %month = (
die ("Can't open input file"); '01', 'Jan',
open (OUTFILE, ">o.txt") || '02', 'Feb',
die ("Can't open output file"); '03', 'Mar',
while ($line = <CODEDFILE>) { '04', 'Apr',
$decoded = unpack("u", $line); '05', 'May',
print OUTFILE ($decoded); '06', 'Jun',
 '07', 'Jul', argumente chiar si implicite(semnificate prin
'08', 'Aug', @)
'09', 'Sep', sub print_coor{
'10', 'Oct', my ($x,$y,$z) = @_;
'11', 'Nov', print "$x $y $z \n";
'12', 'Dec', return $x;};
$k = 1;
); $j = 2;
$pointer = \%month; $m = 4;
printf "\n Adresa unui vector = $pointer\n "; $this = print_coor($k,$j,$m);
foreach $i (sort keys %month) { $that = print_coor(4,5,6);
#cu proceduri sa se listeze vectori care apar
printf "\n $i $$pointer{$i} "; ca argumente (parametrii de intrare)
@names = (mickey, goofy, daffy );
} @phones = (5551234, 5554321, 666 );
$i = 0;
sub listem {
foreach $i (sort keys %$pointer) { my (@a,@b) = @_;
printf "$i este $$pointer{$i} \n"; foreach (@a) {
} print "a[$i] = ". $a[$i] . " " . "\tb[$i] = " .
#sa se listeze si memoreze o matrice(vector $b[$i] ."\n";
de vectori) $i++;
$line = ['solid', 'black', ['1','2','3'] , ['4', '5', '6']]; }
print "\$line->[0] = $line->[0] \n"; }
print "\$line->[1] = $line->[1] \n"; &listem(@names, @phones);
print "\$line->[2][0] = $line->[2][0] \n"; #sa se listeze separat cei doi vectori cu
print "\$line->[2][1] = $line->[2][1] \n"; procedura
print "\$line->[2][2] = $line->[2][2] \n"; @names = (mickey, goofy, daffy );
print "\$line->[3][0] = $line->[3][0] \n"; @phones = (5551234, 5554321, 666 );
print "\$line->[3][1] = $line->[3][1] \n"; $i = 0;
print "\$line->[3][2] = $line->[3][2] \n"; sub listem {
print "\n";
#sa se memoreze un vector tridimensional my ($a,$b) = @_;
$line = ['solid', 'black', ['1','2','3', ['4', '5', '6']]]; foreach (@$a) {
print "\$line->[0] = $line->[0] \n"; print "a[$i] = " . @$a[$i] . " " . "\tb[$i] =
print "\$line->[1] = $line->[1] \n"; " . @$b[$i] ."\n";
print "\$line->[2][0] = $line->[2][0] \n"; $i++;
print "\$line->[2][1] = $line->[2][1] \n"; }
print "\$line->[2][2] = $line->[2][2] \n"; }
print "\$line->[2][3][0] = $line->[2][3][0] \n";
print "\$line->[2][3][1] = $line->[2][3][1] \n";
print "\$line->[2][3][2] = $line->[2][3][2] \n";
print "\n"; &listem(\@names, \@phones);
#sa se listeze un tablou multidimensional #cu proceduri sa se calculeze suma si suma
%cube = ( patratelor dintr-o data si s a se imparta la nr
'0', ['0', '0', '0'], componentelor(mediile)
'1', ['0', '0', '1'], sub average {
'2', ['0', '1', '0'], ($a,$b,$c) = @_;
'3', ['0', '1', '1'], $x = $a + $b + $c;
'4', ['1', '0', '0'], $x2 = $a*$a + $b*$b + $c*$c;
'5', ['1', '0', '1'], return ($x/3, $x2/3 ); }
'6', ['1', '1', '0'], $x = 1;
'7', ['1', '1', '1'] $y = 34;
); $x = 47;
$pointer = \%cube;
print "\n Cub \n"; print "sumelesunt: @{[&average($x,$y,$z)]} \
foreach $i (sort keys %$pointer) { n";
$list = $$pointer{$i}; #sa se explice simplu accesul.pointer la
$x = $list->[0]; pointer prin :$$variabila
$y = $list->[1]; $lang = "java";
$z = $list->[2]; $java = "coffee";
printf "punctul $i = $x,$y,$z \n"; print "${lang}\n";
} print "hot${lang}\n";
#sa se apeleze o procedura prin diverse print "$$lang \n"
#sa se creeze pachetul Cocoa din importarea $name =~ s/.*://; # strip fully-qualified
elemntelor bibliotecii Exporter portion
package Cocoa; unless (exists $self->{$name} ) {
require Exporter; croak "Can't access `$name' field in object
@ISA = qw(Exporter); of class $type";
@EXPORT = qw(setImports, declareMain, }
closeMain); if (@_) {
sub setImports{ return $self->{$name} = shift;
my $class = shift @_; } else {
my @names = @_; return $self->{$name};
foreach (@names) { }
print "import " . $_ . ";\n"; }
}
} $him = new Person;
sub declareMain{ $him->name("Jason");
my $class = shift @_; $him->age(23);
my ( $name, $extends, $implements) = @_; $him->peers( ["Norbert", "Rhys", "Phineas"] );
print "\n public class $name"; printf "%s is %d years old.\n", $him->name,
if ($extends) { $him->age;
print " extends " . $extends; print "His peers are: ", join(", ", @{$him-
} >peers}), ".\n";
#sa se defineasca un desconstructor si sa se
if ($implements) { foloseasca
print " implements " . $implements; package Subtle;
} sub new {
print " { \n"; my $test;
} $test = \$test; # Create a self-reference.
sub closeMain{ warn "CREATING " . \$test;
print "} \n"; return bless \$test;
} }
sub new { sub DESTROY {
my $this = {}; my $self = shift;
print "\n /* \n ** Created by Cocoa.pm \n ** warn "DESTROYING $self";
Use at own risk \n */ \n"; }
bless $this; package main;
return $this; warn "start program";
} {
my $a = Subtle->new;
my $b = Subtle->new;
$$a = 0; # Break this self-reference,
1; but not the other.
#sa se defineasca o clasa si sa se faca o warn "sfarsitul blocului";
instantiere la ea in acelasi program }
package Person; warn "am esit din bloc";
use Carp; warn "nu am timp...";
my %fields = ( exit;
name => undef, # sa se defineasca o clasa prin care se face o
age => undef, instantiere
peers => undef, package HashInstance;
); sub new {
sub new { my $type = shift;
my $that = shift; my %params = @_;
my $class = ref($that) || $that; my $self = {};
my $self = { $self->{High} = $params{High};
%fields, $self->{Low} = $params{Low};
}; return bless $self, $type;
bless $self, $class; }
return $self; package ArrayInstance;
} sub new {
sub AUTOLOAD { my $type = shift;
my $self = shift; my %params = @_;
my $type = ref($self) || croak "$self is not an my $self = [];
object"; $self->[0] = $params{Left};
my $name = $AUTOLOAD; $self->[1] = $params{Right};
 return bless $self, $type; in programul principal
} package Buz;
package main; sub goo { print "here's the goo\n" }
$a = HashInstance->new( High => 42, Low => package Bar;
11 ); @ISA = qw( Buz );
print "High=$a->{High}\n"; sub google { print "google here\n" }
print "Low=$a->{Low}\n"; package Baz;
$b = ArrayInstance->new( Left => 78, Right sub mumble { print "mumbling\n" }
=> 40 ); package Foo;
print "Left=$b->[0]\n"; @ISA = qw( Bar Baz );
print "Right=$b->[1]\n"; sub new {
#sa se faca o instantiere la un scalar my $type = shift;
package ScalarInstance; return bless [], $type;
sub new { }
my $type = shift; sub grr { print "grumble\n" }
my $self; sub goo {
$self = shift; my $self = shift;
return bless \$self, $type; $self->SUPER::goo();
} }
package main; sub mumble {
$a = ScalarInstance->new( 42 ); my $self = shift;
print "a=$$a\n"; $self->SUPER::mumble();
#sa se creeze o calas derivata din prima }
package Base; sub google {
sub new { my $self = shift;
my $type = shift; $self->SUPER::google();
my $self = {}; }
$self->{buz} = 42; package main;
return bless $self, $type; $foo = Foo->new;
} $foo->mumble;
package Derived; $foo->grr;
@ISA = qw( Base ); $foo->goo;
sub new { $foo->google;
my $type = shift; #sa secreeze niste merode(functii sau
my $self = Base->new; proceduri) si sa se apeleze
$self->{biz} = 11; package FOO;
return bless $self, $type; sub new {
} my $type = shift;
package main; return bless {}, $type;
$a = Derived->new; }
print "buz = ", $a->{buz}, "\n"; sub bar {
print "biz = ", $a->{biz}, "\n"; my $self = shift;
#sa se realizeze clase prin care se fac $self->FOO::private::BAZ;
legaturi intre module }
package Inner; package FOO::private;
sub new { sub BAZ {
my $type = shift; print "in BAZ\n";
my $self = {}; }
$self->{buz} = 42; package main;
return bless $self, $type; $a = FOO->new;
} $a->bar;
package Outer; # sa se apeleze metoda in cadrul altei
sub new { metode
my $type = shift; package FOO;
my $self = {}; sub new {
$self->{Inner} = Inner->new; my $type = shift;
$self->{biz} = 11; return bless {}, $type;
return bless $self, $type; }
} sub bar {
package main; my $self = shift;
$a = Outer->new; $self->FOO::private::BAZ;
print "buz = ", $a->{Inner}->{buz}, "\n"; }
print "biz = ", $a->{biz}, "\n"; package FOO::private;
#sa se faca mai multe clase care sunt apelate sub BAZ {
 print "in BAZ\n"; $self->{fizzle} = \%fizzle;
} return bless $self, $type;
package GOOP; }
@ISA = qw( FOO ); package main;
sub new { $a = Bar->new;
my $type = shift; $b = Foo->new;
return bless {}, $type; $a->enter;
} $b->enter;
sub BAZ { #sa se creeze un constructor(functie special
print "in GOOP::BAZ\n"; creata)
} package FOO;
package main; sub new {
$a = GOOP->new; my $type = shift;
$a->bar; my $self = {};
#sa se creeze doua clase in care cea de a return bless $self, $type;
doua apeleaza metoda primeia }
package FOO; sub baz {
sub new { print "in FOO::baz()\n";
my $type = shift; }
return bless {}, $type; package BAR;
} @ISA = qw(FOO);
sub bar { sub baz {
my $self = shift; print "in BAR::baz()\n";
$self->BAZ; }
} package main;
sub BAZ { $a = BAR->new;
print "in BAZ\n"; $a->baz;
} # sa se transforme grade in radiani
package GOOP; $pi = atan2(1,1) * 4;
@ISA = qw( FOO ); $piover180 = $pi/180;
sub new { for ($_ = 0; $_ <= 90; $_++) {
my $type = shift; printf "%3d %7.5f\n", $_, cos($_ *
return bless {}, $type; $piover180);
} }
sub BAZ { #sa se apeleze clasa cocoa.pm care se afla
print "in GOOP::BAZ\n"; salvata in calea C:\PXPERL\LIB
} push (@INC);
package main; use Cocoa;
$a = GOOP->new; $cup = new Cocoa;
$a->bar; $mug = Cocoa::new( 'Name' => 'top','x' =>
#sa se creeze o clasa derivata 10,'y' => 20 );
package Bar; print "Name=$mug->{'Name'}\n";
%fizzle = ( Password => 'XYZZY' ); print "x=$mug->{'x'}\n";
sub new { print "y=$mug->{'y'}\n";
my $type = shift; #sa se exporte date si sa se importe clse din
my $self = {}; Java
$self->{fizzle} = \%fizzle; package Cocoa;
return bless $self, $type; require Exporter;
} @ISA = qw(Exporter);
@EXPORT = qw(setImports, declareMain,
closeMain);
sub setImports{
sub enter { my $class = shift @_;
my $self = shift; my @names = @_;
my $fizzle = $self->{fizzle}; foreach (@names) {
print "The word is ", $fizzle->{Password}, print "import " . $_ . ";\n";
"\n"; }
} }
package Foo; #sa se exporte date si sa se importe clse din
@ISA = qw( Bar ); Java
%fizzle = ( Password => 'Rumple' ); sub declareMain{
sub new { my $class = shift @_;
my $type = shift; my ( $name, $extends, $implements) = @_;
my $self = Bar->new; print "\n public class $name";
 if ($extends) { sub new {
print " extends " . $extends; my $type = shift;
} my $this = Bean->new();
if ($implements) { $this->{'Coffee'} = 'Instant';
print " implements " . $implements; bless $this, $type;
} return $this;
print " { \n"; }
} 1;
sub closeMain{ push (@INC);
print "} \n"; use Coffee;
} $cup = new Coffee;
print "\n -------------------- Initial values
sub new { ------------ \n";
my $this = {}; print "Coffee: $cup->{'Coffee'} \n";
print "\n /* \n ** Created by Cocoa.pm \n ** print "Bean: $cup->{'Bean'} \n";
Use at own risk \n */ \n"; print "\n -------------------- Change Bean Type
bless $this; ---------- \n";
return $this; $cup->setBeanType('Mixed');
} print "Bean Type is now $cup->{'Bean'} \n";
1; print "\n ------------------ Change Coffee Type
use Cocoa; ---------- \n";
$cup = new Cocoa; $cup->setCoffeeType('Instant');
$cup->setImports( 'java.io.InputStream', print "Type of coffee: $cup->{'Coffee'} \n";
'java.net.*'); # sa se creeze un fisier coffee in C:\
$cup->declareMain( "Msg" , PXPERL\LIB si de aici sa se importe metodele
"java.applet.Applet", "Runnable"); sale
$cup->closeMain();
$cup->setImports( 'java.io.InputStream', #un program nu mai importa alt program adica
'java.net.*');3 pe Bean.pm aflat in calea C:\PXPERL\LIB ci e
# sa se creeze un fisier coffee in C:\ declarat la inceput aici folosind cuvantul cheie
PXPERL\LIB si de aici sa se importe metodele PACKAGE..
sale
push (@INC); package Bean;
use Coffee; require Exporter;
$cup = new Coffee; @ISA = qw(Exporter);
print "\n -------------------- Initial values @EXPORT = qw(setBeanType);
------------ \n"; sub new {
print "Coffee: $cup->{'Coffee'} \n"; my $type = shift;
print "Bean: $cup->{'Bean'} \n"; my $this = {};
print "\n -------------------- Change Bean Type $this->{'Bean'} = 'Colombian';
---------- \n"; bless $this, $type;
$cup->setBeanType('Mixed'); return $this;
print "Bean Type is now $cup->{'Bean'} \n"; }
print "\n ------------------ Change Coffee Type sub setBeanType{
---------- \n"; my ($class, $name) = @_;
$cup->setCoffeeType('Instant'); $class->{'Bean'} = $name;
print "Type of coffee: $cup->{'Coffee'} \n"; print "Set bean to $name \n";
# sa se creeze un fisier coffee in C:\ }
PXPERL\LIB si de aici sa se importe metodele 1;
sale package Coffee;
require Exporter;
#un program mai importa alt program adica pe # require Bean;
Bean.pm aflat in calea C:\PXPERL\LIB @ISA = qw(Exporter, Bean);
package Coffee; @EXPORT = qw(setImports, declareMain,
require Exporter; closeMain);
require Bean; sub setCoffeeType{
@ISA = qw(Exporter, Bean); my ($class,$name) = @_;
@EXPORT = qw(setImports, declareMain, $class->{'Coffee'} = $name;
closeMain); print "Set coffee type to $name \n";
sub setCoffeeType{ }
my ($class,$name) = @_; sub new {
$class->{'Coffee'} = $name; my $type = shift;
print "Set coffee type to $name \n"; my $this = Bean->new();
} $this->{'Coffee'} = 'Instant';
 bless $this, $type;
return $this; $cup->makeCup('1',3,'1');
}  # un program care NU e va apela un alt
1; program si va apela proceduri cu parametrii
push (@INC); package Coffee;
use Coffee; #un program care importa alt program adica pe
$cup = new Coffee; Bean.pm
print "\n -------------------- Initial values require Exporter;
------------ \n"; require Bean;
print "Coffee: $cup->{'Coffee'} \n"; @ISA = qw(Exporter, Bean);
print "Bean: $cup->{'Bean'} \n"; @EXPORT = qw(setImports, declareMain,
print "\n -------------------- Change Bean Type closeMain);
---------- \n"; sub setCoffeeType{
$cup->setBeanType('Mixed'); my ($class,$name) = @_;
print "Bean Type is now $cup->{'Bean'} \n"; $class->{'Coffee'} = $name;
print "\n ------------------ Change Coffee Type print "Set coffee type to $name \n";
---------- \n"; }
$cup->setCoffeeType('Instant');
print "Type of coffee: $cup->{'Coffee'} \n"; sub makeCup {
 # un program care se va apela un alt my ($class, $cream, $sugar, $dope) = @_;
program si va apela proceduri cu parametrii print "\
push (@INC); n================================
== \n";
use Coffee; print "Making a cup \n";
print "Add cream \n" if ($cream);
$cup = new Coffee; print "Add $sugar sugar cubes\n" if
($sugar);
# print "Making some really addictive
coffee ;-) \n" if ($dope);
# With no parameters print
"================================
# == \n";
}
print "\n Calling with no parameters: \n";
sub new {
$cup->makeCup; my $type = shift;
my $this = Bean->new();
# $this->{'Coffee'} = 'Instant';
bless $this, $type;
# With one parameter return $this;
}
# 1;
$cup = new Coffee;
print "\n Calling with one parameter: \n"; print "\n Calling with no parameters: \n";
$cup->makeCup;
$cup->makeCup('1'); print "\n Calling with one parameter: \n";
$cup->makeCup('1');
# print "\n Calling with two parameters: \n";
$cup->makeCup(1,'2');
# With two parameters print "\n Calling with three parameters: \n";
$cup->makeCup('1',3,'1');
# push (@INC);
use Coffee;
print "\n Calling with two parameters: \n"; $cup = new Coffee;
print "\n -------------------- Initial values
$cup->makeCup(1,'2'); ------------ \n";
print "Coffee: $cup->{'Coffee'} \n";
# print "Bean: $cup->{'Bean'} \n";
print "\n -------------------- Change Bean Type
# With all three parameters ---------- \n";
$cup->setBeanType('Mixed');
# print "Bean Type is now $cup->{'Bean'} \n";
print "\n ------------------ Change Coffee Type
print "\n Calling with three parameters: \n"; ---------- \n";
 $cup->setCoffeeType('Instant'); print "continut -tip: text/html\n\n";
print "Type of coffee: $cup->{'Coffee'} \n"; print "$count";
#sa se scrie prima aplicatie CGI FORM ACTION="register.cgi"
print "tipul continutului: text/html \n\n"; METHOD=POST>
print "<h1>am receptionat</h1> \n"; <DL>
print "am trimis aprecierile \n"; <DT>Your full name:
# sa se testeze interactiv un CGI <DD><INPUT TYPE=TEXT
print "Enter a value for NAME="fullname" SIZE=60
REQUEST_METHOD: \n"; MAXLENGTH=180>
chop($method=<STDIN>); <DT>Your e-mail address: <EM> RFC822
$ENV{'REQUEST_METHOD'}=$method; (Internet) format </EM>
print "Enter a value for QUERY_STRING: \ <DD><INPUT TYPE=TEXT NAME="email"
n"; SIZE=60 MAXLENGH=180>
chop($query=<STDIN>); </DL>
$ENV{'QUERY_STRING'}=$query; <P> <INPUT TYPE=SUBMIT
exec "script.pl"; VALUE="Register"> </P>
#!/usr/bin/perl </FORM>
# <HTML><HEAD><TITLE>My Address
# counter.cgi - A simple visitor counter Book</title></head>
# <BODY>
# amcf@esoterica.pt, March 96 <H2>Welcome to my address book</h2>
To find addresses that match a certain
# Place the file in a directory which the web category, fill in that category and
server can access then press 'submit'.
$count_file="/somewhere/count_file"; <FORM ACTION="address.cgi"
METHOD="POST">
open(CFILE, $count_file); Name: <INPUT SIZE=45 name="name"><br>
@counts=<CFILE>; Phone: <INPUT SIZE=45
close(CFILE); name="phone"><br>
Street Address: <INPUT SIZE=45
$doc=$ENV{'DOCUMENT_URI'}; # name="street"><BR>
HTTP_REFERER works for CERN server City: <INPUT SIZE=20 name="city"> State:
<INPUT SIZE=3 name="state">
# sa se determine tipul unui document prin Zip: <INPUT SIZE=6 name="zip"><br>
comenzi CGI <INPUT TYPE=SUBMIT Value=" Submit
if ($doc eq "") { $doc = "experience" }; Query ">
if ($doc eq "/index.html") { $doc = "/" } <INPUT TYPE=RESET Value=" Reset Form
$found = 0; "><br>
for $line (@counts) { </body></html>
chop ($line); # wp.pl 1.0 - White Pages search script
($page,$count)=split(/ /, $line); #
$page=~s/'//g; # &nb sp;
if ($page eq $doc) #
{ # Antonio Ferreira &n
$count++; bsp; #
$found = 1; # amcf@esoterica.pt ;
$line = "'$page' $count"; #
$found_count = $count; # &nb sp;
} #
push (@newcount, $line); # April 1996
} #
if ($found == 1) { #####################################
$count = $found_count #####################################
} else { #
$count = 1;
push (@newcount, "'$doc' 1"); require '/pxperl/lib/cgi-lib.pl';
}
@newcount=sort(@newcount); ######################### Variables
open (CFILE, ">$count_file"); ########################
flock(CFILE, 2); $url = 'http://www.your_domain.com/cgi-
for $line (@newcount) { print CFILE "$line\ bin/wp.pl'; # White Pages URL
n"; } $pathBackground = '/bg.gif';
flock(CFILE, 8); $cat = '/usr/bin/cat';
close CFILE; $tr = '/usr/bin/tr';
$grep = '/usr/bin/grep'; <INPUT TYPE=image
$email_list = SRC="/Images/WP/addwp.gif"
'/usr/local/WWW/Docs/WP/email.list'; NAME=addForm BORDER=0>
<INPUT TYPE=image
########################## Start of main SRC="/Images/WP/helpwp.gif" NAME=help
program ########################## BORDER=0>
<IMG SRC="/Images/c_esot.gif"
&ReadParse(*input); # field=value ALIGN=right ALT="">
print &PrintHeader(); # Content-type: </CENTER>
text/html\n\n </FORM>
</BODY>
if (&MethGet() || defined $input{'goback.x'}) { </HTML>
# GET EOM
&InitialForm(); # ... initial }
form
} else { # POST ... ##### Form for email address addition #####
other options sub AddForm {
if (defined $input{'addForm.x'}) { print <<EOM;
&AddForm(); <HTML>
} elsif (defined $input{'addEmail.x'}) { <HEAD>
&AddEmail(); <TITLE>Add an email address to the White
} elsif (defined $input{'help.x'}) { Pages database</TITLE>
&Help(); <!-- (c) Esoterica 1996, amcf@esoterica.pt -->
} else { </HEAD>
&Search();
} <BODY BACKGROUND=$pathBackground>
} <H1 ALIGN=center>Add an email address to
the White Pages database</H1>
exit(0); <P>
<FORM ACTION="$url" METHOD=post>
########################## End of main <CENTER>
program ########################## <PRE>
<B> Name:</B> <INPUT NAME="name"
#################### Subroutines SIZE=40>
################### <B>Company:</B> <INPUT
NAME="company" SIZE=40>
##### Initial search form ##### <B> Email:</B> <INPUT NAME="email"
sub InitialForm { SIZE=40>
print <<EOM; </PRE>
<HTML> <P>
<HEAD> <INPUT TYPE=image
<TITLE>White Pages</TITLE> SRC="/Images/WP/additwp.gif"
<!-- (c) Esoterica 1996, amcf@esoterica.pt -- NAME=addEmail BORDER=0>
</HEAD> <INPUT TYPE=image
<BODY BACKGROUND= SRC="/Images/WP/retwp.gif" NAME=goback
"$pathBackground"> BORDER=0>
<P ALIGN=center><IMG </CENTER>
SRC="/Images/WP/wp.gif" ALT="WHITE </FORM>
PAGES" BORDER=0 WIDTH=319 </BODY>
AHEIGHT=123></P> </HTML>
<H3 ALIGN=center><I>The email directory! EOM
</I></H3> }
<P>
<FORM ACTION="$url" METHOD=post> ##### Add email address to the list #####
<CENTER> sub AddEmail {
<B>Search for:</B> <INPUT NAME="key" if ( index($input{'email'},'@') >= 0 ) {
SIZE=30> <INPUT TYPE=submit if ($input{'company'} eq '') {
NAME=search AVALUE="Get it" $coment = ">";
ALIGN=top> } else {
<P> $coment = " - ".$input{'company'}.">";
<UL> }
Please enter the name (or part of it) of the $line = $input{'email'}." <".
person you want to find. $input{'nome'}.$coment;
</UL> open (LIST,">>$email_list");
 print LIST ("\n$line"); foreach $i (0 .. $#initial_list) {
close(LIST); if (index($initial_list[$i],$key[0])>=0
print <<EOM; && Aindex($initial_list[$i],$key[1])>=0) {
<HTML> $initial_list[$i] =~ s/</&lt;/g;
<HEAD> $initial_list[$i] =~ s/>/&gt;/g;
<TITLE>Email address added</TITLE> $initial_list[$i] =~ s/\n/<BR>\n/g;
<!-- (c) Esoterica 1996, amcf@esoterica.pt --> push(@final_list,$initial_list[$i]);
</HEAD> }
<BODY }
BACKGROUND="$pathBackground"> }
<H1 ALIGN=center>Email address if ($#final_list == -1) {
added</H1> @final_list = ("There isn't any email
<P> address corresponding to the key you
<FORM ACTION="$url" METHOD=post> Agave!");
Your email address was included in the White }
Pages database. print <<EOM;
<P> <HTML>
<INPUT TYPE=image <HEAD>
SRC="/Images/WP/retwp.gif" NAME=goback <TITLE>Results of the White Pages database
BORDER=0> search</TITLE>
</FORM> <!-- (c) Esoterica 1996, amcf@esoterica.pt -->
</BODY> </HEAD>
</HTML> <BODY
EOM BACKGROUND="$pathBackground">
} else { <H1 ALIGN=center>Results of the White
print <<EOM; Pages database search</H1>
<HTML> <P>
<HEAD> <FORM ACTION="$url" METHOD=post>
<TITLE>Incorrect email address</TITLE> <B>Search for:</B> $search_key
<!-- (c) Esoterica 1996, amcf@esoterica.pt --> <P>
</HEAD> <B>Results:</B>
<BODY <HR>
BACKGROUND="$pathBackground"> @final_list
<H1 ALIGN=center>Incorrect email <HR>
address</H1> <INPUT TYPE=image
<P> SRC="/Images/WP/retwp.gif" NAME=goback
<FORM ACTION="$url" METHOD=post> BORDER=0>
The email you entered is incorrect. Please try </FORM>
again. </BODY>
<P> </HTML>
<INPUT TYPE=image EOM
SRC="/Images/WP/retwp.gif" NAME=goback }
BORDER=0>
</FORM> ##### Shows help page #####
</BODY> sub Help {
</HTML> print <<EOM;
EOM <HTML>
} <HEAD>
} <TITLE>White Pages - Help</TITLE>
<!-- (c) Esoterica 1996, amcf@esoterica.pt -->
##### Search on the email address list with the </HEAD>
key given ##### <BODY
sub Search { BACKGROUND="$pathBackground">
$search_key = $input{'key'}; <H1 ALIGN=center>White Pages</H1>
if ($search_key eq '') { <H2 ALIGN=center><I>Help</I></H2>
@final_list = ("The key must contain at <P>
least one character!"); <FORM ACTION="$url" METHOD=post>
} else { <UL>
$search_key =~ tr/A-Z/a-z/; # <LI><B>What is an electronic White Page's
Convert to lower case centre?</B><BR>
@key = split(" ",$search_key); It's a list of electronic mail addresses in the
@initial_list = `$cat $email_list | $tr 'A-Z' Internet.
'a-z'`; <P>
@final_list = (); <LI><B>How does search work?</B><BR>
The list of email addresses contains the real </FORM>
name of people on the sa se realizeze un formular cu butoane
Internet, along with their email address. You radio:
can enter up to two <FORM ACTION="choose.cgi"
words for the program to search on the list and METHOD=POST>
to retrieve documents <P> E-mail address: <INPUT TYPE=TEXT
that contain both words. NAME="email" SIZE=60 MAXSIZE=180>
</UL> </P>
<P> <P> Please add me to the mailing list. </P>
<INPUT TYPE=image <P> I am: </P>
SRC="/Images/WP/retwp.gif" NAME=goback <OL>
BORDER=0> <LI><INPUT TYPE=RADIO
</FORM> NAME="employer" VALUE="private"
</BODY> chECKED>
</HTML> Employed in the private sector
EOM <LI><INPUT TYPE=RADIO
} NAME="employer" VALUE="public">
# sa se faca o sortare dar daca apar si cifre Employed in the public sector
si litere cifrele sa apara la sfarsit si sortate cu o <LI><INPUT TYPE=RADIO
procedura NAME="employer" VALUE="self">
@list1 = ("test", "14", "26", "test2"); Self-employed
@list2 = sort num_last (@list1); <LI><INPUT TYPE=RADIO
print ("@list2\n"); NAME="employer" VALUE="unemployed">
sub num_last { Unemployed
my ($num_a, $num_b); </OL>
$num_a = $a =~ /^[0-9]/; <P> <INPUT TYPE=SUBMIT
$num_b = $b =~ /^[0-9]/; VALUE="Continue">
if ($num_a && $num_b) { <INPUT TYPE=RESET VALUE="Clear
$retval = $a <=> $b; form"> </P>
} elsif ($num_a) { </FORM>
$retval = 1; un formular cu checkboxuri:
} elsif ($num_b) { <FORM ACTION="feedback.cgi"
$retval = -1; METHOD=POST>
} else { <P> Please tell us what you thought of this
$retval = $a cmp $b; Web site. Select the checkboxes which you
} agree with: </P>
$retval; <UL>
} <LI><INPUT TYPE=chECKBOX
#sa se deschida un fisier si sa se dea NAME="opinion"
mesajul corespunzator VALUE="understandable">
open(MYFILE, "e.txt") || The text was understandable.
die ("nu e deschis\n"); <LI><INPUT TYPE=chECKBOX
print STDERR ("s a deschis.\n"); NAME="opinion" VALUE="navigable">
$line = <MYFILE>; I found it easy to find my way through the
while ($line) { Web site.
chop ($line); <LI><INPUT TYPE=chECKBOX
print ("\U$line\E\n"); NAME="opinion" VALUE="stylish">
$line = <MYFILE>; I was impressed by the style and presentation.
} </UL>
sa se realizez un formular de textboxuri: <P> <INPUT TYPE="HIDDEN"
FORM ACTION="register.cgi" NAME="pages" VALUE="brochure">
METHOD=POST> Please add any other comments:
<DL> <TEXTAREA NAME="feedback" ROWS=5
<DT>Your full name: COLS=40>
<DD><INPUT TYPE=TEXT I think your brochure is:
NAME="fullname" SIZE=60 </TEXTAREA>
MAXLENGTH=180> </P>
<DT>Your e-mail address: <EM> RFC822 <P> <INPUT TYPE=SUBMIT
(Internet) format </EM> VALUE="Send comments">
<DD><INPUT TYPE=TEXT NAME="email" <INPUT TYPE=RESET VALUE="Clear
SIZE=60 MAXLENGH=180> form"> </P>
</DL> </FORM>
<P> <INPUT TYPE=SUBMIT un formular cu lise derulante
VALUE="Register"> </P> <FORM ACTION="select.cgi"
METHOD=GET> <LI><INPUT TYPE=chECKBOX
<H2> NAME="opinion" VALUE="navigable">
Choose which software to download: I found it easy to find my way through the
</H2> Web site.
<P> <LI><INPUT TYPE=chECKBOX
<SELECT NAME="package" SIZE=3> NAME="opinion" VALUE="stylish">
<OPTION VALUE="text" SELECTED>Text I was impressed by the style and presentation.
viewer </UL>
<OPTION VALUE="image">Image viewer <P> <INPUT TYPE="HIDDEN"
<OPTION VALUE="movie">Movie player NAME="pages" VALUE="brochure">
<OPTION VALUE="audio">Sound player Please add any other comments:
<OPTION VALUE="editor">Media editor <TEXTAREA NAME="feedback" ROWS=5
</SELECT> COLS=40>
<SELECT NAME="platform"> I think your brochure is:
<OPTION>IBM pc compatible </TEXTAREA>
<OPTION>Macintosh (68000) </P>
<OPTION>Macintosh (Power pc) <P> <INPUT TYPE=SUBMIT
</SELECT> VALUE="Send comments">
<SELECT NAME="options" MULTIPLE> <INPUT TYPE=RESET VALUE="Clear
<OPTION>License form"> </P>
<OPTION>Media </FORM>
<OPTION>Documentation butone de optiuni:
</SELECT> <FORM ACTION="test.cgi"
</P> METHOD=POST>
<P> <P>Comments: <TEXTAREA
<INPUT TYPE="IMAGE" NAME="coords" NAME="comments" ROWS=3
SRC="download.gif"> COLS=40>None</TEXTAREA></P>
</P> <SELECT NAME="choice" SIZE=4>
</FORM> <OPTION>Excellent
formulat cu diferite obiecte de control <OPTION SELECTED>Good
<FORM ACTION="comments.cgi" <OPTION>Average
METHOD=POST> <OPTION>Poor
<P> In order that we may continue to provide a </SELECT>
high quality World Wide Web service, <INPUT TYPE=HIDDEN NAME="where"
please take the time to fill in this form.</P> VALUE="HomePage">
<DL> </FORM>
<DT>Your surname (family name): formular combinat:
<DD><INPUT NAME="surname" SIZE=20 <FORM ACTION="url" METHOD=reqtype >
MAXLENGTH=60> <INPUT [TYPE=TEXT] NAME="id"
<DT>Your first name (given name): [SIZE=nn] [MAXLENGTH=nn]
<DD><INPUT NAME="forename" SIZE=20 [VALUE="default"]>
MAXLENGTH=60> <INPUT TYPE=SUBMIT [NAME="button-
</DL> id"] [VALUE="Button label text"]>
<P>Your title: <INPUT TYPE=RESET [VALUE="Button
[<INPUT TYPE=RADIO NAME="title" label text"]>
VALUE="Mr"> Mr.] <INPUT TYPE=RADIO NAME="radio-set-
[<INPUT TYPE=RADIO NAME="title" id" VALUE="choice-id" [chECKED]>
VALUE="Ms"> Ms.] <INPUT TYPE=chECKBOX NAME="box-
[<INPUT TYPE=RADIO NAME="title" set-id" VALUE="choice-id" [chECKED]>
VALUE="Mrs"> Mrs.] <INPUT TYPE=IMAGE NAME="image-
[<INPUT TYPE=RADIO NAME="title" id" SRC="image-url" [ALIGN=alignment]>
VALUE="Miss"> Miss.] <INPUT TYPE=HIDDEN NAME="data-
[<INPUT TYPE=RADIO NAME="title" id" VALUE="hidden form data" >
VALUE="Dr"> Dr.] <TEXTAREA NAME="text-id"
[<INPUT TYPE=RADIO NAME="title" [COLS=nn] [ROWS=nn]>
VALUE=""> Other.] </P> default text
<P> Please tell us what you thought of this </TEXTAREA>
Web site. Select the checkboxes which you <SELECT NAME="select-id" [SIZE=nn]
agree with: </P> [MULTIPLE]>
<UL> <OPTION [VALUE="choice-id"]
<LI><INPUT TYPE=chECKBOX [SELECTED]>1st choice
NAME="opinion" <OPTION>2nd choice
VALUE="understandable"> <OPTION>...
The text was understandable. </SELECT>
</FORM> <input type=radio name=ab value=point>
 point reviews
HTML><HEAD><TITLE>My Address </form>
Book</title></head> <p>
<BODY> <h2 align=center>Yahoo</h2>
<H2>Welcome to my address book</h2> <form
To find addresses that match a certain action="http://search.yahoo.com/bin/search">
category, fill in that category and <input size=25 name=p> <input type=submit
then press 'submit'. value=Search>
<FORM ACTION="address.cgi" </form>
METHOD="POST"> </body>
Name: <INPUT SIZE=45 name="name"><br> </html>
Phone: <INPUT SIZE=45 preluarea datelor si punera lor in fisier text:
name="phone"><br> #!/bin/perl
Street Address: <INPUT SIZE=45
name="street"><BR> require cgi_head; # Set up the CGI
City: <INPUT SIZE=20 name="city"> State: environment
<INPUT SIZE=3 name="state">
Zip: <INPUT SIZE=6 name="zip"><br> while (-e "datalock") { sleep 1; } # If database
<INPUT TYPE=SUBMIT Value=" Submit is currently being
Query "> # modified, wait.
<INPUT TYPE=RESET Value=" Reset Form system("touch datalock"); # Lock database
"><br>
</body></html> open (DAT, "database.txt"); # open the
<HTML><HEAD><TITLE>My Address database for reading
Book</title></head> while (<DAT>) { $line = $_; } # Read the last
<BODY> line of the database
<h4>Fill out the form below to add an entry to close DAT;
the address book</h4> if ($line =~ /:/) {
<FORM ACTION="add.cgi" @field = split (/:/, $line);
METHOD="POST"> $num = $field[0]; # Get last ID number
Name: <INPUT SIZE=45 $num++;
NAME="name"><br> } else { $num = 0; } # Create new ID
Phone: <INPUT SIZE=45 number
NAME="phone"><br>
Street: <INPUT SIZE=45 open (DAT, ">>database.txt"); # open the
NAME="street"><br> database for appending
City: <INPUT SIZE=20 NAME="city"> State:
<INPUT SIZE=3 NAME="state">
Zip: <INPUT SIZE=6 NAME="zip"> print DAT
<br><br> "$num:$FORM{'name'}:$FORM{'phone'}:
<INPUT TYPE=SUBMIT VALUE=" Add $FORM{'street'}:$FORM{'city'}:
Entry "> $FORM{'state'}:
<INPUT TYPE=RESET VALUE=" Reset A$FORM{'zip'}\n";
Form ">
</form></body></html> close DAT;
<html> system ("rm datalock");
<head> #print <<EOF;
<title>My search form</title> #<HTML><HEAD><TITLE>Addition
</head> Successful</title></head>
<body> #<BODY>
<h1 align=center>My search form</h1> #<h4>Your entry has been added to the
<p> address book</h4>
<h2 align=center>Lycos</h2> #<A HREF="add.html">Go</a> back to the
<form form to add another user.
action="http://www.lycos.com/cgi-bin/pursuit" #</body></html>
method=GET> EOF
<b>Find:</b> <input name="query"><input # sa se creeze o baza de date in care provin
type=submit value="Go Get It"> datele din formularul k12.html (acesta e
<br> address.cgi)
<input type=radio name=ab checked open (DAT, "database.txt") || die "nu pot
value=the_catalog>lycos catalog deschide baza de date: $! !.\n";
<input type=radio name=ab value=a2z>a2z $maxn = 0;
directory while (<DAT>) {
 chop;
@field = split(/:/);
$n = $field[0];
$add[$n]{'name'} = $field[1];
$add[$n]{'phone'} = $field[2];
$add[$n]{'street'} = $field[3];
$add[$n]{'city'} = $field[4];
$add[$n]{'state'} = $field[5];
$add[$n]{'zip'} = $field[6];
} $safepages=$form{"pages"};
$maxn = $n ;
#sa se apeleze acest program CGI de catre
un formular (acesta e comments.cgi)
$encodedQuery="";
$charsRemaining=102400;
$charsRemaining=$ENV{"CONTENT_LENG
TH"} if $ENV{"CONTENT_LENGTH"};
while ($charsRemaining--) {
$encodedQuery.=getc;
} ">>/var/adm/www/comments.log")) {
foreach (split("&", $encodedQuery)) {
($name,$contents) = split("=");
$form{$name}=$contents;
$form{$name}=~s/\+/ /g;
$form{$name}=~s/%(..)/pack("c",hex($1))/ge;
}
print "Content-type: text/html\n\n";
print "<HTML><HEAD><TITLE>Thank-
you</TITLE></HEAD>\n";
print "<BODY><H1>Thank-you</H1>\n";
$safename=$form{"title"}." ".
$form{"surname"};
$safename=~s/[^\w ]/ /g;
$safepages=~s/[^\w ]/ /g;
print "<P>Thank-you for submitting your
comments on ".$safepages.", ".$safename."
A<P>\n";
print "<HR>\n";
print '<P><A HREF="/">Return to home
page</A></P>';
print "\n</BODY></HTML>";
if (open(LOGFILE,
foreach (keys %form) {
print LOGFILE $_.":\n".$form{$_}."\n";
}
close(LOGFILE);
}