Perl-Tutorial: Variable, Array, Hashes mit Programmierbeispiel
Lukas Bennett
Was ist Perl?
Perl ist eine hochrangige, universelle, interpretierte, dynamische Programmiersprache. Perl ist ein Begriff, der für „Practical Extraction and Reporting Language“ steht, obwohl es für Perl kein Akronym gibt. Es wurde 1987 von Larry Wall eingeführt. Die Sprache Perl wurde speziell für die Textbearbeitung entwickelt. Aber jetzt wird sie für eine Vielzahl von Zwecken verwendet, darunter Linux-Systemadministration, Netzwerkprogrammierung, Webentwicklung usw.
Sagen wir es einfach. Während Computer nur Nullen und Einsen verstehen (Binärsprache/Maschinensprache/[Low-Level-Sprache]), ist es für uns Menschen sehr schwierig, in einer Binärsprache zu programmieren. Perl ist eine Programmiersprache, die natürliche Sprachelemente verwendet, Wörter, die in der allgemeinen englischen Sprache verwendet werden, und daher für Menschen einfacher zu verstehen ist [Hochsprache]. Jetzt gibt es ein Problem; Computer können keine Hochsprachen verstehen, die wir Menschen leicht verstehen können. Dafür brauchen wir etwas, das die Hochsprache in die Niedrigsprache übersetzen kann. Hier kommt uns ein Dolmetscher zu Hilfe. Der Interpreter ist eine Software, die das in der Hochsprache geschriebene Programm in eine Niedrigsprache umwandelt, damit der Computer die im Programm geschriebenen Anweisungen verstehen und ausführen kann. Daher ist Perl ein interpretierte Programmiersprache.
Wo wird Perl verwendet?
Die Leistungsfähigkeit der Skriptsprache Perl kann in vielen Bereichen eingesetzt werden. Am häufigsten wird Perl in der Webentwicklung eingesetzt. Perl wird auch verwendet, um viele Aufgaben auf Webservern und andere Verwaltungsaufgaben zu automatisieren. Es kann automatisch E-Mails generieren und Systeme bereinigen. Perl wird immer noch für seinen ursprünglichen Zweck verwendet, d. h. zum Extrahieren von Daten und Generieren von Berichten. Es kann Berichte zur Ressourcennutzung erstellen und auf Sicherheitsprobleme in einem Netzwerk prüfen. Aus diesem Grund ist Perl auch in der Webentwicklung, im Netzwerkbereich und in der Bioinformatik zu einer beliebten Sprache geworden. Abgesehen davon kann Perl auch für die CGI-Programmierung verwendet werden.
Perl kann auch zur Bilderzeugung und -bearbeitung verwendet werden. Darüber hinaus sind die Vernetzung über Telnet, FTP usw., die Erstellung grafischer Benutzeroberflächen, VLSI-Elektronik und die Erstellung von Mailfiltern zur Reduzierung von Spamming-Praktiken einige Anwendungsfälle von Perl.
Perl ist auch für die Implementierung von OOP-Praktiken (objektorientierte Programmierung) bekannt und unterstützt alle Formen der Vererbung (einfach, mehrfach und Diamant), Polymorphismus und Kapselung. Perl ist flexibel genug, um sowohl prozedurale als auch OOP-Praktiken gleichzeitig zu unterstützen. Perl verfügt auch über zusätzliche Module, die es Ihnen ermöglichen, Code zu schreiben oder zu verwenden/wiederzuverwenden, der in Python, PHP, PDL, TCL, Octave, Java, C, C++, Basic, Ruby und Lua in Ihrem Perl-Skript. Das bedeutet, dass Sie Perl mit diesen zusätzlichen Programmiersprachen Vielmehr wird der vorhandene Code neu geschrieben.
Anwendungen der Programmiersprache Perl
Warum Perl verwenden?
Es stimmt, dass es andere Programmiersprachen gibt, mit denen man all die oben genannten Dinge erledigen kann. Warum sollten Sie dann speziell Perl verwenden? Perl ist sehr einfach zu erlernen, insbesondere wenn Sie über einen Hintergrund in der Computerprogrammierung verfügen. Perl wurde so konzipiert, dass es für Menschen leicht zu schreiben und zu verstehen ist und nicht für die Verarbeitung durch Computer. Es verwendet reguläre Ausdrücke. Der natürliche Sprachstil unterscheidet sich von anderen Programmiersprachen, die eine bestimmte Grammatik und Syntax verwenden. Daher ist Perl sehr flexibel und schreibt Ihnen keine bestimmte Denkweise für eine Lösung oder ein Problem vor. Perl ist äußerst portabel. Es kann auf jedem Betriebssystem ausgeführt werden, auf dem ein Perl-Interpreter installiert ist, es ist also plattformunabhängig. Alle Linux Operating Systems werden mit Perl vorinstalliert, sodass Sie sofort mit der Perl-Programmierung in Linux beginnen können. Dies ist anders als bei Shell-Skripten, bei denen sich der Code mit der verwendeten Linux-Distribution ändert, wodurch er immer weniger portierbar wird. Kleinere spezifische Aufgaben werden in Perl sehr einfach und schnell erledigt. In diesem Perl-Tutorial für Anfänger erfahren Sie, wie Sie kleine, schnelle Programme für bestimmte Aufgaben programmieren können. Nehmen wir ein einfaches Beispiel des klassischen Hello World-Programms, mit dem man mit dem Erlernen jeder Programmiersprache beginnen kann, deren Wurzeln UNIX sind:
Beispiel: Perl Hallo Welt
#!/usr/bin/perl print "Hello, world!";
Ausgang:
Hallo Welt!
Die beiden obigen Codezeilen geben Hallo Welt aus! War das nicht zu einfach und schnell? Studenten mit C-Kenntnissen, C++ wissen, dass in diesen Sprachen viel mehr Codezeilen erforderlich sind, um dieselbe Ausgabe zu erhalten.
Sie fragen sich vielleicht warum Perl ist im Web so berühmt. Es ist einfach, da die meisten Dinge, die im Web passieren, aus TEXT bestehen und Perl sehr gut in der Textverarbeitung ist. Wenn wir Perl mit einer der Sprachen vergleichen, ist Perl die beste Sprache, die gut in der Dateiverwaltung, Textverarbeitung und Ausgabeberichterstattung ist
Einer der besten Vorteile von Perl ist, dass es so ist frei zu benutzen
Die Perl-Community ist der festen Überzeugung, dass Software frei verfügbar, frei veränderbar und frei verteilbar sein sollte. Mehrere Freiwillige aus der Perl-Community bemühen sich, die Programmiersprache so gut wie möglich zu machen.
Vor- und Nachteile von Perl
| Vorteile: | Nachteile: |
|---|---|
|
|
|
|
|
Lass uns anfangen
Nachdem wir nun genügend Wissen über die Geschichte von Perl und die grundlegenden Konzepte der Computerprogrammierung haben, die für die Codierung in Perl erforderlich sind, ist es an der Zeit, in die Materie einzutauchen und mit Perl zu beginnen. Im nächsten Kapitel erfahren Sie, wie Sie Perl auf Ihrem System einrichten und sich auf die Codierungsreise in Perl vorbereiten können. Dieses Perl-Skripting-Tutorial verwendet Linux als Betriebssystem, das die Schüler für die Codierung in Perl verwenden werden.
Laden Sie Perl herunter und installieren Sie es – Windows, Mac und Linux
Wie bekomme ich Perl?
Gute Nachrichten Du hast es wahrscheinlich!
Wenn Sie es jedoch noch nicht auf Ihrem System finden, können Sie es trotzdem kostenlos herunterladen.
Um herauszufinden, ob Sie Perl bereits installiert haben, rufen Sie die Befehlszeile auf und geben Sie Folgendes ein: perl -v
Der Befehl zeigt die Version von Perl an, sofern diese installiert ist. In diesem Fall ist die Version v5.14.2. Aber wenn nicht... keine Panik...
Unix
|
Bereits installiert Im Lieferumfang ist Perl vorinstalliert. Möglicherweise müssen Sie jedoch auf die neueste Version aktualisieren. |
Mac OS 
|
Bereits installiert Auf OSX ist Perl vorinstalliert. Möglicherweise müssen Sie es jedoch auf die neueste Version aktualisieren |
Windows
|
Muss installiert werden Es stehen zwei Optionen zur Verfügung
|
Aktualisieren von Perl unter Linux:
Wenn Sie die Perl-Version aktualisieren müssen, geben Sie einfach eine einzige Befehlszeile ein
sudo apt-get install perl
und entspannen. Für den Rest wird gesorgt. Stellen Sie einfach sicher, dass Sie über eine aktive Internetverbindung verfügen.
Installieren Sie Perl für Windows:
Laden Sie zunächst das Active Perl herunter Link. Befolgen Sie diese Schritte, um ActivePerl darauf zu installieren Windows System. Sehen Sie sich dazu die folgenden Screenshots an.
Schritt 1: Sobald Sie das Installationsprogramm heruntergeladen und die Installation gestartet haben, wird das folgende Fenster angezeigt. Klicken Sie auf „Weiter“, um fortzufahren.
Schritt 2: Akzeptieren Sie die Lizenzvereinbarung, um mit der Installation fortzufahren.
Schritt 3: Nachfolgend finden Sie verschiedene Pakete, die installiert werden. Standardmäßig werden alle ausgewählt. Der einzige Unterschied ist PPM (Perl Package Manager). Dies ist das von Active Perl bereitgestellte Dienstprogramm zum Installieren externer Perl-Module oder -Bibliotheken in Ihrem System. Klicken Sie auf Weiter, um fortzufahren.
Schritt 4: Dabei handelt es sich um verschiedene Arten von Perl-Erweiterungen, die für Perl verwendet werden können. Meistens werden wir .Pl, .Plx und .Pm für Perl verwenden. Perl-Module verwenden grundsätzlich .Pm als Dateierweiterung, um auf eine Bibliotheksdatei zu verweisen. Wählen Sie alle Optionen aus und klicken Sie auf die Schaltfläche Weiter.
Schritt 5: Klicken Sie auf die Schaltfläche „Installieren“, um mit der Installation fortzufahren.
Schritt 6: Führen Sie nach der Installation den Befehl „Perl –v“ aus, um zu überprüfen, ob Perl erfolgreich auf Ihrem System installiert wurde.
Es gibt viele Dinge, die für die Einrichtung der Perl-Umgebung sowohl unter Linux als auch unter Linux besprochen werden müssen Windows, da in dieser Installation nicht viele Bibliotheksdateien enthalten sein werden. Sie müssen diese manuell installieren. Sie können diese manuell mit CPAN (Comprehensive Perl) installieren Archive Network) oder PPM, das nur für Perl-Fenster funktioniert. Diese Dateien sind jedoch nicht zwingend erforderlich, um mit dem Codieren in Perl zu beginnen.
Abgesehen von diesem Windows-Setup könnten Sie verwenden Windows 10's neue Funktion des Linux-Subsystems über Windows und verwenden Sie es zum Ausführen von Perl-Code
Erstes Perl-Programm
Hello world!
Perl-Beispiel: Hallo Welt
#!/usr/bin/perl -w #this is just a comment… print "Hello World";
Machen Sie sich keine Sorgen, wenn Sie diesen Text nicht verstehen. Bald wird alles klar sein. Kommen Sie und schauen Sie es sich zeilenweise an:
#!/usr/bin/perl
Dies sagt das OperaSystem dazu auffordern, diese Datei mit dem Programm auszuführen, das sich unter /usr/bin/perl befindet. Einige IDEs benötigen diese Zeile nicht. Wenn es unbedingt erforderlich ist, müssen Sie hier einen Pfad zu Ihrem Dolmetscher angeben. Erinnern! Diese spezielle Zeile muss am Anfang Ihres Programms stehen und mit # beginnen! Warnungen verwenden; Dies ist ein weiterer spezieller Befehl, der den Interpreter anweist, alle Warnungen anzuzeigen, z. B. -w, wodurch Warnungen global aktiviert werden.
print "Hello World";
Die Druckanweisung schreibt Text auf den Bildschirm. Das Semikolon am Ende der Zeile teilt dem Perl-Interpreter mit, dass die Anweisung abgeschlossen ist. Sie müssen am Ende jeder Anweisung im Perl-Code ein Semikolon einfügen. Beachten Sie das Anführungszeichen(“). Es ist für die Druckanweisung erforderlich. Speichern Sie das obige Skript als firstprog.pl
On Windows
Wenn Sie Strawberry installiert haben, können Sie einfach auf Ausführen klicken. Sie können auch die Befehlszeilenschnittstelle ausführen und in die Konsole schreiben:
C:\> perl path\firstprog.pl
oder, wenn sich perl.exe nicht in Ihrem Pfad befindet:
C:\> c:\perl\bin\perl.exe firstprog.pl
Unter Linux/Unix
Sie müssen nur das Terminal öffnen und schreiben:
perl firstprog.pl
Wenn Sie das Programm nicht ausführen können, stellen Sie sicher, dass Sie zur Ausführung berechtigt sind. Geben Sie im Terminal Folgendes ein:
chmod +x firstprog.pl
Ihr Programm ist jetzt ausführbar und betriebsbereit. Schreiben Sie zum Ausführen:
./firstprog
Installieren Sie CPAN-Minus-Module
Module sind Codesätze, die für Aufgaben verwendet werden, die gemeinsame Operationen in mehreren Programmen ausführen. Wenn Sie Perl-Module verwenden, müssen Sie die Codes nicht neu schreiben, um dieselbe Operation auszuführen. Perl kann solche externen Codebibliotheken nutzen. Eine der besten Bibliotheken ist CPAN. Es steht für Comprehensive Perl Archive Network und enthält eine große Menge an Perl-Modulen, die Sie verwenden können. Es ist eine Community oder ein Netzwerk einer großen Anzahl von Entwicklern, die solche Module beisteuern. Indem Sie Unterstützung für CPAN-Module in Ihrem Perl-Modul installieren, können Sie die CPAN-Module nutzen und Ihre Arbeit erleichtern. Die meisten Perl-Module sind in Perl geschrieben, einige verwenden XS (sie sind in C geschrieben) und erfordern daher einen C-Compiler (dieses Setup ist einfach – keine Panik. Module können Abhängigkeiten von anderen Modulen haben (fast immer auf CPAN) und können nicht ohne diese (oder ohne eine bestimmte Version davon) installiert werden. Es lohnt sich, die Dokumentation für die folgenden Optionen gründlich zu lesen. Viele Module auf CPAN erfordern jetzt eine aktuelle Version von Perl (Version 5.8 oder höher). Installieren Sie cpanminus, ein Skript zum Abrufen, Entpacken, Erstellen und Installieren von Modulen von CPAN, um die Installation anderer Module zu vereinfachen (Sie werden uns später danken). So installieren Sie App-cpanminus Perl-Module, geben Sie in der Befehlszeile Folgendes ein:
cpan App::cpanminus
cpan App::cpanminus Stellen Sie sicher, dass Sie über eine Internetverbindung verfügen, während Perl-Module heruntergeladen und installiert werden.
Installieren Sie nun ein beliebiges Modul:
cpan –i <Module_Name>.
Sehen wir uns ein Beispiel für die Installation eines Moduls File::Data an (eine Schnittstelle für den Zugriff auf Dateidaten).
Perl-Variable
Jetzt werden wir über Variablen sprechen. Sie können sich eine Variable wie eine Art Container vorstellen, der einen oder mehrere Werte enthält. Einmal definiert, bleibt der Name der Variablen gleich, aber der Wert oder die Werte ändern sich immer wieder.
Es gibt 3 Arten von Variablen:
Arten von Variablen in Perl
Die einfachsten sind Skalare, und das ist unser heutiges Thema
Skalare Variable
Dieser Variablentyp enthält einen einzelnen Wert.
Sein Name beginnt mit einem Dollarzeichen und einem Perl-Bezeichner (es ist der Name unserer Variablen).
Skalare Variable in Perl
Namenskonvention
Wenn Sie mit anderen Programmiersprachen vertraut sind, wissen Sie, dass es bestimmte Regeln für die Benennung von Variablen gibt. Ebenso gibt es in Perl drei Regeln für die Benennung von Skalaren.
- Alle skalaren Namen beginnen mit einem $. Es ist leicht, daran zu denken, jedem Namen ein $ voranzustellen. Betrachten Sie es als einen $-Skalar.
- Wie PHP. Nach dem ersten Zeichen $, das in Perl etwas Besonderes ist, sind alphanumerische Zeichen, also a bis z, A bis Z und 0 bis 9, erlaubt. Unterstrichzeichen sind ebenfalls zulässig. Verwenden Sie einen Unterstrich, um die Variablennamen in zwei Wörter aufzuteilen. „Aber das erste Zeichen darf keine Zahl sein“
- Obwohl Zahlen Teil des Namens sein können, dürfen sie nicht direkt nach $ stehen. Das bedeutet, dass das erste Zeichen nach $ entweder ein Buchstabe oder ein Unterstrich ist. Diejenigen, die aus C/ kommen,C++ Hintergrund sollte sofort in der Lage sein, die Ähnlichkeit zu erkennen. Beispiele
Perl-Beispiel:
$var; $Var32; $vaRRR43; $name_underscore_23;
Dies sind jedoch keine zulässigen Skalarvariablennamen.
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
Die allgemeine Regel besagt: Wenn Perl nur eines von etwas hat, ist das ein Skalar. Skalare können von Geräten gelesen werden und wir können sie in unseren Programmen verwenden.
Zwei Arten von Skalardatentypen
- Numbers
- Streicher
Numbers:
In dieser Art von Skalardaten könnten wir Folgendes angeben:
- Ganzzahlen, einfach ganze Zahlen, wie 2, 0, 534
- Gleitkommazahlen, es sind reelle Zahlen, wie 3.14, 6.74, 0.333
Hinweis: Im Allgemeinen betrachtet der Perl-Interpreter Ganzzahlen als Gleitkommazahlen. Wenn Sie beispielsweise 2 in Ihre Programme schreiben, betrachtet Perl sie als 2.0000
Ganzzahlige Literale:
Es besteht aus einer oder mehreren Ziffern, optional mit vorangestelltem Plus oder Minus und mit Unterstrichen.
Perl-Beispiele:
0; -2542; 4865415484645 #this also can be written with underscores (for clarity) : 4_865_415_484_645
Wie Sie sehen, ist es nichts Besonderes. Aber glauben Sie mir, das ist die häufigste Art von Skalaren. Sie sind überall.
Gleitkomma-Literale:
Es besteht aus Ziffern, optional Minus, Dezimalpunkt und Exponent.
Perl-Beispiele:
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
Oktale, hexadezimale und binäre Darstellung:
Es ist eine Alternative zum Dezimalsystem. Erlauben Sie mir, Ihnen die oktale, hexadezimale und binäre Darstellung zu zeigen. Eine kurze Tabelle präsentiert alle wichtigen Informationen zu diesem seltsamen Stil:
| Vertretung | Basis | Weitergeführt von |
|---|---|---|
| Oktal | 8 | 0 (Null) |
| Hexadecimal | 16 | 0x |
| Binär | 2 | 0b |
Perl-Beispiele:
255; # 255 in decimal notation 0377; # 255 in octal notation 0xff; # 255 in hexadecimal notation 0b11111111; # 255 in binary notation
Alle diese Werte bedeuten für Perl dasselbe. Perl speichert die Werte nicht im gleichen Format. Diese hexadezimalen, binären und oktalen Werte werden intern in Dezimalwerte umgewandelt.
Die Zuweisung ist die häufigste Operation an einem Skalar und sie ist sehr einfach. Perl verwendet hierfür das Gleichheitszeichen. Es nimmt einen Wert des Ausdrucks von der rechten Seite und fügt diesen Wert unserer Variable hinzu.
Werfen wir einen Blick auf Beispiele:
$size=15; # give $size value of 15 $y = -7.78; # give $y value of -7.78
Darüber hinaus können Sie in Variablen nicht nur eine Zahl, sondern auch einen Ausdruck eingeben.
$z = 6 + 12 # give $z value of 18
Streicher
Strings: Es handelt sich ebenfalls um einen sehr einfachen Skalartyp.
Die maximale Länge einer Zeichenfolge in Perl hängt von der Speicherkapazität des Computers ab. Es gibt keine Begrenzung für die Größe der Zeichenfolge. Ihre Zeichenfolgen können aus einer beliebigen Anzahl von Zeichen, Symbolen oder Wörtern bestehen. Die kürzeste Zeichenfolge enthält keine Zeichen. Die längste Zeit kann den gesamten Systemspeicher füllen. Perl-Programme können vollständig im 7-Bit-ASCII-Zeichensatz geschrieben werden. Perl ermöglicht Ihnen auch das Hinzufügen eines beliebigen 8-Bit- oder 16-Bit-Zeichensatzes. Nicht-ASCII-Zeichen in Zeichenfolgenliteralen. Perl hat auch Unterstützung für Unicode UTF-8 hinzugefügt.
Wie bei Zahlen gibt es zwei verschiedene Arten von Zeichenfolgen:
- String-Literale in einfache Anführungszeichen
- Double zitiert String-Literale
String-Literale in einfachen Anführungszeichen
Einfache Anführungszeichen werden verwendet, um Daten einzuschließen, die wörtlich genommen werden sollen. Ein kurzes Beispiel und alles sollte klar sein:
Perl-Beispiele:
#!/usr/bin/perl $num = 7; $txt = 'it is $num'; print $txt;
Ausgang:
es ist $num
Aufgrund der einfachen Anführungszeichen wird hier der Wert von $num nicht verwendet und die Literalzeichen „$“, „n“, „u“ und „m“ werden zum Wert von $txt hinzugefügt
DoubleString-Literale in Anführungszeichen
Double Anführungszeichen werden verwendet, um Daten einzuschließen, die vor der Verarbeitung interpoliert werden müssen. Das bedeutet, dass Escape-Zeichen und Variablen nicht einfach wörtlich in spätere Operationen eingefügt, sondern an Ort und Stelle ausgewertet werden. Escape-Zeichen können zum Einfügen von Zeilenumbrüchen, Tabulatoren usw. verwendet werden.
Perl-Beispiele:
$num = 7; $txt = "it is $num"; print $txt;
Ausgang:
es ist 7
Aufgrund der Anführungszeichen wird hier der Wert von $num zum Wert von $txt addiert.
Double-Anführungszeichen interpolieren Skalar- und Arrayvariablen, aber keine Hashes. Andererseits können Sie doppelte Anführungszeichen verwenden, um Ausschnitte sowohl von Arrays als auch von Hashes zu interpolieren.
Geheimnisvoll \n
Betrachten Sie das folgende Programm
Perl-Beispiele:
print "hello \n";
Ausgang:
HELLO
Perl zeigt nicht nur „Hallo\n“, sondern nur „Hallo“ an. Warum? Denn „\n“ ist ein Sonderzeichen und bedeutet, dass Sie beim Anzeigen des Textes in Ihrem Programm in eine neue Zeile wechseln möchten. print „Hallo\n neue Zeile“; Nächste Frage: Gibt es noch andere Sonderzeichen? Ja, sie sind! Aber keine Sorge – nur ein paar. Schauen Sie sich die Tabelle unten an
| Konstruieren | Beschreibung |
|---|---|
| \n | Neue Zeile |
| \r | Rückkehr |
| \t | Tab |
| \f | Seitenvorschub |
| \b | Rücktaste |
| \a | Glocke |
| \e | Flucht |
| \ 007 | beliebiger oktaler ASCII-Wert (hier 007 = Glocke) |
| \x7f | beliebiger Hex-Wert (hier 7f = löschen) |
| \\ | umgekehrter Schrägstrich |
| \ " | Doppelzitat |
| \l | Kleinschreibung des nächsten Buchstabens |
| \L | alle folgenden Buchstaben bis \E kleinschreiben |
| \u | Großschreibung des nächsten Buchstabens |
| \U | Alle folgenden Buchstaben bis \E werden groß geschrieben |
| \E | Beenden Sie \L, \U |
Ich weiß, es gibt nicht „nur ein paar“… Aber glauben Sie mir, Sie müssen es einfach wissen
Strings-Variable
Es handelt sich um dieselbe Operation, die wir bei der Zahlenzuweisung sehen. Perl holt sich den String von der rechten Seite des Gleichheitszeichens und fügt diesen String einer Variablen hinzu.
Perl-Beispiele:
$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;
Ausgang:
Tutorial315
Wie Sie sehen, können Sie Zahlen und Zeichenfolgen in dieselben Variablen einfügen. Es gibt keine Variablenklasse.
String-Verkettung (Punkt):
Der Verkettungsoperator „.“ verbindet zwei oder mehr Zeichenfolgen. Denken Sie daran! Wenn die Zeichenfolge Anführungszeichen, Zeilenumbrüche oder Backslashs enthält, müssen alle diese Sonderzeichen mit einem Backslash maskiert werden.
Beispiele für Perl-Variablen:
#!/usr/bin/perl $a = "Tom is"; $b = "favorite cat"; $c = $a ." mother's ". $b; print $c;
Ausgang:
Tom ist die Lieblingskatze der Mutter
Die Saiten
„$a“, „$b“ werden mit dem Operator „.“ verkettet und in „$c“ gespeichert.
Schlussendlich…
Konvertierung zwischen Numbers und Strings:
Wie Sie wissen, konvertiert Perl bei Bedarf automatisch Zahlen in Zeichenfolgen. Woher weiß Perl, was wir gerade brauchen? Das ist ganz einfach – alles hängt vom Operator ab (wir werden später über Operatoren sprechen, akzeptieren Sie jetzt einfach, dass es viele Operatoren gibt, unterschiedliche für Zahlen und Zeichenfolgen). Wenn ein Operator eine Zahl erwartet, verwendet Perl den Wert als Zahl. Wenn ein Operator eine Zeichenfolge erwartet, verwendet Perl den Wert als Zeichenfolge. Mit anderen Worten – Sie müssen sich über diese Art der Konvertierung keine Gedanken machen. Kurzes Beispiel und alles sollte klar sein:
Perl-Beispiele:
$string = "43"; $number = 28; $result = $string + $number; print $result;
Ausgang:
71
Der Wert von $string wird in eine Ganzzahl umgewandelt und zum Wert von $number addiert.
Das Ergebnis der Addition, 71, wird $result zugewiesen.
Geltungsbereich einer Variablen – Zugriffsmodifikatoren
Wir können einen Skalar an einer beliebigen Stelle im Programm deklarieren. Sie müssen jedoch einen Zugriffsmodifikator angeben
Es gibt 3 Arten von Modifikatoren
- my
- aus einer regionalen
- UNSERE
My: Damit können Sie jede Variable deklarieren, die innerhalb des Blocks spezifisch ist. also innerhalb der geschweiften Klammern.
#!/usr/bin/perl
my $var=5;
if(1)
{
my $var_2 =$var;
}
print $var_2;
Keine Leistung
Die Ausgabe des Programms wird nichts sein!
Im obigen Beispiel sehen Sie, dass zwei Variablen deklariert sind, eine innerhalb des If-Blocks ($var_2) und die andere außerhalb des If-Blocks ($var). Auf die Variable, die außerhalb des Blocks deklariert ist, kann der Block zugreifen, auf die Variable, die innerhalb des Blocks deklariert wurde, kann das äußere Programm jedoch nicht zugreifen.
Lokal: Damit können wir tatsächlich dieselben Variablenwerte in unterschiedliche Werte maskieren, ohne den ursprünglichen Wert der Variablen tatsächlich zu ändern. Angenommen, wir haben eine Variable $a, für die der Wert 5 zugewiesen ist, können Sie den Wert dieser Variablen tatsächlich um ändern Erneute Deklaration derselben Variablen mit dem lokalen Schlüsselwort, ohne den ursprünglichen Wert der Variablen zu ändern, der 5 ist. Sehen wir uns anhand eines Beispiels an, wie das funktioniert.
#!/usr/bin/perl
$var = 5;
{
local $var = 3;
print "local,\$var = $var \n";
}
print "global,\$var = $var \n";
Die Ausgabe des obigen Programms erfolgt auf diese Weise.
lokal, $var = 3
global, $var = 5
Auf diese Weise können wir den Wert der Variablen ändern, ohne den ursprünglichen Wert zu beeinflussen.
Our: Sobald eine Variable mit dem Zugriffsmodifikator „our“ deklariert wurde, kann sie im gesamten Paket verwendet werden. Angenommen, Sie haben ein Perl-Modul oder ein Paket test.pm, das eine Variable mit dem Gültigkeitsbereich our deklariert hat. Auf diese Variable kann in allen Skripten zugegriffen werden, die dieses Paket verwenden.
Wenn Sie es mit der Programmierung in Perl ernst meinen, sollten Sie Ihr Programm mit beginnen
#!/usr/local/bin/perl
Verwenden Sie strenge;
Dies wird Ihnen helfen, besseren und saubereren Code zu schreiben. „use strict“ aktiviert das strikte Pragma, wodurch Sie Ihre Variablen mit dem Schlüsselwort my deklarieren können.
Dies ist eine gute Programmierpraxis
#!/usr/local/bin/perl use strict; $var = 10; print "$var";
Ergebnis: Fehler
#!/usr/local/bin/perl use strict; my $var = 10; print "$var";
Ausgang:
10
Perl-Array
Was ist ein Perl-Array?
Ein Array ist ein spezieller Variablentyp, der Daten in Form einer Liste speichert. Auf jedes Element kann über die Indexnummer zugegriffen werden, die für jedes einzelne Element eindeutig ist. Sie können Zahlen, Zeichenfolgen, Gleitkommawerte usw. in Ihrem Array speichern. Das sieht großartig aus. Wie erstellen wir also ein Array in Perl? In Perl können Sie ein Array mit dem Zeichen „@“ definieren, gefolgt von dem Namen, den Sie vergeben möchten. Betrachten wir die Definition eines Arrays in Perl.
mein @array;
So definieren wir ein Array in Perl; Sie denken vielleicht darüber nach, wie wir Daten darin speichern müssen. Es gibt verschiedene Möglichkeiten, Daten in einem Array zu speichern. Dies hängt davon ab, wie Sie es verwenden werden.
my @array=(a,b,c,d); print @array;
Ausgang:
abcd
Dies ist ein Array mit 4 Elementen darin.
Der Array-Index beginnt bei 0 und endet bei seiner maximal deklarierten Größe. In diesem Fall beträgt die maximale Indexgröße 3.
Beispiel für ein Perl-Array
Sie können ein Array auch auf die oben beschriebene Weise deklarieren; Der einzige Unterschied besteht darin, dass Daten in einem Array gespeichert werden, wobei ein Leerzeichen als Trennzeichen dient. Hier bedeutet qw() Anführungszeichen. Die Bedeutung dieser Funktion besteht darin, eine Liste von Wörtern zu erstellen. Sie können qw auf verschiedene Arten verwenden, um ein Array zu deklarieren.
@array1=qw/a b c d/;
@array2= qw' p q r s';
@array3=qw { v x y z};
print @array1;
print @array2;
print @array3;
Ausgang:
abcdpqrsvxyz
Angenommen, Sie möchten der 5 einen Wert zuweisenth Element eines Arrays, wie machen wir das?
$array [4] ='e';
Sequentielles Array
Sequentielle Arrays sind solche, in denen Sie Daten sequentiell speichern. Angenommen, Sie möchten 1-10 Zahlen oder Buchstaben a-z in einem Array speichern. Anstatt alle Buchstaben einzugeben, können Sie etwas wie das Folgende versuchen –
@numbers= (1..10); print @numbers; #Prints numbers from 1 to 10;
Ausgang:
12345678910
Perl-Array-Größe
Wir haben ein Array, das bereits verfügbar ist, und Sie wissen nicht, wie groß dieses Array ist. Wie können Sie das also herausfinden?
@array= qw/a b c d e/; print $size=scalar (@array);
Können wir die Größe eines Arrays ermitteln, ohne Funktionen zu verwenden? Ja wir können.
@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
Ausgang:
5
5
Dynamisches Array
Die obige Methode zum Deklarieren eines Arrays wird aufgerufen statische Arrays, wobei Sie die Größe eines Arrays kennen.
Was ist ein dynamisches Array?
Dynamische Arrays sind solche, die Sie deklarieren, ohne einen Wert anzugeben. Wann genau speichern wir also Werte in diesem Array? Ganz einfach: Wir speichern sie zur Laufzeit. Hier ist ein einfaches Programm dafür.
Für diese Aufgabe werden wir einige integrierte Perl-Funktionen verwenden.
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.
}
Ausgang:
Das ist
irgendwie dyn
mic
rr
y
Die Split-Funktion teilt den Inhalt der Zeichenfolge basierend auf dem ihr bereitgestellten Trennzeichen in ein Array auf. Diese Funktion entfernt auch das Trennzeichen aus der Zeichenfolge, in diesem Fall ist es „a“;
Push, Pop, Shift, Unshift für Perl-Arrays:
Diese Funktionen können in Perl zum Hinzufügen/Löschen von Array-Elementen verwendet werden.
- Perl Push: Fügt ein Array-Element am Ende eines vorhandenen Arrays hinzu.
- Perl Pop: Entfernt das letzte Element aus einem Array.
- Perl Shift: Entfernt das erste Element aus einem Array.
- Perl Unshift: fügt am Anfang eines Arrays ein Element hinzu.
Sehen wir uns ein Beispiel an, in dem wir die folgenden Funktionen verwenden können.
@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";
Ausgang:
1.: Mo. Di. Mi
2. bei Push: Mo. Di. Mi. Do
3. wenn die Verschiebung rückgängig gemacht wird: Fr., Mo., Di., Mi., Do.
4. wenn Pop: Fr Mo Di Mi
5. Schicht: Mo Di Mi
Perl-Hashes
Warum brauchen wir Hash?
Wir haben bereits in den vorherigen Abschnitten etwas über Skalare und Arrays gelernt.
Was genau machen Skalare? Es speichert nur Ganzzahlen und Zeichenfolgen.
Was genau machen Arrays? Es handelt sich um eine Sammlung von Skalaren, bei der Sie über Indizes auf jedes Element eines Arrays zugreifen. Aber ist die Verwendung eines Arrays eine gute Idee, wenn Sie Hunderte und Tausende von Datensätzen haben? Wir werden vergessen, welcher Index welchen Wert hat. Um diese Situation zu überwinden, haben wir so etwas wie Perl-Hash.
Was sind Hashes?
Ein Hash kann auch so viele Skalare enthalten, wie das Array aufnehmen kann. Der einzige Unterschied besteht darin, dass wir keinen Index haben, sondern Schlüssel und Werte. Ein Hash kann deklariert werden, beginnend mit % gefolgt vom Namen des Hashs. Sehen wir uns ein Beispiel an, wie wir einen Perl-Hash definieren und wie wir ihn von einem Array unterscheiden können
Betrachten Sie ein Beispiel mit drei Personen, deren Alter in einem Array dargestellt wird.
@array=('Sainath',23,'Krishna',24,'Shruthi',25); #This is how an array looks.
print @array;
Ausgang:
Sainath33Krishna24Shruthi25
Auf diese Weise ist es schwierig, das einzelne Alter zu ermitteln, da wir uns sowohl die Indexpositionen des Namens als auch das Alter aller Personen merken müssen. Es mag einfach sein, wenn Sie drei Namen haben, aber wenn Sie 3 oder mehr haben? Du kennst die Antwort.
Dies können wir mit einem Hash umgehen.
Hash-Beispiel:
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.
Ausgang:
Sainath33Krishna24Shruthi25Sainath33Krishna24Shruthi25
Wir haben jetzt einen Hash deklariert, großartig!! Aber wie können wir darauf zugreifen oder es ausdrucken? Auf jedes Element im Hash sollte mit dem zugehörigen Schlüssel zugegriffen werden, dem ein Wert zugewiesen wird. Es gibt also eine Eins-zu-Eins-Zuordnung zwischen jedem Schlüssel und Wert im Hash.
Um das Alter einer Person auszudrucken, müssen Sie sich lediglich den Namen dieser Person merken.
print $hash{'Krishna'}; # This how we should access a hash. Key enclosed within {}.
Sie haben sich vielleicht gefragt, warum ich $hash{KeyName} verwendet habe. Denken Sie daran, dass ein Hash wiederum eine Sammlung von Skalaren ist. Wir können also $ verwenden, das einen Skalar darstellt, um auf jedes Hash-Element zuzugreifen.
Hinweis: Jeder Schlüssel im Hash sollte eindeutig sein, sonst überschreibt er Ihren zuvor zugewiesenen Wert.
Wie können wir einen Hash einem anderen Hash zuweisen? Ganz einfach, genauso wie wir es tun
Wir können auch den gesamten Hash drucken.
%hash=( 'Tom' => 23); %newHash=%hash; # Assigning hash to a new hashprint %newHash; print %newHash;
Ausgang:
Tom23
Fügen Sie Perl-Hashes hinzu
Wie Sie sehen, haben wir bereits einen Hash %newHash und müssen ihm nun weitere Einträge hinzufügen.
$newHash{'Jim'}=25;
$newHash{'John'}=26;
$newHash{'Harry'}=27;
print %newHash;
Ausgang:
Jim25John26Harry27
Perl-Löschtaste
Möglicherweise möchten Sie einen Eintrag aus einem Hash löschen. So können wir das machen.
delete $newHash{'Jim'};#This will delete an entry from the hash.
Löschen ist eine integrierte Funktion von Perl. Hier sehen wir ein Beispiel für die Zuweisung eines Hashs zu einem Array.
@array=%newHash; print "@array";
Hinweis: Immer wenn Sie einen Hash drucken oder Hash in einem Array speichern. Die Reihenfolge kann immer abweichen. Es ist nicht immer dasselbe.
Wir können einem Array nur Schlüssel oder Werte eines Hashs zuweisen.
@arraykeys= keys(%newHash); @arrayvalues=values(%newHash); print "@arraykeys\n"; print "@arrayvalues\n"; # \n to print new line.
Um alle Einträge im Hash zu entfernen, können wir den Hash direkt null zuweisen.
%newHash=();# Dadurch wird der Hash ohne Einträge neu definiert.
Bedingte Perl-Anweisungen
Wir können bedingte Anweisungen in Perl verwenden. Was sind also bedingte Anweisungen? Bedingte Anweisungen sind solche, bei denen Sie tatsächlich prüfen, ob bestimmte Umstände in Ihrem Code erfüllt sind.
Denken Sie an ein Beispiel: Sie kaufen ein paar Früchte und möchten nicht, dass der Preis mehr als 100 Dollar beträgt. Die Regel lautet hier also 100 Dollar.
Perl unterstützt zwei Arten von bedingten Anweisungen; Sie sind wenn und sofern nicht.
Perl If
Wenn der Codeblock ausgeführt wird, wenn die Bedingung wahr ist.
my $a=5;
if($a==5)
{
print "The value is $a";
}
Ausgang:
5
Perl, wenn sonst
Das sieht gut aus. Denken wir an eine Situation, in der $a nicht 5 ist.
my $a=10;
if($a==5)
{
print "The values is $a ---PASS";
}
else
{
print "The value is $a ---FAIL";
}
Ausgang:
Der Wert ist 10 – FAIL
Auf diese Weise können wir jeweils nur eine Bedingung steuern. Handelt es sich um eine Einschränkung? Nein, Sie können verschiedene Bedingungen auch mit if… elsif … else steuern.
Perl Else If
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";
}
Ausgang:
Ausgeführter elsif-Block – Der Wert ist 5
Im obigen Fall wird der elsif-Block ausgeführt, da $a gleich 5 ist.
Es kann Situationen geben, in denen sowohl if- als auch elsif-Codeblöcke fehlschlagen. In diesem Szenario wird der else-Codeblock ausgeführt. Sie können die else-Codeprüfung tatsächlich eliminieren, wenn Sie sie nicht einbinden möchten.
Perl verschachteltes If
In diesem Fall können Sie den if-Codeblock in einem weiteren if-Codeblock verwenden.
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";
}
Ausgang:
Im ersten else-Block – Der Wert ist 1
Führen Sie denselben Code aus, indem Sie den Wert von $a ändern. Den Rest könnt ihr herausfinden.
Perl Es sei denn
Sie haben bereits eine Vorstellung davon, was passiert (wenn die Bedingung wahr ist, wird der Codeblock ausgeführt). Unless ist das Gegenteil von if, es sei denn, der Codeblock wird ausgeführt, wenn die Bedingung falsch ist.
my $a=5;
unless($a==5)
{
print "Inside the unless block --- The value is $a";
}
else
{
print "Inside else block--- The value is $a";
}
Ausgang:
Im ersten else-Block – Der Wert ist 1
Ratet mal, was das Ergebnis sein wird. Du hast Recht!!!!!. Die Ausgabe ist die print-Anweisung des else-Blocks. Da die Bedingung im Codeblock „Es sei denn“ wahr ist, denken Sie daran, dass der Block „Es sei denn“ nur dann ausgeführt wird, wenn die Bedingung falsch ist. Ändern Sie den Wert von $a und führen Sie den Code aus. Sie werden den Unterschied sehen.
Perl mit if
$a= " This is Perl";
if($a eq "SASSDSS"){
print "Inside If Block";
}
else
{
print "Inside else block"
}
Ausgang:
Innerhalb des else-Blocks
Verwenden, sofern nicht
$a= " This is Perl";
unless($a eq "SASSDSS"){
print "Inside unless Block";
}
else
{
print "Inside else block"
}
Ausgang:
Drinnen, sofern nicht blockiert
Perl-Schleifen – Kontrollstrukturen
Perl unterstützt Kontrollstrukturen ähnlich wie andere Programmiersprachen. Perl unterstützt vier Arten von Kontrollstrukturen für, foreach, while und Until. Wir verwenden diese Anweisungen, um wiederholt Code auszuführen.
For-Schleife Perl
Der Codeblock wird ausgeführt, bis die Bedingung erfüllt ist. Nehmen wir ein Beispiel für die Perl-Schleife eines Arrays.
my @array=(1..10);
for(my $count=0;$count<10;$count++)
{
print "The array index $count value is $array[$count]";
print "\n";
}
Ausgang:
Der Wert des Array-Index 0 ist 1
Der Wert des Array-Index 1 ist 2
Der Wert des Array-Index 2 ist 3
Der Wert des Array-Index 3 ist 4
Der Wert des Array-Index 4 ist 5
Der Wert des Array-Index 5 ist 6
Der Wert des Array-Index 6 ist 7
Der Wert des Array-Index 7 ist 8
Der Wert des Array-Index 8 ist 9
Der Wert des Array-Index 9 ist 10
Hier sind im for()-Ausdruck viele Anweisungen enthalten. Für jeden von ihnen gibt es eine Bedeutung.
for (Initialisierung; Bedingung; Inkrementierung)
Hier ist eine andere Möglichkeit, for zu verwenden.
for(1..10)
{
print "$_ n";
print "\n";
}
Ausgang:
1n
2n
3n
4n
5n
6n
7n
8n
9n
10n
Perl Foreach
Die for every-Anweisung kann auf die gleiche Weise wie for verwendet werden; Der Hauptunterschied besteht darin, dass wir hier keine Bedingungsprüfung und keine Inkrementierung durchführen.
Nehmen wir das gleiche Beispiel mit foreach perl.
my @array=(1..10);
foreach my $value (@array)
{
print " The value is $value\n";
}
Ausgang:
Der Wert ist 1
Der Wert ist 2
Der Wert ist 3
Der Wert ist 4
Der Wert ist 5
Der Wert ist 6
Der Wert ist 7
Der Wert ist 8
Der Wert ist 9
Der Wert ist 10
Foreach nimmt jedes Element eines Arrays und weist diesen Wert für jede Iteration $var zu. Wir können dafür auch $_ verwenden.
my @array=(1..10);
foreach(@array)
{
print " The value is $_ \n"; # This is same as the above code.
}
Ausgang:
Der Wert ist 1
Der Wert ist 2
Der Wert ist 3
Der Wert ist 4
Der Wert ist 5
Der Wert ist 6
Der Wert ist 7
Der Wert ist 8
Der Wert ist 9
Der Wert ist 10
Das sieht für den Zugriff auf Arrays gut aus. Wie wäre es mit Hashes? Wie können wir mit foreach Hash-Schlüssel und -Werte erhalten?
Wir können foreach verwenden, um durch Schleifen auf Schlüssel und Werte des Hashs zuzugreifen.
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25);
foreach my $key (keys %hash)
{
print "$key \n";
}
Ausgang:
Mickey
Tom
Jerry
Sie fragen sich vielleicht, warum wir in foreach() Schlüssel verwendet haben. Keys ist eine integrierte Funktion von Perl, mit der wir schnell auf die Schlüssel des Hashs zugreifen können. Wie wäre es mit Werten? Wir können die Wertefunktion verwenden, um auf die Werte des Hashs zuzugreifen.
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";
}
Ausgang:
der Wert ist 24
der Wert ist 23
der Wert ist 25
Perl While
Die Perl While-Schleife ist eine Kontrollstruktur, in der der Codeblock ausgeführt wird, bis die Bedingung wahr ist.
Der Codeblock wird nur beendet, wenn die Bedingung falsch ist.
Nehmen wir ein Beispiel für eine Perl-While-Schleife.
Hier liegt ein Problem vor, das eine Eingabe durch den Benutzer erfordert und erst bei der als „7“ angegebenen Zahl behoben wird.
#!/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"
Ausgang:
Erraten Sie eine Zahl zwischen 1 und 10
9
Erraten Sie eine Zahl zwischen 1 und 10
5
Erraten Sie eine Zahl zwischen 1 und 10
7
Sie haben die Glückszahl 7 erraten
Im obigen Beispiel ist die while-Bedingung nicht wahr, wenn wir eine andere Eingabe als „7“ eingeben.
Wenn Sie hier sehen, wie while funktioniert, wird der Codeblock nur ausgeführt, wenn die Bedingung in a while wahr ist.
Perl do-while
Die Do-while-Schleife wird mindestens einmal ausgeführt, auch wenn die Bedingung im while-Abschnitt falsch ist.
Nehmen wir das gleiche Beispiel, indem wir do while verwenden.
$guru99 = 10;
do {
print "$guru99 \n";
$guru99--;
}
while ($guru99 >= 1);
print "Now value is less than 1";
Ausgang:
10
9
8
7
6
5
4
3
2
1
Jetzt ist der Wert kleiner als 1
Perl bis
Der Codeblock „Until“ ähnelt „außer“ in einer bedingten Anweisung. Hier wird der Codeblock nur ausgeführt, wenn die Bedingung im Until-Block falsch ist.
Nehmen wir das gleiche Beispiel, das wir schon einmal verwendet haben.
Hier liegt ein Problem vor, das eine Eingabe durch den Benutzer erfordert und erst behoben wird, wenn ein anderer Name als „sai“ angegeben wird.
print "Enter any name \n";
my $name=<STDIN>;
chomp($name);
until($name ne 'sai')
{
print "Enter any name \n";
$name=<STDIN>;
chomp($name);
}
Ausgang:
Geben Sie einen beliebigen Namen ein, sai
Perl do-bis:
„Do Until“ kann nur verwendet werden, wenn eine Bedingung falsch sein muss und diese mindestens einmal ausgeführt werden sollte.
print "Enter any name \n";
my $name=<STDIN>;
chomp($name);
do
{
print "Enter any name \n";
$name=<STDIN>;
chomp($name);
}until($name ne 'sai');
Ausgang:
Geben Sie einen beliebigen Namen ein, Howard
Geben Sie einen beliebigen Namen ein, Sheldon
Geben Sie einen beliebigen Namen ein, sai
Führen Sie die Beispielcodes „while“, „do-while“, „until“ und „do-until“ aus, um den Unterschied zu erkennen.
Perl OperaDo.
Was ist Operator?
OperaTore in der Computersprache geben eine Aktion an, die an einer Reihe von Variablen oder Werten ausgeführt werden kann, die der Computer verstehen kann. Perl hat die meisten davon integriert Operators aus der Sprache C. Perl hat im Vergleich zu anderen Programmiersprachen viele Operatoren. OperaTore werden als arithmetische, logische, relationale und Zuweisungsoperatoren kategorisiert.
Arithmetik OperaTore:
Arithmetische Operatoren sind solche, die verwendet werden können, um einige grundlegende mathematische Operationen auszuführen. Diese arithmetischen Operatoren sind binäre Operatoren, bei denen wir zwei Argumente benötigen, um eine grundlegende Operation auszuführen. Wir können auch unäre Operatoren für andere grundlegende Operationen verwenden; Sie können den Unterschied in den folgenden Beispielen sehen.
| OperaDo. | Beschreibung | Beispiel |
|---|---|---|
|
+ |
Additionsoperation zum Addieren zweier Werte oder Variablen Werte halten |
$x=5+6; # oder $y=6; $z=$x+$y; |
|
- |
Subtraktionsoperator zum Subtrahieren zweier Werte oder Variablen, die Werte enthalten |
$x=6-5; # oder $y=6; $z=$x-$y; |
|
* |
Multiplikationsoperator zum Multiplizieren zweier Werte oder Variablen mit Werten |
$x=6*5; # oder $y=6; $z=$x*$y; |
|
/ |
Divisionsoperator zum Dividieren zweier Werte oder Variablen, die Werte enthalten |
$x=36/6; # oder $y=6; $z=$x/$y; |
|
** |
Der Exponentialoperator wird verwendet, um den Exponenten bereitzustellen und den Wert abzurufen. Beispiel: 22 = 43 = 27 |
$x=5**5; # oder $x=4; $y=2; $z=$x**$y; |
|
% |
Modulo-Operator, der verwendet wird, um die Erinnerung bei der Division zweier Werte oder Variablen mit Werten zu erhalten |
$x=5%2; # oder $x=10; $y=2; $z=$x % $y; |
|
++ |
Unärer Additionsoperator zum Erhöhen des Wertes einer Variablen um 1 |
$x=5; $x++; Or ++$x; |
|
- |
Unärer Subtraktionsoperator zum Dekrementieren des Wertes einer Variablen um 1 |
$x=5; $x–; # Beitragsdekrement Or –$x;# vor der Dekrementierung |
Beispiel zum Abschließen aller oben genannten Vorgänge.
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");
Ausgang:
Die Addition von 10 und 2 ergibt 12
Sub von 10 und 2 ist 8
Mul von 10 und 2 ist 20
Div von 10 und 2 ist 5
Exp von 10 und 2 ist 100
Mod von 10 und 2 ist 0
Zuordnung OperaTore:
Zuweisungsoperatoren weisen Variablen einfach Werte zu. Dabei gibt es jedoch noch etwas, das wir beachten müssen: Zuweisungsoperatoren führen auch arithmetische Operationen aus und weisen den neuen Wert derselben Variablen zu, an der die Operation ausgeführt wird.
| OperaDo. | Beschreibung | Beispiel |
|---|---|---|
|
+= |
Additionsoperator zum Hinzufügen und Zuweisen des Wertes zur gleichen Variablen |
$x=4; $x+=10; |
|
-= |
Subtraktionsoperator zum Subtrahieren und Zuweisen des Wertes zur gleichen Variablen |
$x=4; $x-=10; |
|
*= |
Multiplikationsoperator zum Hinzufügen und Zuweisen des Wertes zur gleichen Variablen |
$x=4; $x*=10; |
|
/= |
Divisionsoperator zum Dividieren und Zuweisen des Wertes zur gleichen Variablen |
$x=4; $x/=10; |
|
**= |
Exponentialoperator zum Abrufen des Exponenten und Zuweisen des Werts zur gleichen Variablen |
$x=4; $x**=10; |
|
%= |
Modulo-Operator, der verwendet wird, um während der Division eine Erinnerung zu erhalten und den Wert derselben Variablen zuzuweisen |
$x=10; $x%=4; |
Beispiel zum Abschließen aller oben genannten Vorgänge.
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");
Ausgang:
Addieren = 15
Sub= 10
Mul = 50
Div = 10
Logisch und relational OperaTore:
Perl verwendet logische Operatoren zum Vergleichen von Zahlen und Zeichenfolgen. Meistens werden logische Operatoren in bedingten Anweisungen verwendet.
Logisch und relational Operatoren in Perl
| OperaDo. | Beschreibung |
|---|---|
|
==oder Gl |
OperaMit diesem Tor wird überprüft, ob beide Variablen gleich sind |
|
!=Oder ne |
OperaTor wird verwendet, um zu prüfen, ob beide Variablen nicht gleich sind |
|
> oder gt |
Operator verwendet, um zu überprüfen, ob A ist größer als B. |
|
<oder lt |
Operator verwendet, um zu überprüfen, ob A ist kleiner als B. |
|
>=oder ge |
Operator verwendet, um zu überprüfen, ob A ist größer oder gleich B |
|
<=oder le |
Operator verwendet, um zu überprüfen, ob A ist kleiner oder gleich B |
|
|| oder oder |
OperaTor wird verwendet, um zu überprüfen, ob A oder B den Wert halten |
|
&&oder und |
OperaTor, mit dem überprüft wird, ob sowohl A als auch B den Wert halten |
Nehmen wir ein Beispiel, an dem wir alle Szenarien erklären können.
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");
}
Ausgang:
Stimmt – gleich 5 und 5
Stimmt – nicht gleich 6 und 7
Stimmt – 7 größer als 6
Stimmt – 6 weniger als 7
Stimmt – 6 weniger als 7
Stimmt – 7 größer als 6
Beispiele für logische Operatoren finden Sie in späteren Abschnitten.
Spezielle Perl-Variablen
Was sind spezielle Perl-Variablen?
Spezielle Variablen in Perl sind solche, die eine vordefinierte Bedeutung haben. Diese Variablen werden entweder mit echten Namen oder Satzzeichen gekennzeichnet. Wir haben eine spezielle Variable für alle von Perl unterstützten Variablen wie skalare Spezialvariablen, Array-Spezialvariablen und Hash-Spezialvariablen. Die meisten der von uns verwendeten speziellen Variablen sind Skalare.
Wenn wir die spezielle Variable mit ihrem Namen verwenden möchten, müssen wir ein Perl-Modul „Use English“ laden, um dem Perl-Interpreter explizit mitzuteilen, dass wir spezielle Variablen mit ihrem Namen verwenden werden.
Skalare Spezialvariablen
| Variable | Beschreibung |
|---|---|
|
$_$ARG |
Dies ist die Standardvariable, die die aktuellen Werte speichert. |
|
$0 oder $PROGRAM_NAME |
Speichert den Dateinamen des Perl-Skripts. |
|
$/ |
Das Trennzeichen für den Eingabedatensatz hat den Standardwert „\n“, bei dem es sich um ein Zeilenumbruchzeichen handelt |
|
$. |
Enthält die aktuelle Zeilennummer der Datei, die gelesen wird |
|
$, |
Ausgabefeldtrennzeichen, wird hauptsächlich von der print()-Anweisung verwendet. Der Standardwert ist auf 0 gesetzt, wir können den Wert dieser Variablen ändern. |
|
$\ |
Ausgabedatensatztrennzeichen, der Wert dieser Variablen ist leer; Wir können diesem einen beliebigen Wert zuweisen, der von der print()-Anweisung beim Drucken der Ausgabe verwendet wird. |
|
$# |
Diese Variable wird beim Drucken von Zahlen für das Ausgabeformat verwendet. |
|
$%$FORMAT_PAGE_NUMBER |
Enthält die aktuelle Seitenzahl der gelesenen Datei. |
|
$=$FORMAT_LINES_PER_PAGE |
Hält die aktuelle Seitenlänge der gelesenen Datei. |
|
$-$FORMAT_LINES_LEFT |
Enthält den Wert der Anzahl der Zeilen, die auf der Seite noch gedruckt werden müssen. |
|
$~$FORMAT_NAME |
Formatname: Enthält das Format der aktuell ausgewählten Ausgabe, standardmäßig den Datei-Handle-Namen. |
|
$^$FORMAT_TOP_NAME |
Enthält den Wert des Überschriftenformats des Dateihandlers. Der Standardwert ist _TOP, gefolgt vom Namen des Dateihandles. |
|
$|$OUTPUT_AUTOFLUSH |
Der Standardwert ist Null; dies wird verwendet, um den Ausgabepuffer nach jedem write() oder print() zu leeren. |
|
$$ |
Enthält die laufende Prozessnummer des Perl-Interpreters. |
|
$? |
Statuscode: Pipe und Systemaufruf. Der Rückgabestatus des ausgeführten Befehls. |
|
$&$MATCH |
Wird in regulären Ausdrücken verwendet und enthält eine Zeichenfolge des letzten erfolgreichen Mustervergleichs. |
|
$`$VORSPIEL |
Wird in regulären Ausdrücken verwendet und enthält eine Zeichenfolge, der die letzte erfolgreiche Musterübereinstimmung vorangestellt ist. |
|
$'$POSTMATCH |
In regulären Ausdrücken verwendet, enthält dies eine Zeichenfolge, gefolgt von der letzten erfolgreichen Musterübereinstimmung. |
|
$+$LAST_PAREN_MATCH |
Enthält die Zeichenfolge der letzten Klammer, die bei der letzten Mustersuche gefunden wurde. |
|
$ |
1 $, 2 $, 3 $ …. Enthält die Werte des übereinstimmenden Musters der Reihe nach. |
|
$[ |
Erster Index: Array, ein Teilstring. |
|
$] |
Eine Version von Perl. |
|
$“ |
Das für Listenelemente verwendete Trennzeichen ist standardmäßig ein Leerzeichen. |
|
$; |
Indextrennzeichen, das in mehrdimensionalen Arrays verwendet wird |
|
$! |
Im numerischen Kontext wird die Fehlernummer gedruckt. Geben Sie den Fehler im Zeichenfolgenkontext aus. |
|
$@ |
Enthält die Syntaxfehlerinformationen, die verwendet werden, wenn eval() verwendet wird. |
|
$< |
Enthält die tatsächliche UID (Benutzer-ID) des Prozesses, der das Skript ausführt. |
|
$> |
Enthält die effektive UID des Prozesses, der das Skript ausführt. |
|
$( |
Enthält die tatsächliche GID (Gruppen-ID) des Prozesses, der das Skript ausführt. |
|
$) |
Enthält die effektive GID des Prozesses, der das Skript ausführt. |
|
$^D$DEBUGGING |
Enthält den aktuellen Wert der Debugging-Flags. |
|
$^C |
Hält den aktuellen Wert des Flags, wenn der Befehlszeilenschalter –c verwendet wird. |
|
$^F |
Der maximale Systemdateideskriptor ist standardmäßig auf 2 eingestellt |
|
$^I$INPLACE_EDIT |
Enthält den Wert des Befehlszeilenschalters –i. |
|
$^M |
Ein spezieller Speicherpool kann verwendet werden, wenn das Perl-Skript aufgrund eines Speichermangelfehlers abstürzt. |
|
$^O$OSNAME |
OperaDie Systeminformationen werden gespeichert. „Linux“ für Linux-Systeme, „mswin32“ für Windows Systemen. |
|
$^T$BASISZEIT |
Die Zeit, in der die Skripte ausgeführt werden, in Sekunden. |
|
$^W$WARNUNG |
Der aktuelle Wert des Befehlszeilenschalters –w. Warnschalter. |
|
$ARGV |
Name der aktuellen Datei, wenn <> verwendet wird. |
Spezielle Array-Variablen:
| Variable | Beschreibung |
|---|---|
|
@INK |
Enthält eine Liste von Pfaden, in denen Perl-Bibliotheksmodule oder -Skripte durchsucht werden können, während das aktuelle Skript ausgeführt wird. Dieses @INC wird von use- und require-Anweisungen verwendet, um diese Pfade nach Bibliotheksmodulen zu durchsuchen. |
|
@ARGV |
Speichert die übergebenen Befehlszeilenargumente. |
|
@_ |
Wird in Unterprogrammen verwendet, während die Parameter an die Unterprogramme übergeben werden. |
|
@F |
Dies ist das Array, in dem die Eingabezeilen gespeichert werden, wenn Auto Split –a (Befehlszeilenschalter verwendet wird). |
Spezielle Hash-Variablen:
| Variable | Beschreibung |
|---|---|
|
%INKL |
Der Dateiname wird der Schlüssel sein; Werte sind der Pfad zu diesen Dateien. Wird von do, use und require verwendet. |
|
%ENV |
Systemumgebungsvariablen. |
|
%SIG |
Signals-Handler. |
Regulärer Perl-Ausdruck
Was ist ein regulärer Ausdruck?
Der reguläre Ausdruck in Perl ist stark genug, um die Zeichenfolgenmuster innerhalb einer Anweisung oder einer Gruppe von Anweisungen abzugleichen. Reguläre Ausdrücke werden hauptsächlich bei der Textanalyse, beim Musterabgleich und je nach Bedarf bei vielem mehr verwendet. Wir haben bestimmte Operatoren, die speziell bei der Musterbindung regulärer Ausdrücke verwendet werden: =~ und !~. Dies sind Test- und Zuweisungsoperatoren.
Regulärer Ausdruck Operatoren
Regulärer Ausdruck Operatoren in Perl
- Perl-Match – m//
- Perl-Ersatz – s///
- Perl Transliterate – tr///
Bevor wir fortfahren, müssen wir einige Dinge über reguläre Ausdrücke wissen; Es gibt bestimmte Dinge wie Metazeichen und Platzhalter in der Perl-Regex-Syntax.
| Saibling | Bedeutung |
|---|---|
|
\ |
Sonderangebot oder Angebot |
|
* |
Entspricht 0 oder mehr Zeichen |
|
+ |
Entspricht 1 oder mehr Zeichen |
|
? |
Entspricht 0 oder 1 Zeichen |
|
| |
Kann zum Anpassen alternativer Muster verwendet werden |
|
() |
Wird zum Speichern des übereinstimmenden Musters verwendet |
|
[] |
Es können Zeichensätze übergeben werden. Wird speziell für Zahlen und Alphabete verwendet. |
|
{} |
Wird verwendet, um anzugeben, wie oft das Spiel durchgeführt werden kann. |
|
^ |
Anfang der Zeichenfolge |
|
$ |
Ende der Zeichenfolge |
|
\w |
Wird verwendet, um ein einzelnes Zeichen oder Wort abzugleichen, das alphanumerisch sein kann, einschließlich „_“. |
|
\W |
Entspricht etwas anderem als alphanumerischem Wert |
|
\s |
Wird zum Abgleichen von Leerzeichen verwendet |
|
\S |
Passen Sie alles andere als Leerzeichen an |
|
\d |
Zahlen abgleichen. Keine Dezimalwerte und keine negativen Werte |
|
\D |
Findet Übereinstimmungen mit allem außer Zahlen. |
|
\t |
Passen Sie den Tabulatorraum an |
|
\n |
Neue Zeile anpassen |
Die oben genannten Zeichen sind die Zeichensätze, die beim Mustervergleich verwendet werden können.
Sehen wir uns einige Beispiele an.
Stellen Sie sich eine Situation vor, in der der Benutzer während der Skriptausführung eine Eingabe macht und wir prüfen möchten, ob der Benutzer einen Namen als Eingabe eingegeben hat oder nicht. Wir müssen eine reguläre Ausdruckssyntax schreiben, um Ihren Namen zu extrahieren und ihn auszugeben.
my $userinput="Guru99 Rocks";
if($userinput=~m/.*(Guru99).*/)
{
print "Found Pattern";
}
else
{
print "unable to find the pattern";
}
Ausgang:
Gefundenes Muster
Hier haben wir den regulären Ausdruck als /.*(Guru99).*/.* geschrieben, der mit allen Zeichen in einer Zeichenfolge übereinstimmt. A '.' In Perl bezieht sich die Regex-Übereinstimmung auf jedes Zeichen, einschließlich Leerzeichen.
Lassen Sie uns sehen, wie genau wir einen Regex erstellen können.
Betrachten Sie ein Beispiel für eine Zeichenfolge aus mehreren Wörtern, Ziffern und Sonderzeichen wie „Hallo zusammen, das ist meine Nummer: +91-99298373639“;
Regex: /^\w+\s\w+\s\w+\s\w+\s\w+\s\w+\:\+\d+\-\d+/i
Wortraum Wortraum Wortraum Wortraum Wortraum Wortraum Sonderzeichen: Leerzeichen Sonderzeichen + Ziffern Sonderzeichen – Ziffern.
Perl-Match Operatoren
Die Übereinstimmungsoperatoren werden verwendet, um eine Zeichenfolge innerhalb einer Anweisung oder einer Variablen abzugleichen.
my $var="Hello this is perl";
if($var=~m/perl/)
{
print "true";
}
else
{
print "False";
}
Ausgang:
was immer dies auch sein sollte.
Dieser kleine Code gibt „true“ aus, da die Perl-Musterübereinstimmung die Zeichenfolge in einer Variablen identifiziert. Grundsätzlich sucht Perl in der gesamten Zeichenfolge nach dem in // angegebenen Text. Selbst wenn es ihn an einer Stelle findet, gibt es „true“ zurück. Das Muster kann überall in der Variablen vorkommen. Wir können versuchen, =~ durch !~ zu ersetzen, um den Unterschied zwischen diesen beiden Operatoren zu sehen.
Perl-Ersetzung OperaDo.
Dieser Operator kann zum Suchen und Ersetzen beliebiger Zeichen durch Null oder ein anderes Zeichen verwendet werden.
my $a="Hello how are you"; $a=~s/hello/cello/gi; print $a;
Ausgang:
Cello, wie geht es dir?
Hinweis: Wir können tatsächlich jede beliebige Mustervergleichszeichenfolge verwenden, wie wir es auch zuvor in diesem Substitutionsoperator getan haben. Hier haben wir „gi“, g-global und i-Groß-/Kleinschreibung ignorieren verwendet.
Perl-Übersetzung OperaDo.
Dies ähnelt der Substitution, verwendet jedoch keine regulären Perl-Ausdrücke, sondern wir können den Wert oder ein Wort, das wir ersetzen möchten, direkt übergeben.
my $a="Hello how are you"; $a=~tr/hello/cello/; print $a;
Ausgang:
Hallo Kuh, bist du?
Perl-Datei-I/O
Perl wurde für die effektive Bearbeitung von Dateien und E/A-Vorgängen entwickelt. Der Hauptvorteil von Perl liegt in der Dateianalyse und -verarbeitung. Bei der Dateiverarbeitung in Perl werden viele integrierte Funktionen und Operatoren verwendet.
Dateioperationen, die mit Perl ausgeführt werden, werden grundsätzlich mit FILEHANDLE durchgeführt. Wir müssen diesen FILEHANDLE beim Öffnen einer Datei zum Lesen oder Schreiben definieren.
In diesem Perl-Skript-Tutorial lernen Sie-
Perl-Datei öffnen
Wir können eine Datei mit der in Perl verfügbaren Funktion open() öffnen.
open(FILEHANDLE, "filename or complete path of the file");
Jetzt haben wir eine Datei geöffnet, nun stellt sich eine Frage. Ist es zum Lesen oder Schreiben?
Perl-Lesedatei und Perl-Schreibdatei
Perl verfügt über bestimmte Modi, die zum Lesen, Schreiben oder Anhängen einer Datei verwendet werden müssen.
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");
Einige Beispiele zum Lesen einer Datei:
Stellen Sie sich vor, wir haben eine Perl-Datei mit dem Namen file.txt, die nur wenige Textzeilen enthält. Wir müssen diese Datei öffnen und ausdrucken.
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;
Dadurch wird der Dateiinhalt auf dem Ausgabebildschirm gedruckt.
Jetzt schreiben wir ein Programm zum Erstellen und Schreiben von Daten in eine Perl-Datei.
open(FH,">test.txt"); my $var=<>; print FH $var; close FH;
Dadurch werden die zur Laufzeit bereitgestellten Eingaben geschrieben und eine Datei test.txt erstellt, die Eingaben enthält.
Bei der oben beschriebenen Methode wird immer versucht, eine Datei mit dem Namen test.txt zu erstellen und die Eingabe in die Datei zu schreiben. Wir werden dasselbe schreiben, um die Datei anzuhängen.
open(FH,">>test.txt"); my $var=<>; print FH $var; close FH;
| Modi | Beschreibung |
|---|---|
|
< |
Lesen Sie mehr |
|
+< |
Liest und schreibt |
|
> |
Erstellt, schreibt und schneidet ab |
|
+> |
Lesen, schreiben, erstellen und abschneiden |
|
>> |
Schreibt, hängt an und erstellt |
|
+>> |
Lesen, schreiben, anhängen und erstellen |
Jetzt müssen wir anhand einfacher Beispiele sehen, wie man Dateien liest, schreibt und anhängt.
Wir werden noch einige weitere Beispiele und andere Funktionen sehen, die zum besseren Verständnis von Dateien beitragen.
Perl Tell
Diese Methode gibt die aktuelle Position von FILEHANDLER in Bytes zurück, wenn sie angegeben wird. Andernfalls wird die letzte Zeile als Position betrachtet.
open(FH, "test.pl");
while(<FH>)
{
$a=tell FH;
print "$a";
}
Perl-Suche
Die Seek-Funktion ähnelt dem fseek-Systemaufruf. Diese Methode wird verwendet, um den Dateizeiger an einer bestimmten Stelle zu positionieren, indem die Bytes angegeben werden, denen entweder der Anfang des Dateizeigers oder das Ende des Dateizeigers folgt.
seek FH, bytes, WHENCE;
WHENCE ist die Position des Dateizeigers zum Starten. Null setzt es vom Anfang der Datei an.
Beispiel: Input.txt enthält einige Daten wie „Hallo, das ist meine Welt.“
open FH, '+<','input.txt'; seek FH, 5, 0; # This will start reading data after 5 bytes. $/ = undef; $out = <FH>; print $out; close FH;
Ausgang:
das ist meine Welt
Perl-Link aufheben
Mit Unlink wird die Datei gelöscht.
unlink("filename or complete file path");
Umgang mit Verzeichnissen:
Wir können auch Verzeichnisse verwalten, über die wir mehrere Dateien verwalten können.
Mal sehen, wie man ein Verzeichnis öffnet. Wir können die Methoden opendir und readdir verwenden.
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);
Dadurch werden alle verfügbaren Dateien in diesem Verzeichnis gedruckt.
Perl-Dateitests und ihre Bedeutung
|
-r |
So prüfen Sie, ob die Datei/das Verzeichnis für den aktuellen Benutzer/die aktuelle Gruppe lesbar ist |
|
-w |
Um zu überprüfen, ob die Datei/das Verzeichnis vom aktuellen Benutzer/der aktuellen Gruppe beschreibbar ist |
|
-x |
Um zu überprüfen, ob die Datei/das Verzeichnis vom aktuellen Benutzer/der aktuellen Gruppe ausführbar ist |
|
-o |
Um zu überprüfen, ob die Datei/das Verzeichnis dem aktuellen Benutzer gehört |
|
-R |
Um zu prüfen, ob die Datei/das Verzeichnis von diesem realen Benutzer/dieser realen Gruppe gelesen werden kann |
|
-W |
Um zu überprüfen, ob die Datei/das Verzeichnis von diesem echten Benutzer/dieser echten Gruppe beschreibbar ist |
|
-X |
Um zu überprüfen, ob die Datei/das Verzeichnis von diesem echten Benutzer/dieser echten Gruppe ausgeführt werden kann |
|
-O |
Um zu überprüfen, ob die Datei/das Verzeichnis diesem echten Benutzer gehört |
|
-e |
Um zu überprüfen, ob der Datei-/Verzeichnisname vorhanden ist |
|
-z |
Um zu überprüfen, ob die Datei vorhanden ist und die Größe Null hat (bei Verzeichnissen immer „false“) |
|
-f |
Um zu überprüfen, ob Entry eine einfache Datei ist |
|
-d |
Um zu überprüfen, ob Eintrag ein Verzeichnis ist |
|
-l |
Um zu prüfen, ob der Eintrag ein symbolischer Link ist |
|
-S |
Um zu überprüfen, ob Entry ein Socket ist |
|
-p |
Um zu überprüfen, ob Entry eine Named Pipe (ein „FIFO“) ist |
|
-b |
Um zu überprüfen, ob Entry eine Block-Spezialdatei ist (z. B. eine bereitstellbare Festplatte) |
|
-c |
So überprüfen Sie, ob Entry eine spezielle Zeichendatei ist (wie ein E/A-Gerät) |
|
-u |
Um zu überprüfen, ob die Datei oder das Verzeichnis setuid ist |
|
-g |
Um zu überprüfen, ob die Datei oder das Verzeichnis setgid ist |
|
-k |
Um zu überprüfen, ob in der Datei oder im Verzeichnis das Sticky-Bit gesetzt ist |
|
-t |
Das angegebene Dateihandle ist ein TTY (wie bei der Systemfunktion isatty() können Dateinamen mit diesem Test nicht getestet werden) |
|
-T |
Um zu überprüfen, ob die Datei wie eine „Text“-Datei aussieht |
|
-B |
Um zu überprüfen, ob die Datei wie eine „Binärdatei“ aussieht |
|
-M |
Zur Überprüfung des Änderungsalters (gemessen in Tagen) der Datei |
|
-A |
Zur Überprüfung des Zugriffsalters (gemessen in Tagen) der Datei |
|
-C |
Zur Überprüfung des Inode-Änderungsalters (gemessen in Tagen) der Datei |
Perl-Subroutine
Was ist ein Unterprogramm?
Unterprogramme ähneln Funktionen in anderen Programmiersprachen. Wir haben bereits einige integrierte Funktionen wie Print, Chomp, Chop usw. verwendet. Wir können unsere eigenen Unterroutinen in Perl schreiben. Diese Unterprogramme können an einer beliebigen Stelle im Programm geschrieben werden; Es ist vorzuziehen, die Unterprogramme entweder am Anfang oder am Ende des Codes zu platzieren.
Beispiel für Unterprogramme
sub subroutine_name
{
Statements…; # this is how typical subroutines look like.
}
Nachdem wir nun wissen, wie man eine Unterroutine schreibt, wie greifen wir darauf zu?
Wir müssen auf eine Unterroutine zugreifen oder diese aufrufen, indem wir den Namen der Unterroutine mit dem Präfix „&“ verwenden.
sub display
{
print "this is a subroutine";
}
display(); # This is how we call a subroutine
Übergabe von Perl-Parametern und Perl-Argumenten
Unterprogramme oder Perl-Funktionen werden geschrieben, um den wiederverwendbaren Code darin zu platzieren. Der größte Teil des wiederverwendbaren Codes erfordert die Übergabe von Parametern an die Unterroutine. Hier erfahren wir, wie wir Argumente an die Unterroutine übergeben können.
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.
Ausgang:
3 ist der übergebene Wert
@_ ist eine spezielle Array-Variable, die die an die Unterroutinen übergebenen Argumente speichert.
Perl Shift
Wir können auch das Schlüsselwort „shift“ verwenden, das jeweils einen Parameter in eine Variable verschiebt, oder $_[0],$_[1]…, was ein einzelnes Element des @_-Arrays ist
sub display
{
my $var=shift;
print "$var is passed";
}
display("hello");
Ausgang:
hallo ist bestanden
Unterroutinen werden typischerweise in der objektorientierten Programmierung und auch an Stellen verwendet, an denen möglicherweise mehr wiederverwendbarer Code platziert werden muss.
Die Hauptfunktion von Unterprogrammen besteht darin, eine Aufgabe auszuführen und das Ergebnis des wiederverwendbaren Codes zurückzugeben.
Mit dem Schlüsselwort return können wir einen Wert aus einer Unterroutine zurückgeben.
sub add
{
my $a=shift;
my $b=shift;
return($a+$b);
}
my $result=add(5,6);
print $result;
Ausgang:
11
$result enthält den Wert der addierten Werte $a und $b.
Wir können Hashes und Arrays auch direkt an die Unterroutine übergeben.
sub hash
{
my %hash=@_;
print %hash;
}
%value= ( 1=>'a', 2=>'b');
&hash(%value);
Ausgang:
1a2b
Wir können auch einen Hash oder ein Array zurückgeben.
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;
Ausgang:
Innerhalb der Subroutine2b1aNach dem Aufruf der Subroutine2b1a
Perl-Format
Perl verfügt über einen Mechanismus, mit dem wir Berichte erstellen können. Mit dieser Funktion können wir Berichte genau nach Wunsch erstellen und auf dem Ausgabebildschirm oder in einer Datei ausdrucken. Ein einfaches Format kann mit den in Perl verfügbaren Funktionen printf oder sprintf geschrieben werden.
printf "%05d\n", 30;
Dabei werden vor der Zahl 30 führende Nullen eingefügt, sodass die Gesamtzahl der Ziffern 5 beträgt. Dasselbe kann für sprintf verwendet werden.
sprintf "%05d\n", 30; # This will print the same as printf.
Mit printf und sprintf können wir die meisten Perl-Formate erhalten. Bei Berichten wird die Implementierung schwierig sein.
================================================== ============================
Name Adresse Alter Telefon
================================================== ============================
Krishna Chennai 24 929309242
Shruthi Chennai 24 929309232
Oben ist ein Beispielbericht, den wir in Perl auf die gleiche Weise drucken müssen. Dies kann durch die Verwendung von Perl printf und Perl sprintf erreicht werden. Es kann effektiv durch die Verwendung von format implementiert werden.
Ein Format kann auf die folgende Weise deklariert werden.
format FORMATNAME=FORMATLIST.
Hier verwenden wir eine bestimmte Schreibmethode, um die Daten auf dem Ausgabebildschirm oder in der Datei zu drucken.
| Symbol | Beschreibung |
|---|---|
|
@ |
Wird verwendet, um den Beginn des Feldhalters darzustellen |
|
> |
Richtige Ausrichtung des Textes |
|
< |
Linksausrichtung des Textes |
|
| |
Zentrierung |
|
# |
Numerisch, wenn mehrere # angegeben werden. Wird als Kommentar angenommen, wenn ein einzelnes # angegeben wird |
|
. |
Komma |
|
^ |
Der Feldanfangshalter kann auch für mehrzeilige Zeilen und auch für den Zeilenumbruch verwendet werden |
|
~ |
Die Zeile sollte leer sein, wenn die Variable leer ist |
|
@* |
Mehrere Zeilen. |
($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
.
Führen Sie den Code aus, um die Ausgabe anzuzeigen.
Wir verwenden das @-Symbol, um den Anfang des Feldhalters oder der Zeichenfolge anzugeben, „<“ jedes Zeichen.
Wir verwenden STDOUT zum Drucken auf der Standardausgabe. Wir können dies in einen Dateihandler ändern, den wir zum Schreiben von Daten in die Datei verwenden.
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
Wir können „<“ durch „>“ oder „|“ ersetzen. um die Ausrichtung des Textes zu ändern. STDOUT_TOP wird verwendet, um den Header des Formats zu entwerfen. Wir können dasselbe auch mit dem Dateihandler verwenden, indem wir FH_TOP verwenden (FH ist der Dateihandler). Dadurch wird das Format in die Datei ausgegeben, an der wir arbeiten An.
Perl-Codierungsstandards
Jeder Programmierer hat seine eigene Vorstellung davon, wie er den Code unter Verwendung bestimmter Standards schreibt. Diese Standards sollten so vertraut sein, dass andere Programmierer den Code verstehen und richtig unterstützen können.
Codierungsstandards in Perl
Das Schreiben von Code ist einfach und unkompliziert. Das Problem entsteht, wenn er in späteren Phasen gewartet werden muss. Beim Schreiben des Codes müssen die richtigen Richtlinien und Codierungsstandards befolgt werden. Perl definiert auch bestimmte Standards, die für Programmierer beim Schreiben von Code hilfreich sind. Es ist ratsam, beim Schreiben des Codes die Module „Strict“ und „Warnings“ zu laden. Jedes dieser Module hat seine eigene Bedeutung. Strict lässt uns die Variable vor der Verwendung deklarieren und sagt uns auch, ob in Ihrem Code ein leeres Wort vorhanden ist. Das Warnings-Modul kann alternativ verwendet werden, indem die Option „-w“ an den Perl-Interpreter in Shebang übergeben wird. Warnungen werden auf dem Ausgabebildschirm gedruckt.
#!/usr/bin/perl –w
Nachfolgend finden Sie einige Listen mit Standards.
- Verwenden Sie die Module „streng“ und „Warnungen“.
- Entfernen Sie die Variable, die nicht verwendet wird.
- Variablennamen sollten für andere Benutzer verständlich sein. Beispiel: $name, @fileData usw.
- Beim Codieren eines Skripts ist eine Dokumentation erforderlich.
- Codieren Sie keine Werte fest, sondern versuchen Sie, diese dynamisch abzurufen oder den Benutzer während der Laufzeit zur Eingabe aufzufordern (Dateipfad, Dateinamen).
- Maximieren Sie die Wiederverwendung von Code. Versuchen Sie, den wiederverwendbaren Code in Unterroutinen einzufügen.
- Das bedeutet, dass für Unterprogramme vollständige Namen angegeben werden sollten.
- Unterprogramme müssen mit entsprechenden Kommentaren und Dokumentation geschrieben werden.
- Variablen immer initialisieren.
- Überprüfen Sie immer die Rückkehrcodes für Systemaufrufe. Das Öffnen einer Datei kann erfolgen oder auch nicht. Wenn hier ein Rückkehrcode vorhanden ist, wird der Fehlerstatus angezeigt, wenn die Datei nicht vorhanden ist.
Beispiel: open(FH,
- Unterroutine sollte immer einen Wert zurückgeben.
- Öffnen Sie die Locken in derselben Linie.
- Einzeiliger BLOCK kann mit Curly in einer einzigen Zeile platziert werden.
- Verwenden Sie Beschriftungen während der LOOPS, damit Sie die Schleife jederzeit verlassen können, wenn dies erforderlich ist.
- Verwenden Sie Unterstriche, wenn lange Wortphrasen als Variablennamen oder Unterprogramme geschrieben werden.
- Versuchen Sie, beim Codieren einfachen regulären Ausdruck zu verwenden.
Perfektes Beispiel mit Codierungsstandards:
#######################################################################
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-Fehlerbehandlung
Was ist eine Ausnahme?
Eine Ausnahme ist ein Ereignis, das während der Programmausführung auftritt und Ihr Programm anhält oder beendet.
Fehlerbehandlung
Jeder Programmierer muss beim Programmieren auf die Fehlerbehandlung achten. Perl bietet auch Fehlerbehandlungstechniken, mit denen wir den Fehler abfangen und entsprechend behandeln können.
Fehlerbehandlung in Perl
Es gibt viele Möglichkeiten, das Programm auf Fehler zu überprüfen. Wir müssen die Rückkehrcodes der Funktion untersuchen, deren Code wir verwenden. Wenn wir in der Lage sind, diese Rückkehrcodes ordnungsgemäß zu verarbeiten, können die meisten Fehler behandelt werden.
Was wird bei Systemaufrufen zurückgegeben?
Bei Systemaufrufen wird der Rückgabestatus in zwei speziellen Variablen gespeichert: $? Und $!
$! – Dadurch wird die mit der Fehlermeldung verknüpfte Fehlernummer oder Fehlernummer erfasst.
$? – Hier wird die Funktion „Rückgabestatus system()“ gespeichert.
Perl-Operator oder Logical verwenden
Wir können den logischen „Oder“-Operator zur Fehlerbehandlung bei Systemaufrufen verwenden.
Ex:
open(FH,"<test.txt");
Dadurch wird die Datei im Lesemodus geöffnet, sofern die Datei vorhanden ist.
Was passiert, wenn die Datei fehlt?
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-Evaluierung
Die Eval-Funktion kann schwerwiegende Fehler, Fehler bei der Kompilierung, Laufzeitfehler und solche Fehler behandeln, die Ihren Code irgendwann beenden.
Die Perl-Eval-Funktion kann einen Codeblock oder einen Ausdruck enthalten. Evals betrachtet alles, was darin platziert wird, als Zeichenfolge.
Stellen Sie sich eine Situation vor, in der ein Unterprogramm aufgerufen wird, das nicht im Skript definiert ist. In dieser Situation endet das Skript mit der Meldung „undefinierte Unterroutine &XYZ, dieser Fehler kann in der Auswertungsfunktion behandelt werden.“
Es gibt viele Verwendungsmöglichkeiten für den Evals-Blöck. Eine solche Verwendung besteht beispielsweise darin, dass wir während der Laufzeit das betriebssystemspezifische Modul laden möchten.
Beispiel: Eine Division durch Null führt zu einem schwerwiegenden Fehler. Um dies zu handhaben, können wir den Code im Evals-Block platzieren.
$a=5;
$b=0;
eval
{
'$result=$a/$b';
}
if($@)
{
print "$@"; # All the error codes returned by evals will get stored in $@.
}
Ausgang:
Syntaxfehler in C:\Users\XYZ\Text.pl Zeile 8, in der Nähe von „)
{“
Die Ausführung von C:\Users\XYZ\Text.pl wurde aufgrund von Kompilierungsfehlern abgebrochen.
Beispiel: Auswertung mit der Perl-Anweisung „Die“.
sub test
{
die "Dieing in sub test \n";
}
eval
{
test();
};
print "Caught : $@\n";
Ausgang:
Gefangen: Im Untertest gestorben
Versuchen Sie es mit Perl
Perl unterstützt Try-, Catch- und Finally-Codeblöcke nicht wie andere Programmiersprachen. Wir können sie weiterhin verwenden, indem wir ein externes Perl-Modul laden.
verwenden Sie Try::Tiny;
Auf diese Weise können wir Ihren Code im Try-Block platzieren und den Fehler im Warnblock abfangen.
Anstelle von $@, das in eval verwendet wird, verwendet Try::Tiny $_.
# Fehler mit einem Catch-Handler behandeln
try
{
die "Die now";
}
catch
{
warn "caught error: $_"; # not $@
};
Endlich verwenden.
my $y;
try
{
die 'foo'
}
finally
{
$y = 'bar'
};
try
{
die 'Die now'
}
catch
{
warn "Returned from die: $_"
}
finally
{
$y = 'gone'
};
Ausgang:
foo unter C:\Users\XYZ\Text.pl Zeile 4.
Auf diese Weise können wir „try“, „catch“ und „finally“ verwenden.
Versuchen Sie es mit { # Anweisung }
Catch {# Anweisung }
schließlich { # Anweisung };
Or
try
{
# statement
}
finally
{
# statement
};
Ausgang:
Or
try
{
# statement
}
finally
{
# statement
}
catch
{
# statement
};
Ausgang:
Perl-Socket-Programmierung
Was ist eine Steckdose?
Der Socket ist ein Medium, über das zwei Computer in einem Netzwerk interagieren können, indem sie Netzwerkadressen und Ports verwenden.
Angenommen, A (Server) und B (Client) sind zwei Systeme, die über Sockets zum Ausführen einiger Programme miteinander interagieren müssen.
Um dies zu implementieren, müssen wir Sockets sowohl in A (Server) als auch in B (Client) erstellen. A befindet sich im Empfangsstatus und B im Sendestatus.
Ein Server):
Hier möchte der Server eine Verbindung von B (Client) empfangen, einige Aufgaben ausführen und das Ergebnis an B (Client) zurücksenden. Wenn wir den Code ausführen, versucht das Betriebssystem in A, einen Socket zu erstellen und bindet einen Port an diesen Socket. Dann lauscht es vom Absender, also B.
B (Kunde).
Hier möchte der Client ein Programm von seinem System zur Verarbeitung an A (Server) senden. Wenn wir den Code ausführen, versucht das Betriebssystem in B, einen Socket für die Kommunikation mit A (Server) zu erstellen. B muss die IP-Adresse und die Portnummer von A angeben, mit dem B eine Verbindung herstellen möchte.
Wenn dies gut verläuft, werden beide Systeme interagieren, um die Informationen über einen Port auszutauschen. Perl unterstützt auch Socket-Programmierung.
Perl verfügt über eine native API, über die Sockets implementiert werden können. Der Einfachheit halber gibt es viele CPAN-Module, mit denen wir Socket-Programme schreiben.
Serverbetrieb:
- Socket erstellen
- Binden Sie den Socket mit Adresse und Port
- Hören Sie auf den Socket an dieser Portadresse
- Akzeptieren Sie die Client-Verbindungen, die versuchen, eine Verbindung über den Port und die IP des Servers herzustellen
- Vorgänge ausführen
Kunden Operanationen:
- Socket erstellen
- Stellen Sie über seine Portadresse eine Verbindung zum Server her
- Vorgänge ausführen
socket.io
Dies ist ein Modul für die Socket-Programmierung, das auf objektorientierter Programmierung basiert. Dieses Modul unterstützt nicht den in Netzwerken verwendeten INET-Netzwerktyp.
IO::Socket::INET:
Dieses Modul unterstützt die INET-Domäne und basiert auf IO::Sockets. Alle in IO::Sockets verfügbaren Methoden werden im INET-Modul geerbt.
Client und Server verwenden das TCP-Protokoll:
TCP ist ein verbindungsorientiertes Protokoll; Wir werden dieses Protokoll für die Socket-Programmierung verwenden.
Bevor wir fortfahren, sehen wir uns an, wie wir ein Objekt für das Modul IO::Socket::INET und einen Socket erstellen können.
$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";
Die neue Methode im Modul IO::Socket::INET akzeptiert einen Hash als Eingabeparameter für die Unterroutine. Dieser Hash ist vordefiniert und wir müssen lediglich die Werte für die Schlüssel bereitstellen, die wir verwenden möchten. Es gibt eine Liste der von diesem Hash verwendeten Schlüssel.
|
PeerAddr |
Remote-Hostadresse |
|
PeerHost |
Synonym für PeerAddr |
|
PeerPort |
Remote-Port oder -Dienst |
|
LocalAddr |
Bindungsadresse des lokalen Hosts |
|
Localhost |
Synonym für LocalAddr |
|
LocalPort |
Lokaler Host-Bind-Port |
|
Proto |
Protokollname (oder Nummer) |
|
Typ |
Einfaßungsart |
|
Zuhören |
Warteschlangengröße zum Abhören |
|
ReuseAddr |
Legen Sie SO_REUSEADDR vor der Bindung fest |
|
Wiederverwendung: |
Legen Sie SO_REUSEADDR vor der Bindung fest |
|
ReusePort |
Legen Sie SO_REUSEPORT vor dem Binden fest |
|
Sendung |
Legen Sie SO_BROADCAST vor der Bindung fest |
|
Timeout |
Timeout-Wert für verschiedene Vorgänge |
|
MultiHomed |
Probieren Sie alle Adressen für mehrfach vernetzte Hosts aus |
|
Blockierung |
Bestimmen Sie, ob sich die Verbindung im Blockierungsmodus befindet |
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);
Client.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);
Hinweis:
Bei der Socket-Programmierung müssen wir zuerst Server.pl und dann client.pl einzeln in verschiedenen Eingabeaufforderungen ausführen, wenn wir auf einem lokalen Host arbeiten.
Was sind Perl-Module und -Pakete?
Module und Pakete sind eng miteinander verbunden und unabhängig. Paket: Ein Perl-Paket wird auch als Namespace bezeichnet und enthält alle verwendeten eindeutigen Variablen wie Hashes, Arrays, Skalare und Unterroutinen. Modul: Modul ist eine Sammlung wiederverwendbaren Codes, in den wir Unterroutinen schreiben. Diese Module können in Perl-Programme geladen werden, um die in diesen Modulen geschriebenen Unterroutinen zu nutzen.
Was sind Perl-Module?
Standardmodule werden bei der Installation von Perl auf jedem System installiert. CPAN: Umfassendes Perl Archive Network – Ein globales Repository von Perl-Modulen. Unsere eigenen maßgeschneiderten Perl-Module, die von uns geschrieben werden können. Grundsätzlich exportiert ein Modul, wenn es in ein beliebiges Skript geladen wird, alle seine globalen Variablen und Unterroutinen. Diese Unterprogramme können direkt aufgerufen werden, als ob sie im Skript selbst deklariert wären. Perl-Module können mit der Erweiterung .pm des Dateinamens geschrieben werden, z. B. Foo.pm. Ein Modul kann geschrieben werden, indem man „package Foo“ am Anfang des Programms verwendet.
Grundlegendes Perl-Modul:
#!/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;
Keine Leistung
Um dieses Perl-Modul verwenden zu können, müssen wir es im aktuellen Arbeitsverzeichnis ablegen.
Wir können ein Perl-Modul mit „require“ oder „use“ an einer beliebigen Stelle im Code laden. Der Hauptunterschied zwischen „require“ und „use“ besteht darin, dass das geladene Modul zur Laufzeit erforderlich ist und das Laden während der Kompilierungszeit verwendet wird.
#!/usr/bin/perl require Arithmetic; print Arithmetic::add(5,6); print Arithmetic:: subtract (5,6);
Hier, im obigen Beispiel, greifen wir über den vollständig qualifizierten Modulnamen auf die Unterroutinen zu.
Wir können auch über „use Arithmetic“ auf das Paket zugreifen.
Exporteur:
Dieses Modul verfügt über eine Standardfunktion zum Importieren von 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;
Das @EXPORT-Array kann verwendet werden, um eine Liste von Variablen und Unterprogrammen zu übergeben, die standardmäßig an den Aufrufer des Moduls exportiert werden.
Das @EXPORT_OK-Array kann verwendet werden, um eine Liste von Variablen und Unterprogrammen zu übergeben, die bei Bedarf exportiert werden, wobei der Benutzer beim Laden des Moduls angeben muss.
#!/usr/bin/perl use Arithmetic qw(subtract); print add(5,6); print subtract (5,6);
Standardmäßig wird das Hinzufügen einer Unterroutine exportiert. Die Subtraktionsmethode wird nicht exportiert, wenn sie beim Laden des Moduls nicht angegeben wird.
Objektorientierte Programmierung in Perl
In diesem Abschnitt erfahren Sie, wie Sie objektorientierte Perl-Module erstellen. Schauen wir uns zunächst an, was das Objekt ist. Ein Objekt ist eine Instanz, mit der wir auf einige Daten in jedem Perl-Modul zugreifen, diese ändern und lokalisieren können. Dabei geht es um nichts anderes, als Ihr vorhandenes Perl-Paket, Ihre Variablen und Unterroutinen so zu gestalten, dass sie sich in Bezug auf andere Programmiersprachen wie Klassen, Objekte und Methoden verhalten.
Klasse erstellen
Wie man Module erstellt, wissen wir bereits aus dem vorherigen Thema. Der Zweck der Klasse besteht darin, Methoden und Variablen zu speichern. Ein Perl-Modul verfügt über Unterroutinen, die Methoden sind. Wir müssen auf diese Variablen und Unterprogrammobjekte zugreifen.
Perl-Konstruktor
Ein Konstruktor in Perl ist eine Methode, die eine Referenz ausführt und uns zurückgibt, wobei der Modulname mit der Referenz markiert ist. Dies nennt man Segen für die Klasse. Wir verwenden eine bestimmte Variable, um eine Perl-Klasse zu segnen, nämlich 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;
Die neue Methode, die als Konstruktor für eine Klasse verwendet wird. Dieser Konstruktor erstellt ein Objekt für uns und kehrt zu dem Skript zurück, das diesen Konstruktor aufruft.
#!/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 müssen wir verstehen, wie das Objekt erstellt wurde. Immer wenn wir versuchen, ein Objekt für die Klasse zu erstellen, müssen wir den vollständigen Namen der Klasse verwenden. Angenommen, die Perl-Klasse befindet sich in einer lib\Math\Arithmetic.pm. Und wenn wir über das lib-Verzeichnis auf diese Perl-Klasse zugreifen möchten, müssen wir beim Aufruf des Skripts den gesamten Pfad zur Klasse angeben.
benutze lib::Math::Arithmetic;
my $obj = lib::Math::Arithmetic->new();
So erfolgt die Objekterstellung in Perl.
@INC:
Woher weiß das Perl-Skript, wo das Bibliotheksmodul vorhanden ist? Perl kennt nur das aktuelle Verzeichnis des Skripts und den in Perl integrierten Bibliothekspfad. Immer wenn wir ein Perl-Modul verwenden, das sich nicht im aktuellen Verzeichnis oder Perl-Bibliothekspfad befindet, schlägt das Skript immer fehl. Über @INC ist dies ein Array, das alle Verzeichnispfade enthält, in denen nach den Perl-Modulen gesucht werden muss. Versuchen Sie, diesen Befehl auszuführen und sehen Sie, was ausgegeben wird.
perl –e "print @INC"
Dadurch wird eine Ausgabe ausgegeben, und das ist der Pfad, in dem die lib-Module verfügbar sein werden. Immer wenn wir ein neues Bibliotheksmodul verwenden, müssen wir Perl, den Interpreter, anweisen, nach dem bestimmten Speicherort zu suchen, an dem das Perl-Modul verfügbar ist.
push(@INC, "PATH TO YOUR MODULE");
Machen Sie dies als Ihre erste Codezeile. Dadurch wird Ihr Dolmetscher angewiesen, diesen Pfad zu untersuchen. oder -
lib Arithmetic; # List here is your Perl Module location
Perl-Destruktor
Der Destruktor eines Objekts wird standardmäßig am Ende und vor dem Beenden Ihres Skripts aufgerufen. Dies wird verwendet, um Ihre Objekte aus dem Speicher zu zerstören.
PERL V/s Shell-Scripting
- Die Programmierung in Perl verursacht keine Portabilitätsprobleme, die häufig auftreten, wenn beim Shell-Scripting verschiedene Shells verwendet werden.
- Die Fehlerbehandlung ist in Perl sehr einfach
- Aufgrund der enormen Komplexität von Perl können Sie problemlos lange und komplexe Programme schreiben. Im Gegensatz dazu unterstützt Shell keine Namespaces, Module, Objekte, Vererbung usw.
- Shell verfügt über weniger wiederverwendbare Bibliotheken. Nichts im Vergleich zu Perls CPAN
- Shell ist weniger sicher. Es ruft externe Funktionen auf (Befehle wie mv, cp usw. hängen von der verwendeten Shell ab). Im Gegenteil, Perl leistet nützliche Arbeit, indem es interne Funktionen verwendet.
Wie PERL beim Automatisierungstest verwendet wird
Perl wird häufig in der Automatisierung eingesetzt. Es ist vielleicht nicht die beste Programmiersprache der Welt, aber für bestimmte Arten von Aufgaben ist sie am besten geeignet. Lassen Sie uns besprechen, wo und warum Perl verwendet wird Automatisierungstests.
Speichertests
Was ist Speicher? In Dateien gespeicherte Daten.
Angenommen, wir haben etwas mit dem Speicher zu tun Testfall Dabei müssen wir Daten auf eine Partition schreiben, sie lesen und überprüfen, ob die Daten korrekt geschrieben wurden.
Dies kann manuell durchgeführt werden, aber kann ein manueller Tester das Gleiche 10000 Mal durchführen? Es wird ein Albtraum sein! Wir brauchen Automatisierung
Das beste Tool zur Automatisierung von allem, was mit Speicherung zu tun hat, ist Perl aufgrund seiner Dateihandhabungstechniken, REGEX und leistungsstarke Dateianalyse, die im Vergleich zu anderen Programmiersprachen die geringste Ausführungszeit benötigt.
Warum müssen wir den Speicher testen? Denken Sie an große Rechenzentren, in denen Daten kontinuierlich von einem System zum anderen fließen und Tausende von Datensätzen pro Sekunde gespeichert werden. Das Testen der Robustheit eines solchen Speichermechanismus ist unerlässlich.
Viele Unternehmen wie HP, Dell, IBM und viele Serverhersteller verwenden Perl als Schnittstelle zum Testen der Funktionalität in Speicher- und Netzwerkdomänen. NetApp ist ein solches Unternehmen, das sich ausschließlich mit Speicher beschäftigt und Perl als Programmiersprache zur Automatisierung der Testfälle verwendet.
Wenn Sie sich für Perl-Automatisierung interessieren, ist es ratsam, sich über Speicher und Netzwerke zu informieren Concepts.
Server- und Netzwerktests:
Server- und Netzwerktests mit Perl
PERL wird häufig zur Überwachung der Serververfügbarkeit und -leistung verwendet.
Stellen Sie sich ein Rechenzentrum mit 100 Hosts (Servern) vor. Sie müssen eine Verbindung zu jedem Host herstellen und einige Befehle remote ausführen. Sie möchten das System auch neu starten und prüfen, wann es wieder online ist.
Diese Aufgabe manuell für alle 100 Hosts zu erledigen, wäre ein Albtraum. Aber wir können dies mit PERL leicht automatisieren
Entwerfen Sie Schritte, um diese oben genannte Automatisierung mithilfe von PERL zu erreichen
- Übernehmen Sie Eingaben aus der Datei zu Hostinformationen wie (IP, Benutzername und Passwort).
- Verwenden Sie Net::SSH2, um eine Verbindung zu jedem System herzustellen und einen Kanal zum Ausführen der Befehle einzurichten.
- Führen Sie die erforderlichen Befehle aus, z. B. ls, dir, ifconfig, ps usw.
- Starten Sie das System.
- Warten Sie 10 Minuten, bis das System hochfährt.
- Pingen Sie das System mit dem Net::Ping-Modul an und drucken Sie den Status aus.
Wir werden das obige Szenario codieren.
Nehmen wir eine Datei namens Input.txt, in der die vollständigen Informationen zu allen Hosts gespeichert werden, zu denen wir eine Verbindung herstellen und den Befehl ausführen müssen.
Eingabe.txt
192.168.1.2 Root-Passwort
192.168.1.3 Root-Passwort
192.168.1.4 root 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";
}
}
Web-Testen
Perl ist nicht nur auf Speicher- und Netzwerktests beschränkt. Wir können auch webbasierte Tests mit PERL durchführen. WWW-Mechanisieren ist ein Modul, für das verwendet wird Webtests. Im Grunde wird kein Browser gestartet, um die Funktionalität von Webanwendungen zu testen, sondern es wird der Quellcode der HTML-Seiten verwendet.
Wir können auch browserbasierte Tests durchführen Selenium IDE, RC, Web-Treiber. Perl wird unterstützt für Selenium.
\N"; #this speichert die verbleibende Zeichenfolge, nachdem die Musterübereinstimmung abgeschlossen ist.
drucken "
