Perl-zelfstudie: Variabele, Array, Hashes met programmeervoorbeeld
Wat is Perl?
Perl is een hoog niveau, algemene, geïnterpreteerde, dynamische programmeertaal. Perl is een term die staat voor "Practical Extraction and Reporting Language", hoewel er geen acroniem is voor Perl. Het werd geïntroduceerd door Larry Wall in 1987. De Perl-taal is speciaal ontworpen voor tekstbewerking. Maar nu wordt het veel gebruikt voor verschillende doeleinden, waaronder Linux-systeembeheer, netwerkprogrammering, webontwikkeling, enz.
Laten we het op een eenvoudige manier zeggen. Hoewel computers alleen nullen en enen begrijpen (binaire taal/machinetaal/[low-level taal]), is het voor ons mensen erg moeilijk om in een binaire taal te programmeren. Perl is een programmeertaal die natuurlijke taalelementen gebruikt, woorden die in de gewone Engelse taal worden gebruikt en daarom gemakkelijker te begrijpen is voor mensen [taal op hoog niveau]. Nu is er een probleem; computers kunnen geen talen op hoog niveau begrijpen, die wij mensen gemakkelijk kunnen begrijpen. Daarvoor hebben we iets nodig dat de taal op hoog niveau kan vertalen naar taal op laag niveau. Hier komt een tolk ons te hulp. De tolk is een stukje software dat het programma dat in de taal op hoog niveau is geschreven, omzet naar taal op een laag niveau, zodat de computer de instructies die in het programma zijn geschreven, kan begrijpen en uitvoeren. Daarom is Perl een geïnterpreteerde programmeertaal.
Waar wordt Perl gebruikt?
De kracht van de Perl-scripttaal kan op veel gebieden worden geïmplementeerd. Het meest populaire gebruik van Perl is in webontwikkeling. Perl wordt ook gebruikt om veel taken op webservers te automatiseren en andere administratieve taken, het kan automatisch e-mails genereren en systemen opschonen. Perl wordt nog steeds gebruikt voor het oorspronkelijke doel, namelijk het extraheren van gegevens en het genereren van rapporten. Het kan rapporten produceren over resourcegebruik en controleren op beveiligingsproblemen in een netwerk. Om deze reden is Perl een populaire taal geworden die wordt gebruikt in webontwikkeling, netwerken en bioinformatica. Afgezien van dit alles kan Perl ook worden gebruikt voor CGI-programmering.
Perl kan ook worden gebruikt voor het maken en manipuleren van afbeeldingen. Naast dat netwerken via telnet, FTP, etc., zijn grafische gebruikersinterface-creatie, VLSI-elektronica en het maken van mailfilters om spampraktijken te verminderen enkele use cases van Perl.
Perl staat ook bekend om de implementatie van OOP(object georiënteerd programmeren) praktijken en ondersteunt alle vormen van overerving (eenvoudig, meervoudig en diamant), polymorfisme en encapsulatie. Perl is flexibel genoeg om zowel procedurele als OOP praktijken tegelijkertijd te ondersteunen. Perl heeft ook extra modules waarmee u code kunt schrijven of gebruiken/hergebruiken die is geschreven in Python, PHP, PDL, TCL, Octaaf, Java, C, C++, Basic, Ruby en Lua in uw Perl-script. Dit betekent dat je Perl hier extra mee kunt combineren programmeertalen in plaats van bestaande code te herschrijven.
Toepassingen van de programmeertaal Perl
Waarom Perl gebruiken?
Het is waar dat er andere programmeertalen zijn die kunnen worden gebruikt om al het hierboven genoemde te doen. Waarom zou u dan specifiek Perl gebruiken? Perl is heel gemakkelijk te leren, vooral als je een achtergrond hebt in computerprogrammering. Perl is zo ontworpen dat het voor mensen gemakkelijk te schrijven en te begrijpen is, in plaats van dat het gemakkelijk door computers kan worden verwerkt. Er wordt gebruik gemaakt van reguliere expressies. De natuurlijke taalstijl verschilt van andere programmeertalen die specifieke grammatica en syntaxis gebruiken; daarom is Perl zeer flexibel en legt het u geen specifieke manier op om een oplossing of een probleem te bedenken. Perl is uiterst draagbaar. Het kan op elk besturingssysteem draaien dat een Perl-interpreter heeft geïnstalleerd, dus het is platformonafhankelijk. Alle Linux Operating Systems worden geleverd met Perl, dus u kunt direct beginnen met Perl-codering in Linux. Dit is anders dan Shell-scripts, waarbij de code verandert met de smaak van de Linux-distributie die wordt gebruikt, waardoor het steeds minder draagbaar wordt Kleine specifieke taken in Perl worden heel gemakkelijk en snel. In deze Perl-tutorial voor beginners leert u hoe u kleine, snelle programma's voor specifieke taken kunt coderen. Laten we een eenvoudig voorbeeld nemen van het klassieke Hello World-programma dat wordt gebruikt om elke programmeertaal te leren die UNIX als basis heeft:
Voorbeeld: Perl hallo wereld
#!/usr/bin/perl print "Hello, world!";
Output:
Hallo Wereld!
De bovenstaande twee regels code zullen Hallo wereld! Was het niet te simpel en snel? Studenten met kennis van C, C++ zal weten dat er veel meer regels code nodig zijn om dezelfde uitvoer in die talen te verkrijgen.
Je vraagt je misschien af waarom Perl is zo beroemd op internet. Het is eenvoudig omdat de meeste dingen die op internet gebeuren, van TEKST zijn en Perl erg goed is in tekstverwerking. Als we Perl met een van de talen vergelijken, zal Perl de beste taal zijn die goed is in bestandsverwerking, tekstverwerking en uitvoerrapportage
Een van de beste voordelen van Perl is dat dit zo is gratis te gebruiken
De Perl-community gelooft er sterk in dat software vrij beschikbaar, vrij aanpasbaar en vrij te distribueren moet zijn. Verschillende vrijwilligers uit de Perl-community streven ernaar om de programmeertaal zo goed mogelijk te maken.
Voor- en nadelen van Perl
Voors: | nadelen: |
---|---|
|
|
|
|
Laten we beginnen
Met voldoende kennis over de geschiedenis van Perl en basisconcepten van computerprogrammering die nodig zijn voor het coderen in Perl, is het tijd om de sprong te wagen en aan de slag te gaan met Perl. Het volgende hoofdstuk leert je hoe je Perl op je systeem kunt installeren en je kunt voorbereiden op de codeerreis in Perl. Deze Perl-scriptingtutorial neemt Linux als het besturingssysteem dat studenten zullen gebruiken voor het coderen in Perl.
Perl downloaden en installeren – Windows, Mac en Linux
Hoe Perl te verkrijgen?
Goed nieuws waarschijnlijk heb je het!
Maar als u het nog niet op uw systeem kunt vinden, kunt u het nog steeds gratis verkrijgen.
Om erachter te komen of Perl al is geïnstalleerd, gaat u naar de opdrachtregel en typt u: perl -v
Met de opdracht wordt de versie van Perl weergegeven als deze is geïnstalleerd. In dit geval is de versie v5.14.2. Maar zo niet... geen paniek...
Unix |
Al geïnstalleerd Wordt vooraf geïnstalleerd met Perl, hoewel u mogelijk moet updaten naar de nieuwste versie. |
Mac OS |
Al geïnstalleerd OSX wordt geleverd met Perl vooraf geïnstalleerd, hoewel u dit mogelijk moet bijwerken naar de nieuwste versie |
Windows |
Moet installeren Er zijn twee opties beschikbaar
|
Perl bijwerken op Linux:
Als u de Perl-versie moet bijwerken, hoeft u slechts één enkele opdrachtregel in te voeren
sudo apt-get install perl
en ontspan. Voor de rest wordt gezorgd. Zorg ervoor dat u een actieve internetverbinding heeft.
Installeer perl voor Windows:
Download eerst de Active Perl hiervan link. Volg deze stappen om ActivePerl te installeren Windows systeem. Zie de onderstaande schermafbeeldingen voor hetzelfde.
Stap 1: Zodra u het installatieprogramma heeft gedownload en de installatie heeft gestart, ziet u het onderstaande venster. Klik op Volgende om door te gaan.
Stap 2: Accepteer de licentieovereenkomst om door te gaan met de installatie.
Stap 3: Hieronder staan verschillende pakketten die geïnstalleerd zullen worden. Standaard wordt alles geselecteerd. Het enige dat anders is, is PPM (Perl Package Manager). Dit is het hulpprogramma van Active Perl om externe Perl-modules of -bibliotheken in uw systeem te installeren. Klik op Volgende om door te gaan.
Stap 4: Dit zijn verschillende soorten Perl-extensies die voor Perl kunnen worden gebruikt. Meestal zullen we .Pl, .Plx en .Pm gebruiken voor Perl. Perl-modules gebruiken in principe .Pm als bestandsextensie om naar een bibliotheekbestand te verwijzen. Selecteer alle opties en klik op de knop Volgende.
Stap 5: Klik op de knop Installeren om door te gaan met de installatie.
Stap 6: Eenmaal geïnstalleerd, voert u het commando 'Perl –v' uit om te controleren of Perl succesvol op uw systeem is geïnstalleerd.
Er zijn veel dingen die moeten worden besproken voor het instellen van de Perl-omgeving in zowel Linux als Windows, omdat er niet veel bibliotheekbestanden in deze installatie zullen zijn opgenomen. U moet deze handmatig installeren. U kunt deze handmatig installeren met behulp van CPAN (Comprehensive Perl Archive Network) of PPM die alleen voor Perl-vensters werkt. Maar deze bestanden zijn niet verplicht om te beginnen met coderen in Perl.
Naast deze Windows-instelling kunt u het volgende gebruiken: Windows 10's nieuwe functie van Linux-subsysteem over Windows en gebruik het voor het uitvoeren van Perl-code
Eerste Perl-programma
Hello world!
Perl-voorbeeld: Hallo wereld
#!/usr/bin/perl -w #this is just a comment… print "Hello World";
Maak je geen zorgen als je deze tekst niet begrijpt. Alles zal snel duidelijk worden. Kom op en bekijk het per regel:
#!/usr/bin/perl
Dit vertelt de OperaZorg ervoor dat het systeem dit bestand uitvoert met het programma dat zich in /usr/bin/perl bevindt. Sommige IDE's hebben deze regel niet nodig. Als het essentieel is, moet u hier een pad naar uw tolk schrijven. Herinneren! Deze speciale regel moet aan het begin van uw programma staan en moet beginnen vanaf #! gebruik waarschuwingen; Dit is een ander speciaal commando dat de tolk vertelt om eventuele waarschuwingen weer te geven, bijvoorbeeld -w, waardoor waarschuwingen globaal worden geactiveerd.
print "Hello World";
De printinstructie schrijft tekst naar het scherm. De puntkomma aan het einde van de regel vertelt de perl-interpreter dat de instructie is voltooid. U moet aan het einde van elke instructie in Perl-code een puntkomma plaatsen. Let op het aanhalingsteken(“). Het is noodzakelijk voor printinstructies. Sla het bovenstaande script op als firstprog.pl
On Windows
Als je Strawberry hebt geïnstalleerd, kun je eenvoudig op Uitvoeren klikken. U kunt ook de opdrachtregelinterface uitvoeren en op de console schrijven:
C:\> perl path\firstprog.pl
of, als perl.exe niet in uw pad staat:
C:\> c:\perl\bin\perl.exe firstprog.pl
Op Linux/Unix
Je hoeft alleen maar de Terminal te openen en te schrijven:
perl firstprog.pl
Als u het programma niet kunt uitvoeren, zorg er dan voor dat u in aanmerking komt om het uit te voeren. Typ in de terminal:
chmod +x firstprog.pl
Uw programma is nu uitvoerbaar en klaar voor gebruik. Om uit te voeren, schrijf:
./firstprog
Installeer cpan minus-modules
Modules zijn een set codes die worden gebruikt om taken uit te voeren die algemene bewerkingen in verschillende programma's uitvoeren. Als u perl-modules gebruikt, hoeft u de codes niet te herschrijven om dezelfde bewerking uit te voeren. Perl kan gebruikmaken van dergelijke externe codebibliotheken. Een van de beste bibliotheken is de CPAN. Het staat voor Comprehensive Perl Archive Network en bevat een groot aantal Perl-modules die u kunt gebruiken. Het is een community of netwerk van een groot aantal ontwikkelaars die dergelijke modules bijdragen. Door ondersteuning voor CPAN-modules in uw perl-module te installeren, kunt u gebruikmaken van de CPAN-modules en uw werk gemakkelijker maken. De meeste Perl-modules zijn geschreven in Perl, sommige gebruiken XS (ze zijn geschreven in C) en vereisen dus een C-compiler (het is gemakkelijk om deze instelling te krijgen - raak niet in paniek. Modules kunnen afhankelijkheden hebben van andere modules (bijna altijd op CPAN) en kunnen niet zonder hen worden geïnstalleerd (of zonder een specifieke versie ervan). Het is de moeite waard om de documentatie voor de onderstaande opties grondig te lezen. Veel modules op CPAN vereisen nu een recente versie van Perl (versie 5.8 of hoger). Installeer cpanminus, een script om modules van CPAN te krijgen, uit te pakken, te bouwen en te installeren om het installeren van andere modules gemakkelijker te maken (u zult ons later bedanken). Om te installeren App-cpanminus perl-modules, in het opdrachtregeltype:
cpan App::cpanminus
cpan App::cpanminus Zorg ervoor dat u een internetverbinding hebt terwijl perl-modules worden gedownload en geïnstalleerd.
Installeer nu een willekeurige module:
cpan –i <Module_Name>.
Laten we een voorbeeld bekijken van het installeren van een module File::Data (het is een interface voor toegang tot bestandsgegevens).
Perl-variabele
Nu zullen we het hebben over variabelen. Je kunt je een variabele voorstellen als een soort container die een of meer waarden bevat. Eenmaal gedefinieerd, blijft de naam van de variabele hetzelfde, maar de waarde of waarden veranderen keer op keer.
Er zijn 3 soorten variabelen:
Soorten variabelen in Perl
De gemakkelijkste zijn scalairen, en dit is het onderwerp van vandaag
Scalaire variabele
Dit type variabele bevat één enkele waarde.
De naam begint met een dollarteken en een Perl-ID (het is de naam van onze variabele).
Scalaire variabele in Perl
Naamgeving
Als u bekend bent met andere programmeertalen, weet u dat er bepaalde regels zijn voor het benoemen van variabelen. Op dezelfde manier heeft Perl drie regels voor het benoemen van scalairen.
- Alle scalaire namen beginnen met een $. Het is gemakkelijk om te onthouden dat u elke naam moet laten voorafgaan door $. Zie het als een $scalair.
- Zoals PHP. na het eerste teken $, dat speciaal is in Perl, zijn alfanumerieke tekens, dwz a tot z, A tot Z en 0 tot 9, toegestaan. Onderstrepingstekens zijn ook toegestaan. Gebruik een onderstrepingsteken om de namen van de variabelen in twee woorden te splitsen. 'Maar het eerste teken kan geen getal zijn'
- Hoewel getallen deel kunnen uitmaken van de naam, kunnen ze niet direct na $ komen. Dit betekent dat het eerste teken na $ een alfabet of een onderstrepingsteken zal zijn. Die afkomstig zijn van C/C++ achtergrond moet de gelijkenis onmiddellijk kunnen herkennen. Voorbeelden
Perl-voorbeeld:
$var; $Var32; $vaRRR43; $name_underscore_23;
Dit zijn echter geen legale namen van scalaire variabelen.
mohohoh # $ character is missing $ # must be at least one letter $47x # second character must be a letter $variable! # you can't have a ! in a variable name
De algemene regel luidt: als Perl slechts één van iets heeft, is dat een scalair. Scalaire waarden kunnen vanaf apparaten worden gelezen en we kunnen deze in onze programma's gebruiken.
Twee soorten scalaire gegevenstypen
- Numbers
- Strings
Numbers:
In dit type scalaire gegevens zouden we het volgende kunnen specificeren:
- gehele getallen, gewoon gehele getallen, zoals 2, 0, 534
- drijvendekommagetallen, het zijn reële getallen, zoals 3.14, 6.74, 0.333
Let op: Over het algemeen ziet de Perl-interpreter gehele getallen als drijvendekommagetallen. Als u bijvoorbeeld 2 in uw programma's schrijft, ziet Perl dit als 2.0000
Geheel getal letterlijke waarden:
Het bestaat uit een of meer cijfers, eventueel voorafgegaan door een plus of min en met onderstrepingstekens.
Perl-voorbeelden:
0; -2542; 4865415484645 #this also can be written with underscores (for clarity) : 4_865_415_484_645
Zoals je kunt zien: het is niets bijzonders. Maar geloof me, dit is het meest voorkomende type scalairen. Ze zijn overal.
Letterlijke waarden met drijvende komma:
Het bestaat uit cijfers, eventueel min, komma en exponent.
Perl-voorbeelden:
3.14; 255.000; 3.6e20; # it's 3.6 times 10 to the 20th -3.6e20; # same as above, but negative -3.6e-20; #it's negative 3.6 times 10 to the -20th -3.6E-20; #we also can use E – this means the same the lowercase version -3.6e-20
Octale, hexadecimale en binaire weergave:
Het is een alternatief voor het decimale systeem. Staat u mij toe u de octale, hexadecimale en binaire representatie te laten zien. Een korte tabel presenteert alle belangrijke informatie over deze rare stijlen:
Vertegenwoordiging | opbouwen | Vervolg door |
---|---|---|
Octaal | 8 | 0 (nul) |
Hexadecimaal | 16 | 0x |
binair | 2 | 0b |
Perl-voorbeelden:
255; # 255 in decimal notation 0377; # 255 in octal notation 0xff; # 255 in hexadecimal notation 0b11111111; # 255 in binary notation
Al deze waarden voor Perl betekenen hetzelfde. Perl slaat de waarden niet in hetzelfde formaat op. Het zal deze hexadecimale, binaire, octale naar decimale waarden intern converteren.
De toewijzing is de meest voorkomende bewerking op een scalair, en het is heel eenvoudig. Perl gebruikt hiervoor het gelijkteken. Het neemt een waarde van de expressie van de rechterkant en zet deze waarde in onze variabele.
Laten we eens kijken naar voorbeelden:
$size=15; # give $size value of 15 $y = -7.78; # give $y value of -7.78
Bovendien kunt u in de variabele niet alleen een getal invoeren, maar ook een uitdrukking.
$z = 6 + 12 # give $z value of 18
Strings
Strings: Het is ook een heel eenvoudig type scalair.
De maximale lengte van een string in Perl hangt af van de hoeveelheid geheugen die de computer heeft. Er is geen limiet aan de grootte van de tekenreeks; uw tekenreeks kan bestaan uit elk aantal tekens, symbolen of woorden. De kortste string bevat geen tekens. De langste kan het hele systeemgeheugen vullen. Perl-programma's kunnen volledig in een 7-bits ASCII-tekenset worden geschreven. Met Perl kunt u ook elke 8-bits of 16-bits tekenset, oftewel . niet-ASCII-tekens binnen letterlijke tekenreeksen. Perl heeft ook ondersteuning toegevoegd voor Unicode UTF-8.
Net als bij getallen zijn er twee verschillende soorten strings:
- Letterlijke tekenreeksen met enkele aanhalingstekens
- Double citeert letterlijke tekenreeksen
Letterlijke tekenreeksen met enkele aanhalingstekens
Enkele aanhalingstekens worden gebruikt om gegevens die u letterlijk wilt nemen, te omsluiten. Een kort voorbeeld en alles moet duidelijk zijn:
Perl-voorbeelden:
#!/usr/bin/perl $num = 7; $txt = 'it is $num'; print $txt;
Output:
het is $num
Vanwege enkele aanhalingstekens wordt de waarde van $num niet overgenomen en worden de letterlijke tekens '$','n', 'u' en 'm' opgeteld bij de waarde van $txt
Double-geciteerde letterlijke tekenreeksen
Double aanhalingstekens worden gebruikt om gegevens in te sluiten die geïnterpoleerd moeten worden voor verwerking. Dat betekent dat ontsnapte tekens en variabelen niet simpelweg letterlijk in latere bewerkingen worden ingevoegd, maar ter plekke worden geëvalueerd. Escape-tekens kunnen worden gebruikt om nieuwe regels, tabs, etc. in te voegen.
Perl-voorbeelden:
$num = 7; $txt = "it is $num"; print $txt;
Output:
het is 7
Hier wordt door dubbele aanhalingstekens de waarde van $num opgeteld bij de waarde van $txt
Double-quotes interpoleren scalaire en array-variabelen, maar geen hashes. Aan de andere kant kunt u dubbele aanhalingstekens gebruiken om slices van zowel arrays als hashes te interpoleren.
Mysterieus \n
Beschouw het volgende programma
Perl-voorbeelden:
print "hello \n";
Output:
hallo
Perl geeft niet alleen 'hallo\n' weer, maar alleen 'hallo'. Waarom? Omdat '\n' een speciaal teken is en betekent dat u naar een nieuwe regel wilt gaan terwijl de tekst in uw programma wordt weergegeven. druk “hallo\n nieuwe regel” af; Volgende vraag: zijn er nog andere speciale tekens? Ja, dat zijn ze! Maar maak je geen zorgen: het zijn er maar een paar. Bekijk de onderstaande tabel
Bouwen | Beschrijving |
---|---|
\n | nieuwe lijn |
\r | terugkeer |
\t | tab |
\f | vormtoevoer |
\b | backspace |
\a | bel |
\e | ontsnappen |
\ 007 | elke octale ASCII-waarde (hier 007 = bel) |
\x7f | elke hexadecimale waarde (hier 7f = verwijderen) |
\\ | backslash |
| dubbele aanhalingstekens |
\l | kleine volgende letter |
\L | kleine letters alle volgende letters tot \E |
\u | volgende letter in hoofdletter |
\U | hoofdletters alle volgende letters tot \E |
\E | Beëindig \L, \U |
Ik weet het, er zijn niet 'slechts een paar'... Maar geloof me, je moet het gewoon weten
Tekenreeksvariabele
Het is dezelfde operatie die we zien in getallentoewijzing. Perl haalt onze string van de rechterkant van het gelijkteken en zet deze string in een variabele.
Perl-voorbeelden:
$string = 'tutorial'; # give $string the eight-character string 'tutorial' print $string; $string = $size + 3 ; # give $string the current value of $size plus 3 print $string; $string = $ string * 5; # multiplied $string by 5 print $string;
Output:
zelfstudie315
Zoals u ziet, kunt u getallen en strings in dezelfde variabelen plaatsen. Er is geen klasse van variabelen.
Tekenreeksaaneenschakeling (punt):
De concatenatie-operator “.” verenigt twee of meer strings. Onthoud! Als de string aanhalingstekens, carriage returns, backslashes bevat, moeten al deze speciale tekens worden geëscaped met een backslash.
Perl '' variabele Voorbeelden:
#!/usr/bin/perl $a = "Tom is"; $b = "favorite cat"; $c = $a ." mother's ". $b; print $c;
Output:
Tom is moeders favoriete kat
De touwtjes
“$a”, “$b”, wordt samengevoegd en opgeslagen in “$c” met behulp van de “.” operator.
Uiteindelijk…
Conversie tussen Numbers en snaren:
Zoals u weet, converteert Perl automatisch tussen getallen naar strings indien nodig. Hoe weet Perl wat we nu nodig hebben? Dit is eenvoudig - alles hangt af van de operator (we zullen het later over operatoren hebben, maar accepteer dat er veel operatoren zijn, verschillend voor getallen en strings). Als een operator een getal verwacht, gebruikt Perl de waarde als een getal. Als een operator een string verwacht, gebruikt Perl de waarde als een string. Met andere woorden - u hoeft zich geen zorgen te maken over dit soort conversie. Kort voorbeeld en alles zou duidelijk moeten zijn:
Perl-voorbeelden:
$string = "43"; $number = 28; $result = $string + $number; print $result;
Output:
71
de waarde van $string wordt geconverteerd naar een geheel getal en opgeteld bij de waarde van $number.
Het resultaat van de optelling, 71, wordt toegewezen aan $result.
Reikwijdte van een variabele – Toegangsmodificatoren
We kunnen overal in het programma een scalair declareren. Maar u moet een toegangsmodifier opgeven
Er zijn 3 soorten modificatoren
- my
- lokaal
- onze
Mijn: Hiermee kun je elke variabele declareren die specifiek is binnen het blok. dat wil zeggen binnen de accolades.
#!/usr/bin/perl my $var=5; if(1) { my $var_2 =$var; } print $var_2;
Geen uitvoer
De output van het programma zal niets zijn!
In het bovenstaande voorbeeld ziet u dat er twee variabelen zijn gedeclareerd: de ene bevindt zich binnen het if-blok ($var_2) en de andere bevindt zich buiten het If-blok ($var). De variabele die buiten het blok is gedeclareerd, zal toegankelijk zijn voor het if-blok, maar de variabele die binnen het if-blok is gedeclareerd, zal niet toegankelijk zijn voor het buitenste programma.
Lokaal: Hiermee kunnen we feitelijk dezelfde variabelewaarden maskeren naar verschillende waarden zonder de oorspronkelijke waarde van de variabele daadwerkelijk te veranderen. Stel dat we een variabele $a hebben waaraan de waarde 5 is toegewezen, dan kun je de waarde van die variabele daadwerkelijk wijzigen door dezelfde variabele opnieuw declareren met behulp van een lokaal trefwoord zonder de oorspronkelijke waarde van de variabele, namelijk 5, te wijzigen. Laten we met een voorbeeld zien hoe dit werkt.
#!/usr/bin/perl $var = 5; { local $var = 3; print "local,\$var = $var \n"; } print "global,\$var = $var \n";
De uitvoer van het bovenstaande programma zal op deze manier zijn.
lokaal, $var = 3
globaal, $var = 5
Op deze manier kunnen we de waarde van de variabele wijzigen zonder de oorspronkelijke waarde te beïnvloeden.
Onze: zodra een variabele is gedeclareerd met de toegangsmodificator ‘our’, kan deze voor het hele pakket worden gebruikt. Stel dat u een Perl-module of een pakket test.pm heeft waarin een variabele is gedeclareerd met scope our. Deze variabele is toegankelijk in alle scripts die dat pakket gebruiken.
Als u serieus wilt programmeren in Perl, moet u uw programma beginnen met
#!/usr/local/bin/perl
gebruik strikt;
Dit zal je helpen betere en schonere code te schrijven. 'gebruik strikt' schakelt strikt pragma in, waardoor u uw variabelen met mijn trefwoord kunt declareren.
Dit is een goede programmeerpraktijk
#!/usr/local/bin/perl use strict; $var = 10; print "$var";
Resultaat: fout
#!/usr/local/bin/perl use strict; my $var = 10; print "$var";
Output:
10
Perl-array
Wat is Perl-array?
Een Array is een speciaal type variabele die gegevens opslaat in de vorm van een lijst; elk element kan worden benaderd met behulp van het indexnummer dat uniek is voor elk element. U kunt getallen, strings, zwevende waarden, enz. opslaan in uw array. Dit ziet er geweldig uit, dus hoe maken we een array in Perl? In Perl kunt u een array definiëren met behulp van het teken '@' gevolgd door de naam die u wilt geven. Laten we eens kijken naar het definiëren van een array in Perl.
mijn @array;
Dit is hoe we een array in Perl definiëren; je denkt misschien hoe we er gegevens in moeten opslaan. Er zijn verschillende manieren om gegevens in een array op te slaan. Dit hangt af van hoe je het gaat gebruiken.
my @array=(a,b,c,d); print @array;
Output:
abcd
Dit is een array met 4 elementen erin.
De array-index begint bij 0 en eindigt bij de maximaal aangegeven grootte. In dit geval is de maximale indexgrootte 3.
Voorbeeld van een Perl-array
Je kunt een array ook op de bovenstaande manier declareren; het enige verschil is dat het gegevens in een array opslaat, waarbij een witte ruimte als scheidingsteken wordt beschouwd. Hier betekent qw() citaatwoord. De betekenis van deze functie is het genereren van een lijst met woorden. U kunt de qw op meerdere manieren gebruiken om een array te declareren.
@array1=qw/a b c d/; @array2= qw' p q r s'; @array3=qw { v x y z}; print @array1; print @array2; print @array3;
Output:
abcdpqrsvxyz
Stel dat u een waarde aan de 5 wilt toekennenth element van een array, hoe gaan we dat doen.
$matrix [4] ='e';
Sequentiële array
Sequentiële arrays zijn arrays waarin u gegevens sequentieel opslaat. Stel dat u 1-10 getallen of letters az in een array wilt opslaan. In plaats van alle letters te typen, kunt u iets proberen zoals hieronder:
@numbers= (1..10); print @numbers; #Prints numbers from 1 to 10;
Output:
12345678910
Perl-arraygrootte
We hebben een array die al beschikbaar is, en je weet niet wat de grootte van die array is, dus wat is de mogelijke manier om die te vinden.
@array= qw/a b c d e/; print $size=scalar (@array);
Kunnen we de grootte van een array bepalen zonder functies te gebruiken? Ja dat kunnen we.
@array= qw/a b c d e/; print $size=scalar (@array); print "\n"; print $size=$#array + 1; # $#array will print the Max Index of the array, which is 5 in this case
Output:
5
5
Dynamische array
De bovenstaande methode voor het declareren van een array wordt aangeroepen statische arrays, waar u de grootte van een array kent.
Wat is dynamische array?
Dynamische arrays zijn arrays die u declareert zonder enige waarde op te geven. Dus wanneer slaan we waarden precies op in die array? Eenvoudig: we slaan ze op tijdens de looptijd. Hier is een eenvoudig programma voor.
We zullen enkele ingebouwde Perl-functies gebruiken om deze taak uit te voeren.
my $string="This is a kind of dynamic array"; my @array; @array=split('a',$string); foreach(@array) { print "$_ \n”; # This is a special variable which stores the current value. }
Output:
Dit is
soort dyn
mic
rr
y
De splitsfunctie splitst de inhoud van de tekenreeks in een array op basis van het scheidingsteken dat eraan wordt gegeven. Deze functie verwijdert ook het scheidingsteken uit de string, in dit geval is het 'a';
Push, Pop, shift, unshift voor Perl-arrays:
Deze functies kunnen in Perl worden gebruikt om array-elementen toe te voegen/verwijderen.
- Perl Push: voegt een array-element toe aan het einde van een bestaande array.
- Perl Pop: verwijdert het laatste element uit een array.
- Perl Shift: verwijdert het eerste element uit een array.
- Perl Unshift: voegt een element toe aan het begin van een array.
Laten we een voorbeeld bekijken waarin we de onderstaande functies kunnen gebruiken.
@days = ("Mon","Tue","Wed"); print "1st : @days\n"; push(@days, "Thu"); # adds one element at the end of an array print "2nd when push : @days\n"; unshift(@days, "Fri"); # adds one element at the beginning of an array print "3rd when unshift : @days\n"; pop(@days); print "4th when pop : @days\n"; # remove one element from the last of an array. shift(@days); # remove one element from the beginning of an array. print "5th when shift : @days\n";
Output:
1e: ma di wo
2e bij push: ma di wo do
3e bij het ongedaan maken van de dienst: Vrijdag Maandag Dinsdag Woensdag Donderdag
4e wanneer pop: vr ma di wo
5e wanneer dienst: ma di wo
Perl-hashes
Waarom hebben we hasj nodig?
We hebben in eerdere paragrafen al over scalaires en arrays geleerd.
Wat doen scalaires precies? Het slaat alleen gehele getallen en strings op.
Wat doen arrays precies? Het is een verzameling scalairen, waarbij u elk element van een array kunt benaderen met behulp van indices. Maar is het een goed idee om een array te gebruiken als je honderden en duizenden records hebt? We zullen vergeten welke index welke waarde heeft. Om deze situatie te overwinnen hebben we zoiets als perl hash.
Wat zijn hashes?
Een hash kan ook zoveel scalairen bevatten als de array kan bevatten. Het enige verschil is dat we geen index hebben, maar sleutels en waarden. Een hash kan worden gedeclareerd, beginnend met % gevolgd door de naam van de hash. Laten we een voorbeeld bekijken van hoe we een Perl-hash kunnen definiëren en hoe we deze kunnen onderscheiden van een array
Beschouw een voorbeeld van drie mensen en hun leeftijden worden weergegeven in een array.
@array=('Sainath',23,'Krishna',24,'Shruthi',25); #This is how an array looks. print @array;
Output:
Sainath33Krishna24Shruthi25
Op deze manier is het moeilijk om de individuele leeftijden te kennen, omdat we zowel de indexlocaties van de namen als de leeftijden van alle mensen moeten onthouden. Het kan eenvoudig zijn als je 3 namen hebt, maar als je er 1000 of meer hebt? Jij weet het antwoord.
Dit kunnen we ondervangen door een hasj te gebruiken.
Hash-voorbeeld:
print %hash=( 'Sainath' => 23, 'Krishna' => 24, 'Shruthi' => 25); # This is how we create a hash. print %hash=('Sainath',23,'Krishna',24,'Shruthi',25);# This way of assigning is called list.
Output:
Sainath33Krishna24Shruthi25Sainath33Krishna24Shruthi25
We hebben nu een hasj uitgeroepen, geweldig!! Maar hoe kunnen we deze openen of afdrukken? Elk element in de hash moet toegankelijk zijn met de bijbehorende sleutel, waaraan een waarde wordt toegewezen. Er is dus een één-één-toewijzing tussen elk van de sleutels en de waarden in de hash.
Om de leeftijd van een persoon af te drukken, hoeft u alleen maar de naam van die persoon te onthouden.
print $hash{'Krishna'}; # This how we should access a hash. Key enclosed within {}.
Je hebt je misschien afgevraagd waarom ik $hash{KeyName} gebruikte, onthoud dat een hash ook weer een verzameling scalairen is. We kunnen dus $ gebruiken, wat scalair vertegenwoordigt, om toegang te krijgen tot elk hash-element.
Opmerking: elke sleutel in de hash moet uniek zijn, anders overschrijft deze uw waarde die eerder is toegewezen.
Hoe kunnen we een hash aan een andere hash toewijzen? Simpel, op dezelfde manier als wij doen
Wij kunnen ook hele hasj bedrukken.
%hash=( 'Tom' => 23); %newHash=%hash; # Assigning hash to a new hashprint %newHash; print %newHash;
Output:
Tom23
Perl-hashes toevoegen
Zoals je kunt zien hebben we al een hash %newHash, en nu moeten we er meer vermeldingen aan toevoegen.
$newHash{'Jim'}=25; $newHash{'John'}=26; $newHash{'Harry'}=27; print %newHash;
Output:
Jim25John26Harry27
Perl Delete-toets
Mogelijk wilt u een vermelding uit een hash verwijderen. Dit is hoe we dat kunnen doen.
delete $newHash{'Jim'};#This will delete an entry from the hash.
Verwijderen is een ingebouwde functie van Perl. Hier zullen we een voorbeeld zien van het toewijzen van een hash aan een array.
@array=%newHash; print "@array";
Opmerking: Telkens wanneer u een hash afdrukt of wanneer u hash in een array opslaat. De volgorde kan altijd afwijken. Het is niet altijd hetzelfde.
We kunnen alleen sleutels of waarden van een hash aan een array toewijzen.
@arraykeys= keys(%newHash); @arrayvalues=values(%newHash); print "@arraykeys\n"; print "@arrayvalues\n"; # \n to print new line.
Om alle vermeldingen in de hash te verwijderen, kunnen we de hash direct aan null toewijzen.
%newHash=();# Dit zal de hash opnieuw definiëren zonder invoer.
Voorwaardelijke verklaringen van Perl
We kunnen voorwaardelijke verklaringen gebruiken in Perl. Wat zijn voorwaardelijke uitspraken? Voorwaardelijke verklaringen zijn verklaringen waarbij u feitelijk controleert of aan bepaalde omstandigheden in uw code is voldaan.
Denk eens aan een voorbeeld: u koopt wat fruit en u wilt niet dat de prijs meer dan 100 dollar bedraagt. De regel hier is dus 100 dollar.
Perl ondersteunt twee soorten voorwaardelijke instructies; ze zijn als en tenzij.
Perl Als
Als het codeblok wordt uitgevoerd, wanneer de voorwaarde waar is.
my $a=5; if($a==5) { print "The value is $a"; }
Output:
5
Perl als anders
Dit ziet er goed uit. Laten we eens nadenken over een situatie waarin $a niet 5 is.
my $a=10; if($a==5) { print "The values is $a ---PASS"; } else { print "The value is $a ---FAIL"; }
Output:
De waarde is 10 —FOUT
Op deze manier kunnen we slechts één voorwaarde tegelijk controleren. Is het een beperking? Nee, je kunt ook verschillende omstandigheden controleren met if… elsif… else.
Perl Anders Als
my $a=5; if($a==6) { print "Executed If block -- The value is $a"; } elsif($a==5) { print "Executed elsif block --The value is $a"; } else { print "Executed else block – The value is $a"; }
Output:
Elsif-blok uitgevoerd – De waarde is 5
In het bovenstaande geval wordt het elsif-blok uitgevoerd omdat $a gelijk is aan 5.
Er kunnen situaties zijn waarin zowel if- als elsif-codeblokken mislukken. In dit scenario wordt het else-codeblok uitgevoerd. U kunt de else-codecontrole zelfs elimineren als u deze niet wilt opnemen.
Perl genest als
In dit geval kunt u het if-codeblok in nog een if-codeblok gebruiken.
my $a=11; #Change values to 11,2,5 and observe output if($a<10){ print "Inside 1st if block"; if($a<5){ print "Inside 2nd if block --- The value is $a"; } else{ print " Inside 2nd else block --- The value is $a"; } } else{ print "Inside 1st else block – The value is $a"; }
Output:
Binnen het 1e else-blok – De waarde is 11
Voer dezelfde code uit door de waarde van $a te wijzigen; de rest kun je ontdekken.
Perl Tenzij
Je hebt al een idee wat als het doet (als de voorwaarde waar is, wordt het codeblok uitgevoerd). Tenzij is het tegenovergestelde van if, tenzij het codeblok wordt uitgevoerd als de voorwaarde onwaar is.
my $a=5; unless($a==5) { print "Inside the unless block --- The value is $a"; } else { print "Inside else block--- The value is $a"; }
Output:
Binnen het 1e else-blok – De waarde is 5
Raad eens wat de opbrengst zal zijn. Je hebt gelijk!!!!!. De uitvoer zal de printinstructie van het else-blok zijn. Vanwege de voorwaarde in het tenzij-codeblok is waar, moet u er rekening mee houden dat het tenzij-blok alleen wordt uitgevoerd als de voorwaarde onwaar is. Verander de waarde van $a en voer de code uit. Je zult het verschil zien.
Perl Gebruik als
$a= " This is Perl"; if($a eq "SASSDSS"){ print "Inside If Block"; } else { print "Inside else block" }
Output:
Binnen anders blok
Gebruik tenzij
$a= " This is Perl"; unless($a eq "SASSDSS"){ print "Inside unless Block"; } else { print "Inside else block" }
Output:
Binnen tenzij Blok
Perl Loops – Controlestructuren
Perl ondersteunt besturingsstructuren die vergelijkbaar zijn met andere programmeertalen. Perl ondersteunt vier soorten controlestructuren: foreach, while en until. We gebruiken deze instructies om herhaaldelijk code uit te voeren.
Voor lus Perl
Het codeblok wordt namelijk uitgevoerd totdat aan de voorwaarde is voldaan. Laten we een voorbeeld nemen van hoe u een Perl-array in een lus kunt plaatsen.
my @array=(1..10); for(my $count=0;$count<10;$count++) { print "The array index $count value is $array[$count]"; print "\n"; }
Output:
De array-index 0-waarde is 1
De array-index 1-waarde is 2
De array-index 2-waarde is 3
De array-index 3-waarde is 4
De array-index 4-waarde is 5
De array-index 5-waarde is 6
De array-index 6-waarde is 7
De array-index 7-waarde is 8
De array-index 8-waarde is 9
De array-index 9-waarde is 10
Hier, in de for ()-expressie, zijn veel uitspraken opgenomen. Voor elk van hen is er een betekenis.
voor (initialisatie; voorwaarde; oplopend)
Hier is een andere manier om for te gebruiken.
for(1..10) { print "$_ n"; print "\n"; }
Output:
1n
2n
3n
4n
5n
6n
7n
8n
9n
10n
Perl Foreach
De for elke verklaring kan op dezelfde manier worden gebruikt als for; het belangrijkste verschil is dat we hierin geen conditiecontrole en verhoging hebben.
Laten we hetzelfde voorbeeld nemen met foreach perl.
my @array=(1..10); foreach my $value (@array) { print " The value is $value\n"; }
Output:
De waarde is 1
De waarde is 2
De waarde is 3
De waarde is 4
De waarde is 5
De waarde is 6
De waarde is 7
De waarde is 8
De waarde is 9
De waarde is 10
Foreach neemt elk element van een array en wijst die waarde voor elke iteratie toe aan $var. We kunnen hiervoor ook $_ gebruiken.
my @array=(1..10); foreach(@array) { print " The value is $_ \n"; # This is same as the above code. }
Output:
De waarde is 1
De waarde is 2
De waarde is 3
De waarde is 4
De waarde is 5
De waarde is 6
De waarde is 7
De waarde is 8
De waarde is 9
De waarde is 10
Dit ziet er goed uit voor toegang tot arrays. Hoe zit het met Hashes, hoe kunnen we hash-sleutels en -waarden verkrijgen met behulp van foreach?
We kunnen foreach gebruiken om toegang te krijgen tot sleutels en waarden van de hash door deze in een lus te plaatsen.
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25); foreach my $key (keys %hash) { print "$key \n"; }
Output:
Mickey
Tom
Jerry
Je vraagt je misschien af waarom we sleutels in foreach() gebruikten. Keys is een ingebouwde functie van Perl waarmee we snel toegang hebben tot de sleutels van de hash. Hoe zit het met waarden? We kunnen de waardenfunctie gebruiken voor toegang tot waarden van de hash.
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25); foreach my $value(values %hash) # This will push each value of the key to $value { print " the value is $value \n"; }
Output:
de waarde is 24
de waarde is 23
de waarde is 25
Perl Terwijl
De Perl While-lus is een besturingsstructuur, waarbij het codeblok wordt uitgevoerd totdat de voorwaarde waar is.
Het codeblok wordt alleen afgesloten als de voorwaarde onwaar is.
Laten we een voorbeeld nemen voor de Perl While-lus.
Hier is een probleem dat invoer van de gebruiker vereist en pas zal verdwijnen als het opgegeven nummer '7' is.
#!/usr/bin/perl $guru99 = 0; $luckynum = 7; print "Guess a Number Between 1 and 10\n"; $guru99 = <STDIN>; while ($guru99 != $luckynum) { print "Guess a Number Between 1 and 10 \n "; $guru99 = <STDIN>; } print "You guessed the lucky number 7"
Output:
Raad een getal tussen 1 en 10
9
Raad een getal tussen 1 en 10
5
Raad een getal tussen 1 en 10
7
Je raadt het geluksgetal 7
In het bovenstaande voorbeeld zal de while-voorwaarde niet waar zijn als we een andere invoer dan '7' invoeren.
Als je ziet hoe while hier werkt, wordt het codeblok alleen uitgevoerd als de voorwaarde over een tijdje waar is.
Perl doe-terwijl
De Do while-lus wordt minstens één keer uitgevoerd, zelfs als de voorwaarde in de while-sectie onwaar is.
Laten we hetzelfde voorbeeld nemen door do while te gebruiken.
$guru99 = 10; do { print "$guru99 \n"; $guru99--; } while ($guru99 >= 1); print "Now value is less than 1";
Output:
10
9
8
7
6
5
4
3
2
1
De waarde is nu kleiner dan 1
Perl tot
Totdat het codeblok vergelijkbaar is met tenzij in een voorwaardelijke instructie. Hier wordt het codeblok alleen uitgevoerd als de voorwaarde in until-blok onwaar is.
Laten we hetzelfde voorbeeld nemen dat we een tijdje gebruikten.
Hier is een probleem dat input van de gebruiker vereist en pas zal verdwijnen nadat de naam anders dan 'sai' is opgegeven.
print "Enter any name \n"; my $name=<STDIN>; chomp($name); until($name ne 'sai') { print "Enter any name \n"; $name=<STDIN>; chomp($name); }
Output:
Voer een willekeurige naam in
Perl do-tot:
Do until kan alleen worden gebruikt als een voorwaarde onwaar moet zijn, en deze moet minstens één keer worden uitgevoerd.
print "Enter any name \n"; my $name=<STDIN>; chomp($name); do { print "Enter any name \n"; $name=<STDIN>; chomp($name); }until($name ne 'sai');
Output:
Voer een willekeurige naam Howard in
Voer een willekeurige naam Sheldon in
Voer een willekeurige naam in
Voer de voorbeeldcodes while, do-while, until en do-until uit om het verschil te zien.
Perl Operator
Wat is OperaTor?
OperaToren in computertaal duiden op een actie die kan worden uitgevoerd op een reeks variabelen of waarden die de computer kan begrijpen. Perl heeft de meeste van de Operators uit de C-taal. Perl heeft veel operatoren vergeleken met andere programmeertalen. OperaTors worden gecategoriseerd als rekenkundige, logische, relationele en toewijzingsoperatoren.
Rekenkunde OperaTorens:
Rekenkundige operatoren zijn operatoren die gebruikt kunnen worden om een aantal basis wiskundige bewerkingen uit te voeren. Deze rekenkundige operatoren zijn binaire operatoren waarbij we twee argumenten nodig hebben om een basisbewerking uit te voeren. We kunnen ook unaire operatoren gebruiken voor andere basisbewerkingen; u kunt het verschil zien in de onderstaande voorbeelden.
Operator | Beschrijving | Voorbeeld |
---|---|---|
+ |
Optelbewerking die wordt gebruikt voor het optellen van twee waarden of variabelen waarden vasthouden |
$x=5+6; # of $y=6; $z=$x+$y; |
- |
Aftrekoperator die wordt gebruikt voor het aftrekken van twee waarden of variabelen die waarden bevatten |
$x=6-5; # of $y=6; $z=$x-$y; |
* |
Vermenigvuldigingsoperator die wordt gebruikt om twee waarden of variabelen die waarden bevatten te vermenigvuldigen |
$x=6*5; # of $y=6; $z=$x*$y; |
/ |
De delingsoperator die wordt gebruikt om twee waarden of variabelen die waarden bevatten te delen |
$x=36/6; # of $y=6; $z=$x/$y; |
** |
De exponentiële operator die wordt gebruikt om de exponent te leveren en de waarde te verkrijgen. Bijv.: 22 = 43 = 27 |
$x=5**5; # of $x=4; $y=2; $z=$x**$y; |
% |
Modulus-operator die wordt gebruikt om een herinnering te krijgen tijdens de deling van twee waarden of variabelen die waarden bevatten |
$x=5%2; # of $x=10; $y=2; $z=$x % $y; |
++ |
Eenzijdige opteloperator om de waarde van een variabele met 1 te verhogen |
$x=5; $x++; Or ++$x; |
- |
Eenzijdige aftrekkingsoperator om de waarde van een variabele met 1 te verlagen |
$x=5; $x–; # postverlaging Or –$x;# vooraf verlagen |
Voorbeeld om alle bovenstaande bewerkingen uit te voeren.
my $x=10; my $y=2; my $z; $z=$x+$y; print ("Add of $x and $y is $z \n"); $z=$x-$y; print ("Sub of $x and $y is $z \n"); $z=$x*$y; print ("Mul of $x and $y is $z \n"); $z=$x/$y; print ("Div of $x and $y is $z \n"); $z=$x**$y; print ("Exp of $x and $y is $z \n"); $z=$x%$y; print ("Mod of $x and $y is $z \n");
Output:
Optelling van 10 en 2 is 12
Sub van 10 en 2 is 8
Mul van 10 en 2 is 20
Div van 10 en 2 is 5
Exp van 10 en 2 is 100
Modus van 10 en 2 is 0
Toewijzing OperaTorens:
Toewijzingsoperatoren wijzen simpelweg waarden toe aan variabelen, maar er is nog iets dat we hierbij moeten onthouden: toewijzingsoperatoren voeren ook rekenkundige bewerkingen uit en wijzen de nieuwe waarde toe aan dezelfde variabele waarop de bewerking wordt uitgevoerd.
Operator | Beschrijving | Voorbeeld |
---|---|---|
+= |
Opteloperator die wordt gebruikt voor het optellen en toewijzen van de waarde aan dezelfde variabele |
$x=4; $x+=10; |
-= |
Aftrekoperator die wordt gebruikt voor het aftrekken en toewijzen van de waarde aan dezelfde variabele |
$x=4; $x-=10; |
*= |
Vermenigvuldigingsoperator die wordt gebruikt voor het optellen en toewijzen van de waarde aan dezelfde variabele |
$x=4; $x*=10; |
/= |
Delingsoperator die wordt gebruikt voor het delen en toewijzen van de waarde aan dezelfde variabele |
$x=4; $x/=10; |
** = |
Exponentiële operator die wordt gebruikt om de exponent te verkrijgen en de waarde aan dezelfde variabele toe te wijzen |
$x=4; $x**=10; |
%= |
Modulusoperator die wordt gebruikt om een herinnering te krijgen tijdens de deling en de waarde aan dezelfde variabele toe te wijzen |
$x=10; $x%=4; |
Voorbeeld om alle bovenstaande bewerkingen uit te voeren.
my $x=10; $x+=5; print("Add = $x\n"); $x-=5; print("Sub= $x\n"); $x*=5; print("Mul = $x\n"); $x/=5; print("Div = $x\n");
Output:
Optellen = 15
Onder= 10
Mul = 50
Afd. = 10
Logisch en relationeel OperaTorens:
Perl gebruikt logische operatoren om getallen en strings te vergelijken. Meestal worden logische operatoren gebruikt in voorwaardelijke statements.
Logisch en relationeel Operators in Perl
Operator | Beschrijving |
---|---|
==of verg |
Operator gebruikt om te controleren of beide variabelen gelijk zijn |
!=Of nee |
Operator gebruikt om te controleren of beide variabelen niet gelijk zijn |
> of gt |
Operator controleerde of A is groter dan B |
<of lt |
Operator controleerde of A is kleiner dan B |
>=of ge |
Operator controleerde of A is groter dan of gelijk aan B |
<=of le |
Operator controleerde of A is kleiner dan of gelijk aan B |
|| of of |
Operator die wordt gebruikt om te controleren of A of B waarde vasthoudt |
&&of en |
Operator die wordt gebruikt om te controleren of zowel A als B waarde vasthouden |
Laten we een voorbeeld nemen waarin we alle scenario's kunnen uitleggen.
my $x=5; my $y=5; if($x == $y){ print ("True -- equal $x and $y \n"); } else{ print ("False -- not equal $x and $y\n"); } $x=6; $y=7; if($x != $y){ print ("True -- not equal $x and $y\n"); } else{ print ("False -- equal $x and $y\n"); } if($y > $x){ print ("True -- $y greater than $x\n"); } else{ print ("False -- $y greater than $x\n"); } if($x < $y){ print ("True -- $x less than $y\n"); } else{ print ("False -- $x less than $y\n"); } if($x <= $y){ print ("True -- $x less than $y\n"); } else{ print ("False -- $x less than $y\n"); } if($y >= $x){ print ("True -- $y greater than $x\n"); } else{ print ("False -- $y greater than $x\n"); }
Output:
Waar — gelijk aan 5 en 5
Waar – niet gelijk aan 6 en 7
Waar – 7 groter dan 6
Waar: 6 minder dan 7
Waar: 6 minder dan 7
Waar – 7 groter dan 6
Voorbeelden van logische operatoren vindt u in latere paragrafen.
Perl speciale variabelen
Wat zijn speciale Perl-variabelen?
Speciale variabelen in Perl zijn variabelen die een vooraf gedefinieerde betekenis hebben. Deze variabelen worden aangegeven met echte naam- of leestekens. We hebben een speciale variabele voor alle door Perl ondersteunde variabelen, zoals speciale scalaire variabelen, speciale array-variabelen en speciale hash-variabelen. De meeste speciale variabelen die we gebruiken, zijn scalairen.
Als we de speciale variabele met zijn naam willen gebruiken, moeten we een Perl-module 'use English' laden, om de Perl-interpreter expliciet te zeggen dat we speciale variabelen gaan gebruiken met zijn naam.
Scalaire speciale variabelen
Veranderlijk | Beschrijving |
---|---|
$_$ARG |
Dit is de standaardvariabele waarin de huidige waarden worden opgeslagen. |
$0 of $PROGRAM_NAME |
Slaat de bestandsnaam van het Perl-script op. |
$/ |
Het invoerrecordscheidingsteken, dit heeft de standaardwaarde '\n', wat een nieuwregelteken is |
$. |
Bevat het huidige regelnummer van het bestand dat wordt gelezen |
$, |
Uitvoerveldscheidingsteken, dit wordt hoofdzakelijk gebruikt door de print()-instructie. De standaardwaarde hiervan is ingesteld op 0, we kunnen de waarde van deze variabele wijzigen. |
$\ |
Uitvoerrecordscheidingsteken, de waarde van deze variabele zal leeg zijn; we kunnen hier elke waarde aan toekennen, die zal worden gebruikt door de print()-instructie tijdens het afdrukken van de uitvoer. |
$# |
Deze variabele wordt gebruikt voor het uitvoerformaat bij het afdrukken van getallen. |
$%$FORMAT_PAGE_NUMBER |
Bevat het huidige paginanummer van het gelezen bestand. |
$=$FORMAT_LINES_PER_PAGE |
Houdt de huidige paginalengte van het gelezen bestand vast. |
$-$FORMAT_LINES_LEFT |
Bevat de waarde van het aantal regels dat nog moet worden afgedrukt vanaf de pagina. |
$~$FORMAT_NAME |
Formaatnaam: bevat standaard het formaat van de momenteel geselecteerde uitvoer, de bestandshandlenaam. |
$^$FORMAT_TOP_NAME |
Bevat de waarde van het kopformaat van de bestandshandler. De standaardwaarde is _TOP gevolgd door de naam van de bestandshandler. |
$|$OUTPUT_AUTOFLUSH |
De standaardwaarde is nul. Hiermee wordt de uitvoerbuffer na elke write() of print() leeggemaakt. |
$$ |
Bevat het lopende procesnummer van de Perl-interpreter. |
$? |
Statuscode: Pijp- en systeemoproep. De retourstatus van de uitgevoerde opdracht. |
$&$WEDSTRIJD |
Dit wordt gebruikt in reguliere expressies en bevat een reeks van de laatste succesvolle patroonovereenkomst. |
$`$PREMATCH |
Dit wordt gebruikt in reguliere expressies en bevat een tekenreeks voorafgegaan door de laatste succesvolle patroonovereenkomst. |
$'$POSTWEDSTRIJD |
Dit wordt gebruikt in reguliere expressies en bevat een tekenreeks die wordt gevolgd door de laatste succesvolle patroonovereenkomst. |
$+$LAST_PAREN_MATCH |
Bevat de tekenreeks van het laatste haakje dat overeenkomt met de laatste patroonzoekopdracht. |
$ |
$1, $2, $3... Houdt de waarden van het patroon op volgorde vast. |
$[ |
Eerste index: Array, een subtekenreeks. |
$] |
Een versie van Perl. |
$” |
Het scheidingsteken dat voor lijstelementen wordt gebruikt, is standaard een witruimte. |
$; |
Subscriptscheidingsteken gebruikt in multidimensionale arrays |
$! |
Drukt in numerieke context het foutnummer af. Druk de fout af in tekenreekscontext. |
$@ |
Zal de informatie over de syntaxisfout bevatten, gebruikt wanneer eval() wordt gebruikt. |
$< |
Bevat de echte UID (gebruikers-ID) van het proces dat het script uitvoert. |
$> |
Bevat de effectieve UID van het proces dat het script uitvoert. |
$( |
Bevat de echte GID (groeps-ID) van het proces dat het script uitvoert. |
$) |
Bevat de effectieve GID van het proces dat het script uitvoert. |
$^D$DEBUGGING |
Bevat de huidige waarde van de foutopsporingsvlaggen. |
$^C |
Bevat de huidige waarde van de vlag wanneer de opdrachtregeloptie –c wordt gebruikt. |
$^F |
De maximale systeembestandsdescriptor is standaard ingesteld op 2 |
$^I$INPLACE_EDIT |
Bevat de waarde van de opdrachtregelschakelaar –i. |
$^M |
Een speciale geheugenpool kan worden gebruikt wanneer het Perl-script stopt met een geheugenfout. |
$^O$OSNAAM |
Operasysteeminformatie wordt opgeslagen. 'Linux' voor Linux-systemen, 'mswin32' voor Windows systemen. |
$^T$BASISTIJD |
Het tijdstip waarop de scripts worden uitgevoerd, in seconden. |
$^W$WAARSCHUWING |
De huidige waarde van de opdrachtregeloptie –w. Waarschuwingsschakelaar. |
$ARGV |
Naam van het huidige bestand, wanneer <> wordt gebruikt. |
Array speciale variabelen:
Veranderlijk | Beschrijving |
---|---|
@INC |
Bevat een lijst met paden, waar Perl-bibliotheekmodules of -scripts kunnen worden bekeken tijdens het uitvoeren van het huidige script. Deze @INC wordt gebruikt door use en vereist instructies om naar die paden voor bibliotheekmodules te kijken. |
@ARGV |
Slaat de doorgegeven opdrachtregelargumenten op. |
@_ |
Wordt gebruikt in subroutines, terwijl de parameters worden doorgegeven aan de subroutines. |
@F |
Dit is de array waarin de invoerregels worden opgeslagen bij automatische splitsing –a (opdrachtregelschakelaar wordt gebruikt). |
Hash speciale variabelen:
Veranderlijk | Beschrijving |
---|---|
%INC |
De bestandsnaam zijn de sleutels; waarden zijn het pad naar die bestanden. Gebruikt door doen, gebruiken en vereisen. |
%ENV |
Systeemomgevingsvariabelen. |
%SIG |
Signals begeleider. |
Reguliere expressie van Perl
Wat is reguliere expressie?
Perl reguliere expressie is sterk genoeg in het matchen van stringpatronen binnen een statement of groep statements. Reguliere expressies worden meestal gebruikt in tekstparsing, patroonmatching en nog veel meer, afhankelijk van de vereisten. We hebben bepaalde operatoren, die speciaal worden gebruikt door reguliere expressie patroonbinding =~ en !~, Dit zijn test- en toewijzingsoperatoren.
Regular Expression Operaverdraaid
Regular Expression Operators in Perl
- Perl Match — m//
- Perl-vervanger – s///
- Perl-transliteratie – tr///
Voordat we verder gaan, moeten we een paar dingen weten over reguliere expressie; er zijn bepaalde dingen zoals metatekens en jokertekens in de Perl Regex-syntaxis.
Verkolen | Betekenis |
---|---|
\ |
Speciaal of offerte |
* |
Match 0 of meer karakters |
+ |
Match 1 of meer karakters |
? |
Match 0 of 1 karakter |
| |
Kan worden gebruikt om alternatieve patronen te matchen |
() |
Wordt gebruikt om het overeenkomende patroon op te slaan |
[] |
Een set karakters kan worden doorgegeven. Specifiek gebruikt voor numeriek en alfabetten. |
{} |
Wordt gebruikt voor het opgeven van het aantal keren dat de wedstrijd kan worden uitgevoerd. |
^ |
Begin van de reeks |
$ |
Einde van de reeks |
\w |
Wordt gebruikt om een enkel teken of woord te matchen dat alfanumeriek kan zijn, inclusief “_” |
\W |
Match alles anders dan alfanumeriek |
\s |
Wordt gebruikt om witruimten te matchen |
\S |
Overeenkomen met alles behalve witruimte |
\d |
Matchnummers. Geen decimale waarden en negatieve waarden |
\D |
Koppel alles behalve getallen. |
\t |
Zorg ervoor dat de tabruimte overeenkomt |
\n |
Match nieuwe regel |
Bovenstaand zijn de reeks tekens die kunnen worden gebruikt tijdens het matchen van patronen.
Laten we een paar voorbeelden bekijken.
Beschouw een situatie waarin de gebruiker enige invoer invoert tijdens de uitvoering van het script, en we willen controleren of de gebruiker een naam als invoer heeft ingevoerd of niet. We moeten een syntaxis voor reguliere expressies schrijven om uw naam te extraheren en deze af te drukken.
my $userinput="Guru99 Rocks"; if($userinput=~m/.*(Guru99).*/) { print "Found Pattern"; } else { print "unable to find the pattern"; }
Output:
Patroon gevonden
Hier hebben we de reguliere expressie geschreven als /.*(Guru99).*/.* komt overeen met alle tekens in een string. A '.' in perl regex match verwijst naar elk teken inclusief spatie.
Laten we eens kijken hoe we precies een Regex kunnen construeren.
Beschouw een voorbeeld van een reeks van meerdere woorden en cijfers en speciale symbolen zoals deze: "Hallo allemaal, dit is mijn nummer: +91-99298373639";
Regex: /^\w+\s\w+\s\w+\s\w+\s\w+\s\w+\:\+\d+\-\d+/i
Woordruimte woordruimte woordruimte woordruimte woordruimte woordruimte speciaal teken : spatie speciaal teken+cijfers speciaal teken –cijfers.
Perl-match Operaverdraaid
De match-operatoren worden gebruikt om een string binnen een bepaalde instructie of in een variabele te matchen.
my $var="Hello this is perl"; if($var=~m/perl/) { print "true"; } else { print "False"; }
Output:
waar
Deze kleine code zal 'true' printen, aangezien de perl patroon matching de string in een variabele identificeert. In principe zoekt Perl naar de tekst die in // is gegeven in de hele string, zelfs als het op één plek vindt, zal het 'true' retourneren. Het patroon kan overal in de variabele staan. We kunnen proberen =~ te vervangen door !~ om het verschil tussen die twee operatoren te zien.
Perl-vervanging Operator
Deze operator kan worden gebruikt voor het zoeken en vervangen van elk teken door een nulteken of een ander teken.
my $a="Hello how are you"; $a=~s/hello/cello/gi; print $a;
Output:
cello hoe gaat het
Let op: We kunnen eigenlijk elke patroonmatchingstring gebruiken zoals we eerder deden in deze substitutie-operator. Hier gebruikten we 'gi', g-globaal, i-negeer hoofdlettergevoelig.
Perl-vertaling Operator
Dit is vergelijkbaar met Substitutie, maar er worden geen perl-reguliere expressies gebruikt. In plaats daarvan kunnen we direct de waarde doorgeven of een woord dat we willen vervangen.
my $a="Hello how are you"; $a=~tr/hello/cello/; print $a;
Output:
Hallo koe ben jij
Perl-bestand I/O
Perl is ontworpen om bestanden en I/O-bewerkingen effectief te manipuleren. Het belangrijkste voordeel van Perl is het parsen en verwerken van bestanden. Er zijn veel ingebouwde functies en operatoren die worden gebruikt tijdens het verwerken van bestanden in Perl.
In principe worden bestandsbewerkingen die met Perl worden uitgevoerd, uitgevoerd met FILEHANDLE. We moeten deze FILEHANDLE definiëren tijdens het openen van een bestand voor lezen of schrijven.
In deze Perl-script-tutorial leert u:
Perl Bestand openen
We kunnen een bestand openen met de functie open() die beschikbaar is in Perl.
open(FILEHANDLE, "filename or complete path of the file");
Nu we een bestand hebben geopend, rijst er een vraag. Is het om te lezen of om te schrijven?
Perl-leesbestand en Perl-schrijfbestand
Perl heeft bepaalde modi die gebruikt moeten worden om een bestand te lezen, schrijven of toe te voegen.
Read – open(my $fh,"<filename or complete path of the file"); Write – open(my $fh,">filename or complete path of the file"); Append – open(my $fh,">>filename or complete path of the file");
Enkele voorbeelden voor het lezen van een bestand:
Stel dat we een perl-bestand hebben met de naam file.txt en dat er weinig regels tekst in staan. We moeten dit bestand openen en hetzelfde afdrukken.
open(FH,"<file.txt"); while(<FH>) # Looping the file contents using the FH as a filehandle. { print "$_"; } close FH;
or
open(FH,"<file.txt"); my @content=<FH>; # specifying the input of the array is FH. foreach(@content) { print "$_"; } close FH;
Hierdoor wordt de bestandsinhoud op het uitvoerscherm afgedrukt.
Nu gaan we een programma schrijven om gegevens te maken en naar een perl-bestand te schrijven.
open(FH,">test.txt"); my $var=<>; print FH $var; close FH;
Hierdoor wordt de invoer geschreven die tijdens runtime is opgegeven en wordt een bestand test.txt gemaakt dat invoer bevat.
Op de bovenstaande manier wordt altijd geprobeerd een bestand met de naam test.txt te maken en wordt de invoer naar het bestand geschreven; we zullen hetzelfde schrijven om het bestand toe te voegen.
open(FH,">>test.txt"); my $var=<>; print FH $var; close FH;
Modes | Beschrijving |
---|---|
< |
Lees |
+< |
Leest en schrijft |
> |
Creëert, schrijft en kapt af |
+> |
Lezen, schrijven, creëren en afkappen |
>> |
Schrijft, voegt toe en creëert |
+>> |
Lezen, schrijven, toevoegen en creëren |
Nu we moeten zien hoe we bestanden moeten lezen, schrijven en toevoegen met behulp van basisvoorbeelden.
We zullen nog enkele voorbeelden en andere functies zien die helpen om meer over bestanden te begrijpen.
Perl Vertel
Deze methode retourneert de huidige positie van FILEHANDLER in bytes, indien gespecificeerd, anders beschouwt de methode de laatste regel als de positie.
open(FH, "test.pl"); while(<FH>) { $a=tell FH; print "$a"; }
Perl Zoek
De zoekfunctie is vergelijkbaar met de fseek-systeemaanroep. Deze methode wordt gebruikt om de bestandsaanwijzer naar een specifieke locatie te positioneren door de bytes op te geven, gevolgd door het begin van de bestandsaanwijzer of het einde van de bestandsaanwijzer.
seek FH, bytes, WHENCE;
WHENCE is de positie van de bestandsaanwijzer om te starten. Zero stelt dit in vanaf het begin van het bestand.
Voorbeeld: Laat input.txt enkele gegevens bevatten, zoals "Hallo, dit is mijn wereld."
open FH, '+<','input.txt'; seek FH, 5, 0; # This will start reading data after 5 bytes. $/ = undef; $out = <FH>; print $out; close FH;
Output:
dit is mijn wereld
Perl ontkoppelen
Ontkoppelen wordt gebruikt om het bestand te verwijderen.
unlink("filename or complete file path");
Omgaan met mappen:
We kunnen ook mappen beheren waarmee we meerdere bestanden kunnen verwerken.
laten we eens kijken hoe we een map kunnen openen. We kunnen de methoden opendir en readdir gebruiken.
opendir(DIR,"C:\\Program Files\\"); #DIR is the directory handler. while(readdir(DIR)) # loop through the output of readdir to print the directory contents. { print "$_\n"; } closedir(DIR); #used to close the directory handler.
or
opendir(DIR,"C:\\Program Files\\"); @content=readdir(DIR); foreach(@content) { print "$_\n"; } closedir(DIR);
Hierdoor worden alle beschikbare bestanden in die map afgedrukt.
Perl-bestandstests en hun betekenis
-r |
Om te controleren of het bestand/de map leesbaar is voor de huidige gebruiker/groep |
-w |
Om te controleren of het bestand/de map beschrijfbaar is door de huidige gebruiker/groep |
-x |
Om te controleren of bestand/map uitvoerbaar is door de huidige gebruiker/groep |
-o |
Om te controleren of het bestand/de map eigendom is van de huidige gebruiker |
-R |
Om te controleren of het bestand/de map leesbaar is voor deze echte gebruiker/groep |
-W |
Om te controleren of het bestand/de map beschrijfbaar is door deze echte gebruiker/groep |
-X |
Om te controleren of het bestand/de map uitvoerbaar is door deze echte gebruiker/groep |
-O |
Om te controleren of het bestand/de map eigendom is van deze echte gebruiker |
-e |
Om te controleren of de bestands-/mapnaam bestaat |
-z |
Om te controleren of het bestand bestaat en een grootte van nul heeft (altijd onwaar voor mappen) |
-f |
Om te controleren of Entry een gewoon bestand is |
-d |
Om te controleren of Entry een map is |
-l |
Om te controleren of Entry een symbolische link is |
-S |
Om te controleren of Entry een stopcontact is |
-p |
Controleren of Entry een Named Pipe is (een “FIFO”) |
-b |
Controleren of Entry een speciaal blokbestand is (zoals een monteerbare schijf) |
-c |
Controleren of Entry een speciaal tekenbestand is (zoals een I/O-apparaat) |
-u |
Om te controleren of het bestand of de map setuid is |
-g |
Om te controleren of het bestand of de map setgid is |
-k |
Om te controleren of het bestand of de map de sticky bit heeft ingesteld |
-t |
De opgegeven bestandshandle is een TTY (zoals bij de systeemfunctie isatty() kunnen bestandsnamen niet worden getest door deze test) |
-T |
Om te controleren of Bestand op een “tekst”-bestand lijkt |
-B |
Om te controleren of het bestand op een “binair” bestand lijkt |
-M |
Om de wijzigingsleeftijd (gemeten in dagen) van het bestand te controleren |
-A |
Om de toegangsleeftijd (gemeten in dagen) van het bestand te controleren |
-C |
Om de Inode-modificatie-leeftijd (gemeten in dagen) van het bestand te controleren |
Perl-subroutine
Wat is een subroutine?
subroutines zijn vergelijkbaar met functies in andere programmeertalen. We hebben al een aantal ingebouwde functies gebruikt, zoals print, chomp, chop, enz. We kunnen onze eigen subroutines in Perl schrijven. Deze subroutines kunnen overal in het programma worden geschreven; het verdient de voorkeur om de subroutines aan het begin of aan het einde van de code te plaatsen.
Subroutines Voorbeeld
sub subroutine_name { Statements…; # this is how typical subroutines look like. }
Nu we weten hoe we een subroutine moeten schrijven, hoe krijgen we er toegang toe?
We moeten een subroutine openen of oproepen met behulp van de subroutinenaam voorafgegaan door het '&'-symbool.
sub display { print "this is a subroutine"; } display(); # This is how we call a subroutine
Perl-parameters en Perl-argumenten doorgeven
Subroutines of perl-functies worden geschreven om de herbruikbare code erin te plaatsen. Voor het grootste deel van de herbruikbare code moeten parameters worden doorgegeven aan de subroutine. Hier zullen we leren hoe we argumenten aan de subroutine kunnen doorgeven.
sub display { my $var=@_; # @_ is a special variable which stores the list of arguments passed. print "$var is the value passed"; } display(2,3,4); #this is how we need to pass the arguments.
Output:
3 is de doorgegeven waarde
@_ is een speciale arrayvariabele die de argumenten opslaat die aan de subroutines worden doorgegeven.
Perl Shift
We kunnen ook het trefwoord 'shift' gebruiken, dat één parameter per keer naar een variabele verschuift of $_[0],$_[1]… wat een afzonderlijk element is van de @_ array.
sub display { my $var=shift; print "$var is passed"; } display("hello");
Output:
Hallo is voorbij
Subroutines worden doorgaans gebruikt bij objectgeoriënteerd programmeren en ook op plaatsen waar mogelijk meer herbruikbare code moet worden geplaatst.
De belangrijkste functionaliteit van subroutines is het uitvoeren van een taak en het retourneren van het resultaat van de herbruikbare code.
We kunnen een waarde uit de subroutine retourneren met behulp van het return-trefwoord.
sub add { my $a=shift; my $b=shift; return($a+$b); } my $result=add(5,6); print $result;
Output:
11
$result zal de waarde van de toegevoegde $a en $b behouden.
We kunnen hashes en arrays ook rechtstreeks aan de subroutine doorgeven.
sub hash { my %hash=@_; print %hash; } %value= ( 1=>'a', 2=>'b'); &hash(%value);
Output:
1a2b
We kunnen ook een hash of een array retourneren.
sub hashArray { my %hash=@_; print "Inside Sub-routine"; print %hash; return(%hash); } %hash=(1=>'a', 2=>'b'); my(@ret)=hashArray(%hash); print "After Sub-routine call"; print @ret;
Output:
Binnen subroutine2b1aNa subroutineoproep2b1a
Perl-formaat
Perl heeft een mechanisme waarmee we rapporten kunnen genereren. Met deze functie kunnen we rapporten maken precies zoals we willen terwijl we afdrukken op het Output-scherm of in een bestand. Een eenvoudig formaat kan worden geschreven met behulp van de printf- of sprintf-functies die beschikbaar zijn in Perl.
printf "%05d\n", 30;
Dit omvat het plaatsen van voorloopnullen voor het getal 30, waardoor het totaal aantal cijfers op 5 komt. Hetzelfde kan worden gebruikt voor sprintf.
sprintf "%05d\n", 30; # This will print the same as printf.
Met printf en sprintf kunnen we de meeste Perl-formaten verkrijgen. In het geval van rapporten zal het moeilijk zijn om te implementeren.
================================================== =========================
Naam Adres Leeftijd Telefoon
================================================== =========================
Krishna Chennai 24 929309242
Shruthi Chennai 24 929309232
Het bovenstaande is een voorbeeldrapport dat we op dezelfde manier in Perl moeten printen. Dit kan worden bereikt door gebruik te maken van perl printf en perl sprintf. Het kan effectief worden geïmplementeerd met behulp van format.
Een formaat kan op de onderstaande manier worden gedeclareerd.
format FORMATNAME=FORMATLIST.
Hier zullen we een bepaalde schrijfmethode gebruiken om de gegevens op het uitvoerscherm of in het bestand af te drukken.
Symbool | Beschrijving |
---|---|
@ |
Wordt gebruikt om het begin van de veldhouder weer te geven |
> |
Rechtse uitlijning van tekst |
< |
Links uitlijnen van tekst |
| |
Midden uitlijning |
# |
Numeriek als er meerdere # zijn opgegeven. Wordt aangenomen als commentaar als er één # is opgegeven |
. |
Decimale punt |
^ |
Begin van veldhouder kan ook worden gebruikt voor meerdere regels en ook voor de woordomloop |
~ |
De regel moet leeg zijn als de variabele leeg is |
@* |
Meerdere lijnen. |
($name,$addr,$age,$phone)=("krishna","chennai","24","929309242"); write; ($name,$addr,$age,$phone)=("shruthi","chennai","24","929309232"); write; format STDOUT_TOP= =============================================================== NAME ADDRESS AGE PHONE =============================================================== . format STDOUT= @<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<< @<<< @<<<<<<<<<< $name, $addr, $age, $phone .
Voer de code uit om de uitvoer te zien.
We gebruiken het @-symbool om het begin van de veldhouder of tekenreeks op te geven, '<' voor elk teken.
We gebruiken STDOUT om op de standaarduitvoer af te drukken. We kunnen dit wijzigen in een bestandshandler die we gebruiken om gegevens in het bestand te schrijven.
open(REPORT,">test.txt"); ($name,$addr,$age,$phone)=("krishna","chennai","24","929309232"); write REPORT; ($name,$addr,$age,$phone)=("shruthi","chennai","24","929309232"); write REPORT; format REPORT_TOP= =============================================================== NAME ADDRESS AGE PHONE =============================================================== . format REPORT= @<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<< @<<< @<<<<<<<<<< $name, $addr, $age, $phone
We kunnen '<' vervangen door '>' of '|' om de uitlijning van de tekst te wijzigen. STDOUT_TOP wordt gebruikt om de header van het formaat te ontwerpen. We kunnen hetzelfde ook gebruiken met de bestandshandler met behulp van FH_TOP (FH is de bestandshandler). Dit zal het formaat uitvoeren naar het bestand waarmee we werken op.
Perl-coderingsnormen
Elke programmeur zal zijn eigen gevoel hebben voor het schrijven van de code met behulp van bepaalde standaarden; deze standaarden moeten zo bekend zijn dat andere programmeurs de code goed kunnen begrijpen en ondersteunen.
Codeerstandaarden in Perl
Het schrijven van code is eenvoudig en gemakkelijk. Het probleem ontstaat wanneer het in latere stadia onderhouden moet worden. De juiste richtlijnen en coderingsnormen moeten worden gevolgd tijdens het schrijven van de code. Perl definieert ook bepaalde normen die handig zijn voor programmeurs om code te schrijven. Het is raadzaam om 'strict' en 'warnings module' te laden tijdens het schrijven van de code. Elk van deze modules heeft zijn eigen belang. Strict zorgt ervoor dat we de variabele declareren voordat we deze gebruiken en vertelt ook of er een kaal woord in uw code aanwezig is. De Warnings module kan alternatief worden gebruikt door de '-w' optie door te geven aan de Perl interpreter in shebang. Warnings worden afgedrukt op het uitvoerscherm.
#!/usr/bin/perl –w
Hieronder vindt u enkele lijsten met normen.
- Gebruik de modules 'strikt' en 'waarschuwingen'.
- Verwijder de variabele die niet in gebruik is.
- Namen van variabelen moeten begrijpelijk zijn voor andere gebruikers. Bijvoorbeeld: $name, @fileData enz.
- Bij het coderen van een script is documentatie vereist.
- Voer geen waarden in, maar probeer deze dynamisch op te halen of vraag de gebruiker om deze tijdens runtime in te voeren. (Bestandspad, Bestandsnamen).
- Maximaliseer hergebruik van code. Probeer de herbruikbare code in subroutines te plaatsen.
- Dit betekent dat er volledige namen moeten worden gegeven voor subroutines.
- Subroutines moeten worden geschreven met de juiste opmerkingen en documentatie.
- Initialiseer variabelen altijd.
- Controleer altijd de retourcodes voor systeemoproepen. Het openen van een bestand kan wel of niet gebeuren. Als u hier een retourcode heeft, wordt de foutstatus weergegeven als het bestand niet bestaat.
Bijv.: open(FH,
- Subroutine moet altijd een waarde retourneren.
- Open krullend in dezelfde lijn.
- Enkele lijn BLOCK kan in een enkele lijn met krullen worden geplaatst.
- Gebruik labels tijdens de LOOPS, het is gemakkelijk om de lus te verlaten wanneer dat nodig is.
- Gebruik een onderstrepingsteken terwijl lange woordgroepen worden geschreven als een variabelenaam of subroutine.
- Probeer eenvoudige regex te gebruiken tijdens het coderen.
Perfect voorbeeld met coderingsstandaarden:
####################################################################### Program to read the file content # Date: 22-2-2013 # Author : Guru99 ######################################################################## #!/usr/bin/perl use strict; use warnings; my $line; open FR, "file.txt" || die("Cannot open the file $!"); while ($line=<FR>) { print $line; } # Looping file handler to print data
Perl-foutafhandeling
Wat is een uitzondering?
Een uitzondering is een gebeurtenis die optreedt tijdens de uitvoering van het programma, waardoor uw programma wordt opgeschort of beëindigd.
foutafhandeling
Foutafhandeling is iets waar elke programmeur tijdens het programmeren rekening mee moet houden. Perl biedt ook foutafhandelingstechnieken waarmee we de fout kunnen onderscheppen en dienovereenkomstig kunnen afhandelen.
Foutafhandeling in Perl
Er zijn veel manieren om te controleren op fouten in het programma. We moeten de retourcodes onderzoeken van de functie waarvoor we code gebruiken. Als we die retourcodes goed kunnen afhandelen, kan het grootste deel van de foutafhandeling worden gerealiseerd.
Wat komt er terug bij systeemaanroepen?
In het geval van systeemaanroepen wordt de retourstatus opgeslagen in twee speciale variabelen $? En $!
$! – Hiermee wordt het foutnummer of het foutnummer dat bij de foutmelding hoort, opgespoord.
$? – Dit houdt de return status system() functie vast.
Met behulp van de Perl-operator of Logisch
We kunnen logische operatoren of operatoren gebruiken voor foutverwerking bij systeemaanroepen.
ex:
open(FH,"<test.txt");
Hierdoor wordt het bestand in leesmodus geopend als het bestand bestaat.
Wat als het bestand ontbreekt?
open(FH,"<test.txt") or die("File not exists $!"); # This will perl exit the program if the file not exists. open(FH,"<test.txt") or warn ("File not exists $!"); # This will print a warning message on STDERR
Perl Eval
De Eval-functie kan fatale fouten, compileerfouten, runtime-fouten en fouten die uw code op een bepaald moment beëindigen, verwerken.
De Perl Eval-functie kan een codeblok of een expressie bevatten. Evals beschouwt alles wat erin wordt geplaatst als een string.
Beschouw een situatie waarin een subroutine wordt aangeroepen die niet in het script is gedefinieerd. In deze situatie eindigt het script met de mededeling “ongedefinieerde subroutine &XYZ, deze fout kan worden afgehandeld in de eval-functie.
Er zijn veel toepassingen voor het evals-blok. Een voorbeeld hiervan is wanneer we de module willen laden die specifiek is voor het besturingssysteem tijdens runtime.
Bijvoorbeeld: delen door nul veroorzaakt een fatale fout; Om dit af te handelen kunnen we de code in het evals-blok plaatsen.
$a=5; $b=0; eval { '$result=$a/$b'; } if($@) { print "$@"; # All the error codes returned by evals will get stored in $@. }
Output:
syntaxisfout op C:\Users\XYZ\Text.pl regel 8, nabij “)
{“
Uitvoering van C:\Users\XYZ\Text.pl afgebroken vanwege compilatiefouten.
Voorbeeld: eval met behulp van de perl die-instructie.
sub test { die "Dieing in sub test \n"; } eval { test(); }; print "Caught : $@\n";
Output:
Gevangen: Sterven in subtest
Perl gebruiken Probeer
Perl ondersteunt geen try-, catch- en eindelijk-codeblokken zoals andere programmeertalen. We kunnen ze nog steeds gebruiken door een externe Perl-module te laden.
gebruik Probeer::Tiny;
Hiermee kunnen we uw code in het try-blok plaatsen en de fout in het waarschuwingsblok opvangen.
In plaats van $@ gebruikt in eval Try::Tiny gebruikt $_.
# fouten afhandelen met een catch-handler
try { die "Die now"; } catch { warn "caught error: $_"; # not $@ };
Eindelijk gebruiken.
my $y; try { die 'foo' } finally { $y = 'bar' }; try { die 'Die now' } catch { warn "Returned from die: $_" } finally { $y = 'gone' };
Output:
foo op C:\Users\XYZ\Text.pl regel 4.
We kunnen op deze manier proberen, vangen en uiteindelijk gebruiken.
probeer { # verklaring }
catch {# verklaring }
tenslotte { # verklaring };
Or
try { # statement } finally { # statement };
Output:
Or
try { # statement } finally { # statement } catch { # statement };
Output:
Perl Socket-programmering
Wat is een stopcontact?
De socket is een medium waarmee twee computers op een netwerk kunnen communiceren door gebruik te maken van netwerkadressen en poorten.
Stel dat A (Server) en B (Client) twee systemen zijn die met elkaar moeten communiceren via Sockets om bepaalde programma's uit te voeren.
Om dit te implementeren moeten we sockets creëren in zowel A (Server) als B (Client), A zal zich in de ontvangende staat bevinden en B zal in de zendende staat zijn.
Een server):
Hier wil de server een verbinding ontvangen van B (Client), een aantal taken uitvoeren en het resultaat terugsturen naar B (Client). Wanneer we de code uitvoeren, probeert het besturingssysteem in A een socket te maken en bindt één poort aan die socket. Vervolgens luistert het van de verzender, namelijk B.
B (klant).
Hier wil de client een programma van zijn systeem naar A (Server) sturen voor verwerking. Wanneer we de code uitvoeren, probeert het besturingssysteem in B een socket te maken voor communicatie met A (Server), B moet het IP-adres en het poortnummer van A opgeven waarmee B verbinding wil maken.
Als dit goed gaat, zullen beide systemen samenwerken om de informatie via één poort uit te wisselen. Perl ondersteunt ook socketprogrammering.
Perl heeft een native API waarmee sockets kunnen worden geïmplementeerd. Om het u gemakkelijk te maken, zijn er veel CPAN-modules waarmee we socketprogramma's schrijven.
Serverbewerkingen:
- Maak stopcontact
- Bindaansluiting met adres en poort
- Luister naar de socket op dat poortadres
- Accepteer de clientverbindingen die verbinding proberen te maken via de poort en het IP-adres van de server
- Operaties uitvoeren
Bedrijf Operabanden:
- Maak stopcontact
- Maak verbinding met de server via het poortadres
- Operaties uitvoeren
socket.io
Dit is een module voor socketprogrammering, gebaseerd op objectgeoriënteerd programmeren. Deze module ondersteunt niet het INET-netwerktype dat in netwerken wordt gebruikt.
IO::Socket::INET:
Deze module ondersteunt het INET-domein en is gebouwd op IO::Sockets. Alle beschikbare methoden in IO::Sockets worden overgenomen in de INET-module.
Client en server die het TCP-protocol gebruiken:
TCP is een verbindingsgericht protocol; we zullen dit protocol gebruiken voor socketprogrammering.
Laten we, voordat we verder gaan, kijken hoe we een object voor de IO::Socket::INET-module kunnen maken en een socket kunnen maken.
$socket = IO::Socket::INET->new(PeerPort => 45787, PeerAddr => inet_ntoa(INADDR_BROADCAST), Proto => udp,LocalAddr => 'localhost',Broadcast => 1 ) or die "Can't create socket and bind it : $@n";
De nieuwe methode in de IO::Socket::INET-module accepteert een hash als invoerparameter voor de subroutine. Deze hash is vooraf gedefinieerd en we hoeven alleen maar de waarden op te geven voor de sleutels die we willen gebruiken. Er is een lijst met sleutels die door deze hash worden gebruikt.
PeerAdr |
Hostadres op afstand |
PeerHost |
Synoniem voor PeerAddr |
PeerPort |
Afgelegen haven of service |
LokaalAdr |
Lokaal host-bindadres |
Localhost |
Synoniem voor LocalAdr |
Lokale poort |
Lokale host-bindpoort |
Proto |
Protocolnaam (of nummer) |
Type |
Socket type |
Listen |
Wachtrijgrootte voor luisteren |
HergebruikAdr |
Stel SO_REUSEADDR in vóór binding |
visfuik |
Stel SO_REUSEADDR in vóór binding |
Hergebruikpoort |
Stel SO_REUSEPORT in vóór binding |
Uitzending |
Stel SO_BROADCAST in vóór binding |
Timeout |
Time-outwaarde voor verschillende bewerkingen |
MultiHomed |
Probeer alle adressen voor multihomed hosts |
Het blokkeren van |
Bepaal of de verbinding in de blokkeermodus staat |
Server.pl
use IO::Socket; use strict; use warnings; my $socket = new IO::Socket::INET ( LocalHost => 'localhost', LocalPort => '45655', Proto => 'tcp', Listen => 1, Reuse => 1, ); die "Could not create socket: $!n" unless $socket; print "Waiting for the client to send datan"; my $new_socket = $socket->accept(); while(<$new_socket>) { print $_; } close($socket);
Klant.pl
use strict; use warnings; use IO::Socket; my $socket = new IO::Socket::INET ( PeerAddr => 'localhost', PeerPort => '45655', Proto => 'tcp', ); die "Could not create socket: $!n" unless $socket; print $socket "Hello this is socket connection!n"; close($socket);
Opmerking:
Bij socketprogrammering moeten we eerst Server.pl en vervolgens client.pl afzonderlijk uitvoeren in verschillende opdrachtprompts als we op een lokale host draaien.
Wat zijn Perl-modules en -pakketten
Modules en Pakketten zijn nauw met elkaar verwant en zijn onafhankelijk. Pakket: Een Perl-pakket wordt ook wel naamruimte genoemd en bevat alle unieke variabelen, zoals hashes, arrays, scalairen en subroutines. Module: Module is een verzameling herbruikbare code, waarin we subroutines schrijven. Deze modules kunnen in Perl-programma's worden geladen om gebruik te maken van de subroutines die in die modules zijn geschreven.
Wat zijn Perl-modules?
Standaardmodules worden tijdens de installatie van Perl op elk systeem geïnstalleerd. CPAN: Uitgebreide Perl Archive Network – Een wereldwijde opslagplaats van Perl-modules. Onze eigen aangepaste Perl-modules die door ons kunnen worden geschreven. In principe zal een module, wanneer deze in een script wordt geladen, al zijn globale variabelen en subroutines exporteren. Deze subroutines kunnen rechtstreeks worden aangeroepen alsof ze in het script zelf zijn gedeclareerd. Perl-modules kunnen worden geschreven met de extensie .pm met de bestandsnaam Ex: Foo.pm. Een module kan worden geschreven door aan het begin van het programma 'pakket Foo' te gebruiken.
Basis Perl-module:
#!/usr/bin/perl package Arithmetic; sub add { my $a=$_[0]; my $b=$_[1]; return ($a+$b); } sub subtract { my $a=$_[0]; my $b=$_[1]; return ($a-$b); } 1;
Geen uitvoer
Om deze Perl-module te gebruiken, moeten we deze in de huidige werkmap plaatsen.
We kunnen een Perl-module laden met behulp van require of use waar dan ook in de code. Het belangrijkste verschil tussen vereisen en gebruiken is dat de geladen module tijdens runtime vereist is en dat de module wordt gebruikt tijdens het compileren.
#!/usr/bin/perl require Arithmetic; print Arithmetic::add(5,6); print Arithmetic:: subtract (5,6);
Hier, in het bovenstaande voorbeeld, hebben we toegang tot de subroutines met behulp van de volledig gekwalificeerde modulenaam.
We hebben ook toegang tot het pakket via 'gebruik Arithmetic'.
Exporteur:
Deze module heeft een standaardfunctionaliteit voor het importeren van methoden.
#!/usr/bin/perl package Arithmetic; require Exporter; @ISA= qw(Exporter); # This is basically for implementing inheritance. @EXPORT = qw(add); @EXPORT_OK = qw(subtract); sub add { my $a=$_[0]; my $b=$_[1]; return ($a+$b); } sub subtract { my $a=$_[0]; my $b=$_[1]; return ($a-$b); } 1;
De @EXPORT-array kan worden gebruikt om een lijst met variabelen en subroutines door te geven, die standaard worden geëxporteerd naar de aanroeper van de module.
De @EXPORT_OK-array kan worden gebruikt om een lijst met variabelen en subroutines door te geven die op aanvraag worden geëxporteerd, waar de gebruiker dit moet opgeven tijdens het laden van de module.
#!/usr/bin/perl use Arithmetic qw(subtract); print add(5,6); print subtract (5,6);
Standaard wordt het toevoegen van een subroutine geëxporteerd. De aftrekmethode wordt niet geëxporteerd als deze niet is opgegeven tijdens het laden van de module.
Objectgeoriënteerd programmeren in Perl
In deze sectie leren we hoe u Perl-objectgeoriënteerde modules kunt maken. Laten we eerst eens kijken wat het object is? Een object is een exemplaar waarmee we bepaalde gegevens in elke Perl-module kunnen openen, wijzigen en lokaliseren. Dit is niets anders dan ervoor zorgen dat uw bestaande Perl-pakket, variabelen en subroutines zich gedragen als klassen, objecten en methoden in verwijzing naar andere programmeertalen.
Klasse creëren
We weten al hoe we modules uit het vorige onderwerp moeten maken. Het doel van de klasse is het opslaan van methoden en variabelen. Een Perl-module heeft subroutines die methoden zijn. We moeten toegang krijgen tot deze variabelen en subroutineobjecten.
Perl-constructeur
Een constructor in Perl is een methode die een referentie uitvoert en ons terugstuurt, waarbij de modulenaam aan de referentie is getagd. Dit wordt de klas zegenen genoemd. We gebruiken een bepaalde variabele voor het zegenen van een perl-klasse, namelijk bless.
#!/usr/bin/perl package Arithmetic; sub new { my $class=shift; my $self={}; bless $self, $class; return $self; } sub add { my $self= shift; my $a=$_[0]; my $b=$_[1]; return ($a+$b); } sub subtract { my $self= shift; my $a=$_[0]; my $b=$_[1]; return ($a-$b); } 1;
De nieuwe methode die wordt gebruikt als constructor voor een klasse. Deze constructor zal een object voor ons maken en terugkeren naar het script dat deze constructor aanroept.
#!/usr/bin/perl use Arithmetic; my $obj= Arithmetic->new(); my $result= $obj->add(5,6); print "$result"; $result = $obj->subtract(6,5); print "$result";
Hier moeten we begrijpen hoe het object is gemaakt. Telkens wanneer we proberen een object voor de klasse te maken, moeten we de volledige naam van de klasse gebruiken. Stel dat de perl-klasse zich in een lib\Math\Arithmetic.pm bevindt. En als we toegang willen krijgen tot deze perl-klasse vanuit de lib-directory, moeten we het volledige pad van naar de klasse opgeven terwijl we het script aanroepen.
gebruik lib::Wiskunde::Rekenkunde;
my $obj = lib::Math::Arithmetic->new();
Dit is hoe het maken van objecten in Perl gebeurt.
@INC:
Hoe weet het Perl-script waar de bibliotheekmodule bestaat? Perl kent alleen de huidige map van het script en het ingebouwde bibliotheekpad van Perl. Telkens wanneer we een Perl-module gebruiken, die zich niet in de huidige map of het Perl-bibliotheekpad bevindt, zal het script altijd mislukken. Over @INC, dit is een array die alle mappaden bevat waar naar de Perl-modules moet worden gezocht. Probeer deze opdracht uit te voeren en kijk wat de uitvoer zal zijn.
perl –e "print @INC"
Dit zal enige uitvoer opleveren, en dat is het pad waar de lib-modules beschikbaar zullen zijn. Telkens wanneer we een nieuwe bibliotheekmodule gebruiken, moeten we Perl, tolk, vertellen dat hij naar die specifieke locatie moet kijken waar de Perl-module beschikbaar is.
push(@INC, "PATH TO YOUR MODULE");
Maak dit als uw eerste regel code. Dit zal uw tolk vertellen dat hij naar dat pad moet kijken. of .
lib Arithmetic; # List here is your Perl Module location
Perl-vernietiger
De destructor van een object wordt standaard aangeroepen aan het einde en voordat uw script wordt afgesloten. Dit wordt gebruikt om uw objecten uit het geheugen te vernietigen.
PERL V/s Shell-scripting
- Programmeren in Perl veroorzaakt geen portabiliteitsproblemen, wat gebruikelijk is bij het gebruik van verschillende shells in shell-scripting.
- Foutafhandeling is heel eenvoudig in Perl
- Je kunt op Perl gemakkelijk lange en complexe programma's schrijven vanwege de omvang ervan. Dit in tegenstelling tot Shell, dat geen namespaces, modules, object, overerving etc. ondersteunt.
- Shell heeft minder herbruikbare bibliotheken beschikbaar. Niets vergeleken met de CPAN van Perl
- Shell is minder veilig. Het roept externe functies op (opdrachten zoals mv, cp etc. zijn afhankelijk van de gebruikte shell). Integendeel, Perl doet nuttig werk bij het gebruik van interne functies.
Hoe PERL wordt gebruikt bij automatiseringstesten
Perl wordt veel gebruikt in de automatisering. Het is misschien niet de beste programmeertaal ter wereld, maar het is het meest geschikt voor bepaalde soorten taken. Laten we bespreken waar en waarom Perl wordt gebruikt Automatisering testen.
Opslag testen
Wat is opslag? Gegevens opgeslagen in Bestanden.
Stel dat we een opslaggerelateerd probleem hebben Testgeval waar we gegevens op één partitie moeten schrijven, lezen en verifiëren dat de gegevens correct zijn geschreven.
Dit kan handmatig, maar kan een handmatige tester hetzelfde 10000 keer uitvoeren? Het zal een nachtmerrie zijn! We hebben automatisering nodig
Het beste hulpmiddel om alles wat met opslag te maken heeft te automatiseren is Perl vanwege de bestandsverwerkingstechnieken, REGEX en krachtige bestandsparsering die de minste uitvoeringstijd in beslag neemt in vergelijking met andere programmeertalen.
Waarom moeten we de opslag testen? Denk aan grote datacenters waar data continu van het ene systeem naar het andere systeem stroomt, met 1000'en records die per seconde worden opgeslagen. Het testen van de robuustheid van een dergelijk opslagmechanisme is essentieel.
Veel bedrijven zoals HP, Dell, IBM en veel serverfabrikanten gebruiken Perl als interface om de functionaliteit in opslag- en netwerkdomeinen te testen. NetApp is zo'n bedrijf dat volledig op Storage werkt en Perl als programmeertaal gebruikt om de testcases te automatiseren.
Als je geïnteresseerd bent in Perl Automation, dan is het raadzaam om meer te leren over Storage & Networking Concepts.
Server- en netwerktesten:
Server- en netwerktesten met Perl
PERL wordt veel gebruikt bij het monitoren van de uptime en prestaties van servers.
Overweeg een datacenter met 100 hosts (servers). U moet verbinding maken met elke host en enkele opdrachten op afstand uitvoeren. U wilt ook het systeem opnieuw opstarten en controleren wanneer het weer online komt.
Het handmatig uitvoeren van deze taak voor alle 100 hosts zal een nachtmerrie zijn. Maar we kunnen dit eenvoudig automatiseren met PERL
Ontwerpstappen om bovenstaande automatisering te bereiken met behulp van PERL
- Neem invoer uit het bestand over de hostinformatie zoals (IP, gebruikersnaam en wachtwoord).
- Gebruik Net::SSH2 om verbinding te maken met elk systeem en een kanaal tot stand te brengen om de opdrachten uit te voeren.
- Voer een reeks vereiste opdrachten uit, bijvoorbeeld: ls, dir, ifconfig,ps enz.
- Start het systeem opnieuw op.
- Wacht 10 minuten totdat het systeem actief is.
- Ping het systeem met de Net::Ping-module en druk de status af.
We zullen het bovenstaande scenario coderen.
Laten we een bestand nemen met de naam Input.txt, waarin de volledige informatie wordt opgeslagen over alle hosts waarmee we verbinding moeten maken en de opdracht moeten uitvoeren.
Invoer.txt
192.168.1.2 root-wachtwoord
192.168.1.3 root-wachtwoord
192.168.1.4 wortel root123
HostCheck.pl
use Net::SSH2; use Net::Ping; use strict; use warnings; my $ping = Net::Ping->new(); # Creating object for Net::Ping my $SSHObj = Net::SSH2->new(); #Creating object for Net::SSH2 open( FH, "Input.txt" ); # Opening file and placing content to FH my @hosts = <FH>; my $ip; my @ips; foreach (@hosts) { if ( $_ =~ /(.*)\s+(\w+)\s+(.*)/ ) #Regex to get each info from file { $ip = $1; my $user = $2; my $password = $3; $SSHObj->connect($ip); print "Connecting to host -- $ip --Uname:$user --Password:$password\n"; my $status = $SSHObj->auth_password( $user, $password ); print "$status\n"; die("unable to establish connection to -- $ip") unless ($status); my $shell = $SSHObj->channel(); print "$_\n" while <$shell>; $shell->blocking(1); $shell->pty('tty'); $shell->shell(); sleep(5); #Executing the list of command on particular host. Can be any command print $shell "ls \n"; print "$_\n" while <$shell>; print $shell "ps \n"; print "$_\n" while <$shell>; print $shell "dir \n"; print "$_\n" while <$shell>; print $shell "init 6\n"; #rebooting the system push( @ips, $ip ); } } sleep 600; foreach (@ips) { if ( $ping->ping($_) ) { print "$_ is alive.\n" if $ping->ping($_); } else { print "$_ is not still up --waiting for it to come up\n"; } }
Webtesten
Perl beperkt zich niet alleen tot het testen van opslag en netwerken. We kunnen ook webgebaseerde tests uitvoeren met behulp van PERL. WWW-Mechaniseren waarvoor één module wordt gebruikt webtesten. Kortom, het zal geen enkele browser starten om de functionaliteit van webapplicaties te testen, maar het gebruikt de broncode van de HTML-pagina's.
We kunnen ook browsergebaseerde tests uitvoeren met behulp van Selenium IDE, RC, webstuurprogramma. Perl wordt ondersteund Selenium.
\N"; #this zal de resterende string vasthouden nadat de patter-match is voltooid.
afdrukken “