Perl - Kurzanleitung

Perl ist eine universelle Programmiersprache, die ursprünglich für die Textmanipulation entwickelt wurde und jetzt für eine Vielzahl von Aufgaben verwendet wird, darunter Systemadministration, Webentwicklung, Netzwerkprogrammierung, GUI-Entwicklung und mehr.

Was ist Perl?

Perl ist eine stabile, plattformübergreifende Programmiersprache.
Obwohl Perl offiziell kein Akronym ist, wurde es nur von wenigen verwendet Practical Extraction and Report Language.
Es wird für unternehmenskritische Projekte im öffentlichen und privaten Sektor eingesetzt.
Perl ist eine Open Source- Software, die unter ihrer Artistic License oder der GNU General Public License (GPL) lizenziert ist .
Perl wurde von Larry Wall erstellt.
Perl 1.0 wurde 1987 für die alt.comp.sources von Usenet veröffentlicht.
Zum Zeitpunkt des Schreibens dieses Tutorials war die neueste Version von Perl 5.16.2.
Perl ist im Oxford English Dictionary aufgeführt .

Das PC Magazine gab Perl als Finalisten für den Technical Excellence Award 1998 in der Kategorie Development Tool bekannt.

Perl-Funktionen

Perl nutzt die besten Funktionen aus anderen Sprachen wie C, awk, sed, sh und BASIC.
Perls Datenbankintegrationsschnittstelle DBI unterstützt Datenbanken von Drittanbietern, darunter Oracle, Sybase, Postgres, MySQL und andere.
Perl arbeitet mit HTML, XML und anderen Auszeichnungssprachen.
Perl unterstützt Unicode.
Perl ist Y2K-konform.
Perl unterstützt sowohl prozedurale als auch objektorientierte Programmierung.
Perl ist über XS oder SWIG mit externen C / C ++ - Bibliotheken verbunden.
Perl ist erweiterbar. Über das Comprehensive Perl Archive Network ( CPAN ) stehen über 20.000 Module von Drittanbietern zur Verfügung .
Der Perl-Interpreter kann in andere Systeme eingebettet werden.

Perl und das Web

Perl war aufgrund seiner Textbearbeitungsfunktionen und seines schnellen Entwicklungszyklus die beliebteste Webprogrammiersprache.
Perl ist weithin als " Klebeband des Internets " bekannt.
Perl kann verschlüsselte Webdaten verarbeiten, einschließlich E-Commerce-Transaktionen.
Perl kann in Webserver eingebettet werden, um die Verarbeitung um bis zu 2000% zu beschleunigen.
Mit mod_perl von Perl kann der Apache-Webserver einen Perl-Interpreter einbetten.
Das DBI- Paket von Perl erleichtert die Integration von Webdatenbanken.

Perl wird interpretiert

Perl ist eine interpretierte Sprache, was bedeutet, dass Ihr Code unverändert ausgeführt werden kann, ohne dass eine Kompilierungsphase durchgeführt wird, in der ein nicht portierbares ausführbares Programm erstellt wird.

Herkömmliche Compiler konvertieren Programme in Maschinensprache. Wenn Sie ein Perl-Programm ausführen, wird es zuerst in einen Bytecode kompiliert, der dann (während das Programm ausgeführt wird) in Maschinenanweisungen konvertiert wird. Es ist also nicht ganz dasselbe wie Muscheln oder Tclstrictly ohne Zwischendarstellung interpretiert.

Es ist auch nicht wie bei den meisten Versionen von C oder C ++, die direkt in ein maschinenabhängiges Format kompiliert werden. Es liegt irgendwo dazwischen, zusammen mit Python und awk und Emacs .elc Dateien.

Bevor wir mit dem Schreiben unserer Perl-Programme beginnen, sollten wir uns mit dem Einrichten unserer Perl-Umgebung vertraut machen. Perl ist auf einer Vielzahl von Plattformen verfügbar -

Unix (Solaris, Linux, FreeBSD, AIX, HP / UX, SunOS, IRIX usw.)
Gewinnen Sie 9x / NT / 2000 /
WinCE
Macintosh (PPC, 68 KB)
Solaris (x86, SPARC)
OpenVMS
Alpha (7.2 und höher)
Symbian
Debian GNU / kFreeBSD
MirOS BSD
Und viele mehr...

Dies ist wahrscheinlicher, dass auf Ihrem System Perl installiert ist. Geben Sie einfach den folgenden Befehl an der Eingabeaufforderung $ ein:

$perl -v

Wenn Sie Perl auf Ihrem Computer installiert haben, erhalten Sie folgende Meldung:

This is perl 5, version 16, subversion 2 (v5.16.2) built for i686-linux

Copyright 1987-2012, Larry Wall

Perl may be copied only under the terms of either the Artistic License or the
GNU General Public License, which may be found in the Perl 5 source kit.

Complete documentation for Perl, including FAQ lists, should be found on
this system using "man perl" or "perldoc perl".  If you have access to the
Internet, point your browser at http://www.perl.org/, the Perl Home Page.

Wenn Sie Perl noch nicht installiert haben, fahren Sie mit dem nächsten Abschnitt fort.

Perl-Installation erhalten

Der aktuellste und aktuellste Quellcode, Binärdateien, Dokumentationen, Nachrichten usw. sind auf der offiziellen Website von Perl verfügbar.

Perl Official Website - - https://www.perl.org/

Sie können die Perl-Dokumentation von der folgenden Site herunterladen.

Perl Documentation Website - - https://perldoc.perl.org

Installieren Sie Perl

Die Perl-Distribution ist für eine Vielzahl von Plattformen verfügbar. Sie müssen nur den für Ihre Plattform geltenden Binärcode herunterladen und Perl installieren.

Wenn der Binärcode für Ihre Plattform nicht verfügbar ist, benötigen Sie einen C-Compiler, um den Quellcode manuell zu kompilieren. Das Kompilieren des Quellcodes bietet mehr Flexibilität bei der Auswahl der Funktionen, die Sie für Ihre Installation benötigen.

Hier finden Sie eine kurze Übersicht über die Installation von Perl auf verschiedenen Plattformen.

Unix- und Linux-Installation

Hier sind die einfachen Schritte zum Installieren von Perl auf einem Unix / Linux-Computer.

Öffnen Sie einen Webbrowser und gehen Sie zu https://www.perl.org/get.html.
Folgen Sie dem Link, um den für Unix / Linux verfügbaren komprimierten Quellcode herunterzuladen.
Herunterladen perl-5.x.y.tar.gz Datei und geben Sie die folgenden Befehle an der Eingabeaufforderung $ aus.

$tar -xzf perl-5.x.y.tar.gz
$cd perl-5.x.y $./Configure -de
$make $make test
$make install

NOTE - Hier ist $ eine Unix-Eingabeaufforderung, an der Sie Ihren Befehl eingeben. Stellen Sie daher sicher, dass Sie $ nicht eingeben, während Sie die oben genannten Befehle eingeben.

Dadurch wird Perl an einem Standardspeicherort / usr / local / bin installiert, und seine Bibliotheken werden in / usr / local / lib / perlXX installiert , wobei XX die von Ihnen verwendete Perl-Version ist.

Es wird eine Weile dauern, bis der Quellcode nach der Ausgabe des kompiliert ist makeBefehl. Sobald die Installation abgeschlossen ist, können Sie Probleme habenperl -vBefehl an der Eingabeaufforderung $, um die Perl-Installation zu überprüfen. Wenn alles in Ordnung ist, wird die oben gezeigte Meldung angezeigt.

Windows-Installation

Hier sind die Schritte zum Installieren von Perl auf einem Windows-Computer.

Folgen Sie dem Link für die Installation von Strawberry Perl unter Windows http://strawberryperl.com
Laden Sie entweder die 32-Bit- oder die 64-Bit-Version der Installation herunter.
Führen Sie die heruntergeladene Datei aus, indem Sie im Windows Explorer darauf doppelklicken. Dadurch wird der Perl-Installationsassistent aufgerufen, der sehr einfach zu bedienen ist. Akzeptieren Sie einfach die Standardeinstellungen, warten Sie, bis die Installation abgeschlossen ist, und Sie können loslegen!

Macintosh-Installation

Um eine eigene Version von Perl zu erstellen, benötigen Sie 'make', ein Teil der Apples-Entwicklertools, die normalerweise mit Mac OS-Installations-DVDs geliefert werden. Sie benötigen nicht die neueste Version von Xcode (die jetzt in Rechnung gestellt wird), um make zu installieren.

Hier sind die einfachen Schritte zum Installieren von Perl auf einem Mac OS X-Computer.

Öffnen Sie einen Webbrowser und gehen Sie zu https://www.perl.org/get.html.
Folgen Sie dem Link, um den für Mac OS X verfügbaren komprimierten Quellcode herunterzuladen.
Herunterladen perl-5.x.y.tar.gz Datei und geben Sie die folgenden Befehle an der Eingabeaufforderung $ aus.

$tar -xzf perl-5.x.y.tar.gz
$cd perl-5.x.y $./Configure -de
$make $make test
$make install

Perl ausführen

Im Folgenden finden Sie die verschiedenen Möglichkeiten zum Starten von Perl.

Interaktiver Dolmetscher

Sie können eingeben perlund starten Sie die Codierung sofort im interaktiven Interpreter, indem Sie sie über die Befehlszeile starten. Sie können dies unter Unix, DOS oder einem anderen System tun, das Ihnen einen Befehlszeileninterpreter oder ein Shell-Fenster bietet.

$perl  -e <perl code>           # Unix/Linux

or 

C:>perl -e <perl code>          # Windows/DOS

Hier ist die Liste aller verfügbaren Befehlszeilenoptionen -

Sr.Nr.	Option & Beschreibung
1	-d[:debugger] Führt das Programm unter dem Debugger aus
2	-Idirectory Gibt das @ INC / # include-Verzeichnis an
3	-T Aktiviert Verschmutzungsprüfungen
4	-t Aktiviert Verschmutzungswarnungen
5	-U Ermöglicht unsichere Vorgänge
6	-w Aktiviert viele nützliche Warnungen
7	-W Aktiviert alle Warnungen
8	-X Deaktiviert alle Warnungen
9	-e program Führt das als Programm gesendete Perl-Skript aus
10	file Führt das Perl-Skript aus einer bestimmten Datei aus

Skript über die Befehlszeile

Ein Perl-Skript ist eine Textdatei, die Perl-Code enthält und über die Befehlszeile ausgeführt werden kann, indem der Interpreter in Ihrer Anwendung wie folgt aufgerufen wird:

$perl  script.pl          # Unix/Linux

or 

C:>perl script.pl         # Windows/DOS

Integrierte Entwicklungsumgebung

Sie können Perl auch in einer grafischen Benutzeroberfläche ausführen. Sie benötigen lediglich eine GUI-Anwendung auf Ihrem System, die Perl unterstützt. Sie können Padre, die Perl-IDE, herunterladen . Sie können auch das Eclipse Plugin EPIC - Perl Editor und IDE für Eclipse verwenden, wenn Sie mit Eclipse vertraut sind.

Bevor Sie mit dem nächsten Kapitel fortfahren, stellen Sie sicher, dass Ihre Umgebung ordnungsgemäß eingerichtet ist und einwandfrei funktioniert. Wenn Sie die Umgebung nicht ordnungsgemäß einrichten können, können Sie sich an Ihren Systemadministrator wenden.

Alle in den folgenden Kapiteln aufgeführten Beispiele wurden mit der Version 5.16.2 ausgeführt, die unter der CentOS-Version von Linux verfügbar ist.

Perl leiht Syntax und Konzepte aus vielen Sprachen: awk, sed, C, Bourne Shell, Smalltalk, Lisp und sogar Englisch. Es gibt jedoch einige deutliche Unterschiede zwischen den Sprachen. Dieses Kapitel wurde entwickelt, um Sie schnell mit der in Perl erwarteten Syntax vertraut zu machen.

Ein Perl-Programm besteht aus einer Folge von Deklarationen und Anweisungen, die von oben nach unten ausgeführt werden. Mit Schleifen, Unterprogrammen und anderen Steuerstrukturen können Sie innerhalb des Codes herumspringen. Jede einfache Anweisung muss mit einem Semikolon (;) enden.

Perl ist eine Freiformsprache: Sie können sie nach Belieben formatieren und einrücken. Whitespace dient hauptsächlich zum Trennen von Token, im Gegensatz zu Sprachen wie Python, wo es ein wichtiger Teil der Syntax ist, oder Fortran, wo es unerheblich ist.

Erstes Perl-Programm

Programmierung im interaktiven Modus

Sie können Perl Interpreter mit verwenden -eOption in der Befehlszeile, mit der Sie Perl-Anweisungen über die Befehlszeile ausführen können. Versuchen wir etwas an der $ prompt wie folgt:

$perl -e 'print "Hello World\n"'

Diese Ausführung führt zu folgendem Ergebnis:

Hello, world

Skriptmodus-Programmierung

Angenommen, Sie befinden sich bereits in der Eingabeaufforderung $, öffnen wir eine Textdatei hello.pl mit dem vi- oder vim-Editor und fügen die folgenden Zeilen in Ihre Datei ein.

#!/usr/bin/perl

# This will print "Hello, World"
print "Hello, world\n";

Hier /usr/bin/perlIst aktuell die Perl-Interpreter-Binärdatei. Bevor Sie Ihr Skript ausführen, müssen Sie den Modus der Skriptdatei ändern und Ausführungsberechtigungen erteilen. Im Allgemeinen funktioniert die Einstellung 0755 einwandfrei, und schließlich führen Sie das obige Skript wie folgt aus:

$chmod 0755 hello.pl $./hello.pl

Diese Ausführung führt zu folgendem Ergebnis:

Hello, world

Sie können Klammern für Funktionsargumente verwenden oder sie nach Ihrem persönlichen Geschmack weglassen. Sie sind nur gelegentlich erforderlich, um die Vorrangfragen zu klären. Die folgenden zwei Aussagen führen zum gleichen Ergebnis.

print("Hello, world\n");
print "Hello, world\n";

Perl-Dateierweiterung

Ein Perl-Skript kann in jedem normalen einfachen Texteditorprogramm erstellt werden. Für jeden Plattformtyp stehen verschiedene Programme zur Verfügung. Es gibt viele Programme für Programmierer, die im Internet heruntergeladen werden können.

Als Perl-Konvention muss eine Perl-Datei mit der Dateierweiterung .pl oder .PL gespeichert werden, um als funktionierendes Perl-Skript erkannt zu werden. Dateinamen können Zahlen, Symbole und Buchstaben enthalten, dürfen jedoch kein Leerzeichen enthalten. Verwenden Sie an Stellen mit Leerzeichen einen Unterstrich (_).

Kommentare in Perl

Kommentare in jeder Programmiersprache sind Freunde von Entwicklern. Kommentare können verwendet werden, um das Programm benutzerfreundlich zu gestalten. Sie werden vom Interpreter einfach übersprungen, ohne die Codefunktionalität zu beeinträchtigen. Zum Beispiel im obigen Programm eine Zeile, die mit Hash beginnt# ist ein Kommentar.

Einfach gesagt, Kommentare in Perl beginnen mit einem Hash-Symbol und laufen bis zum Ende der Zeile -

# This is a comment in perl

Zeilen, die mit = beginnen, werden als Beginn eines Abschnitts der eingebetteten Dokumentation (Pod) interpretiert, und alle nachfolgenden Zeilen bis zum nächsten Schnitt werden vom Compiler ignoriert. Es folgt das Beispiel -

#!/usr/bin/perl

# This is a single line comment
print "Hello, world\n";

=begin comment
This is all part of multiline comment.
You can use as many lines as you like
These comments will be ignored by the 
compiler until the next =cut is encountered.
=cut

Dies führt zu folgendem Ergebnis:

Hello, world

Leerzeichen in Perl

Ein Perl-Programm kümmert sich nicht um Leerzeichen. Das folgende Programm funktioniert einwandfrei -

#!/usr/bin/perl

print       "Hello, world\n";

Wenn sich jedoch Leerzeichen innerhalb der angegebenen Zeichenfolgen befinden, werden sie unverändert gedruckt. Zum Beispiel -

#!/usr/bin/perl

# This would print with a line break in the middle
print "Hello
          world\n";

Dies führt zu folgendem Ergebnis:

Hello
          world

Alle Arten von Leerzeichen wie Leerzeichen, Tabulatoren, Zeilenumbrüche usw. sind für den Interpreter gleichwertig, wenn sie außerhalb der Anführungszeichen verwendet werden. Eine Zeile, die nur Leerzeichen enthält, möglicherweise mit einem Kommentar, wird als Leerzeile bezeichnet, und Perl ignoriert sie vollständig.

Einfache und doppelte Anführungszeichen in Perl

Sie können doppelte oder einfache Anführungszeichen um Literalzeichenfolgen wie folgt verwenden:

#!/usr/bin/perl

print "Hello, world\n";
print 'Hello, world\n';

Dies führt zu folgendem Ergebnis:

Hello, world
Hello, world\n$

Es gibt einen wichtigen Unterschied zwischen einfachen und doppelten Anführungszeichen. Nur doppelte AnführungszeicheninterpolateVariablen und Sonderzeichen wie Zeilenumbrüche \ n, während einfache Anführungszeichen keine Variablen oder Sonderzeichen interpolieren. Überprüfen Sie das folgende Beispiel, in dem wir $ a als Variable verwenden, um einen Wert zu speichern und diesen Wert später zu drucken.

#!/usr/bin/perl

$a = 10; print "Value of a = $a\n";
print 'Value of a = $a\n';

Dies führt zu folgendem Ergebnis:

Value of a = 10
Value of a = $a\n$

"Hier" -Dokumente

Sie können mehrzeiligen Text bequem speichern oder drucken. Sogar Sie können Variablen im "hier" -Dokument verwenden. Im Folgenden finden Sie eine einfache Syntax. Überprüfen Sie sorgfältig, ob zwischen dem << und dem Bezeichner kein Leerzeichen stehen darf.

Ein Bezeichner kann entweder ein bloßes Wort oder ein zitierter Text sein, wie wir unten EOF verwendet haben. Wenn der Bezeichner in Anführungszeichen gesetzt ist, bestimmt die Art des verwendeten Anführungszeichens die Behandlung des Textes im Dokument hier, genau wie beim regulären Anführungszeichen. Ein nicht zitierter Bezeichner funktioniert wie doppelte Anführungszeichen.

#!/usr/bin/perl

$a = 10;
$var = <<"EOF"; This is the syntax for here document and it will continue until it encounters a EOF in the first line. This is case of double quote so variable value will be interpolated. For example value of a = $a
EOF
print "$var\n"; $var = <<'EOF';
This is case of single quote so variable value will be 
interpolated. For example value of a = $a EOF print "$var\n";

Dies führt zu folgendem Ergebnis:

This is the syntax for here document and it will continue
until it encounters a EOF in the first line.
This is case of double quote so variable value will be
interpolated. For example value of a = 10

This is case of single quote so variable value will be
interpolated. For example value of a = $a

Fluchtzeichen

Perl verwendet das Backslash-Zeichen (\), um alle Arten von Zeichen zu umgehen, die unseren Code beeinträchtigen könnten. Nehmen wir ein Beispiel, in dem wir doppelte Anführungszeichen und $ sign drucken möchten -

#!/usr/bin/perl

$result = "This is \"number\""; print "$result\n";
print "\$result\n";

Dies führt zu folgendem Ergebnis:

This is "number"
$result

Perl-Kennungen

Ein Perl-Bezeichner ist ein Name, mit dem eine Variable, Funktion, Klasse, ein Modul oder ein anderes Objekt identifiziert wird. Ein Perl-Variablenname beginnt entweder mit $, @ oder%, gefolgt von null oder mehr Buchstaben, Unterstrichen und Ziffern (0 bis 9).

Perl erlaubt keine Interpunktionszeichen wie @, $ und% in Bezeichnern. Perl ist eincase sensitiveProgrammiersprache. So$Manpower und $manpower sind zwei verschiedene Bezeichner in Perl.

Perl ist eine lose typisierte Sprache, und Sie müssen während der Verwendung in Ihrem Programm keinen Typ für Ihre Daten angeben. Der Perl-Interpreter wählt den Typ basierend auf dem Kontext der Daten selbst aus.

Perl verfügt über drei grundlegende Datentypen: Skalare, Arrays von Skalaren und Hashes von Skalaren, auch als assoziative Arrays bezeichnet. Hier finden Sie einige Details zu diesen Datentypen.

Sr.Nr.	Typen & Beschreibung
1	Scalar Skalare sind einfache Variablen. Vor ihnen steht ein Dollarzeichen ($). Ein Skalar ist entweder eine Zahl, eine Zeichenfolge oder eine Referenz. Eine Referenz ist eigentlich eine Adresse einer Variablen, die wir in den kommenden Kapiteln sehen werden.
2	Arrays Arrays sind geordnete Listen von Skalaren, auf die Sie mit einem numerischen Index zugreifen, der mit 0 beginnt. Vor ihnen steht ein "at" -Zeichen (@).
3	Hashes Hashes sind ungeordnete Sätze von Schlüssel / Wert-Paaren, auf die Sie mit den Schlüsseln als Index zugreifen. Vor ihnen steht ein Prozentzeichen (%).

Numerische Literale

Perl speichert alle Zahlen intern entweder als vorzeichenbehaftete Ganzzahlen oder als Gleitkommawerte mit doppelter Genauigkeit. Numerische Literale werden in einem der folgenden Gleitkomma- oder Ganzzahlformate angegeben:

Art	Wert
Ganze Zahl	1234
Negative ganze Zahl	-100
Gleitkomma	2000
Wissenschaftliche Schreibweise	16.12E14
Hexadezimal	0xffff
Oktal	0577

String-Literale

Zeichenfolgen sind Zeichenfolgen. Dies sind normalerweise alphanumerische Werte, die entweder durch einfache (') oder doppelte (") Anführungszeichen begrenzt sind. Sie funktionieren ähnlich wie UNIX-Shell-Anführungszeichen, bei denen Sie Zeichenfolgen in einfachen Anführungszeichen und Zeichenfolgen in doppelten Anführungszeichen verwenden können.

String-Literale mit doppelten Anführungszeichen ermöglichen eine variable Interpolation, Zeichenfolgen mit einfachen Anführungszeichen nicht. Es gibt bestimmte Zeichen, wenn sie mit einem Schrägstrich versehen sind, eine besondere Bedeutung haben und zur Darstellung wie Zeilenumbruch (\ n) oder Tabulator (\ t) verwendet werden.

Sie können Zeilenumbrüche oder eine der folgenden Escape-Sequenzen direkt in Ihre Zeichenfolgen in doppelten Anführungszeichen einbetten -

Fluchtabfolge	Bedeutung
\\	Backslash
\ '	Einfaches Zitat
""	Doppeltes Zitat
\ein	Alarm oder Glocke
\ b	Rücktaste
\ f	Formularvorschub
\ n	Neue Zeile
\ r	Wagenrücklauf
\ t	Horizontale Registerkarte
\ v	Vertikale Registerkarte
\ 0nn	Erstellt oktalformatierte Zahlen
\ xnn	Erstellt hexideciamal formatierte Zahlen
\ cX	Steuert Zeichen, x kann ein beliebiges Zeichen sein
\ u	Erzwingt das Großbuchstaben des nächsten Zeichens
\ l	Erzwingt, dass das nächste Zeichen in Kleinbuchstaben geschrieben wird
\ U.	Erzwingt, dass alle folgenden Zeichen in Großbuchstaben geschrieben werden
\ L.	Erzwingt alle folgenden Zeichen in Kleinbuchstaben
\ Q.	Backslash alle folgenden nicht alphanumerischen Zeichen
\ E.	Beenden Sie \ U, \ L oder \ Q.

Beispiel

Mal sehen, wie sich Strings mit einfachen und doppelten Anführungszeichen verhalten. Hier verwenden wir in der obigen Tabelle erwähnte String-Escapezeichen und verwenden die skalare Variable, um String-Werte zuzuweisen.

#!/usr/bin/perl

# This is case of interpolation.
$str = "Welcome to \ntutorialspoint.com!";
print "$str\n"; # This is case of non-interpolation. $str = 'Welcome to \ntutorialspoint.com!';
print "$str\n"; # Only W will become upper case. $str = "\uwelcome to tutorialspoint.com!";
print "$str\n"; # Whole line will become capital. $str = "\UWelcome to tutorialspoint.com!";
print "$str\n"; # A portion of line will become capital. $str = "Welcome to \Ututorialspoint\E.com!"; 
print "$str\n"; # Backsalash non alpha-numeric including spaces. $str = "\QWelcome to tutorialspoint's family";
print "$str\n";

Dies führt zu folgendem Ergebnis:

Welcome to
tutorialspoint.com!
Welcome to \ntutorialspoint.com!
Welcome to tutorialspoint.com!
WELCOME TO TUTORIALSPOINT.COM!
Welcome to TUTORIALSPOINT.com!
Welcome\ to\ tutorialspoint\'s\ family

Variablen sind die reservierten Speicherplätze zum Speichern von Werten. Dies bedeutet, dass Sie beim Erstellen einer Variablen Speicherplatz im Speicher reservieren.

Basierend auf dem Datentyp einer Variablen weist der Interpreter Speicher zu und entscheidet, was im reservierten Speicher gespeichert werden kann. Durch Zuweisen verschiedener Datentypen zu Variablen können Sie daher Ganzzahlen, Dezimalstellen oder Zeichenfolgen in diesen Variablen speichern.

Wir haben erfahren, dass Perl die folgenden drei grundlegenden Datentypen hat:

Scalars
Arrays
Hashes

Dementsprechend werden wir in Perl drei Arten von Variablen verwenden. EINscalarVor der Variablen steht ein Dollarzeichen ($), in dem entweder eine Zahl, eine Zeichenfolge oder eine Referenz gespeichert werden kann. EinarrayVor der Variablen steht das Zeichen @ und es werden geordnete Listen von Skalaren gespeichert. Endlich dieHash Die Variable wird durch das Vorzeichen% vorangestellt und zum Speichern von Sätzen von Schlüssel / Wert-Paaren verwendet.

Perl verwaltet jeden Variablentyp in einem separaten Namespace. Sie können also ohne Angst vor Konflikten denselben Namen für eine skalare Variable, ein Array oder einen Hash verwenden. Dies bedeutet, dass $ foo und @foo zwei verschiedene Variablen sind.

Variablen erstellen

Perl-Variablen müssen nicht explizit deklariert werden, um Speicherplatz zu reservieren. Die Deklaration erfolgt automatisch, wenn Sie einer Variablen einen Wert zuweisen. Das Gleichheitszeichen (=) wird verwendet, um Variablen Werte zuzuweisen.

Beachten Sie, dass dies obligatorisch ist, um eine Variable zu deklarieren, bevor wir sie verwenden, wenn wir sie verwenden use strict Aussage in unserem Programm.

Der Operand links vom Operator = ist der Name der Variablen, und der Operand rechts vom Operator = ist der in der Variablen gespeicherte Wert. Zum Beispiel -

$age = 25;             # An integer assignment
$name = "John Paul"; # A string $salary = 1445.50;     # A floating point

Hier sind 25, "John Paul" und 1445.50 die Werte, die den Variablen " Alter" , " Name" und " Gehalt " zugewiesen sind . In Kürze werden wir sehen, wie wir Arrays und Hashes Werte zuweisen können.

Skalare Variablen

Ein Skalar ist eine einzelne Dateneinheit. Diese Daten können eine Ganzzahl, ein Gleitkomma, ein Zeichen, eine Zeichenfolge, ein Absatz oder eine gesamte Webseite sein. Einfach zu sagen, es könnte alles sein, aber nur eine einzige Sache.

Hier ist ein einfaches Beispiel für die Verwendung skalarer Variablen:

#!/usr/bin/perl

$age = 25;             # An integer assignment
$name = "John Paul"; # A string $salary = 1445.50;     # A floating point

print "Age = $age\n"; print "Name = $name\n";
print "Salary = $salary\n";

Dies führt zu folgendem Ergebnis:

Age = 25
Name = John Paul
Salary = 1445.5

Array-Variablen

Ein Array ist eine Variable, die eine geordnete Liste von Skalarwerten speichert. Array-Variablen wird ein "at" (@) vorangestellt. Um auf ein einzelnes Element eines Arrays zu verweisen, verwenden Sie das Dollarzeichen ($) mit dem Variablennamen, gefolgt vom Index des Elements in eckigen Klammern.

Hier ist ein einfaches Beispiel für die Verwendung von Array-Variablen:

#!/usr/bin/perl

@ages = (25, 30, 40);             
@names = ("John Paul", "Lisa", "Kumar");

print "\$ages[0] = $ages[0]\n";
print "\$ages[1] = $ages[1]\n";
print "\$ages[2] = $ages[2]\n";
print "\$names[0] = $names[0]\n";
print "\$names[1] = $names[1]\n";
print "\$names[2] = $names[2]\n";

Hier haben wir das Escape-Zeichen (\) vor dem $ -Zeichen verwendet, um es zu drucken. Andere Perl verstehen es als Variable und drucken seinen Wert. Bei der Ausführung wird das folgende Ergebnis erzielt:

$ages[0] = 25
$ages[1] = 30 $ages[2] = 40
$names[0] = John Paul $names[1] = Lisa
$names[2] = Kumar

Hash-Variablen

Ein Hash ist eine Menge von key/valuePaare. Vor Hash-Variablen steht ein Prozentzeichen (%). Um auf ein einzelnes Element eines Hash zu verweisen, verwenden Sie den Namen der Hash-Variablen, gefolgt von dem "Schlüssel", der dem Wert in geschweiften Klammern zugeordnet ist.

Hier ist ein einfaches Beispiel für die Verwendung von Hash-Variablen:

#!/usr/bin/perl

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

print "\$data{'John Paul'} = $data{'John Paul'}\n"; print "\$data{'Lisa'} = $data{'Lisa'}\n"; print "\$data{'Kumar'} = $data{'Kumar'}\n";

Dies führt zu folgendem Ergebnis:

$data{'John Paul'} = 45
$data{'Lisa'} = 30 $data{'Kumar'} = 40

Variabler Kontext

Perl behandelt dieselbe Variable je nach Kontext unterschiedlich, dh in der Situation, in der eine Variable verwendet wird. Schauen wir uns das folgende Beispiel an:

#!/usr/bin/perl

@names = ('John Paul', 'Lisa', 'Kumar');

@copy = @names;
$size = @names; print "Given names are : @copy\n"; print "Number of names are : $size\n";

Dies führt zu folgendem Ergebnis:

Given names are : John Paul Lisa Kumar
Number of names are : 3

Hier ist @names ein Array, das in zwei verschiedenen Kontexten verwendet wurde. Zuerst haben wir es in ein anderes Array kopiert, dh in eine Liste, sodass alle Elemente zurückgegeben wurden, vorausgesetzt, der Kontext ist Listenkontext. Als nächstes haben wir dasselbe Array verwendet und versucht, dieses Array in einem Skalar zu speichern. In diesem Fall wurde nur die Anzahl der Elemente in diesem Array zurückgegeben, vorausgesetzt, der Kontext ist ein skalarer Kontext. Die folgende Tabelle listet die verschiedenen Kontexte auf -

Sr.Nr.	Kontext & Beschreibung
1	Scalar Die Zuordnung zu einer skalaren Variablen wertet die rechte Seite in einem skalaren Kontext aus.
2	List Die Zuweisung zu einem Array oder einem Hash wertet die rechte Seite in einem Listenkontext aus.
3	Boolean Boolescher Kontext ist einfach jeder Ort, an dem ein Ausdruck ausgewertet wird, um festzustellen, ob er wahr oder falsch ist.
4	Void Diesem Kontext ist es nicht nur egal, wie hoch der Rückgabewert ist, er möchte auch nicht einmal einen Rückgabewert.
5	Interpolative Dieser Kontext tritt nur in Anführungszeichen oder in Anführungszeichen auf.

Ein Skalar ist eine einzelne Dateneinheit. Diese Daten können eine Ganzzahl, ein Gleitkomma, ein Zeichen, eine Zeichenfolge, ein Absatz oder eine gesamte Webseite sein.

Hier ist ein einfaches Beispiel für die Verwendung skalarer Variablen:

#!/usr/bin/perl

$age = 25; # An integer assignment $name = "John Paul";   # A string 
$salary = 1445.50; # A floating point print "Age = $age\n";
print "Name = $name\n"; print "Salary = $salary\n";

Dies führt zu folgendem Ergebnis:

Age = 25
Name = John Paul
Salary = 1445.5

Numerische Skalare

Ein Skalar ist meistens entweder eine Zahl oder eine Zeichenfolge. Das folgende Beispiel zeigt die Verwendung verschiedener Arten von numerischen Skalaren -

#!/usr/bin/perl

$integer = 200; $negative = -300;
$floating = 200.340; $bigfloat = -1.2E-23;

# 377 octal, same as 255 decimal
$octal = 0377; # FF hex, also 255 decimal $hexa = 0xff;

print "integer = $integer\n"; print "negative = $negative\n";
print "floating = $floating\n"; print "bigfloat = $bigfloat\n";
print "octal = $octal\n"; print "hexa = $hexa\n";

Dies führt zu folgendem Ergebnis:

integer = 200
negative = -300
floating = 200.34
bigfloat = -1.2e-23
octal = 255
hexa = 255

String-Skalare

Das folgende Beispiel zeigt die Verwendung verschiedener Arten von String-Skalaren. Beachten Sie den Unterschied zwischen Zeichenfolgen in einfachen Anführungszeichen und Zeichenfolgen in doppelten Anführungszeichen -

#!/usr/bin/perl

$var = "This is string scalar!"; $quote = 'I m inside single quote - $var'; $double = "This is inside single quote - $var"; $escape = "This example of escape -\tHello, World!";

print "var = $var\n"; print "quote = $quote\n";
print "double = $double\n"; print "escape = $escape\n";

Dies führt zu folgendem Ergebnis:

var = This is string scalar!
quote = I m inside single quote - $var
double = This is inside single quote - This is string scalar!
escape = This example of escape -       Hello, World

Skalare Operationen

Sie werden ein Detail der verschiedenen in Perl verfügbaren Operatoren in einem separaten Kapitel sehen, aber hier werden wir einige numerische Operationen und Zeichenfolgenoperationen auflisten.

#!/usr/bin/perl

$str = "hello" . "world";       # Concatenates strings.
$num = 5 + 10; # adds two numbers. $mul = 4 * 5;                   # multiplies two numbers.
$mix = $str . $num; # concatenates string and number. print "str = $str\n";
print "num = $num\n"; print "mix = $mix\n";

Dies führt zu folgendem Ergebnis:

str = helloworld
num = 15
mul = 20
mix = helloworld15

Mehrzeilige Saiten

Wenn Sie mehrzeilige Zeichenfolgen in Ihre Programme einfügen möchten, können Sie die folgenden einfachen einfachen Anführungszeichen verwenden:

#!/usr/bin/perl

$string = 'This is a multiline string'; print "$string\n";

Dies führt zu folgendem Ergebnis:

This is
a multiline
string

Sie können die Dokumentensyntax "hier" auch verwenden, um mehrzeilige Zeilen wie folgt zu speichern oder zu drucken.

#!/usr/bin/perl

print <<EOF;
This is
a multiline
string
EOF

Dies führt auch zum gleichen Ergebnis -

This is
a multiline
string

V-Saiten

Ein Literal der Form v1.20.300.4000 wird als Zeichenfolge analysiert, die aus Zeichen mit den angegebenen Ordnungszahlen besteht. Diese Form wird als V-Strings bezeichnet.

Ein V-String bietet eine alternative und besser lesbare Möglichkeit, Strings zu erstellen, anstatt die etwas weniger lesbare Interpolationsform "\ x {1} \ x {14} \ x {12c} \ x {fa0}" zu verwenden.

Sie sind jedes Literal, das mit av beginnt und auf das ein oder mehrere durch Punkte getrennte Elemente folgen. Zum Beispiel -

#!/usr/bin/perl

$smile = v9786; $foo    = v102.111.111;
$martin = v77.97.114.116.105.110; print "smile = $smile\n";
print "foo = $foo\n"; print "martin = $martin\n";

Dies führt auch zum gleichen Ergebnis -

smile = ☺
foo = foo
martin = Martin
Wide character in print at main.pl line 7.

Spezielle Literale

Bisher müssen Sie ein Gefühl für String-Skalare und deren Verkettung und Interpolation haben. Lassen Sie mich Ihnen drei spezielle Literale vorstellen: __FILE__, __LINE__ und __PACKAGE__ repräsentieren den aktuellen Dateinamen, die Zeilennummer und den Paketnamen an diesem Punkt in Ihrem Programm.

Sie dürfen nur als separate Token verwendet werden und werden nicht in Zeichenfolgen interpoliert. Überprüfen Sie das folgende Beispiel -

#!/usr/bin/perl

print "File name ". __FILE__ . "\n";
print "Line Number " . __LINE__ ."\n";
print "Package " . __PACKAGE__ ."\n";

# they can not be interpolated
print "__FILE__ __LINE__ __PACKAGE__\n";

Dies führt zu folgendem Ergebnis:

File name hello.pl
Line Number 4
Package main
__FILE__ __LINE__ __PACKAGE__

Hier ist ein einfaches Beispiel für die Verwendung der Array-Variablen:

#!/usr/bin/perl

@ages = (25, 30, 40);             
@names = ("John Paul", "Lisa", "Kumar");

print "\$ages[0] = $ages[0]\n"; print "\$ages[1] = $ages[1]\n"; print "\$ages[2] = $ages[2]\n"; print "\$names[0] = $names[0]\n"; print "\$names[1] = $names[1]\n"; print "\$names[2] = $names[2]\n";

$ages[0] = 25 $ages[1] = 30
$ages[2] = 40 $names[0] = John Paul
$names[1] = Lisa $names[2] = Kumar

In Perl werden List- und Array-Begriffe häufig so verwendet, als wären sie austauschbar. Aber die Liste sind die Daten und das Array ist die Variable.

Array-Erstellung

Array-Variablen wird das @ -Zeichen vorangestellt und entweder mit Klammern oder mit dem qw-Operator gefüllt. Zum Beispiel -

@array = (1, 2, 'Hello');
@array = qw/This is an array/;

In der zweiten Zeile wird der Operator qw // verwendet, der eine Liste von Zeichenfolgen zurückgibt und die begrenzte Zeichenfolge durch Leerzeichen trennt. In diesem Beispiel führt dies zu einem Array mit vier Elementen. Das erste Element ist 'this' und das letzte (vierte) ist 'array'. Dies bedeutet, dass Sie verschiedene Zeilen wie folgt verwenden können:

@days = qw/Monday
Tuesday
...
Sunday/;

Sie können ein Array auch füllen, indem Sie jeden Wert wie folgt einzeln zuweisen:

$array[0] = 'Monday'; ... $array[6] = 'Sunday';

Zugriff auf Array-Elemente

Wenn Sie über ein Array auf einzelne Elemente zugreifen, müssen Sie der Variablen ein Dollarzeichen ($) voranstellen und dann den Elementindex in eckigen Klammern nach dem Namen der Variablen anhängen. Zum Beispiel -

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

print "$days[0]\n";
print "$days[1]\n"; print "$days[2]\n";
print "$days[6]\n"; print "$days[-1]\n";
print "$days[-7]\n";

Dies führt zu folgendem Ergebnis:

Mon
Tue
Wed
Sun
Sun
Mon

Array-Indizes beginnen bei Null. Um auf das erste Element zuzugreifen, müssen Sie 0 als Indizes angeben. Sie können auch einen negativen Index angeben. In diesem Fall wählen Sie das Element am Ende und nicht am Anfang des Arrays aus. Dies bedeutet Folgendes:

print $days[-1]; # outputs Sun
print $days[-7]; # outputs Mon

Sequential Number Arrays

Perl bietet eine Verknüpfung für fortlaufende Zahlen und Buchstaben. Anstatt beispielsweise jedes Element beim Zählen bis 100 auszutippen, können wir Folgendes tun:

#!/usr/bin/perl

@var_10 = (1..10);
@var_20 = (10..20);
@var_abc = (a..z);

print "@var_10\n";   # Prints number from 1 to 10
print "@var_20\n";   # Prints number from 10 to 20
print "@var_abc\n";  # Prints number from a to z

Hier heißt Doppelpunkt (..) range operator. Dies führt zu folgendem Ergebnis:

1 2 3 4 5 6 7 8 9 10
10 11 12 13 14 15 16 17 18 19 20
a b c d e f g h i j k l m n o p q r s t u v w x y z

Array-Größe

Die Größe eines Arrays kann mithilfe des skalaren Kontexts auf dem Array bestimmt werden. Der zurückgegebene Wert ist die Anzahl der Elemente im Array.

@array = (1,2,3);
print "Size: ",scalar @array,"\n";

Der zurückgegebene Wert ist immer die physische Größe des Arrays, nicht die Anzahl der gültigen Elemente. Sie können dies demonstrieren, und der Unterschied zwischen scalar @array und $ # array mithilfe dieses Fragments ist wie folgt:

#!/usr/bin/perl

@array = (1,2,3);
$array[50] = 4; $size = @array;
$max_index = $#array;

print "Size:  $size\n"; print "Max Index: $max_index\n";

Dies führt zu folgendem Ergebnis:

Size: 51
Max Index: 50

Das Array enthält nur vier Elemente, die Informationen enthalten. Das Array ist jedoch 51 Elemente lang und weist den höchsten Index von 50 auf.

Hinzufügen und Entfernen von Elementen im Array

Perl bietet eine Reihe nützlicher Funktionen zum Hinzufügen und Entfernen von Elementen in einem Array. Sie haben vielleicht eine Frage, was eine Funktion ist? Bisher hast du benutztprintFunktion zum Drucken verschiedener Werte. In ähnlicher Weise gibt es verschiedene andere Funktionen oder manchmal auch Unterroutinen genannt, die für verschiedene andere Funktionen verwendet werden können.

Sr.Nr.	Typen & Beschreibung
1	push @ARRAY, LIST Schiebt die Werte der Liste an das Ende des Arrays.
2	pop @ARRAY Springt ab und gibt den letzten Wert des Arrays zurück.
3	shift @ARRAY Verschiebt den ersten Wert des Arrays und gibt ihn zurück, verkürzt das Array um 1 und verschiebt alles nach unten.
4	unshift @ARRAY, LIST Stellt die Liste vor das Array und gibt die Anzahl der Elemente im neuen Array zurück.

#!/usr/bin/perl

# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins  = @coins\n";

# add one element at the end of the array
push(@coins, "Penny");
print "2. \@coins  = @coins\n";

# add one element at the beginning of the array
unshift(@coins, "Dollar");
print "3. \@coins  = @coins\n";

# remove one element from the last of the array.
pop(@coins);
print "4. \@coins  = @coins\n";

# remove one element from the beginning of the array.
shift(@coins);
print "5. \@coins  = @coins\n";

Dies führt zu folgendem Ergebnis:

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime Nickel Penny
3. @coins = Dollar Quarter Dime Nickel Penny
4. @coins = Dollar Quarter Dime Nickel
5. @coins = Quarter Dime Nickel

Array-Elemente schneiden

Sie können auch ein "Slice" aus einem Array extrahieren, dh Sie können mehr als ein Element aus einem Array auswählen, um ein anderes Array zu erstellen.

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

@weekdays = @days[3,4,5];

print "@weekdays\n";

Dies führt zu folgendem Ergebnis:

Thu Fri Sat

Die Spezifikation für ein Slice muss eine Liste gültiger Indizes enthalten, entweder positiv oder negativ, die jeweils durch ein Komma getrennt sind. Für die Geschwindigkeit können Sie auch die verwenden.. Bereichsoperator -

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

@weekdays = @days[3..5];

print "@weekdays\n";

Dies führt zu folgendem Ergebnis:

Thu Fri Sat

Array-Elemente ersetzen

Jetzt werden wir eine weitere Funktion namens aufführen splice(), die die folgende Syntax hat -

splice @ARRAY, OFFSET [ , LENGTH [ , LIST ] ]

Diese Funktion entfernt die durch OFFSET und LENGTH angegebenen Elemente von @ARRAY und ersetzt sie gegebenenfalls durch LIST. Schließlich werden die aus dem Array entfernten Elemente zurückgegeben. Es folgt das Beispiel -

#!/usr/bin/perl

@nums = (1..20);
print "Before - @nums\n";

splice(@nums, 5, 5, 21..25); 
print "After - @nums\n";

Dies führt zu folgendem Ergebnis:

Before - 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
After - 1 2 3 4 5 21 22 23 24 25 11 12 13 14 15 16 17 18 19 20

Hier beginnt der eigentliche Austausch mit der 6. Nummer, danach werden fünf Elemente von 6 auf 10 durch die Nummern 21, 22, 23, 24 und 25 ersetzt.

Strings in Arrays umwandeln

Schauen wir uns eine weitere Funktion an, die aufgerufen wird split(), die die folgende Syntax hat -

split [ PATTERN [ , EXPR [ , LIMIT ] ] ]

Diese Funktion teilt eine Zeichenfolge in ein Array von Zeichenfolgen auf und gibt sie zurück. Wenn LIMIT angegeben ist, wird höchstens diese Anzahl von Feldern aufgeteilt. Wenn PATTERN weggelassen wird, wird das Leerzeichen aufgeteilt. Es folgt das Beispiel -

#!/usr/bin/perl

# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens"; $var_names = "Larry,David,Roger,Ken,Michael,Tom";

# transform above strings into arrays.
@string = split('-', $var_string); @names = split(',', $var_names);

print "$string[3]\n"; # This will print Roses print "$names[4]\n";   # This will print Michael

Dies führt zu folgendem Ergebnis:

Roses
Michael

Arrays in Strings umwandeln

Wir können die verwenden join()Funktion, um die Array-Elemente wieder zu verbinden und eine lange skalare Zeichenfolge zu bilden. Diese Funktion hat die folgende Syntax:

join EXPR, LIST

Diese Funktion verbindet die separaten Zeichenfolgen von LIST zu einer einzelnen Zeichenfolge mit Feldern, die durch den Wert von EXPR getrennt sind, und gibt die Zeichenfolge zurück. Es folgt das Beispiel -

#!/usr/bin/perl

# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens"; $var_names = "Larry,David,Roger,Ken,Michael,Tom";

# transform above strings into arrays.
@string = split('-', $var_string); @names = split(',', $var_names);

$string1 = join( '-', @string ); $string2 = join( ',', @names );

print "$string1\n"; print "$string2\n";

Dies führt zu folgendem Ergebnis:

Rain-Drops-On-Roses-And-Whiskers-On-Kittens
Larry,David,Roger,Ken,Michael,Tom

Arrays sortieren

Das sort()Die Funktion sortiert jedes Element eines Arrays gemäß den numerischen ASCII-Standards. Diese Funktion hat die folgende Syntax:

sort [ SUBROUTINE ] LIST

Diese Funktion sortiert die LISTE und gibt den sortierten Array-Wert zurück. Wenn SUBROUTINE angegeben ist, wird beim Sortieren der Elemente die angegebene Logik innerhalb der SUBTROUTINE angewendet.

#!/usr/bin/perl

# define an array
@foods = qw(pizza steak chicken burgers);
print "Before: @foods\n";

# sort this array
@foods = sort(@foods);
print "After: @foods\n";

Dies führt zu folgendem Ergebnis:

Before: pizza steak chicken burgers
After: burgers chicken pizza steak

Bitte beachten Sie, dass die Sortierung basierend auf dem numerischen ASCII-Wert der Wörter durchgeführt wird. Die beste Option ist also, zuerst jedes Element des Arrays in Kleinbuchstaben umzuwandeln und dann die Sortierfunktion auszuführen.

Arrays zusammenführen

Da ein Array nur eine durch Kommas getrennte Folge von Werten ist, können Sie sie wie unten gezeigt miteinander kombinieren.

#!/usr/bin/perl

@numbers = (1,3,(4,5,6));

print "numbers = @numbers\n";

Dies führt zu folgendem Ergebnis:

numbers = 1 3 4 5 6

Die eingebetteten Arrays werden einfach Teil des Hauptarrays, wie unten gezeigt -

#!/usr/bin/perl

@odd = (1,3,5);
@even = (2, 4, 6);

@numbers = (@odd, @even);

print "numbers = @numbers\n";

Dies führt zu folgendem Ergebnis:

numbers = 1 3 5 2 4 6

Elemente aus Listen auswählen

Die Listennotation ist identisch mit der für Arrays. Sie können ein Element aus einem Array extrahieren, indem Sie eckige Klammern an die Liste anhängen und einen oder mehrere Indizes angeben.

#!/usr/bin/perl

$var = (5,4,3,2,1)[4]; print "value of var = $var\n"

Dies führt zu folgendem Ergebnis:

value of var = 1

Ebenso können wir Slices extrahieren, ohne dass ein führendes @ -Zeichen erforderlich ist -

#!/usr/bin/perl

@list = (5,4,3,2,1)[1..3];

print "Value of list = @list\n";

Dies führt zu folgendem Ergebnis:

Value of list = 4 3 2

Ein Hash ist eine Menge von key/valuePaare. Vor Hash-Variablen steht ein Prozentzeichen (%). Um auf ein einzelnes Element eines Hash zu verweisen, verwenden Sie den Namen der Hash-Variablen, dem ein "$" -Zeichen vorangestellt ist, gefolgt von dem "Schlüssel", der dem Wert in geschweiften Klammern zugeordnet ist.

Hier ist ein einfaches Beispiel für die Verwendung der Hash-Variablen:

#!/usr/bin/perl

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

print "\$data{'John Paul'} = $data{'John Paul'}\n"; print "\$data{'Lisa'} = $data{'Lisa'}\n"; print "\$data{'Kumar'} = $data{'Kumar'}\n";

Dies führt zu folgendem Ergebnis:

$data{'John Paul'} = 45
$data{'Lisa'} = 30 $data{'Kumar'} = 40

Hashes erstellen

Hashes werden auf eine der beiden folgenden Arten erstellt. Bei der ersten Methode weisen Sie einem benannten Schlüssel einzeln einen Wert zu -

$data{'John Paul'} = 45; $data{'Lisa'} = 30;
$data{'Kumar'} = 40;

Im zweiten Fall verwenden Sie eine Liste, die konvertiert wird, indem einzelne Paare aus der Liste entnommen werden: Das erste Element des Paares wird als Schlüssel und das zweite als Wert verwendet. Zum Beispiel -

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

Aus Gründen der Übersichtlichkeit können Sie => als Alias für verwenden, um die Schlüssel / Wert-Paare wie folgt anzugeben:

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

Hier ist eine weitere Variante des obigen Formulars. Sehen Sie es sich an. Hier wurde allen Schlüsseln ein Bindestrich (-) vorangestellt, und um sie herum ist kein Zitat erforderlich.

%data = (-JohnPaul => 45, -Lisa => 30, -Kumar => 40);

Es ist jedoch wichtig zu beachten, dass es ein einziges Wort gibt, dh ohne Leerzeichen wurden Schlüssel in dieser Form der Hash-Bildung verwendet. Wenn Sie Ihren Hash auf diese Weise aufbauen, wird auf Schlüssel nur mit Bindestrich zugegriffen, wie unten gezeigt.

$val = %data{-JohnPaul}
$val = %data{-Lisa}

Zugriff auf Hash-Elemente

Wenn Sie über einen Hash auf einzelne Elemente zugreifen, müssen Sie der Variablen ein Dollarzeichen ($) voranstellen und dann den Elementschlüssel in geschweiften Klammern nach dem Namen der Variablen anhängen. Zum Beispiel -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

print "$data{'John Paul'}\n"; print "$data{'Lisa'}\n";
print "$data{'Kumar'}\n";

Dies führt zu folgendem Ergebnis:

45
30
40

Scheiben extrahieren

Sie können Slices eines Hash genauso extrahieren wie Slices aus einem Array. Sie müssen das Präfix @ für die Variable verwenden, um den zurückgegebenen Wert zu speichern, da es sich um eine Liste von Werten handelt.

#!/uer/bin/perl


%data = (-JohnPaul => 45, -Lisa => 30, -Kumar => 40);

@array = @data{-JohnPaul, -Lisa};

print "Array : @array\n";

Dies führt zu folgendem Ergebnis:

Array : 45 30

Schlüssel und Werte extrahieren

Mit können Sie eine Liste aller Schlüssel aus einem Hash abrufen keys Funktion, die die folgende Syntax hat -

keys %HASH

Diese Funktion gibt ein Array aller Schlüssel des genannten Hash zurück. Es folgt das Beispiel -

#!/usr/bin/perl 

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@names = keys %data;

print "$names[0]\n";
print "$names[1]\n"; print "$names[2]\n";

Dies führt zu folgendem Ergebnis:

Lisa
John Paul
Kumar

Ebenso können Sie verwenden valuesFunktion, um eine Liste aller Werte zu erhalten. Diese Funktion hat die folgende Syntax:

values %HASH

Diese Funktion gibt ein normales Array zurück, das aus allen Werten des benannten Hash besteht. Es folgt das Beispiel -

#!/usr/bin/perl 

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@ages = values %data;

print "$ages[0]\n"; print "$ages[1]\n";
print "$ages[2]\n";

Dies führt zu folgendem Ergebnis:

30
45
40

Auf Existenz prüfen

Wenn Sie versuchen, über einen nicht vorhandenen Hash auf ein Schlüssel / Wert-Paar zuzugreifen, erhalten Sie normalerweise das undefinedWenn Sie Warnungen aktiviert haben, wird zur Laufzeit eine Warnung generiert. Sie können dies umgehen, indem Sie dieexists Funktion, die true zurückgibt, wenn der benannte Schlüssel vorhanden ist, unabhängig davon, welchen Wert er haben könnte -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

if( exists($data{'Lisa'} ) ) {
   print "Lisa is $data{'Lisa'} years old\n";
} else {
   print "I don't know age of Lisa\n";
}

Hier haben wir die IF ... ELSE-Anweisung eingeführt, die wir in einem separaten Kapitel untersuchen werden. Im Moment nehmen Sie das einfach anif( condition ) Teil wird nur ausgeführt, wenn die gegebene Bedingung andernfalls wahr ist elseTeil wird ausgeführt. Wenn wir also das obige Programm ausführen, wird das folgende Ergebnis erzeugt, da hier die gegebene Bedingung vorliegt ($ data {'Lisa'} gibt true zurück -

Lisa is 30 years old

Hash-Größe abrufen

Sie können die Größe ermitteln, dh die Anzahl der Elemente aus einem Hash, indem Sie den skalaren Kontext für Schlüssel oder Werte verwenden. Sagen Sie einfach zuerst, dass Sie ein Array mit den Schlüsseln oder Werten erhalten müssen, und dann können Sie die Größe des Arrays wie folgt ermitteln:

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@keys = keys %data;
$size = @keys; print "1 - Hash size: is $size\n";

@values = values %data;
$size = @values; print "2 - Hash size: is $size\n";

Dies führt zu folgendem Ergebnis:

1 - Hash size: is 3
2 - Hash size: is 3

Hinzufügen und Entfernen von Elementen in Hashes

Das Hinzufügen eines neuen Schlüssel / Wert-Paares kann mit einer Codezeile unter Verwendung eines einfachen Zuweisungsoperators erfolgen. Um ein Element aus dem Hash zu entfernen, müssen Sie es verwendendelete Funktion wie unten im Beispiel gezeigt -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys; print "1 - Hash size: is $size\n";

# adding an element to the hash;
$data{'Ali'} = 55; @keys = keys %data; $size = @keys;
print "2 - Hash size:  is $size\n"; # delete the same element from the hash; delete $data{'Ali'};
@keys = keys %data;
$size = @keys; print "3 - Hash size: is $size\n";

Dies führt zu folgendem Ergebnis:

1 - Hash size: is 3
2 - Hash size: is 4
3 - Hash size: is 3

Perl-Bedingungsanweisungen helfen bei der Entscheidungsfindung, bei der der Programmierer eine oder mehrere Bedingungen angeben muss, die vom Programm bewertet oder getestet werden sollen, sowie eine Anweisung oder Anweisungen, die ausgeführt werden sollen, wenn die Bedingung als wahr und optional als andere bestimmt wird Anweisungen, die ausgeführt werden sollen, wenn festgestellt wird, dass die Bedingung falsch ist.

Es folgt das Allgemeine einer typischen Entscheidungsstruktur, die in den meisten Programmiersprachen zu finden ist:

Die Nummer 0, die Zeichenfolgen '0' und "", die leere Liste () und undef sind alle false in einem booleschen Kontext und alle anderen Werte sind true. Negation eines wahren Wertes durch! oder not gibt einen speziellen falschen Wert zurück.

Die Programmiersprache Perl bietet die folgenden Arten von bedingten Anweisungen.

Sr.Nr.	Aussage & Beschreibung
1	if-Anweisung Ein if statement besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.
2	if ... else-Anweisung Ein if statement kann von einem optionalen gefolgt werden else statement.
3	if ... elsif ... else-Anweisung Ein if statement kann von einem optionalen gefolgt werden elsif statement und dann durch eine optionale else statement.
4	es sei denn, Aussage Ein unless statement besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.
5	es sei denn ... sonst Aussage Ein unless statement kann von einem optionalen gefolgt werden else statement.
6	es sei denn ... elsif..else Aussage Ein unless statement kann von einem optionalen gefolgt werden elsif statement und dann durch eine optionale else statement.
7	switch-Anweisung Mit den neuesten Versionen von Perl können Sie die switchErklärung. Dies ermöglicht eine einfache Möglichkeit, einen variablen Wert mit verschiedenen Bedingungen zu vergleichen.

Das ? : Operator

Lassen Sie uns das überprüfen conditional operator ? :die verwendet werden kann, um zu ersetzen if...elseAussagen. Es hat die folgende allgemeine Form -

Exp1 ? Exp2 : Exp3;

Wobei Exp1, Exp2 und Exp3 Ausdrücke sind. Beachten Sie die Verwendung und Platzierung des Doppelpunkts.

Der Wert eines? Der Ausdruck wird wie folgt bestimmt: Exp1 wird ausgewertet. Wenn es wahr ist, wird Exp2 ausgewertet und wird zum Wert des gesamten? Ausdruck. Wenn Exp1 falsch ist, wird Exp3 ausgewertet und sein Wert wird zum Wert des Ausdrucks. Unten finden Sie ein einfaches Beispiel für die Verwendung dieses Operators:

#!/usr/local/bin/perl
 
$name = "Ali"; $age = 10;

$status = ($age > 60 )? "A senior citizen" : "Not a senior citizen";

print "$name is - $status\n";

Dies führt zu folgendem Ergebnis:

Ali is - Not a senior citizen

Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen. Im Allgemeinen werden Anweisungen nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw.

Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.

Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Im Folgenden wird die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen beschrieben:

Die Programmiersprache Perl bietet die folgenden Schleifentypen, um die Schleifenanforderungen zu erfüllen.

Sr.Nr.	Schleifentyp & Beschreibung
1	while-Schleife Wiederholt eine Anweisung oder eine Gruppe von Anweisungen, während eine bestimmte Bedingung erfüllt ist. Es testet die Bedingung, bevor der Schleifenkörper ausgeführt wird.
2	bis Schleife Wiederholt eine Anweisung oder eine Gruppe von Anweisungen, bis eine bestimmte Bedingung erfüllt ist. Es testet die Bedingung, bevor der Schleifenkörper ausgeführt wird.
3	für Schleife Führt eine Folge von Anweisungen mehrmals aus und verkürzt den Code, der die Schleifenvariable verwaltet.
4	foreach Schleife Die foreach-Schleife durchläuft einen normalen Listenwert und setzt die Variable VAR nacheinander auf jedes Element der Liste.
5	do ... while-Schleife Wie eine while-Anweisung, nur dass sie die Bedingung am Ende des Schleifenkörpers testet
6	verschachtelte Schleifen Sie können eine oder mehrere Schleifen in einer anderen while-, for- oder do..while-Schleife verwenden.

Schleifensteuerungsanweisungen

Schleifensteueranweisungen ändern die Ausführung von ihrer normalen Reihenfolge. Wenn die Ausführung einen Bereich verlässt, werden alle automatischen Objekte, die in diesem Bereich erstellt wurden, zerstört.

Perl unterstützt die folgenden Steueranweisungen. Klicken Sie auf die folgenden Links, um deren Details zu überprüfen.

Sr.Nr.	Steueranweisung & Beschreibung
1	nächste Aussage Bewirkt, dass die Schleife den Rest ihres Körpers überspringt und ihren Zustand sofort erneut testet, bevor sie wiederholt wird.
2	letzte Aussage Beendet die Schleifenanweisung und überträgt die Ausführung an die Anweisung unmittelbar nach der Schleife.
3	Aussage fortsetzen Ein fortgesetzter BLOCK wird immer ausgeführt, kurz bevor die Bedingung erneut ausgewertet werden soll.
4	Anweisung wiederholen Der Befehl redo startet den Schleifenblock neu, ohne die Bedingung erneut auszuwerten. Der Fortsetzungsblock, falls vorhanden, wird nicht ausgeführt.
5	gehe zu Aussage Perl unterstützt einen goto-Befehl mit drei Formen: goto label, goto expr und goto & name.

Die Endlosschleife

Eine Schleife wird zur Endlosschleife, wenn eine Bedingung niemals falsch wird. DasforZu diesem Zweck wird traditionell eine Schleife verwendet. Da keiner der drei Ausdrücke, die diefor Wenn eine Schleife erforderlich ist, können Sie eine Endlosschleife erstellen, indem Sie den bedingten Ausdruck leer lassen.

#!/usr/local/bin/perl
 
for( ; ; ) {
   printf "This loop will run forever.\n";
}

Sie können die obige Endlosschleife beenden, indem Sie die Tasten Strg + C drücken.

Wenn der bedingte Ausdruck fehlt, wird angenommen, dass er wahr ist. Möglicherweise haben Sie einen Initialisierungs- und Inkrementausdruck, aber als Programmierer verwenden Sie häufiger das Konstrukt for (;;), um eine Endlosschleife zu kennzeichnen.

Was ist ein Operator?

Eine einfache Antwort kann gegeben werden, indem der Ausdruck 4 + 5 gleich 9 ist . Hier heißen 4 und 5 Operanden und + Operator. Die Perl-Sprache unterstützt viele Operatortypen. Im Folgenden finden Sie eine Liste wichtiger und am häufigsten verwendeter Operatoren.

Rechenzeichen
Gleichstellungsoperatoren
Logische Operatoren
Zuweisungsoperatoren
Bitweise Operatoren
Logische Operatoren
Zitatähnliche Operatoren
Verschiedene Betreiber

Schauen wir uns alle Operatoren einzeln an.

Perl-Arithmetikoperatoren

Variable annehmen $a holds 10 and variable $b hält 20, dann folgen die Perl-Rechenoperatoren -

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	+ ( Addition ) Fügt Werte auf beiden Seiten des Operators hinzu Example - - $a + $b wird 30 geben
2	- (Subtraction) Subtrahiert den rechten Operanden vom linken Operanden Example - - $a - $b ergibt -10
3	* (Multiplication) Multipliziert Werte auf beiden Seiten des Operators Example - - $a * $b ergibt 200
4	/ (Division) Teilt den linken Operanden durch den rechten Operanden Example - - $b / $a wird 2 geben
5	% (Modulus) Teilt den linken Operanden durch den rechten Operanden und gibt den Rest zurück Example - - $b % $a ergibt 0
6	(Exponent) Führt eine Exponentialberechnung (Leistungsberechnung) für Operatoren durch Example - - $a$b gibt 10 zur Potenz 20

Perl-Gleichheitsoperatoren

Diese werden auch als Vergleichsoperatoren bezeichnet. Variable annehmen$a holds 10 and variable $Wenn b 20 hält, überprüfen wir die folgenden numerischen Gleichheitsoperatoren:

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	== (equal to) Überprüft, ob der Wert von zwei Operanden gleich ist oder nicht. Wenn ja, wird die Bedingung wahr. Example - (($a == $b) ist nicht wahr.
2	!= (not equal to) Überprüft, ob der Wert von zwei Operanden gleich ist oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. Example - (($a != $b) ist wahr.
3	<=> Überprüft, ob der Wert von zwei Operanden gleich ist oder nicht, und gibt -1, 0 oder 1 zurück, je nachdem, ob das linke Argument numerisch kleiner, gleich oder größer als das rechte Argument ist. Example - (($a <=> $b) gibt -1 zurück.
4	> (greater than) Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. Example - (($a > $b) ist nicht wahr.
5	< (less than) Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. Example - (($a < $b) ist wahr.
6	>= (greater than or equal to) Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. Example - (($a >= $b) ist nicht wahr.
7	<= (less than or equal to) Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. Example - (($a <= $b) ist wahr.

Nachfolgend finden Sie eine Liste der Aktienbetreiber. Variable annehmen$a holds "abc" and variable $Wenn b "xyz" enthält, können Sie die folgenden Zeichenfolgengleichheitsoperatoren überprüfen:

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	lt Gibt true zurück, wenn das linke Argument stringweise kleiner als das rechte Argument ist. Example - (($a lt $b) ist wahr.
2	gt Gibt true zurück, wenn das linke Argument stringweise größer als das rechte Argument ist. Example - (($a gt $b) ist falsch.
3	le Gibt true zurück, wenn das linke Argument in der Zeichenfolge kleiner oder gleich dem rechten Argument ist. Example - (($a le $b) ist wahr.
4	ge Gibt true zurück, wenn das linke Argument in der Zeichenfolge größer oder gleich dem rechten Argument ist. Example - (($a ge $b) ist falsch.
5	eq Gibt true zurück, wenn das linke Argument dem rechten Argument entspricht. Example - (($a eq $b) ist falsch.
6	ne Gibt true zurück, wenn das linke Argument stringwise nicht dem rechten Argument entspricht. Example - (($a ne $b) ist wahr.
7	cmp Gibt -1, 0 oder 1 zurück, je nachdem, ob das linke Argument kleiner als, gleich oder größer als das rechte Argument ist. Example - (($a cmp $b) ist -1.

Perl-Zuweisungsoperatoren

Variable annehmen $a holds 10 and variable $b hält 20, dann sind unten die in Perl verfügbaren Zuweisungsoperatoren und ihre Verwendung -

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	= Einfacher Zuweisungsoperator, Weist Werte von Operanden auf der rechten Seite dem Operanden auf der linken Seite zu Example - - $c = $a + $b will assigned value of $a + $b into $c
2	+= UND-Zuweisungsoperator hinzufügen. Er fügt dem linken Operanden den rechten Operanden hinzu und weist das Ergebnis dem linken Operanden zu Example - - $c += $a ist äquivalent zu $c = $c + $ a
3	-= Subtrahieren UND Zuweisungsoperator, subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu Example - $ c - = $a is equivalent to $c = $c - $ein
4	= Multiplizieren Sie den UND-Zuweisungsoperator. Er multipliziert den rechten Operanden mit dem linken Operanden und weist das Ergebnis dem linken Operanden zu Example* - - $c = $a ist äquivalent zu $c = $c $ a
5	/= UND-Zuweisungsoperator teilen. Er teilt den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu Example - $ c / = $a is equivalent to $c = $c / $ein
6	%= Modul- UND Zuweisungsoperator. Der Modul wird mit zwei Operanden verwendet und das Ergebnis dem linken Operanden zugewiesen Example - - $c %= $a ist äquivalent zu $c = $c% a
7	= Exponent UND Zuweisungsoperator, Führt eine Exponentialberechnung (Potenzberechnung) für Operatoren durch und weist dem linken Operanden einen Wert zu Example - - $c = $a ist äquivalent zu $c = $c ** $ a

Perl Bitwise Operatoren

Der bitweise Operator bearbeitet Bits und führt eine bitweise Operation durch. Angenommen, $ a = 60; und $ b = 13; Jetzt im Binärformat werden sie wie folgt sein:

$ a = 0011 1100

$ b = 0000 1101

-----------------

$ a & $ b = 0000 1100

$ a | $ b = 0011 1101

$ a ^ $ b = 0011 0001

~ $ a = 1100 0011

Es gibt folgende bitweise Operatoren, die von der Perl-Sprache unterstützt werden. Nehmen Sie an, wenn $a = 60; and $b = 13

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	& Der binäre UND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist. Example - (($a & $b) ergibt 12, was 0000 1100 ist
2	\| Der binäre ODER-Operator kopiert ein Bit, wenn es in einem anderen Operanden vorhanden ist. Example - (($a \| $b) ergibt 61, was 0011 1101 ist
3	^ Der binäre XOR-Operator kopiert das Bit, wenn es in einem Operanden gesetzt ist, aber nicht in beiden. Example - (($a ^ $b) ergibt 49, was 0011 0001 ist
4	~ Der Komplementoperator für binäre Einsen ist unär und hat den Effekt, dass Bits umgedreht werden. Example - (~ $ a) ergibt -61, was aufgrund einer vorzeichenbehafteten Binärzahl 1100 0011 in 2er-Komplementform ist.
5	<< Binärer Linksschaltoperator. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben. Example - $ a << 2 ergibt 240, was 1111 0000 ist
6	>> Binärer Rechtsschieber. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach rechts verschoben. Example - $ a >> 2 ergibt 15, was 0000 1111 ist

Perl Logical Operators

Es gibt folgende logische Operatoren, die von der Perl-Sprache unterstützt werden. Angenommen, die Variable $ a ist wahr und die Variable $ b ist falsch, dann -

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	and Wird als logischer UND-Operator bezeichnet. Wenn beide Operanden wahr sind, wird die Bedingung wahr. Example - ($ a und $ b) ist falsch.
2	&& Der logische UND-Operator im C-Stil kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist. Example - ($ a && $ b) ist falsch.
3	or Wird als logischer ODER-Operator bezeichnet. Wenn einer der beiden Operanden nicht Null ist, wird die Bedingung wahr. Example - ($ a oder $ b) ist wahr.
4	\|\| Der logische ODER-Operator im C-Stil kopiert ein Bit, wenn es in einem anderen Operanden vorhanden ist. Example - ($ a \|\| $ b) ist wahr.
5	not Wird als logischer NICHT-Operator bezeichnet. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT false. Example - nicht ($ a und $ b) ist wahr.

Zitatähnliche Operatoren

Es gibt folgende Anführungszeichen-ähnliche Operatoren, die von der Perl-Sprache unterstützt werden. In der folgenden Tabelle steht ein {} für ein beliebiges Trennzeichenpaar, das Sie auswählen.

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	q{ } Schließt eine Zeichenfolge mit einfachen Anführungszeichen ein Example - q {abcd} gibt 'abcd'
2	qq{ } Schließt eine Zeichenfolge mit doppelten Anführungszeichen ein Example - qq {abcd} gibt "abcd"
3	qx{ } Schließt eine Zeichenfolge mit invertierten Anführungszeichen ein Example - qx {abcd} gibt `abcd` an

Verschiedene Betreiber

Es gibt verschiedene Operatoren, die von der Perl-Sprache unterstützt werden. Angenommen, Variable a hält 10 und Variable b hält 20, dann -

Beispiel zeigen

Sr.Nr.	Betreiber & Beschreibung
1	. Der binäre Operator dot (.) Verkettet zwei Zeichenfolgen. Example - Wenn $ a = "abc", $b = "def" then $a. $ b gibt "abcdef"
2	x Der Wiederholungsoperator x gibt eine Zeichenfolge zurück, die aus dem linken Operanden besteht, der so oft wiederholt wird, wie vom rechten Operanden angegeben. Example - ('-' x 3) gibt ---.
3	.. Der Bereichsoperator .. gibt eine Liste von Werten zurück, die (um eins) vom linken zum rechten Wert zählen Example - (2..5) ergibt (2, 3, 4, 5)
4	++ Der Operator Auto Increment erhöht den ganzzahligen Wert um eins Example - $ a ++ ergibt 11
5	-- Der Operator "Automatische Dekrementierung" verringert den ganzzahligen Wert um eins Example - $ a-- gibt 9
6	-> Der Pfeiloperator wird hauptsächlich zum Dereferenzieren einer Methode oder Variablen von einem Objekt oder einem Klassennamen verwendet Example - $ obj->$a is an example to access variable $a from object $obj.

Perl Operators Precedence

The following table lists all operators from highest precedence to lowest.

Show Example

left	terms and list operators (leftward)
left	->
nonassoc	++ --
right	**
right	! ~ \ and unary + and -
left	=~ !~
left	* / % x
left	+ - .
left	<< >>
nonassoc	named unary operators
nonassoc	< > <= >= lt gt le ge
nonassoc	== != <=> eq ne cmp ~~
left	&
left	| ^
left	&&
left	|| //
nonassoc	..  ...
right	?:
right	= += -= *= etc.
left	, =>
nonassoc	list operators (rightward)
right	not
left	and
left	or xor

This chapter will give you the basic understanding on how to process and manipulate dates and times in Perl.

Current Date and Time

Let's start with localtime() function, which returns values for the current date and time if given no arguments. Following is the 9-element list returned by the localtime function while using in list context −

sec,     # seconds of minutes from 0 to 61
min,     # minutes of hour from 0 to 59
hour,    # hours of day from 0 to 24
mday,    # day of month from 1 to 31
mon,     # month of year from 0 to 11
year,    # year since 1900
wday,    # days since sunday
yday,    # days since January 1st
isdst    # hours of daylight savings time

Try the following example to print different elements returned by localtime() function −

#!/usr/local/bin/perl
 
@months = qw( Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec );
@days = qw(Sun Mon Tue Wed Thu Fri Sat Sun);

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
print "$mday $months[$mon] $days[$wday]\n";

When the above code is executed, it produces the following result −

16 Feb Sat

If you will use localtime() function in scalar context, then it will return date and time from the current time zone set in the system. Try the following example to print current date and time in full format −

#!/usr/local/bin/perl
 
$datestring = localtime();
print "Local date and time $datestring\n";

When the above code is executed, it produces the following result −

Local date and time Sat Feb 16 06:50:45 2013

GMT Time

The function gmtime() works just like localtime() function but the returned values are localized for the standard Greenwich time zone. When called in list context, $isdst, the last value returned by gmtime, is always 0. There is no Daylight Saving Time in GMT.

You should make a note on the fact that localtime() will return the current local time on the machine that runs the script and gmtime() will return the universal Greenwich Mean Time, or GMT (or UTC).

Try the following example to print the current date and time but on GMT scale −

#!/usr/local/bin/perl

$datestring = gmtime(); print "GMT date and time $datestring\n";

When the above code is executed, it produces the following result −

GMT date and time Sat Feb 16 13:50:45 2013

Format Date and Time

You can use localtime() function to get a list of 9-elements and later you can use the printf() function to format date and time based on your requirements as follows −

#!/usr/local/bin/perl
 
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(); printf("Time Format - HH:MM:SS\n"); printf("%02d:%02d:%02d", $hour, $min, $sec);

When the above code is executed, it produces the following result −

Time Format - HH:MM:SS
06:58:52

Epoch time

You can use the time() function to get epoch time, i.e., the numbers of seconds that have elapsed since a given date, in Unix is January 1, 1970.

#!/usr/local/bin/perl
 
$epoc = time(); print "Number of seconds since Jan 1, 1970 - $epoc\n";

When the above code is executed, it produces the following result −

Number of seconds since Jan 1, 1970 - 1361022130

You can convert a given number of seconds into date and time string as follows −

#!/usr/local/bin/perl

$datestring = localtime(); print "Current date and time $datestring\n";

$epoc = time(); $epoc = $epoc - 24 * 60 * 60; # one day before of current date. $datestring = localtime($epoc); print "Yesterday's date and time $datestring\n";

When the above code is executed, it produces the following result −

Current date and time Tue Jun  5 05:54:43 2018
Yesterday's date and time Mon Jun  4 05:54:43 2018

POSIX Function strftime()

You can use the POSIX function strftime() to format date and time with the help of the following table. Please note that the specifiers marked with an asterisk (*) are locale-dependent.

Specifier	Replaced by	Example
`%a`	Abbreviated weekday name *	`Thu`
`%A`	Full weekday name *	`Thursday`
`%b`	Abbreviated month name *	`Aug`
`%B`	Full month name *	`August`
`%c`	Date and time representation *	`Thu Aug 23 14:55:02 2001`
`%C`	Year divided by 100 and truncated to integer (`00-99`)	`20`
`%d`	Day of the month, zero-padded (`01-31`)	`23`
`%D`	Short `MM/DD/YY` date, equivalent to `%m/%d/%y`	`08/23/01`
`%e`	Day of the month, space-padded (`1-31`)	`23`
`%F`	Short `YYYY-MM-DD` date, equivalent to `%Y-%m-%d`	`2001-08-23`
`%g`	Week-based year, last two digits (`00-99`)	`01`
`%G`	Week-based year	`2001`
`%h`	Abbreviated month name * (same as `%b`)	`Aug`
`%H`	Hour in 24h format (`00-23`)	`14`
`%I`	Hour in 12h format (`01-12`)	`02`
`%j`	Day of the year (`001-366`)	`235`
`%m`	Month as a decimal number (`01-12`)	`08`
`%M`	Minute (`00-59`)	`55`
`%n`	New-line character (`'\n'`)
`%p`	AM or PM designation	`PM`
`%r`	12-hour clock time *	`02:55:02 pm`
`%R`	24-hour `HH:MM` time, equivalent to `%H:%M`	`14:55`
`%S`	Second (`00-61`)	`02`
`%t`	Horizontal-tab character (`'\t'`)
`%T`	ISO 8601 time format (`HH:MM:SS`), equivalent to `%H:%M:%S`	`14:55`
`%u`	ISO 8601 weekday as number with Monday as `1` (`1-7`)	`4`
`%U`	Week number with the first Sunday as the first day of week one (`00-53`)	`33`
`%V`	ISO 8601 week number (`00-53`)	`34`
`%w`	Weekday as a decimal number with Sunday as `0` (`0-6`)	`4`
`%W`	Week number with the first Monday as the first day of week one (`00-53`)	`34`
`%x`	Date representation *	`08/23/01`
`%X`	Time representation *	`14:55:02`
`%y`	Year, last two digits (`00-99`)	`01`
`%Y`	Year	`2001`
`%z`	ISO 8601 offset from UTC in timezone (1 minute = 1, 1 hour = 100) If timezone cannot be termined, no characters	`+100`
`%Z`	Timezone name or abbreviation * If timezone cannot be termined, no characters	`CDT`
`%%`	A `%` sign	`%`

Let's check the following example to understand the usage −

#!/usr/local/bin/perl
use POSIX qw(strftime);

$datestring = strftime "%a %b %e %H:%M:%S %Y", localtime; printf("date and time - $datestring\n");

# or for GMT formatted appropriately for your locale:
$datestring = strftime "%a %b %e %H:%M:%S %Y", gmtime; printf("date and time - $datestring\n");

When the above code is executed, it produces the following result −

date and time - Sat Feb 16 07:10:23 2013
date and time - Sat Feb 16 14:10:23 2013

A Perl subroutine or function is a group of statements that together performs a task. You can divide up your code into separate subroutines. How you divide up your code among different subroutines is up to you, but logically the division usually is so each function performs a specific task.

Perl uses the terms subroutine, method and function interchangeably.

Define and Call a Subroutine

The general form of a subroutine definition in Perl programming language is as follows −

sub subroutine_name {
   body of the subroutine
}

The typical way of calling that Perl subroutine is as follows −

subroutine_name( list of arguments );

In versions of Perl before 5.0, the syntax for calling subroutines was slightly different as shown below. This still works in the newest versions of Perl, but it is not recommended since it bypasses the subroutine prototypes.

&subroutine_name( list of arguments );

Let's have a look into the following example, which defines a simple function and then call it. Because Perl compiles your program before executing it, it doesn't matter where you declare your subroutine.

#!/usr/bin/perl

# Function definition
sub Hello {
   print "Hello, World!\n";
}

# Function call
Hello();

When above program is executed, it produces the following result −

Hello, World!

Passing Arguments to a Subroutine

You can pass various arguments to a subroutine like you do in any other programming language and they can be acessed inside the function using the special array @_. Thus the first argument to the function is in $_[0], the second is in $_[1], and so on.

You can pass arrays and hashes as arguments like any scalar but passing more than one array or hash normally causes them to lose their separate identities. So we will use references ( explained in the next chapter ) to pass any array or hash.

Let's try the following example, which takes a list of numbers and then prints their average −

#!/usr/bin/perl

# Function definition
sub Average {
   # get total number of arguments passed.
   $n = scalar(@_); $sum = 0;

   foreach $item (@_) { $sum += $item; } $average = $sum / $n;

   print "Average for the given numbers : $average\n";
}

# Function call
Average(10, 20, 30);

When above program is executed, it produces the following result −

Average for the given numbers : 20

Passing Lists to Subroutines

Because the @_ variable is an array, it can be used to supply lists to a subroutine. However, because of the way in which Perl accepts and parses lists and arrays, it can be difficult to extract the individual elements from @_. If you have to pass a list along with other scalar arguments, then make list as the last argument as shown below −

#!/usr/bin/perl

# Function definition
sub PrintList {
   my @list = @_;
   print "Given list is @list\n";
}
$a = 10;
@b = (1, 2, 3, 4);

# Function call with list parameter
PrintList($a, @b);

When above program is executed, it produces the following result −

Given list is 10 1 2 3 4

Passing Hashes to Subroutines

When you supply a hash to a subroutine or operator that accepts a list, then hash is automatically translated into a list of key/value pairs. For example −

#!/usr/bin/perl

# Function definition
sub PrintHash {
   my (%hash) = @_;

   foreach my $key ( keys %hash ) {
      my $value = $hash{$key}; print "$key : $value\n";
   }
}
%hash = ('name' => 'Tom', 'age' => 19);

# Function call with hash parameter
PrintHash(%hash);

When above program is executed, it produces the following result −

name : Tom
age : 19

Returning Value from a Subroutine

You can return a value from subroutine like you do in any other programming language. If you are not returning a value from a subroutine then whatever calculation is last performed in a subroutine is automatically also the return value.

You can return arrays and hashes from the subroutine like any scalar but returning more than one array or hash normally causes them to lose their separate identities. So we will use references ( explained in the next chapter ) to return any array or hash from a function.

Let's try the following example, which takes a list of numbers and then returns their average −

#!/usr/bin/perl

# Function definition
sub Average {
   # get total number of arguments passed.
   $n = scalar(@_);
   $sum = 0; foreach $item (@_) {
      $sum += $item;
   }
   $average = $sum / $n; return $average;
}

# Function call
$num = Average(10, 20, 30); print "Average for the given numbers : $num\n";

When above program is executed, it produces the following result −

Average for the given numbers : 20

Private Variables in a Subroutine

By default, all variables in Perl are global variables, which means they can be accessed from anywhere in the program. But you can create private variables called lexical variables at any time with the my operator.

The my operator confines a variable to a particular region of code in which it can be used and accessed. Outside that region, this variable cannot be used or accessed. This region is called its scope. A lexical scope is usually a block of code with a set of braces around it, such as those defining the body of the subroutine or those marking the code blocks of if, while, for, foreach, and eval statements.

Following is an example showing you how to define a single or multiple private variables using my operator −

sub somefunc {
   my $variable; # $variable is invisible outside somefunc()
   my ($another, @an_array, %a_hash); # declaring many variables at once
}

Let's check the following example to distinguish between global and private variables −

#!/usr/bin/perl

# Global variable
$string = "Hello, World!";

# Function definition
sub PrintHello {
   # Private variable for PrintHello function
   my $string; $string = "Hello, Perl!";
   print "Inside the function $string\n"; } # Function call PrintHello(); print "Outside the function $string\n";

When above program is executed, it produces the following result −

Inside the function Hello, Perl!
Outside the function Hello, World!

Temporary Values via local()

The local is mostly used when the current value of a variable must be visible to called subroutines. A local just gives temporary values to global (meaning package) variables. This is known as dynamic scoping. Lexical scoping is done with my, which works more like C's auto declarations.

If more than one variable or expression is given to local, they must be placed in parentheses. This operator works by saving the current values of those variables in its argument list on a hidden stack and restoring them upon exiting the block, subroutine, or eval.

Let's check the following example to distinguish between global and local variables −

#!/usr/bin/perl

# Global variable
$string = "Hello, World!"; sub PrintHello { # Private variable for PrintHello function local $string;
   $string = "Hello, Perl!"; PrintMe(); print "Inside the function PrintHello $string\n";
}
sub PrintMe {
   print "Inside the function PrintMe $string\n"; } # Function call PrintHello(); print "Outside the function $string\n";

When above program is executed, it produces the following result −

Inside the function PrintMe Hello, Perl!
Inside the function PrintHello Hello, Perl!
Outside the function Hello, World!

State Variables via state()

There are another type of lexical variables, which are similar to private variables but they maintain their state and they do not get reinitialized upon multiple calls of the subroutines. These variables are defined using the state operator and available starting from Perl 5.9.4.

Let's check the following example to demonstrate the use of state variables −

#!/usr/bin/perl

use feature 'state';

sub PrintCount {
   state $count = 0; # initial value print "Value of counter is $count\n";
   $count++;
}

for (1..5) {
   PrintCount();
}

When above program is executed, it produces the following result −

Value of counter is 0
Value of counter is 1
Value of counter is 2
Value of counter is 3
Value of counter is 4

Prior to Perl 5.10, you would have to write it like this −

#!/usr/bin/perl

{
   my $count = 0; # initial value

   sub PrintCount {
      print "Value of counter is $count\n"; $count++;
   }
}

for (1..5) {
   PrintCount();
}

Subroutine Call Context

The context of a subroutine or statement is defined as the type of return value that is expected. This allows you to use a single function that returns different values based on what the user is expecting to receive. For example, the following localtime() returns a string when it is called in scalar context, but it returns a list when it is called in list context.

my $datestring = localtime( time );

In this example, the value of $timestr is now a string made up of the current date and time, for example, Thu Nov 30 15:21:33 2000. Conversely −

($sec,$min,$hour,$mday,$mon, $year,$wday,$yday,$isdst) = localtime(time);

Now the individual variables contain the corresponding values returned by localtime() subroutine.

A Perl reference is a scalar data type that holds the location of another value which could be scalar, arrays, or hashes. Because of its scalar nature, a reference can be used anywhere, a scalar can be used.

You can construct lists containing references to other lists, which can contain references to hashes, and so on. This is how the nested data structures are built in Perl.

Create References

It is easy to create a reference for any variable, subroutine or value by prefixing it with a backslash as follows −

$scalarref = \$foo; $arrayref  = \@ARGV;
$hashref = \%ENV; $coderef   = \&handler;
$globref   = \*foo;

You cannot create a reference on an I/O handle (filehandle or dirhandle) using the backslash operator but a reference to an anonymous array can be created using the square brackets as follows −

$arrayref = [1, 2, ['a', 'b', 'c']];

Similar way you can create a reference to an anonymous hash using the curly brackets as follows −

$hashref = {
   'Adam'  => 'Eve',
   'Clyde' => 'Bonnie',
};

A reference to an anonymous subroutine can be created by using sub without a subname as follows −

$coderef = sub { print "Boink!\n" };

Dereferencing

Dereferencing returns the value from a reference point to the location. To dereference a reference simply use $, @ or % as prefix of the reference variable depending on whether the reference is pointing to a scalar, array, or hash. Following is the example to explain the concept −

#!/usr/bin/perl

$var = 10;

# Now $r has reference to $var scalar.
$r = \$var;

# Print value available at the location stored in $r. print "Value of $var is : ", $$r, "\n"; @var = (1, 2, 3); # Now $r has reference to @var array.
$r = \@var; # Print values available at the location stored in $r.
print "Value of @var is : ",  @$r, "\n"; %var = ('key1' => 10, 'key2' => 20); # Now $r has reference to %var hash.
$r = \%var; # Print values available at the location stored in $r.
print "Value of %var is : ", %$r, "\n";

When above program is executed, it produces the following result −

Value of 10 is : 10
Value of 1 2 3 is : 123
Value of %var is : key220key110

If you are not sure about a variable type, then its easy to know its type using ref, which returns one of the following strings if its argument is a reference. Otherwise, it returns false −

SCALAR
ARRAY
HASH
CODE
GLOB
REF

Let's try the following example −

#!/usr/bin/perl

$var = 10;
$r = \$var;
print "Reference type in r : ", ref($r), "\n"; @var = (1, 2, 3); $r = \@var;
print "Reference type in r : ", ref($r), "\n"; %var = ('key1' => 10, 'key2' => 20); $r = \%var;
print "Reference type in r : ", ref($r), "\n";

When above program is executed, it produces the following result −

Reference type in r : SCALAR
Reference type in r : ARRAY
Reference type in r : HASH

Circular References

A circular reference occurs when two references contain a reference to each other. You have to be careful while creating references otherwise a circular reference can lead to memory leaks. Following is an example −

#!/usr/bin/perl

 my $foo = 100;
 $foo = \$foo;
 
 print "Value of foo is : ", $$foo, "\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Value of foo is : REF(0x9aae38)

Verweise auf Funktionen

Dies kann vorkommen, wenn Sie einen Signalhandler erstellen müssen, damit Sie eine Referenz auf eine Funktion erstellen können, indem Sie diesem Funktionsnamen \ & voranstellen. Um diese Referenz zu dereferenzieren, müssen Sie lediglich eine Referenzvariable mit kaufmännischem Und & voranstellen. Das Folgende ist ein Beispiel -

#!/usr/bin/perl

# Function definition
sub PrintHash {
   my (%hash) = @_;
   
   foreach $item (%hash) {
      print "Item : $item\n"; } } %hash = ('name' => 'Tom', 'age' => 19); # Create a reference to above function. $cref = \&PrintHash;

# Function call using reference.
&$cref(%hash);

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Item : name
Item : Tom
Item : age
Item : 19

Perl verwendet eine Schreibvorlage namens "Format", um Berichte auszugeben. Um die Formatierungsfunktion von Perl zu verwenden, müssen Sie zuerst ein Format definieren und dann dieses Format zum Schreiben formatierter Daten verwenden.

Definieren Sie ein Format

Es folgt die Syntax zum Definieren eines Perl-Formats:

format FormatName =
fieldline
value_one, value_two, value_three
fieldline
value_one, value_two
.

Hier FormatNamerepräsentiert den Namen des Formats. DasfieldlineAuf diese Weise sollten die Daten formatiert werden. Die Wertezeilen stellen die Werte dar, die in die Feldzeile eingegeben werden. Sie beenden das Format mit einem einzelnen Punkt.

Nächster fieldlinekann beliebigen Text oder Feldhalter enthalten. Die Feldhalter bieten Platz für Daten, die zu einem späteren Zeitpunkt dort abgelegt werden. Ein Feldhalter hat das Format -

@<<<<

Dieser Feldhalter ist linksbündig mit einem Feld von 5. Sie müssen das @ -Zeichen und die <-Zeichen zählen, um die Anzahl der Felder im Feld zu ermitteln. Andere Feldhalter sind -

@>>>> right-justified
@|||| centered
@####.## numeric field holder
@* multiline field holder

Ein Beispielformat wäre -

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age @#####.## $salary
===================================
.

In diesem Beispiel wird $ name innerhalb von 22 Zeichen als linksbündig und nach diesem Alter in zwei Leerzeichen geschrieben.

Verwenden des Formats

Um diese Formatdeklaration aufzurufen, verwenden wir die write Schlüsselwort -

write EMPLOYEE;

Das Problem ist, dass der Formatname normalerweise der Name eines geöffneten Dateihandles ist und die write-Anweisung die Ausgabe an dieses Dateihandle sendet. Da die Daten an STDOUT gesendet werden sollen, müssen wir EMPLOYEE dem STDOUT-Dateihandle zuordnen. Zunächst müssen wir jedoch mithilfe der Funktion select () sicherstellen, dass STDOUT unser ausgewähltes Dateihandle ist.

select(STDOUT);

Wir würden dann EMPLOYEE mit STDOUT verknüpfen, indem wir den neuen Formatnamen mit STDOUT setzen und die spezielle Variable $ ~ oder $ FORMAT_NAME wie folgt verwenden:

$~ = "EMPLOYEE";

Wenn wir jetzt ein write () ausführen, werden die Daten an STDOUT gesendet. Denken Sie daran: Wenn Sie Ihren Bericht in einem anderen Dateihandle anstelle von STDOUT schreiben möchten, können Sie mit der Funktion select () dieses Dateihandle auswählen, und der Rest der Logik bleibt unverändert.

Nehmen wir das folgende Beispiel. Hier haben wir fest codierte Werte, nur um die Verwendung anzuzeigen. Bei der tatsächlichen Verwendung lesen Sie Werte aus einer Datei oder Datenbank, um tatsächliche Berichte zu erstellen, und müssen möglicherweise den Abschlussbericht erneut in eine Datei schreiben.

#!/usr/bin/perl

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age
@#####.##
$salary =================================== . select(STDOUT); $~ = EMPLOYEE;

@n = ("Ali", "Raza", "Jaffer");
@a  = (20,30, 40);
@s = (2000.00, 2500.00, 4000.000);

$i = 0; foreach (@n) { $name = $_; $age = $a[$i];
   $salary = $s[$i++];
   write;
}

Bei der Ausführung wird das folgende Ergebnis erzielt:

===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Definieren Sie einen Berichtskopf

Alles sieht gut aus. Sie möchten jedoch Ihrem Bericht eine Kopfzeile hinzufügen. Dieser Header wird oben auf jeder Seite gedruckt. Das ist sehr einfach. Abgesehen von der Definition einer Vorlage müssten Sie einen Header definieren und ihn der Variablen $ ^ oder $ FORMAT_TOP_NAME zuweisen -

#!/usr/bin/perl

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age @#####.## $salary
===================================
.

format EMPLOYEE_TOP =
===================================
Name                    Age
===================================
.

select(STDOUT);
$~ = EMPLOYEE; $^ = EMPLOYEE_TOP;

@n = ("Ali", "Raza", "Jaffer");
@a  = (20,30, 40);
@s = (2000.00, 2500.00, 4000.000);

$i = 0; foreach (@n) { $name = $_; $age = $a[$i];
   $salary = $s[$i++];
   write;
}

Jetzt sieht Ihr Bericht so aus:

===================================
Name                    Age
===================================
===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Definieren Sie eine Paginierung

Was ist, wenn Ihr Bericht mehr als eine Seite umfasst? Sie haben eine Lösung dafür, verwenden Sie einfach$% oder $ FORMAT_PAGE_NUMBER zusammen mit dem Header wie folgt vairable -

format EMPLOYEE_TOP =
===================================
Name                    Age Page @<
                                 $%
===================================                               
.

Jetzt sieht Ihre Ausgabe wie folgt aus:

===================================
Name                    Age Page 1
===================================
===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Anzahl der Zeilen auf einer Seite

Sie können die Anzahl der Zeilen pro Seite mithilfe einer speziellen Variablen festlegen $= (oder $ FORMAT_LINES_PER_PAGE), Standardmäßig ist $ = 60.

Definieren Sie eine Berichtsfußzeile

Während $ ^ oder $FORMAT_TOP_NAME contains the name of the current header format, there is no corresponding mechanism to automatically do the same thing for a footer. If you have a fixed-size footer, you can get footers by checking variable $- oder $ FORMAT_LINES_LEFT vor jedem Schreiben () und drucken Sie die Fußzeile bei Bedarf selbst in einem anderen Format, das wie folgt definiert ist -

format EMPLOYEE_BOTTOM =
End of Page @<
            $%
.

Eine vollständige Liste der Variablen zum Formatieren finden Sie im Abschnitt Perl-Spezialvariablen .

Die Grundlagen des Umgangs mit Dateien sind einfach: Sie ordnen a zu filehandle mit einer externen Entität (normalerweise einer Datei) und verwenden Sie dann eine Vielzahl von Operatoren und Funktionen in Perl, um die Daten zu lesen und zu aktualisieren, die in dem mit dem Dateihandle verknüpften Datenstrom gespeichert sind.

Ein Dateihandle ist eine benannte interne Perl-Struktur, die eine physische Datei mit einem Namen verknüpft. Alle Dateihandles können lesen / schreiben, sodass Sie alle Dateien oder Geräte lesen und aktualisieren können, die einem Dateihandle zugeordnet sind. Wenn Sie jedoch ein Dateihandle zuordnen, können Sie den Modus angeben, in dem das Dateihandle geöffnet wird.

Drei grundlegende Dateihandles sind - STDIN, STDOUT, und STDERR, die Standardeingabe-, Standardausgabe- und Standardfehlergeräte darstellen.

Dateien öffnen und schließen

Es gibt zwei Funktionen mit mehreren Formularen, mit denen Sie jede neue oder vorhandene Datei in Perl öffnen können.

open FILEHANDLE, EXPR
open FILEHANDLE

sysopen FILEHANDLE, FILENAME, MODE, PERMS
sysopen FILEHANDLE, FILENAME, MODE

Hier ist FILEHANDLE das vom open Funktion und EXPR ist der Ausdruck mit dem Dateinamen und dem Modus zum Öffnen der Datei.

Funktion öffnen

Es folgt die zu öffnende Syntax file.txtim schreibgeschützten Modus. Hier bedeutet weniger als <Zeichen, dass die Datei im schreibgeschützten Modus geöffnet werden muss.

open(DATA, "<file.txt");

Hier ist DATA das Dateihandle, mit dem die Datei gelesen wird. Hier ist das Beispiel, das eine Datei öffnet und ihren Inhalt über den Bildschirm druckt.

#!/usr/bin/perl

open(DATA, "<file.txt") or die "Couldn't open file file.txt, $!"; while(<DATA>) { print "$_";
}

Es folgt die Syntax zum Öffnen von file.txt im Schreibmodus. Hier bedeutet weniger als>, dass die Datei im Schreibmodus geöffnet werden muss.

open(DATA, ">file.txt") or die "Couldn't open file file.txt, $!";

In diesem Beispiel wird die Datei tatsächlich abgeschnitten (geleert), bevor sie zum Schreiben geöffnet wird. Dies ist möglicherweise nicht der gewünschte Effekt. Wenn Sie eine Datei zum Lesen und Schreiben öffnen möchten, können Sie vor den Zeichen> oder <ein Pluszeichen setzen.

Zum Beispiel, um eine Datei zum Aktualisieren zu öffnen, ohne sie abzuschneiden -

open(DATA, "+<file.txt"); or die "Couldn't open file file.txt, $!";

So schneiden Sie die Datei zuerst ab -

open DATA, "+>file.txt" or die "Couldn't open file file.txt, $!";

Sie können eine Datei im Anhänge-Modus öffnen. In diesem Modus wird der Schreibpunkt auf das Ende der Datei gesetzt.

open(DATA,">>file.txt") || die "Couldn't open file file.txt, $!";

Ein doppeltes >> öffnet die Datei zum Anhängen und platziert den Dateizeiger am Ende, sodass Sie sofort mit dem Anhängen von Informationen beginnen können. Sie können jedoch nur dann daraus lesen, wenn Sie auch ein Pluszeichen davor platzieren.

open(DATA,"+>>file.txt") || die "Couldn't open file file.txt, $!";

Es folgt die Tabelle, in der die möglichen Werte der verschiedenen Modi aufgeführt sind

Sr.Nr.	Entitäten & Definition
1	< or r Schreibgeschützter Zugriff
2	> or w Erstellt, schreibt und schneidet ab
3	>> or a Schreibt, hängt an und erstellt
4	+< or r+ Liest und schreibt
5	+> or w+ Liest, schreibt, erstellt und schneidet ab
6	+>> or a+ Liest, schreibt, hängt an und erstellt

Sysopen-Funktion

Das sysopen Die Funktion ähnelt der Hauptöffnungsfunktion, verwendet jedoch das System open() Funktion unter Verwendung der ihm zur Verfügung gestellten Parameter als Parameter für die Systemfunktion -

Um beispielsweise eine Datei zum Aktualisieren zu öffnen, emulieren Sie die +<filename Format von offen -

sysopen(DATA, "file.txt", O_RDWR);

Oder um die Datei vor dem Aktualisieren abzuschneiden -

sysopen(DATA, "file.txt", O_RDWR|O_TRUNC );

Sie können O_CREAT verwenden, um eine neue Datei zu erstellen, und O_WRONLY, um eine Datei im schreibgeschützten Modus zu öffnen, und O_RDONLY, um eine Datei im schreibgeschützten Modus zu öffnen.

Das PERMSArgument gibt die Dateiberechtigungen für die angegebene Datei an, wenn diese erstellt werden muss. Standardmäßig dauert es0x666.

Es folgt die Tabelle, in der die möglichen Werte von MODE angegeben sind.

Sr.Nr.	Entitäten & Definition
1	O_RDWR Lesen und Schreiben
2	O_RDONLY Schreibgeschützt
3	O_WRONLY Nur schreiben
4	O_CREAT Erstellen Sie die Datei
5	O_APPEND Hängen Sie die Datei an
6	O_TRUNC Schneiden Sie die Datei ab
7	O_EXCL Stoppt, wenn die Datei bereits vorhanden ist
8	O_NONBLOCK Nicht blockierende Benutzerfreundlichkeit

Funktion schließen

Um ein Dateihandle zu schließen und damit das Dateihandle von der entsprechenden Datei zu trennen, verwenden Sie die closeFunktion. Dadurch werden die Puffer des Dateihandles geleert und der Dateideskriptor des Systems geschlossen.

close FILEHANDLE
close

Wenn kein FILEHANDLE angegeben ist, wird das aktuell ausgewählte Dateihandle geschlossen. Es wird nur dann true zurückgegeben, wenn die Puffer erfolgreich geleert und die Datei geschlossen werden konnte.

close(DATA) || die "Couldn't close file properly";

Dateien lesen und schreiben

Sobald Sie ein offenes Dateihandle haben, müssen Sie in der Lage sein, Informationen zu lesen und zu schreiben. Es gibt verschiedene Möglichkeiten, Daten in die Datei zu lesen und zu schreiben.

Der Operator <FILEHANDL>

Die Hauptmethode zum Lesen der Informationen aus einem geöffneten Dateihandle ist der Operator <FILEHANDLE>. In einem skalaren Kontext wird eine einzelne Zeile aus dem Dateihandle zurückgegeben. Zum Beispiel -

#!/usr/bin/perl

print "What is your name?\n";
$name = <STDIN>;
print "Hello $name\n";

Wenn Sie den Operator <FILEHANDLE> in einem Listenkontext verwenden, wird eine Liste von Zeilen aus dem angegebenen Dateihandle zurückgegeben. Zum Beispiel, um alle Zeilen aus einer Datei in ein Array zu importieren -

#!/usr/bin/perl

open(DATA,"<import.txt") or die "Can't open data";
@lines = <DATA>;
close(DATA);

getc Funktion

Die Funktion getc gibt ein einzelnes Zeichen aus dem angegebenen FILEHANDLE oder STDIN zurück, wenn keines angegeben ist.

getc FILEHANDLE
getc

Wenn ein Fehler aufgetreten ist oder sich das Dateihandle am Ende der Datei befindet, wird stattdessen undef zurückgegeben.

Funktion lesen

Die Lesefunktion liest einen Informationsblock aus dem gepufferten Dateihandle: Mit dieser Funktion werden Binärdaten aus der Datei gelesen.

read FILEHANDLE, SCALAR, LENGTH, OFFSET
read FILEHANDLE, SCALAR, LENGTH

Die Länge der gelesenen Daten wird durch LENGTH definiert, und die Daten werden am Anfang von SCALAR platziert, wenn kein OFFSET angegeben ist. Andernfalls werden Daten nach OFFSET-Bytes in SCALAR platziert. Die Funktion gibt die Anzahl der bei Erfolg gelesenen Bytes zurück, Null am Ende der Datei oder undef, wenn ein Fehler aufgetreten ist.

Druckfunktion

Bei all den verschiedenen Methoden zum Lesen von Informationen aus Dateihandles ist die Hauptfunktion zum Zurückschreiben von Informationen die Druckfunktion.

print FILEHANDLE LIST
print LIST
print

Die Druckfunktion druckt den ausgewerteten Wert von LIST in FILEHANDLE oder in das aktuelle Ausgabe-Dateihandle (standardmäßig STDOUT). Zum Beispiel -

print "Hello World!\n";

Dateien kopieren

Hier ist das Beispiel, in dem eine vorhandene Datei file1.txt geöffnet, zeilenweise gelesen und eine weitere Kopierdatei file2.txt generiert wird.

#!/usr/bin/perl

# Open file to read
open(DATA1, "<file1.txt");

# Open new file to write
open(DATA2, ">file2.txt");

# Copy data from one file to another.
while(<DATA1>) {
   print DATA2 $_;
}
close( DATA1 );
close( DATA2 );

Datei umbenennen

Hier ist ein Beispiel, das zeigt, wie wir eine Datei file1.txt in file2.txt umbenennen können. Angenommen, die Datei ist im Verzeichnis / usr / test verfügbar.

#!/usr/bin/perl

rename ("/usr/test/file1.txt", "/usr/test/file2.txt" );

Diese Funktion renames nimmt zwei Argumente und benennt nur die vorhandene Datei um.

Vorhandene Datei löschen

Hier ist ein Beispiel, das zeigt, wie eine Datei file1.txt mit dem gelöscht wird unlink Funktion.

#!/usr/bin/perl

unlink ("/usr/test/file1.txt");

Positionierung in einer Datei

Sie können verwenden, um tell Funktion, um die aktuelle Position einer Datei zu kennen und seek Funktion zum Zeigen einer bestimmten Position innerhalb der Datei.

Funktion erzählen

Die erste Voraussetzung ist, Ihre Position in einer Datei zu finden, was Sie mit der Tell-Funktion tun -

tell FILEHANDLE
tell

Dies gibt die Position des Dateizeigers in Bytes innerhalb von FILEHANDLE zurück, falls angegeben, oder das aktuell standardmäßig ausgewählte Dateihandle, falls keines angegeben ist.

Funktion suchen

Die Suchfunktion positioniert den Dateizeiger auf die angegebene Anzahl von Bytes in einer Datei -

seek FILEHANDLE, POSITION, WHENCE

Die Funktion verwendet die fseek-Systemfunktion, und Sie haben die gleiche Fähigkeit, relativ zu drei verschiedenen Punkten zu positionieren: dem Start, dem Ende und der aktuellen Position. Sie tun dies, indem Sie einen Wert für WHENCE angeben.

Null legt die Position relativ zum Dateianfang fest. Beispielsweise setzt die Zeile den Dateizeiger auf das 256. Byte in der Datei.

seek DATA, 256, 0;

Dateiinformationen

Sie können bestimmte Funktionen in Perl sehr schnell mit einer Reihe von Testoperatoren testen, die zusammen als -X-Tests bezeichnet werden. Um beispielsweise einen schnellen Test der verschiedenen Berechtigungen für eine Datei durchzuführen, können Sie ein Skript wie das folgende verwenden:

#/usr/bin/perl

my $file = "/usr/test/file1.txt"; my (@description, $size);
if (-e $file) { push @description, 'binary' if (-B _); push @description, 'a socket' if (-S _); push @description, 'a text file' if (-T _); push @description, 'a block special file' if (-b _); push @description, 'a character special file' if (-c _); push @description, 'a directory' if (-d _); push @description, 'executable' if (-x _); push @description, (($size = -s _)) ? "$size bytes" : 'empty'; print "$file is ", join(', ',@description),"\n";
}

Hier ist die Liste der Funktionen, die Sie für eine Datei oder ein Verzeichnis überprüfen können -

Sr.Nr.	Operator & Definition
1	-A Startzeit des Skripts abzüglich der letzten Zugriffszeit der Datei in Tagen.
2	-B Ist es eine Binärdatei?
3	-C Startzeit des Skripts abzüglich der letzten Inode-Änderungszeit der Datei in Tagen.
3	-M Startzeit des Skripts abzüglich der Änderungszeit der Datei in Tagen.
4	-O Ist die Datei im Besitz der realen Benutzer-ID?
5	-R Ist die Datei für die reale Benutzer-ID oder die reale Gruppe lesbar?
6	-S Ist die Datei ein Socket?
7	-T Ist es eine Textdatei?
8	-W Ist die Datei durch die reale Benutzer-ID oder die reale Gruppe beschreibbar?
9	-X Ist die Datei mit der realen Benutzer-ID oder der realen Gruppe ausführbar?
10	-b Ist es eine Block-Spezialdatei?
11	-c Ist es eine spezielle Zeichendatei?
12	-d Ist die Datei ein Verzeichnis?
13	-e Existiert die Datei?
14	-f Ist es eine einfache Datei?
15	-g Hat die Datei das setgid-Bit gesetzt?
16	-k Hat die Datei das Sticky-Bit gesetzt?
17	-l Ist die Datei ein symbolischer Link?
18	-o Ist die Datei im Besitz der effektiven Benutzer-ID?
19	-p Ist die Datei eine Named Pipe?
20	-r Ist die Datei für die effektive Benutzer- oder Gruppen-ID lesbar?
21	-s Gibt die Größe der Datei zurück, Nullgröße = leere Datei.
22	-t Wird das Dateihandle von einem TTY (Terminal) geöffnet?
23	-u Hat die Datei das Setuid-Bit gesetzt?
24	-w Ist die Datei durch die effektive Benutzer- oder Gruppen-ID beschreibbar?
25	-x Ist die Datei durch die effektive Benutzer- oder Gruppen-ID ausführbar?
26	-z Ist die Dateigröße Null?

Im Folgenden sind die Standardfunktionen aufgeführt, die zum Spielen mit Verzeichnissen verwendet werden.

opendir DIRHANDLE, EXPR  # To open a directory
readdir DIRHANDLE        # To read a directory
rewinddir DIRHANDLE      # Positioning pointer to the begining
telldir DIRHANDLE        # Returns current position of the dir
seekdir DIRHANDLE, POS   # Pointing pointer to POS inside dir
closedir DIRHANDLE       # Closing a directory.

Alle Dateien anzeigen

Es gibt verschiedene Möglichkeiten, alle in einem bestimmten Verzeichnis verfügbaren Dateien aufzulisten. Verwenden wir zunächst die einfache Methode, um alle Dateien mithilfe von zu erhalten und aufzulistenglob Betreiber -

#!/usr/bin/perl

# Display all the files in /tmp directory.
$dir = "/tmp/*"; my @files = glob( $dir );

foreach (@files ) {
   print $_ . "\n"; } # Display all the C source files in /tmp directory. $dir = "/tmp/*.c";
@files = glob( $dir ); foreach (@files ) { print $_ . "\n";
}

# Display all the hidden files.
$dir = "/tmp/.*"; @files = glob( $dir );
foreach (@files ) {
   print $_ . "\n"; } # Display all the files from /tmp and /home directories. $dir = "/tmp/* /home/*";
@files = glob( $dir ); foreach (@files ) { print $_ . "\n";
}

Hier ist ein weiteres Beispiel, das ein Verzeichnis öffnet und alle in diesem Verzeichnis verfügbaren Dateien auflistet.

#!/usr/bin/perl

opendir (DIR, '.') or die "Couldn't open directory, $!"; while ($file = readdir DIR) {
   print "$file\n";
}
closedir DIR;

Ein weiteres Beispiel zum Drucken der Liste der C-Quelldateien, die Sie möglicherweise verwenden, ist:

#!/usr/bin/perl

opendir(DIR, '.') or die "Couldn't open directory, $!";
foreach (sort grep(/^.*\.c$/,readdir(DIR))) { print "$_\n";
}
closedir DIR;

Neues Verzeichnis erstellen

Sie können verwenden mkdirFunktion zum Erstellen eines neuen Verzeichnisses. Sie benötigen die erforderliche Berechtigung, um ein Verzeichnis zu erstellen.

#!/usr/bin/perl

$dir = "/tmp/perl"; # This creates perl directory in /tmp directory. mkdir( $dir ) or die "Couldn't create $dir directory, $!";
print "Directory created successfully\n";

Entfernen Sie ein Verzeichnis

Sie können verwenden rmdirFunktion zum Entfernen eines Verzeichnisses. Sie benötigen die erforderliche Berechtigung, um ein Verzeichnis zu entfernen. Außerdem sollte dieses Verzeichnis leer sein, bevor Sie versuchen, es zu entfernen.

#!/usr/bin/perl

$dir = "/tmp/perl"; # This removes perl directory from /tmp directory. rmdir( $dir ) or die "Couldn't remove $dir directory, $!";
print "Directory removed successfully\n";

Ändern Sie ein Verzeichnis

Sie können verwenden chdirFunktion zum Ändern eines Verzeichnisses und zum Wechseln an einen neuen Speicherort. Sie benötigen die erforderliche Berechtigung, um ein Verzeichnis zu ändern und in das neue Verzeichnis zu wechseln.

#!/usr/bin/perl

$dir = "/home"; # This changes perl directory and moves you inside /home directory. chdir( $dir ) or die "Couldn't go inside $dir directory, $!";
print "Your new location is $dir\n";

Die Ausführung und die Fehler gehören immer zusammen. Wenn Sie eine Datei öffnen, die nicht vorhanden ist. Wenn Sie mit dieser Situation nicht richtig umgegangen sind, wird Ihr Programm als von schlechter Qualität eingestuft.

Das Programm stoppt, wenn ein Fehler auftritt. Daher wird eine ordnungsgemäße Fehlerbehandlung verwendet, um verschiedene Arten von Fehlern zu behandeln, die während einer Programmausführung auftreten können, und geeignete Maßnahmen zu ergreifen, anstatt das Programm vollständig anzuhalten.

Sie können einen Fehler auf verschiedene Arten identifizieren und abfangen. Es ist sehr einfach, Fehler in Perl abzufangen und sie dann richtig zu behandeln. Hier sind einige Methoden, die verwendet werden können.

Die if-Anweisung

Das if statementist die naheliegende Wahl, wenn Sie den Rückgabewert einer Anweisung überprüfen müssen. zum Beispiel -

if(open(DATA, $file)) {
   ...
} else {
   die "Error: Couldn't open the file - $!";
}

Hier Variable $! gibt die eigentliche Fehlermeldung zurück. Alternativ können wir die Anweisung in Situationen, in denen dies sinnvoll ist, auf eine Zeile reduzieren. zum Beispiel -

open(DATA, $file) || die "Error: Couldn't open the file $!";

Die es sei denn Funktion

Das unlessFunktion ist das logische Gegenteil von if: Anweisungen können den Erfolgsstatus vollständig umgehen und nur ausgeführt werden, wenn der Ausdruck false zurückgibt. Zum Beispiel -

unless(chdir("/etc")) {
   die "Error: Can't change directory - $!";
}

Das unlessDie Anweisung wird am besten verwendet, wenn Sie einen Fehler oder eine Alternative nur dann auslösen möchten, wenn der Ausdruck fehlschlägt. Die Anweisung ist auch sinnvoll, wenn sie in einer einzeiligen Anweisung verwendet wird -

die "Error: Can't change directory!: $!" unless(chdir("/etc"));

Hier sterben wir nur, wenn die chdir-Operation fehlschlägt und sie gut liest.

Der ternäre Operator

Für sehr kurze Tests können Sie den bedingten Operator verwenden ?:

print(exists($hash{value}) ? 'There' : 'Missing',"\n");

Es ist hier nicht ganz so klar, was wir erreichen wollen, aber der Effekt ist der gleiche wie bei der Verwendung eines if oder unlessErklärung. Der bedingte Operator wird am besten verwendet, wenn Sie schnell einen der beiden Werte innerhalb eines Ausdrucks oder einer Anweisung zurückgeben möchten.

Die Warnfunktion

Die Warnfunktion löst nur eine Warnung aus, eine Nachricht wird an STDERR gedruckt, es werden jedoch keine weiteren Maßnahmen ergriffen. Daher ist es nützlicher, wenn Sie nur eine Warnung für den Benutzer drucken und mit dem Rest des Vorgangs fortfahren möchten.

chdir('/etc') or warn "Can't change directory";

Die Würfelfunktion

Die Die-Funktion funktioniert genauso wie warn, außer dass sie auch exit aufruft. Innerhalb eines normalen Skripts bewirkt diese Funktion, dass die Ausführung sofort beendet wird. Sie sollten diese Funktion verwenden, falls es sinnlos ist, fortzufahren, wenn ein Fehler im Programm vorliegt -

chdir('/etc') or die "Can't change directory";

Fehler innerhalb der Module

Es gibt zwei verschiedene Situationen, mit denen wir umgehen sollten -

Melden eines Fehlers in einem Modul, in dem der Dateiname und die Zeilennummer des Moduls angegeben sind. Dies ist nützlich, wenn Sie ein Modul debuggen oder wenn Sie speziell einen modulbezogenen Fehler anstelle eines skriptbezogenen Fehlers auslösen möchten.
Melden eines Fehlers in einem Modul, das die Informationen des Anrufers zitiert, damit Sie die Zeile innerhalb des Skripts debuggen können, die den Fehler verursacht hat. Auf diese Weise hervorgerufene Fehler sind für den Endbenutzer nützlich, da sie den Fehler in Bezug auf die Ursprungszeile des aufrufenden Skripts hervorheben.

Das warn und dieFunktionen funktionieren etwas anders als erwartet, wenn sie innerhalb eines Moduls aufgerufen werden. Zum Beispiel das einfache Modul -

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   warn "Error in module!";
}
1;

Wenn aus einem Skript wie unten aufgerufen -

use T;
function();

Es wird das folgende Ergebnis erzeugt -

Error in module! at T.pm line 9.

Dies ist mehr oder weniger das, was Sie erwartet haben, aber nicht unbedingt das, was Sie wollen. Aus Sicht eines Modulprogrammierers sind die Informationen nützlich, da sie auf einen Fehler im Modul selbst hinweisen. Für einen Endbenutzer sind die bereitgestellten Informationen ziemlich nutzlos, und für alle außer dem gehärteten Programmierer sind sie völlig sinnlos.

Die Lösung für solche Probleme ist das Carp-Modul, das eine vereinfachte Methode zum Melden von Fehlern in Modulen bietet, die Informationen über das aufrufende Skript zurückgeben. Das Karpfenmodul bietet vier Funktionen: Karpfen, Glucksen, Krächzen und Geständnis. Diese Funktionen werden unten diskutiert.

Die Karpfenfunktion

Die Karpfenfunktion ist das grundlegende Äquivalent von warn und druckt die Nachricht an STDERR, ohne das Skript tatsächlich zu verlassen und den Skriptnamen zu drucken.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   carp "Error in module!";
}
1;

Wenn aus einem Skript wie unten aufgerufen -

use T;
function();

Es wird das folgende Ergebnis erzeugt -

Error in module! at test.pl line 4

Die Gluckfunktion

Die Cluck-Funktion ist eine Art aufgeladener Karpfen. Sie folgt demselben Grundprinzip, druckt jedoch auch eine Stapelverfolgung aller Module, die zum Aufruf der Funktion geführt haben, einschließlich der Informationen im ursprünglichen Skript.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp qw(cluck);

sub function {
   cluck "Error in module!";
}
1;

Wenn aus einem Skript wie unten aufgerufen -

use T;
function();

Es wird das folgende Ergebnis erzeugt -

Error in module! at T.pm line 9
   T::function() called at test.pl line 4

Die Krächzfunktion

Das croak Funktion ist äquivalent zu die, außer dass der Anrufer eine Ebene höher gemeldet wird. Wie die beendet auch diese Funktion das Skript, nachdem der Fehler an STDERR gemeldet wurde -

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   croak "Error in module!";
}
1;

Wenn aus einem Skript wie unten aufgerufen -

use T;
function();

Es wird das folgende Ergebnis erzeugt -

Error in module! at test.pl line 4

Wie bei Karpfen gelten die gleichen Grundregeln für das Einbeziehen von Zeilen- und Dateiinformationen gemäß den Warn- und Matrizenfunktionen.

Die Geständnisfunktion

Das confess Funktion ist wie cluck;; Es ruft die auf und druckt dann eine Stapelverfolgung bis zum Ursprungsskript.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   confess "Error in module!";
}
1;

Wenn aus einem Skript wie unten aufgerufen -

use T;
function();

Es wird das folgende Ergebnis erzeugt -

Error in module! at T.pm line 9
   T::function() called at test.pl line 4

Es gibt einige Variablen, die in Perl eine vordefinierte und besondere Bedeutung haben. Dies sind die Variablen, die Interpunktionszeichen nach dem üblichen Variablenindikator ($, @ oder%) verwenden, z. B. $ _ (siehe unten).

Die meisten speziellen Variablen haben einen englischen langen Namen, z. B. die Betriebssystemfehlervariable $! kann als $ OS_ERROR geschrieben werden. Aber wenn Sie englische Namen verwenden möchten, müssen Sie eine Zeile einfügenuse English;oben in Ihrer Programmdatei. Dies führt den Interpreter dazu, die genaue Bedeutung der Variablen zu erfassen.

Die am häufigsten verwendete Spezialvariable ist $ _, die die Standardeingabe und die Mustersuchzeichenfolge enthält. Zum Beispiel in den folgenden Zeilen -

#!/usr/bin/perl

foreach ('hickory','dickory','doc') {
   print $_;
   print "\n";
}

Bei der Ausführung wird das folgende Ergebnis erzielt:

hickory
dickory
doc

Lassen Sie uns noch einmal dasselbe Beispiel überprüfen, ohne die Variable $ _ explizit zu verwenden -

#!/usr/bin/perl

foreach ('hickory','dickory','doc') {
   print;
   print "\n";
}

Bei der Ausführung wird auch das folgende Ergebnis erzielt:

hickory
dickory
doc

Bei der ersten Ausführung der Schleife wird "Hickory" gedruckt. Beim zweiten Mal wird "dickory" gedruckt, und beim dritten Mal wird "doc" gedruckt. Dies liegt daran, dass in jeder Iteration der Schleife die aktuelle Zeichenfolge eingefügt wird$_, and is used by default by print. Here are the places where Perl will assume $_ auch wenn Sie es nicht angeben -

Verschiedene unäre Funktionen, einschließlich Funktionen wie ord und int sowie alle Dateitests (-f, -d) mit Ausnahme von -t, der standardmäßig STDIN ist.
Verschiedene Listenfunktionen wie Drucken und Aufheben der Verknüpfung.
Die Mustervergleichsoperationen m //, s /// und tr /// bei Verwendung ohne einen Operator = ~.
Die Standard-Iteratorvariable in einer foreach-Schleife, wenn keine andere Variable angegeben wird.
Die implizite Iteratorvariable in den Funktionen grep und map.
Der Standardort zum Einfügen eines Eingabedatensatzes, wenn das Ergebnis einer Zeileneingabeoperation als einziges Kriterium eines while-Tests (dh) selbst getestet wird. Beachten Sie, dass dies außerhalb eines Weile-Tests nicht der Fall ist.

Spezielle Variablentypen

Basierend auf der Verwendung und Art der speziellen Variablen können wir sie in die folgenden Kategorien einteilen:

Globale skalare Spezialvariablen.
Globale Array-Spezialvariablen.
Globale Hash-Spezialvariablen.
Globale spezielle Dateihandles.
Globale Sonderkonstanten.
Spezielle Variablen für reguläre Ausdrücke.
Dateihandle-Spezialvariablen.

Globale skalare Spezialvariablen

Hier ist die Liste aller skalaren Spezialvariablen. Wir haben entsprechende englische Namen zusammen mit den symbolischen Namen aufgelistet.

$ _	Der Standardeingabe- und Mustersuchbereich.
$ ARG	Der Standardeingabe- und Mustersuchbereich.
$.	Die aktuelle Eingabezeilennummer des zuletzt gelesenen Dateihandles. Ein explizites Schließen des Dateihandles setzt die Zeilennummer zurück.
$ NR
$ /	Das Trennzeichen für Eingabedatensätze; Zeilenumbruch standardmäßig. Wenn die Nullzeichenfolge festgelegt ist, werden Leerzeilen als Trennzeichen behandelt.
$ RS
$,	Das Ausgabefeldtrennzeichen für den Druckoperator.
$ OFS	Das Ausgabefeldtrennzeichen für den Druckoperator.
$ \	Das Trennzeichen für den Ausgabedatensatz für den Druckoperator.
$ ORS
$ "	Wie "$", außer dass es für Listenwerte gilt, die in eine Zeichenfolge in doppelten Anführungszeichen (oder eine ähnlich interpretierte Zeichenfolge) interpoliert wurden. Standard ist ein Leerzeichen.
$ LIST_SEPARATOR
$;	Das tiefgestellte Trennzeichen für die mehrdimensionale Array-Emulation. Standard ist "\ 034".
$ SUBSCRIPT_SEPARATOR
$ ^ L.	Was für ein Format wird ausgegeben, um einen Formfeed durchzuführen. Standard ist "\ f".
$ FORMAT_FORMFEED
$:	Der aktuelle Zeichensatz, nach dem eine Zeichenfolge unterbrochen werden kann, um Fortsetzungsfelder (beginnend mit ^) in einem Format zu füllen. Standard ist "\ n" ".
$ FORMAT_LINE_BREAK_CHARACTERS
$ ^ A.	Der aktuelle Wert des Schreibakkumulators für Formatzeilen.
$ AKKU	Der aktuelle Wert des Schreibakkumulators für Formatzeilen.
$ #	Enthält das Ausgabeformat für gedruckte Zahlen (veraltet).
$ OFMT	Enthält das Ausgabeformat für gedruckte Zahlen (veraltet).
$?	Der Status, der vom letzten Pipe-Schließen, Backtick-Befehl (``) oder Systembetreiber zurückgegeben wurde.
$ CHILD_ERROR
$!	Bei Verwendung in einem numerischen Kontext wird der aktuelle Wert der Variablen errno angegeben, wodurch der letzte Systemaufruffehler identifiziert wird. Bei Verwendung in einem Zeichenfolgenkontext wird die entsprechende Systemfehlerzeichenfolge ausgegeben.
$OS_ERROR or $ERRNO
$ @	Die Perl-Syntaxfehlermeldung vom letzten Auswertungsbefehl.
$ EVAL_ERROR	Die Perl-Syntaxfehlermeldung vom letzten Auswertungsbefehl.
$$	Die PID des Perl-Prozesses, auf dem dieses Skript ausgeführt wird.
$ PROCESS_ID oder $ PID
$ <	Die tatsächliche Benutzer-ID (UID) dieses Prozesses.
$REAL_USER_ID or $UID	Die tatsächliche Benutzer-ID (UID) dieses Prozesses.
$>	Die effektive Benutzer-ID dieses Prozesses.
$ EFFECTIVE_USER_ID oder $ EUID	Die effektive Benutzer-ID dieses Prozesses.
$ (	Die reale Gruppen-ID (gid) dieses Prozesses.
$REAL_GROUP_ID or $GID	Die reale Gruppen-ID (gid) dieses Prozesses.
$)	Das effektive Gid dieses Prozesses.
$ EFFECTIVE_GROUP_ID oder $ EGID	Das effektive Gid dieses Prozesses.
$ 0	Enthält den Namen der Datei, die das ausgeführte Perl-Skript enthält.
$ PROGRAM_NAME
$ [	Der Index des ersten Elements in einem Array und des ersten Zeichens in einem Teilstring. Standard ist 0.
$]	Gibt die Version plus Patchlevel geteilt durch 1000 zurück.
$ PERL_VERSION	Gibt die Version plus Patchlevel geteilt durch 1000 zurück.
$ ^ D.	Der aktuelle Wert der Debugging-Flags.
$ DEBUGGING	Der aktuelle Wert der Debugging-Flags.
$ ^ E.	Erweiterte Fehlermeldung auf einigen Plattformen.
$ EXTENDED_OS_ERROR	Erweiterte Fehlermeldung auf einigen Plattformen.
$ ^ F.	Der maximale Systemdateideskriptor, normalerweise 2.
$ SYSTEM_FD_MAX	Der maximale Systemdateideskriptor, normalerweise 2.
$ ^ H.	Enthält interne Compiler-Hinweise, die von bestimmten pragmatischen Modulen aktiviert werden.
$ ^ I.	Der aktuelle Wert der Inplace-Edit-Erweiterung. Verwenden Sie undef, um die Inplace-Bearbeitung zu deaktivieren.
$ INPLACE_EDIT
$ ^ M.	Die Inhalte von $M can be used as an emergency memory pool in case Perl dies with an out-of-memory error. Use of $M erfordert eine spezielle Zusammenstellung von Perl. Weitere Informationen finden Sie im INSTALL-Dokument.
$ ^ O.	Enthält den Namen des Betriebssystems, für das die aktuelle Perl-Binärdatei kompiliert wurde.
$ OSNAME
$ ^ P.	Das interne Flag, das der Debugger löscht, damit er sich nicht selbst debuggt.
$ PERLDB
$ ^ T.	Die Zeit, zu der das Skript in Sekunden seit der Epoche ausgeführt wurde.
$ BASETIME
$ ^ W.	Der aktuelle Wert des Warnschalters, entweder wahr oder falsch.
$ WARNUNG
$ ^ X.	Der Name, unter dem die Perl-Binärdatei selbst ausgeführt wurde.
$ EXECUTABLE_NAME
$ ARGV	Enthält den Namen der aktuellen Datei beim Lesen von <ARGV>.

Globale Array-Spezialvariablen

@ ARGV	Das Array mit den für das Skript bestimmten Befehlszeilenargumenten.
@INC	Das Array mit der Liste der Stellen, an denen nach Perl-Skripten gesucht werden soll, die von den Konstrukten do, require oder use ausgewertet werden sollen.
@F	Das Array, in das die Eingabezeilen aufgeteilt werden, wenn der Befehlszeilenschalter -a angegeben wird.

Globale Hash-Spezialvariablen

% INC	Der Hash, der Einträge für den Dateinamen jeder Datei enthält, die über do oder require eingefügt wurde.
% ENV	Der Hash, der Ihre aktuelle Umgebung enthält.
% SIG	Der Hash, mit dem Signalhandler für verschiedene Signale eingestellt werden.

Globale spezielle Dateihandles

ARGV	Das spezielle Dateihandle, das in @ARGV über Befehlszeilendateinamen iteriert. Wird normalerweise als Null-Dateihandle in <> geschrieben.
STDERR	Das spezielle Dateihandle für Standardfehler in jedem Paket.
STDIN	Das spezielle Dateihandle für die Standardeingabe in jedem Paket.
STDOUT	Das spezielle Dateihandle für die Standardausgabe in jedem Paket.
DATEN	Das spezielle Dateihandle, das sich auf alles bezieht, was auf das Token __END__ in der Datei folgt, die das Skript enthält. Oder das spezielle Dateihandle für alles, was dem Token __DATA__ in einer erforderlichen Datei folgt, solange Sie Daten im selben Paket lesen __DATA__ in.
_ (Unterstrich)	Das spezielle Dateihandle, mit dem die Informationen des letzten stat-, lstat- oder Dateitestoperators zwischengespeichert werden.

Globale Sonderkonstanten

__ENDE__	Zeigt das logische Ende Ihres Programms an. Jeder folgende Text wird ignoriert, kann jedoch über das DATA-Dateihandle gelesen werden.
__DATEI__	Stellt den Dateinamen an der Stelle in Ihrem Programm dar, an der er verwendet wird. Nicht in Strings interpoliert.
__LINIE__	Repräsentiert die aktuelle Zeilennummer. Nicht in Strings interpoliert.
__PAKET__	Stellt den aktuellen Paketnamen zur Kompilierungszeit dar oder undefiniert, wenn kein aktuelles Paket vorhanden ist. Nicht in Strings interpoliert.

Spezielle Variablen für reguläre Ausdrücke

$ digit	Enthält den Text, der mit den entsprechenden Klammern im zuletzt übereinstimmenden Muster übereinstimmt. Zum Beispiel stimmt $ 1 mit dem überein, was im ersten Satz von Klammern im vorherigen regulären Ausdruck enthalten war.
$ &	Die Zeichenfolge, die mit der letzten erfolgreichen Musterübereinstimmung übereinstimmt.
$ MATCH
$ `	Die Zeichenfolge vor allem, was mit der letzten erfolgreichen Musterübereinstimmung übereinstimmt.
$ PREMATCH
$ '	Die Zeichenfolge, die auf die letzte erfolgreiche Musterübereinstimmung folgt.
$ POSTMATCH
$ +	Die letzte Klammer, die mit dem letzten Suchmuster übereinstimmt. Dies ist nützlich, wenn Sie nicht wissen, welches der alternativen Muster übereinstimmt. Zum Beispiel: / Version: (. ) \| Revision: (. ) / && ($rev = $+);
$ LAST_PAREN_MATCH

Dateihandle-Spezialvariablen

$ \|	Bei Einstellung ungleich Null wird nach jedem Schreiben oder Drucken auf dem aktuell ausgewählten Ausgangskanal ein Flush (3) erzwungen.
$ OUTPUT_AUTOFLUSH
$%	Die aktuelle Seitenzahl des aktuell ausgewählten Ausgangskanals.
$ FORMAT_PAGE_NUMBER
$ =	Die aktuelle Seitenlänge (druckbare Zeilen) des aktuell ausgewählten Ausgabekanals. Standard ist 60.
$ FORMAT_LINES_PER_PAGE
$ -	Die Anzahl der Zeilen, die auf der Seite des aktuell ausgewählten Ausgangskanals verbleiben.
$ FORMAT_LINES_LEFT
$ ~	Der Name des aktuellen Berichtsformats für den aktuell ausgewählten Ausgabekanal. Standard ist der Name des Dateihandles.
$ FORMAT_NAME
$ ^	Der Name des aktuellen Top-of-Page-Formats für den aktuell ausgewählten Ausgabekanal. Standard ist der Name des Dateihandles, an das _TOP angehängt ist.
$ FORMAT_TOP_NAME

Jeder Programmierer hat natürlich seine eigenen Vorlieben in Bezug auf die Formatierung, aber es gibt einige allgemeine Richtlinien, die das Lesen, Verstehen und Verwalten Ihrer Programme erleichtern.

Das Wichtigste ist, dass Sie Ihre Programme jederzeit unter dem Flag -w ausführen. Sie können es für bestimmte Teile des Codes explizit über das Pragma ohne Warnungen oder die Variable $ ^ W deaktivieren, wenn Sie müssen. Sie sollten auch immer unter strikter Verwendung laufen oder den Grund dafür kennen. Die Verwendung von Sigtrap und sogar die Verwendung von Diagnose-Pragmas können sich ebenfalls als nützlich erweisen.

In Bezug auf die Ästhetik des Code-Layouts ist Larry nur der Meinung, dass die schließende geschweifte Klammer eines mehrzeiligen BLOCK mit dem Schlüsselwort übereinstimmen sollte, mit dem das Konstrukt gestartet wurde. Darüber hinaus hat er andere Vorlieben, die nicht so stark sind -

4-spaltiger Einzug.
Wenn möglich, lockig in derselben Zeile wie das Schlüsselwort öffnen, andernfalls in einer Zeile.
Leerzeichen vor dem öffnenden Locken eines mehrzeiligen BLOCKES.
Einzeiliger BLOCK kann in eine Zeile eingefügt werden, einschließlich Locken.
Kein Leerzeichen vor dem Semikolon.
Semikolon im "kurzen" einzeiligen BLOCK weggelassen.
Platz um die meisten Operatoren.
Leerzeichen um einen "komplexen" Index (in Klammern).
Leere Linien zwischen Stücken, die verschiedene Dinge tun.
Andere ungekuschelt.
Kein Leerzeichen zwischen Funktionsname und öffnender Klammer.
Leerzeichen nach jedem Komma.
Lange Zeilen nach einem Operator unterbrochen (außer und und oder).
Leerzeichen nach dem letzten Klammerabgleich in der aktuellen Zeile.
Richten Sie die entsprechenden Elemente vertikal aus.
Lassen Sie redundante Interpunktion aus, solange die Klarheit nicht leidet.

Hier sind einige weitere inhaltliche Stilprobleme, über die Sie nachdenken sollten: Nur weil Sie etwas auf eine bestimmte Weise tun KÖNNEN, heißt das nicht, dass Sie es auf diese Weise tun sollten. Perl bietet Ihnen verschiedene Möglichkeiten, etwas zu tun. Wählen Sie daher die am besten lesbare aus. Zum Beispiel -

open(FOO,$foo) || die "Can't open $foo: $!";

Ist besser als -

die "Can't open $foo: $!" unless open(FOO,$foo);

Weil der zweite Weg den Hauptpunkt der Anweisung in einem Modifikator verbirgt. Andererseits,

print "Starting analysis\n" if $verbose;

Ist besser als -

$verbose && print "Starting analysis\n";

Denn der Hauptpunkt ist nicht, ob der Benutzer -v eingegeben hat oder nicht.

Gehen Sie nicht durch dumme Verrenkungen, um eine Schleife oben oder unten zu verlassen, wenn Perl den letzten Operator bereitstellt, damit Sie in der Mitte beenden können. Einfach ein wenig "übertreffen", um es sichtbarer zu machen -

LINE:
for (;;) {
   statements;
   last LINE if $foo;
   next LINE if /^#/;
   statements;
}

Lassen Sie uns einige weitere wichtige Punkte sehen -

Haben Sie keine Angst, Loop-Labels zu verwenden - sie dienen dazu, die Lesbarkeit zu verbessern und mehrstufige Loop-Unterbrechungen zu ermöglichen. Siehe das vorherige Beispiel.
Vermeiden Sie die Verwendung von grep () (oder map ()) oder `backticks` in einem leeren Kontext, wenn Sie nur deren Rückgabewerte wegwerfen. Diese Funktionen haben alle Rückgabewerte. Verwenden Sie sie daher. Verwenden Sie andernfalls stattdessen eine foreach () -Schleife oder die system () -Funktion.
Wenn Sie Funktionen verwenden, die möglicherweise nicht auf jedem Computer implementiert sind, testen Sie das Konstrukt aus Gründen der Portabilität in einer Bewertung, um festzustellen, ob es fehlschlägt. Wenn Sie wissen, in welcher Version oder auf welchem Patchlevel eine bestimmte Funktion implementiert wurde, können Sie $] ($ PERL_VERSION auf Englisch) testen, um festzustellen, ob sie vorhanden sein wird. Mit dem Konfigurationsmodul können Sie auch Werte abfragen, die vom Konfigurationsprogramm bei der Installation von Perl festgelegt wurden.
Wählen Sie mnemonische Bezeichner. Wenn Sie sich nicht erinnern können, was Mnemonik bedeutet, haben Sie ein Problem.
Während kurze Bezeichner wie $ gotit wahrscheinlich in Ordnung sind, verwenden Sie Unterstriche, um Wörter in längeren Bezeichnern zu trennen. Es ist im Allgemeinen leichter zu lesen$var_names_like_this than $VarNamesLikeThis, insbesondere für Nicht-Muttersprachler von Englisch. Es ist auch eine einfache Regel, die konsistent mit VAR_NAMES_LIKE_THIS funktioniert.
Paketnamen sind manchmal eine Ausnahme von dieser Regel. Perl reserviert informell Modulnamen in Kleinbuchstaben für "Pragma" -Module wie Integer und Strict. Andere Module sollten mit einem Großbuchstaben beginnen und gemischte Groß- und Kleinschreibung verwenden, jedoch wahrscheinlich ohne Unterstriche, da die Darstellung von Modulnamen durch primitive Dateisysteme als Dateien, die in einige wenige Bytes passen müssen, eingeschränkt ist.
Wenn Sie einen wirklich haarigen regulären Ausdruck haben, verwenden Sie den Modifikator / x und geben Sie ein Leerzeichen ein, damit er etwas weniger wie Linienrauschen aussieht. Verwenden Sie keinen Schrägstrich als Trennzeichen, wenn Ihr regulärer Ausdruck Schrägstriche oder umgekehrte Schrägstriche aufweist.
Überprüfen Sie immer die Rückkehrcodes von Systemaufrufen. Gute Fehlermeldungen sollten an STDERR gesendet werden, einschließlich des Programms, das das Problem verursacht hat, des fehlgeschlagenen Systemaufrufs und der fehlgeschlagenen Argumente, und (SEHR WICHTIG) sollten die Standard-Systemfehlermeldung für die Fehler enthalten. Hier ist ein einfaches, aber ausreichendes Beispiel -

opendir(D, $dir) or die "can't opendir $dir: $!";

Denken Sie an die Wiederverwendbarkeit. Warum sollten Sie bei einem One-Shot Brainpower verschwenden, wenn Sie so etwas vielleicht noch einmal machen möchten? Ziehen Sie in Betracht, Ihren Code zu verallgemeinern. Erwägen Sie das Schreiben eines Moduls oder einer Objektklasse. Erwägen Sie, Ihren Code mit strikter Verwendung sauber auszuführen und Warnungen (oder -w) zu verwenden. Erwägen Sie, Ihren Code preiszugeben. Erwägen Sie, Ihr gesamtes Weltbild zu ändern. Bedenken Sie ... oh, egal.
Seien Sie konsequent.
Sei nett.

Ein regulärer Ausdruck ist eine Zeichenfolge, die das Muster oder die Muster definiert, die Sie anzeigen. Die Syntax von regulären Ausdrücken in Perl ist sehr ähnlich zu der, die Sie in anderen Programmen finden, die reguläre Ausdrücke unterstützensed, grep, und awk.

Die grundlegende Methode zum Anwenden eines regulären Ausdrucks besteht darin, die Musterbindungsoperatoren = ~ und zu verwenden !~. Der erste Operator ist ein Test- und Zuweisungsoperator.

In Perl gibt es drei Operatoren für reguläre Ausdrücke.

Übereinstimmenden regulären Ausdruck - m //
Regulären Ausdruck ersetzen - s ///
Regulatorischen Ausdruck transliterieren - tr ///

Die Schrägstriche dienen jeweils als Trennzeichen für den von Ihnen angegebenen regulären Ausdruck (Regex). Wenn Sie mit einem anderen Trennzeichen vertraut sind, können Sie es anstelle eines Schrägstrichs verwenden.

Der Match-Operator

Der Übereinstimmungsoperator m // wird verwendet, um eine Zeichenfolge oder Anweisung mit einem regulären Ausdruck abzugleichen. Um beispielsweise die Zeichenfolge "foo" mit der skalaren $ -Leiste abzugleichen, können Sie eine Anweisung wie die folgende verwenden:

#!/usr/bin/perl

$bar = "This is foo and again foo"; if ($bar =~ /foo/) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo"; if ($bar =~ /foo/) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

First time is matching
Second time is matching

Das m // funktioniert tatsächlich auf die gleiche Weise wie die q // -Operatorreihe. Sie können eine beliebige Kombination von natürlich übereinstimmenden Zeichen verwenden, um als Begrenzer für den Ausdruck zu fungieren. Zum Beispiel sind m {}, m () und m> <alle gültig. Das obige Beispiel kann also wie folgt umgeschrieben werden:

#!/usr/bin/perl

$bar = "This is foo and again foo"; if ($bar =~ m[foo]) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo"; if ($bar =~ m{foo}) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Sie können m in m // weglassen, wenn die Trennzeichen Schrägstriche sind. Für alle anderen Trennzeichen müssen Sie jedoch das Präfix m verwenden.

Beachten Sie, dass der gesamte Übereinstimmungsausdruck, dh der Ausdruck links von = ~ oder! ~ Und der Übereinstimmungsoperator, true (in einem skalaren Kontext) zurückgibt, wenn der Ausdruck übereinstimmt. Daher die Aussage -

$true = ($foo =~ m/foo/);

wird eingestellt $true to 1 if $foo entspricht dem regulären Ausdruck oder 0, wenn die Übereinstimmung fehlschlägt. In einem Listenkontext gibt die Übereinstimmung den Inhalt aller gruppierten Ausdrücke zurück. Wenn Sie beispielsweise die Stunden, Minuten und Sekunden aus einer Zeitzeichenfolge extrahieren, können Sie Folgendes verwenden:

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Operator-Modifikatoren abgleichen

Der Übereinstimmungsoperator unterstützt seine eigenen Modifikatoren. Der Modifikator / g ermöglicht eine globale Übereinstimmung. Der Modifikator / i macht die Übereinstimmung zwischen Groß- und Kleinschreibung nicht berücksichtigt. Hier ist die vollständige Liste der Modifikatoren

Sr.Nr.	Modifikator & Beschreibung
1	i Macht den Match Case unempfindlich.
2	m Gibt an, dass die Operatoren ^ und $ jetzt mit einer Zeilenumbruchgrenze anstelle einer Zeichenfolgengrenze übereinstimmen, wenn die Zeichenfolge Zeilenumbruch- oder Wagenrücklaufzeichen enthält.
3	o Wertet den Ausdruck nur einmal aus.
4	s Ermöglicht die Verwendung von. einem Zeilenumbruchzeichen entsprechen.
5	x Ermöglicht die Verwendung von Leerzeichen im Ausdruck, um die Übersichtlichkeit zu verbessern.
6	g Findet global alle Übereinstimmungen.
7	cg Ermöglicht die Fortsetzung der Suche, auch wenn eine globale Übereinstimmung fehlschlägt.

Nur einmal übereinstimmen

Es gibt auch eine einfachere Version des Match-Operators - das? PATTERN? Operator. Dies ist im Grunde identisch mit dem Operator m //, außer dass er innerhalb der Zeichenfolge, die Sie zwischen den einzelnen zurückzusetzenden Aufrufen suchen, nur einmal übereinstimmt.

Sie können dies beispielsweise verwenden, um das erste und das letzte Element in einer Liste abzurufen.

#!/usr/bin/perl

@list = qw/food foosball subeo footnote terfoot canic footbrdige/;

foreach (@list) {
   $first = $1 if /(foo.*?)/; $last = $1 if /(foo.*)/; } print "First: $first, Last: $last\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

First: foo, Last: footbrdige

Variablen für reguläre Ausdrücke

Zu den Variablen für reguläre Ausdrücke gehören $, was auch immer das letzte übereinstimmende Gruppierungsspiel enthält; $&, die die gesamte übereinstimmende Zeichenfolge enthält; $`, die alles vor der übereinstimmenden Zeichenfolge enthält; und$', die alles nach der übereinstimmenden Zeichenfolge enthält. Der folgende Code zeigt das Ergebnis -

#!/usr/bin/perl

$string = "The food is in the salad bar";
$string =~ m/foo/; print "Before: $`\n";
print "Matched: $&\n"; print "After: $'\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Before: The
Matched: foo
After: d is in the salad bar

Der Substitutionsoperator

Der Ersetzungsoperator s /// ist eigentlich nur eine Erweiterung des Übereinstimmungsoperators, mit der Sie den übereinstimmenden Text durch neuen Text ersetzen können. Die Grundform des Operators ist -

s/PATTERN/REPLACEMENT/;

Das MUSTER ist der reguläre Ausdruck für den gesuchten Text. Der ERSATZ ist eine Spezifikation für den Text oder regulären Ausdruck, mit dem der gefundene Text ersetzt werden soll. Zum Beispiel können wir alle Vorkommen von ersetzendog mit cat mit dem folgenden regulären Ausdruck -

#/user/bin/perl

$string = "The cat sat on the mat"; $string =~ s/cat/dog/;

print "$string\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

The dog sat on the mat

Modifikatoren für Substitutionsoperatoren

Hier ist die Liste aller Modifikatoren, die mit dem Substitutionsoperator verwendet werden.

Sr.Nr.	Modifikator & Beschreibung
1	i Macht den Match Case unempfindlich.
2	m Gibt an, dass die Operatoren ^ und $ jetzt mit einer Zeilenumbruchgrenze anstelle einer Zeichenfolgengrenze übereinstimmen, wenn die Zeichenfolge Zeilenumbruch- oder Wagenrücklaufzeichen enthält.
3	o Wertet den Ausdruck nur einmal aus.
4	s Ermöglicht die Verwendung von. einem Zeilenumbruchzeichen entsprechen.
5	x Ermöglicht die Verwendung von Leerzeichen im Ausdruck, um die Übersichtlichkeit zu verbessern.
6	g Ersetzt alle Vorkommen des gefundenen Ausdrucks durch den Ersetzungstext.
7	e Wertet den Ersatz aus, als wäre es eine Perl-Anweisung, und verwendet seinen Rückgabewert als Ersatztext.

Der Übersetzungsoperator

Die Übersetzung ist ähnlich, aber nicht identisch mit den Substitutionsprinzipien, aber im Gegensatz zur Substitution verwendet die Übersetzung (oder Transliteration) keine regulären Ausdrücke für die Suche nach Ersatzwerten. Die Übersetzungsoperatoren sind -

tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds

Die Übersetzung ersetzt alle Vorkommen der Zeichen in SEARCHLIST durch die entsprechenden Zeichen in REPLACEMENTLIST. Verwenden Sie zum Beispiel "Die Katze saß auf der Matte". Zeichenfolge, die wir in diesem Kapitel verwendet haben -

#/user/bin/perl

$string = 'The cat sat on the mat'; $string =~ tr/a/o/;

print "$string\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

The cot sot on the mot.

Es können auch Standard-Perl-Bereiche verwendet werden, mit denen Sie Zeichenbereiche entweder nach Buchstaben oder nach numerischen Werten angeben können. Um die Groß- und Kleinschreibung der Zeichenfolge zu ändern, können Sie anstelle von die folgende Syntax verwendenuc Funktion.

$string =~ tr/a-z/A-Z/;

Übersetzungsoperator-Modifikatoren

Im Folgenden finden Sie eine Liste der Operatoren für die Übersetzung.

Sr.Nr.	Modifikator & Beschreibung
1	c Ergänzt die Suchliste.
2	d Löscht gefundene, aber nicht ersetzte Zeichen.
3	s Squashes duplizieren ersetzte Zeichen.

Der Modifikator / d löscht die Zeichen, die mit SEARCHLIST übereinstimmen und keinen entsprechenden Eintrag in REPLACEMENTLIST haben. Zum Beispiel -

#!/usr/bin/perl 

$string = 'the cat sat on the mat.'; $string =~ tr/a-z/b/d;

print "$string\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

b b   b.

Der letzte Modifikator / s entfernt die doppelten Zeichenfolgen, die ersetzt wurden.

#!/usr/bin/perl

$string = 'food';
$string = 'food'; $string =~ tr/a-z/a-z/s;

print "$string\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

fod

Komplexere reguläre Ausdrücke

Sie müssen nicht nur auf festen Zeichenfolgen übereinstimmen. Tatsächlich können Sie mit komplexeren regulären Ausdrücken fast alles abgleichen, wovon Sie träumen können. Hier ist ein kurzer Spickzettel -

In der folgenden Tabelle ist die in Python verfügbare Syntax für reguläre Ausdrücke aufgeführt.

Sr.Nr.	Muster & Beschreibung
1	^ Entspricht dem Zeilenanfang.
2	$ Entspricht dem Zeilenende.
3	. Entspricht einem einzelnen Zeichen außer Zeilenumbruch. Mit der Option m kann auch der Zeilenumbruch abgeglichen werden.
4	[...] Entspricht einem einzelnen Zeichen in Klammern.
5	[^...] Entspricht einem einzelnen Zeichen, das nicht in Klammern steht.
6	* Entspricht 0 oder mehr Vorkommen des vorhergehenden Ausdrucks.
7	+ Entspricht 1 oder mehr Vorkommen des vorhergehenden Ausdrucks.
8	? Entspricht 0 oder 1 Vorkommen des vorhergehenden Ausdrucks.
9	{ n} Entspricht genau n Vorkommen des vorhergehenden Ausdrucks.
10	{ n,} Entspricht n oder mehr Vorkommen des vorhergehenden Ausdrucks.
11	{ n, m} Entspricht mindestens n und höchstens m Vorkommen des vorhergehenden Ausdrucks.
12	a\| b Entspricht entweder a oder b.
13	\w Entspricht Wortzeichen.
14	\W Entspricht Nichtwortzeichen.
15	\s Entspricht dem Leerzeichen. Entspricht [\ t \ n \ r \ f].
16	\S Entspricht Nicht-Leerzeichen.
17	\d Entspricht den Ziffern. Entspricht [0-9].
18	\D Entspricht nicht-stelligen.
19	\A Entspricht dem Stringanfang.
20	\Z Entspricht dem Ende der Zeichenfolge. Wenn eine neue Zeile vorhanden ist, stimmt sie kurz vor der neuen Zeile überein.
21	\z Entspricht dem Ende der Zeichenfolge.
22	\G Spielpunkt, an dem das letzte Spiel beendet wurde.
23	\b Entspricht den Wortgrenzen außerhalb der Klammern. Entspricht der Rücktaste (0x08) in Klammern.
24	\B Entspricht Nichtwortgrenzen.
25	\n, \t, etc. Entspricht Zeilenumbrüchen, Wagenrückläufen, Tabulatoren usw.
26	\1...\9 Entspricht dem n-ten gruppierten Unterausdruck.
27	\10 Entspricht dem n-ten gruppierten Unterausdruck, wenn er bereits übereinstimmt. Ansonsten bezieht sich auf die oktale Darstellung eines Zeichencodes.
28	[aeiou] Entspricht einem einzelnen Zeichen im angegebenen Satz
29	[^aeiou] Entspricht einem einzelnen Zeichen außerhalb des angegebenen Satzes

Das Metazeichen ^ entspricht dem Anfang der Zeichenfolge und das Metasymbol $ entspricht dem Ende der Zeichenfolge. Hier einige kurze Beispiele.

# nothing in the string (start and end are adjacent)
/^$/   

# a three digits, each followed by a whitespace
# character (eg "3 4 5 ")
/(\d\s) {3}/  

# matches a string in which every
# odd-numbered letter is a (eg "abacadaf")
/(a.)+/  

# string starts with one or more digits
/^\d+/

# string that ends with one or more digits
/\d+$/

Schauen wir uns ein anderes Beispiel an.

#!/usr/bin/perl

$string = "Cats go Catatonic\nWhen given Catnip";
($start) = ($string =~ /\A(.*?) /);
@lines = $string =~ /^(.*?) /gm; print "First word: $start\n","Line starts: @lines\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

First word: Cats
Line starts: Cats When

Übereinstimmende Grenzen

Das \bstimmt an jeder Wortgrenze überein, wie durch den Unterschied zwischen der Klasse \ w und der Klasse \ W definiert. Da \ w die Zeichen für ein Wort enthält und \ W das Gegenteil, bedeutet dies normalerweise die Beendigung eines Wortes. Das\BAssertion entspricht jeder Position, die keine Wortgrenze ist. Zum Beispiel -

/\bcat\b/ # Matches 'the cat sat' but not 'cat on the mat'
/\Bcat\B/ # Matches 'verification' but not 'the cat on the mat'
/\bcat\B/ # Matches 'catatonic' but not 'polecat'
/\Bcat\b/ # Matches 'polecat' but not 'catatonic'

Alternativen auswählen

Die | Das Zeichen entspricht dem Standard oder dem bitweisen ODER in Perl. Es gibt alternative Übereinstimmungen innerhalb eines regulären Ausdrucks oder einer Gruppe an. Um beispielsweise "Katze" oder "Hund" in einem Ausdruck zu finden, können Sie Folgendes verwenden:

if ($string =~ /cat|dog/)

Sie können einzelne Elemente eines Ausdrucks zusammenfassen, um komplexe Übereinstimmungen zu unterstützen. Die Suche nach Namen von zwei Personen könnte mit zwei getrennten Tests wie diesem erreicht werden -

if (($string =~ /Martin Brown/) ||  ($string =~ /Sharon Brown/)) This could be written as follows if ($string =~ /(Martin|Sharon) Brown/)

Gruppierung Matching

Unter dem Gesichtspunkt des regulären Ausdrucks gibt es keinen Unterschied, außer vielleicht, dass der erstere etwas klarer ist.

$string =~ /(\S+)\s+(\S+)/; and $string =~ /\S+\s+\S+/;

Der Vorteil der Gruppierung besteht jedoch darin, dass wir eine Sequenz aus einem regulären Ausdruck extrahieren können. Gruppierungen werden als Liste in der Reihenfolge zurückgegeben, in der sie im Original erscheinen. Im folgenden Fragment haben wir beispielsweise die Stunden, Minuten und Sekunden aus einer Zeichenfolge herausgezogen.

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Neben dieser direkten Methode sind übereinstimmende Gruppen auch in den speziellen $ x-Variablen verfügbar, wobei x die Nummer der Gruppe im regulären Ausdruck ist. Wir könnten daher das vorhergehende Beispiel wie folgt umschreiben:

#!/usr/bin/perl

$time = "12:05:30";

$time =~ m/(\d+):(\d+):(\d+)/; my ($hours, $minutes, $seconds) = ($1, $2, $3); print "Hours : $hours, Minutes: $minutes, Second: $seconds\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hours : 12, Minutes: 05, Second: 30

Wenn Gruppen in Substitutionsausdrücken verwendet werden, kann die $ x-Syntax im Ersatztext verwendet werden. Auf diese Weise könnten wir eine Datumszeichenfolge neu formatieren -

#!/usr/bin/perl

$date = '03/26/1999';
$date =~ s#(\d+)/(\d+)/(\d+)#$3/$1/$2#;

print "$date\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

1999/03/26

Die \ G Behauptung

Mit der Zusicherung \ G können Sie die Suche ab dem Punkt fortsetzen, an dem die letzte Übereinstimmung stattgefunden hat. Im folgenden Code haben wir beispielsweise \ G verwendet, damit wir an der richtigen Position suchen und dann einige Informationen extrahieren können, ohne einen komplexeren, einzelnen regulären Ausdruck erstellen zu müssen.

#!/usr/bin/perl

$string = "The time is: 12:31:02 on 4/12/00";

$string =~ /:\s+/g; ($time) = ($string =~ /\G(\d+:\d+:\d+)/); $string =~ /.+\s+/g;
($date) = ($string =~ m{\G(\d+/\d+/\d+)});

print "Time: $time, Date: $date\n";

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Time: 12:31:02, Date: 4/12/00

Die \ G-Zusicherung ist eigentlich nur das Metasymboläquivalent der pos-Funktion. Zwischen Aufrufen mit regulären Ausdrücken können Sie also weiterhin pos verwenden und sogar den Wert von pos (und damit \ G) ändern, indem Sie pos als lvalue-Subroutine verwenden.

Beispiele für reguläre Ausdrücke

Wörtliche Zeichen

Sr.Nr.	Beispiel & Beschreibung
1	Perl Match "Perl".

Zeichenklassen

Sr.Nr.	Beispiel & Beschreibung
1	[Pp]ython Entspricht "Python" oder "Python"
2	rub[ye] Entspricht "Rubin" oder "Rube"
3	[aeiou] Entspricht einem beliebigen Kleinbuchstaben
4	[0-9] Entspricht einer beliebigen Ziffer. das gleiche wie [0123456789]
5	[a-z] Entspricht einem beliebigen ASCII-Kleinbuchstaben
6	[A-Z] Entspricht einem beliebigen ASCII-Großbuchstaben
7	[a-zA-Z0-9] Entspricht einem der oben genannten Punkte
8	[^aeiou] Entspricht etwas anderem als einem Kleinbuchstaben
9	[^0-9] Entspricht etwas anderem als einer Ziffer

Sonderzeichenklassen

Sr.Nr.	Beispiel & Beschreibung
1	. Entspricht jedem Zeichen außer Zeilenumbruch
2	\d Entspricht einer Ziffer: [0-9]
3	\D Entspricht einer nichtstelligen Zahl: [^ 0-9]
4	\s Entspricht einem Leerzeichen: [\ t \ r \ n \ f]
5	\S Entspricht Nicht-Leerzeichen: [^ \ t \ r \ n \ f]
6	\w Entspricht einem einzelnen Wortzeichen: [A-Za-z0-9_]
7	\W Entspricht einem Nichtwortzeichen: [^ A-Za-z0-9_]

Wiederholungsfälle

Sr.Nr.	Beispiel & Beschreibung
1	ruby? Entspricht "rub" oder "ruby": das y ist optional
2	ruby* Entspricht "reiben" plus 0 oder mehr ys
3	ruby+ Entspricht "reiben" plus 1 oder mehr ys
4	\d{3} Entspricht genau 3 Ziffern
5	\d{3,} Entspricht 3 oder mehr Ziffern
6.	\d{3,5} Entspricht 3, 4 oder 5 Ziffern

Nongreedy Wiederholung

Dies entspricht der geringsten Anzahl von Wiederholungen -

Sr.Nr.	Beispiel & Beschreibung
1	*<.>** Gierige Wiederholung: Entspricht "<python> perl>"
2	*<.?>** Nongreedy: Entspricht "<python>" in "<python> perl>"

Gruppieren mit Klammern

Sr.Nr.	Beispiel & Beschreibung
1	\D\d+ Keine Gruppe: + wiederholt \ d
2	(\D\d)+ Gruppiert: + wiederholt \ D \ d Paar
3	([Pp]ython(, )?)+ Match "Python", "Python, Python, Python" usw.

Rückreferenzen

Dies entspricht wieder einer zuvor übereinstimmenden Gruppe -

Sr.Nr.	Beispiel & Beschreibung
1	([Pp])ython&\1ails Entspricht Python & Pails oder Python & Pails
2	*(['"])[^\1]\1** Einfache oder doppelte Zeichenfolge. \ 1 stimmt mit der 1. Gruppe überein. \ 2 stimmt mit der 2. Gruppe überein usw.

Alternativen

Sr.Nr.	Beispiel & Beschreibung
1	python\|perl Entspricht "Python" oder "Perl"
2	rub(y\|le)) Entspricht "Rubin" oder "Rubel"
3	Python(!+\|\?) "Python" gefolgt von einem oder mehreren! oder einer?

Anker

Hier müssen Übereinstimmungspositionen angegeben werden.

Sr.Nr.	Beispiel & Beschreibung
1	^Python Entspricht "Python" am Anfang eines Strings oder einer internen Zeile
2	Python$ Entspricht "Python" am Ende einer Zeichenfolge oder Zeile
3	\APython Entspricht "Python" am Anfang eines Strings
4	Python\Z Entspricht "Python" am Ende eines Strings
5	\bPython\b Entspricht "Python" an einer Wortgrenze
6	\brub\B \ B ist eine Nichtwortgrenze: Entspricht "rub" in "rube" und "ruby", aber nicht allein
7	Python(?=!) Entspricht "Python", wenn ein Ausrufezeichen folgt
8	Python(?!!) Entspricht "Python", wenn kein Ausrufezeichen folgt

Spezielle Syntax mit Klammern

Sr.Nr.	Beispiel & Beschreibung
1	R(?#comment) Entspricht "R". Der Rest ist ein Kommentar
2	R(?i)uby Groß- und Kleinschreibung wird nicht berücksichtigt, während "uby"
3	R(?i:uby) Das gleiche wie oben
4	rub(?:y\|le)) Nur gruppieren, ohne \ 1 Rückreferenz zu erstellen

Verwenden des sendmail-Dienstprogramms

Senden einer einfachen Nachricht

Wenn Sie auf einem Linux / Unix-Computer arbeiten, können Sie einfach verwenden sendmailDienstprogramm in Ihrem Perl-Programm zum Senden von E-Mails. Hier ist ein Beispielskript, mit dem eine E-Mail an eine bestimmte E-Mail-ID gesendet werden kann. Stellen Sie einfach sicher, dass der angegebene Pfad für das Dienstprogramm sendmail korrekt ist. Dies kann für Ihren Linux / Unix-Computer anders sein.

#!/usr/bin/perl
 
$to = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = 'This is test email sent by Perl Script'; open(MAIL, "|/usr/sbin/sendmail -t"); # Email Header print MAIL "To: $to\n";
print MAIL "From: $from\n"; print MAIL "Subject: $subject\n\n";
# Email Body
print MAIL $message;

close(MAIL);
print "Email Sent Successfully\n";

Tatsächlich ist das obige Skript ein Client-E-Mail-Skript, das E-Mails erstellt und an den Server sendet, der lokal auf Ihrem Linux / Unix-Computer ausgeführt wird. Dieses Skript ist nicht für das Senden von E-Mails an das tatsächliche Ziel verantwortlich. Sie müssen also sicherstellen, dass der E-Mail-Server ordnungsgemäß konfiguriert ist und auf Ihrem Computer ausgeführt wird, um E-Mails an die angegebene E-Mail-ID zu senden.

Senden einer HTML-Nachricht

Wenn Sie HTML-formatierte E-Mails mit sendmail senden möchten, müssen Sie nur hinzufügen Content-type: text/html\n im Header-Teil der E-Mail wie folgt -

#!/usr/bin/perl
 
$to = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = '<h1>This is test email sent by Perl Script</h1>'; open(MAIL, "|/usr/sbin/sendmail -t"); # Email Header print MAIL "To: $to\n";
print MAIL "From: $from\n"; print MAIL "Subject: $subject\n\n";
print MAIL "Content-type: text/html\n";
# Email Body
print MAIL $message;

close(MAIL);
print "Email Sent Successfully\n";

Verwenden des MIME :: Lite-Moduls

Wenn Sie auf einem Windows-Computer arbeiten, haben Sie keinen Zugriff auf das Dienstprogramm sendmail. Sie haben jedoch die Möglichkeit, Ihren eigenen E-Mail-Client mit dem MIME: Lite-Perl-Modul zu schreiben. Sie können dieses Modul von MIME-Lite-3.01.tar.gz herunterladen und auf Ihrem Computer Windows oder Linux / Unix installieren. Um es zu installieren, folgen Sie den einfachen Schritten -

$tar xvfz MIME-Lite-3.01.tar.gz
$cd MIME-Lite-3.01 $perl Makefile.PL
$make $make install

Das war's und Sie haben das MIME :: Lite-Modul auf Ihrem Computer installiert. Jetzt können Sie Ihre E-Mail mit einfachen Skripten senden, die unten erläutert werden.

Senden einer einfachen Nachricht

Im Folgenden finden Sie ein Skript, mit dem E-Mails an die angegebene E-Mail-ID gesendet werden.

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]'; $cc = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = 'This is test email sent by Perl Script'; $msg = MIME::Lite->new(
                 From     => $from, To => $to,
                 Cc       => $cc, Subject => $subject,
                 Data     => $message ); $msg->send;
print "Email Sent Successfully\n";

Senden einer HTML-Nachricht

Wenn Sie HTML-formatierte E-Mails mit sendmail senden möchten, müssen Sie nur hinzufügen Content-type: text/html\nim Header-Teil der E-Mail. Im Folgenden finden Sie das Skript, mit dem HTML-formatierte E-Mails gesendet werden.

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]'; $cc = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = '<h1>This is test email sent by Perl Script</h1>'; $msg = MIME::Lite->new(
                 From     => $from, To => $to,
                 Cc       => $cc, Subject => $subject,
                 Data     => $message ); $msg->attr("content-type" => "text/html");         
$msg->send;
print "Email Sent Successfully\n";

Anhang senden

Wenn Sie einen Anhang senden möchten, dient das folgende Skript dem Zweck:

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]';
$cc = '[email protected]'; $from = '[email protected]';
$subject = 'Test Email'; $message = 'This is test email sent by Perl Script';

$msg = MIME::Lite->new( From => $from,
                 To       => $to, Cc => $cc,
                 Subject  => $subject, Type => 'multipart/mixed' ); # Add your text message. $msg->attach(Type         => 'text',
             Data         => $message ); # Specify your file as attachement. $msg->attach(Type         => 'image/gif',
             Path         => '/tmp/logo.gif',
             Filename     => 'logo.gif',
             Disposition  => 'attachment'
            );       
$msg->send;
print "Email Sent Successfully\n";

Mit der Methode attach () können Sie beliebig viele Dateien in Ihre E-Mail einfügen.

Verwenden des SMTP-Servers

Wenn auf Ihrem Computer kein E-Mail-Server ausgeführt wird, können Sie jeden anderen E-Mail-Server verwenden, der am Remotestandort verfügbar ist. Um jedoch einen anderen E-Mail-Server verwenden zu können, benötigen Sie eine ID, ein Kennwort, eine URL usw. Sobald Sie alle erforderlichen Informationen haben, müssen Sie diese Informationen einfach in angebensend() Methode wie folgt -

$msg->send('smtp', "smtp.myisp.net", AuthUser=>"id", AuthPass=>"password" );

Sie können sich an Ihren E-Mail-Server-Administrator wenden, um die oben genannten Informationen zu erhalten. Wenn eine Benutzer-ID und ein Kennwort noch nicht verfügbar sind, kann Ihr Administrator diese in wenigen Minuten erstellen.

Was ist eine Steckdose?

Socket ist ein Berkeley UNIX-Mechanismus zum Erstellen einer virtuellen Duplexverbindung zwischen verschiedenen Prozessen. Dies wurde später auf jedes bekannte Betriebssystem portiert, um die Kommunikation zwischen Systemen über geografische Standorte hinweg zu ermöglichen, die auf verschiedenen Betriebssystemsoftware ausgeführt werden. Ohne den Socket wäre der größte Teil der Netzwerkkommunikation zwischen Systemen niemals zustande gekommen.

Bei näherer Betrachtung; Ein typisches Computersystem in einem Netzwerk empfängt und sendet Informationen wie gewünscht von den verschiedenen darauf ausgeführten Anwendungen. Diese Informationen werden an das System weitergeleitet, da ihm eine eindeutige IP-Adresse zugewiesen ist. Auf dem System werden diese Informationen an die relevanten Anwendungen weitergegeben, die verschiedene Ports überwachen. Beispielsweise wartet ein Internetbrowser auf Port 80 auf Informationen, die vom Webserver empfangen werden. Wir können auch unsere benutzerdefinierten Anwendungen schreiben, die Informationen zu einer bestimmten Portnummer abhören und senden / empfangen können.

Lassen Sie uns zunächst zusammenfassen, dass ein Socket eine IP-Adresse und ein Port ist, sodass die Verbindung Daten über ein Netzwerk senden und empfangen kann.

Um das oben erwähnte Socket-Konzept zu erläutern, nehmen wir ein Beispiel für die Client-Server-Programmierung mit Perl. Um eine Client-Server-Architektur zu vervollständigen, müssten wir die folgenden Schritte ausführen:

So erstellen Sie einen Server

Erstellen Sie einen Socket mit socket Anruf.
Binden Sie den Socket mit an eine Portadresse bind Anruf.
Hören Sie den Socket an der Portadresse mit ab listen Anruf.
Akzeptieren Sie Clientverbindungen mit accept Anruf.

So erstellen Sie einen Client

Erstellen Sie einen Socket mit socket Anruf.
Verbinden Sie (den Socket) mit dem Server über connect Anruf.

Das folgende Diagramm zeigt die vollständige Abfolge der Aufrufe, mit denen Client und Server miteinander kommunizieren.

Serverseitige Socket-Anrufe

Der Aufruf von socket ()

Das socket()Anruf ist der erste Anruf beim Herstellen einer Netzwerkverbindung, bei dem ein Socket erstellt wird. Dieser Aufruf hat die folgende Syntax:

socket( SOCKET, DOMAIN, TYPE, PROTOCOL );

Der obige Aufruf erstellt ein SOCKET und andere drei Argumente sind Ganzzahlen, die die folgenden Werte für TCP / IP-Verbindungen haben sollten.

DOMAINsollte PF_INET sein. Es ist wahrscheinlich 2 auf Ihrem Computer.
TYPE sollte SOCK_STREAM für die TCP / IP-Verbindung sein.
PROTOCOL sollte sein (getprotobyname('tcp'))[2]. Es ist das spezielle Protokoll wie TCP, das über den Socket gesprochen wird.

Der vom Server ausgegebene Socket-Funktionsaufruf sieht also ungefähr so aus:

use Socket     # This defines PF_INET and SOCK_STREAM

socket(SOCKET,PF_INET,SOCK_STREAM,(getprotobyname('tcp'))[2]);

Der Aufruf von bind ()

Die durch den Aufruf von socket () erstellten Sockets sind unbrauchbar, bis sie an einen Hostnamen und eine Portnummer gebunden sind. Der Server verwendet Folgendesbind() Funktion zur Angabe des Ports, an dem Verbindungen von den Clients akzeptiert werden.

bind( SOCKET, ADDRESS );

Hier ist SOCKET der Deskriptor, der vom Aufruf von socket () zurückgegeben wird, und ADDRESS ist eine Socket-Adresse (für TCP / IP), die drei Elemente enthält:

Die Adressfamilie (Für TCP / IP ist das AF_INET, wahrscheinlich 2 auf Ihrem System).
Die Portnummer (zum Beispiel 21).
Die Internetadresse des Computers (zum Beispiel 10.12.12.168).

Da bind () von einem Server verwendet wird, der keine eigene Adresse kennen muss, sieht die Argumentliste folgendermaßen aus:

use Socket        # This defines PF_INET and SOCK_STREAM

$port = 12345; # The unique port used by the sever to listen requests $server_ip_address = "10.12.12.168";
bind( SOCKET, pack_sockaddr_in($port, inet_aton($server_ip_address)))
   or die "Can't bind to port $port! \n";

Das or die Die Klausel ist sehr wichtig, da der Port nicht sofort wiederverwendbar ist, wenn ein Server ohne ausstehende Verbindungen ausfällt, es sei denn, Sie verwenden die Option SO_REUSEADDR using setsockopt()Funktion. Hierpack_sockaddr_in() Die Funktion wird verwendet, um den Port und die IP-Adresse in ein Binärformat zu packen.

Der listen () Aufruf

Wenn dies ein Serverprogramm ist, muss ein Aufruf an gesendet werden listen()Warten Sie auf den angegebenen Port, um abzuhören, dh warten Sie auf die eingehenden Anforderungen. Dieser Aufruf hat die folgende Syntax:

listen( SOCKET, QUEUESIZE );

Der obige Aufruf verwendet den Socket-Deskriptor, der vom Socket () -Aufruf zurückgegeben wird, und QUEUESIZE ist die maximale Anzahl ausstehender Verbindungsanforderungen, die gleichzeitig zulässig sind.

Der Aufruf accept ()

Wenn dies ein Serverprogramm ist, muss ein Aufruf an das access()Funktion zum Akzeptieren der eingehenden Verbindungen. Dieser Aufruf hat die folgende Syntax:

accept( NEW_SOCKET, SOCKET );

Der von Socket () -Funktion zurückgegebene SOCKET-Deskriptor für den Empfangsaufruf erhält nach erfolgreichem Abschluss einen neuen Socket-Deskriptor NEW_SOCKET für die gesamte zukünftige Kommunikation zwischen dem Client und dem Server. Wenn der Aufruf von access () fehlschlägt, wird FLASE zurückgegeben, das im Socket-Modul definiert ist, das wir ursprünglich verwendet haben.

Im Allgemeinen wird accept () in einer Endlosschleife verwendet. Sobald eine Verbindung eintrifft, erstellt der Server entweder einen untergeordneten Prozess, um sie zu verarbeiten, oder bedient sie selbst und wartet dann wieder auf weitere Verbindungen.

while(1) {
   accept( NEW_SOCKET, SOCKT );
   .......
}

Jetzt sind alle Anrufe in Bezug auf den Server beendet und wir sehen einen Anruf, der vom Client benötigt wird.

Clientseitige Socket-Anrufe

Der Aufruf von connect ()

Wenn Sie das Client-Programm vorbereiten möchten, verwenden Sie zuerst socket() Rufen Sie an, um einen Socket zu erstellen, und dann müssten Sie verwenden connect()Rufen Sie an, um eine Verbindung zum Server herzustellen. Sie haben bereits die Socket () - Aufrufsyntax gesehen und sie bleibt dem Server-Socket () - Aufruf ähnlich, aber hier ist die Syntax fürconnect() Anruf -

connect( SOCKET, ADDRESS );

Hier ist SCOKET der Socket-Deskriptor, der vom vom Client ausgegebenen Socket () -Aufruf zurückgegeben wird, und ADDRESS ist eine Socket-Adresse, die dem Bindungsaufruf ähnlich ist , außer dass sie die IP-Adresse des Remote-Servers enthält.

$port = 21;    # For example, the ftp port
$server_ip_address = "10.12.12.168"; connect( SOCKET, pack_sockaddr_in($port, inet_aton($server_ip_address))) or die "Can't connect to port $port! \n";

Wenn Sie erfolgreich eine Verbindung zum Server herstellen, können Sie Ihre Befehle mithilfe des SOCKET-Deskriptors an den Server senden. Andernfalls wird Ihr Client durch eine Fehlermeldung ausgegeben.

Client - Server Beispiel

Es folgt ein Perl-Code zum Implementieren eines einfachen Client-Server-Programms mithilfe des Perl-Sockets. Hier wartet der Server auf eingehende Anfragen und sobald die Verbindung hergestellt ist, antwortet er einfach Smile vom Server . Der Client liest diese Nachricht und druckt sie auf dem Bildschirm aus. Mal sehen, wie es gemacht wurde, vorausgesetzt, wir haben unseren Server und Client auf demselben Computer.

Skript zum Erstellen eines Servers

#!/usr/bin/perl -w
# Filename : server.pl

use strict;
use Socket;

# use port 7890 as default
my $port = shift || 7890; my $proto = getprotobyname('tcp');
my $server = "localhost"; # Host IP running the server # create a socket, make it reusable socket(SOCKET, PF_INET, SOCK_STREAM, $proto)
   or die "Can't open socket $!\n"; setsockopt(SOCKET, SOL_SOCKET, SO_REUSEADDR, 1) or die "Can't set socket option to SO_REUSEADDR $!\n";

# bind to a port, then listen
bind( SOCKET, pack_sockaddr_in($port, inet_aton($server)))
   or die "Can't bind to port $port! \n"; listen(SOCKET, 5) or die "listen: $!";
print "SERVER started on port $port\n"; # accepting a connection my $client_addr;
while ($client_addr = accept(NEW_SOCKET, SOCKET)) { # send them a message, close connection my $name = gethostbyaddr($client_addr, AF_INET ); print NEW_SOCKET "Smile from the server"; print "Connection recieved from $name\n";
   close NEW_SOCKET;
}

Um den Server im Hintergrundmodus auszuführen, geben Sie an der Unix-Eingabeaufforderung den folgenden Befehl ein:

$perl sever.pl&

Skript zum Erstellen eines Clients

!/usr/bin/perl -w
# Filename : client.pl

use strict;
use Socket;

# initialize host and port
my $host = shift || 'localhost';
my $port = shift || 7890; my $server = "localhost";  # Host IP running the server

# create the socket, connect to the port
socket(SOCKET,PF_INET,SOCK_STREAM,(getprotobyname('tcp'))[2])
   or die "Can't create a socket $!\n"; connect( SOCKET, pack_sockaddr_in($port, inet_aton($server))) or die "Can't connect to port $port! \n";

my $line; while ($line = <SOCKET>) {
   print "$line\n"; } close SOCKET or die "close: $!";

Starten wir nun unseren Client an der Eingabeaufforderung, die eine Verbindung zum Server herstellt und die vom Server gesendete Nachricht liest und diese auf dem Bildschirm wie folgt anzeigt:

$perl client.pl
Smile from the server

NOTE - Wenn Sie die tatsächliche IP-Adresse in Punktnotation angeben, wird empfohlen, die IP-Adresse sowohl auf dem Client als auch auf dem Server im gleichen Format anzugeben, um Verwechslungen zu vermeiden.

Wir haben bereits Referenzen in anonymen Perl- und Perl-Arrays und -Hashes untersucht. Das objektorientierte Konzept in Perl basiert stark auf Referenzen und anonymen Arrays und Hashes. Beginnen wir mit dem Erlernen grundlegender Konzepte von objektorientiertem Perl.

Objektgrundlagen

Es gibt drei Hauptbegriffe, die unter dem Gesichtspunkt erläutert werden, wie Perl mit Objekten umgeht. Die Begriffe sind Objekt, Klasse und Methode.

Ein objectIn Perl wird lediglich auf einen Datentyp verwiesen, der weiß, zu welcher Klasse er gehört. Das Objekt wird als Referenz in einer skalaren Variablen gespeichert. Da ein Skalar nur einen Verweis auf das Objekt enthält, kann derselbe Skalar verschiedene Objekte in verschiedenen Klassen enthalten.
EIN class In Perl befindet sich ein Paket, das die entsprechenden Methoden zum Erstellen und Bearbeiten von Objekten enthält.
EIN methodInnerhalb von Perl befindet sich eine Unterroutine, die mit dem Paket definiert wird. Das erste Argument für die Methode ist eine Objektreferenz oder ein Paketname, je nachdem, ob die Methode das aktuelle Objekt oder die Klasse beeinflusst.

Perl bietet eine bless() Funktion, mit der eine Referenz zurückgegeben wird, die letztendlich zu einem Objekt wird.

Eine Klasse definieren

Es ist sehr einfach, eine Klasse in Perl zu definieren. Eine Klasse entspricht einem Perl-Paket in seiner einfachsten Form. Um eine Klasse in Perl zu erstellen, erstellen wir zuerst ein Paket.

Ein Paket ist eine in sich geschlossene Einheit von benutzerdefinierten Variablen und Unterprogrammen, die immer wieder verwendet werden können.

Perl-Pakete bieten einen separaten Namespace innerhalb eines Perl-Programms, der Unterprogramme und Variablen unabhängig von Konflikten mit denen in anderen Paketen hält.

Um eine Klasse namens Person in Perl zu deklarieren, tun wir -

package Person;

Der Umfang der Paketdefinition erstreckt sich bis zum Ende der Datei oder bis ein anderes Paketschlüsselwort gefunden wird.

Objekte erstellen und verwenden

Um eine Instanz einer Klasse (eines Objekts) zu erstellen, benötigen wir einen Objektkonstruktor. Dieser Konstruktor ist eine im Paket definierte Methode. Die meisten Programmierer benennen diese Objektkonstruktormethode neu, aber in Perl können Sie einen beliebigen Namen verwenden.

Sie können jede Art von Perl-Variable als Objekt in Perl verwenden. Die meisten Perl-Programmierer wählen entweder Verweise auf Arrays oder Hashes.

Lassen Sie uns unseren Konstruktor für unsere Person-Klasse mithilfe einer Perl-Hash-Referenz erstellen. Beim Erstellen eines Objekts müssen Sie einen Konstruktor angeben, bei dem es sich um eine Unterroutine innerhalb eines Pakets handelt, die eine Objektreferenz zurückgibt. Die Objektreferenz wird erstellt, indem eine Referenz auf die Klasse des Pakets gesegnet wird. Zum Beispiel -

package Person;
sub new {
   my $class = shift;
   my $self = { _firstName => shift, _lastName => shift, _ssn => shift, }; # Print all the values just for clarification. print "First Name is $self->{_firstName}\n";
   print "Last Name is $self->{_lastName}\n"; print "SSN is $self->{_ssn}\n";
   bless $self, $class;
   return $self;
}

Lassen Sie uns nun sehen, wie Sie ein Objekt erstellen.

$object = new Person( "Mohammad", "Saleem", 23234345);

Sie können einfachen Hash in Ihrem Konstruktor verwenden, wenn Sie keiner Klassenvariablen einen Wert zuweisen möchten. Zum Beispiel -

package Person;
sub new {
   my $class = shift; my $self = {};
   bless $self, $class;
   return $self;
}

Methoden definieren

Andere objektorientierte Sprachen haben das Konzept der Datensicherheit, um zu verhindern, dass ein Programmierer Objektdaten direkt ändert, und sie bieten Zugriffsmethoden zum Ändern von Objektdaten. Perl hat keine privaten Variablen, aber wir können immer noch das Konzept der Hilfsmethoden verwenden, um Objektdaten zu manipulieren.

Definieren wir eine Hilfsmethode, um den Vornamen einer Person zu erhalten.

sub getFirstName {
   return $self->{_firstName};
}

Eine weitere Hilfsfunktion zum Festlegen des Vornamens einer Person -

sub setFirstName {
   my ( $self, $firstName ) = @_;
   $self->{_firstName} = $firstName if defined($firstName); return $self->{_firstName};
}

Schauen wir uns nun ein vollständiges Beispiel an: Behalten Sie das Personenpaket und die Hilfsfunktionen in der Person.pm-Datei.

#!/usr/bin/perl 

package Person;

sub new {
   my $class = shift; my $self = {
      _firstName => shift,
      _lastName  => shift,
      _ssn       => shift,
   };
   # Print all the values just for clarification.
   print "First Name is $self->{_firstName}\n"; print "Last Name is $self->{_lastName}\n";
   print "SSN is $self->{_ssn}\n"; bless $self, $class; return $self;
}
sub setFirstName {
   my ( $self, $firstName ) = @_;
   $self->{_firstName} = $firstName if defined($firstName); return $self->{_firstName};
}

sub getFirstName {
   my( $self ) = @_; return $self->{_firstName};
}
1;

Verwenden wir nun das Objekt Person in der Datei employee.pl wie folgt:

#!/usr/bin/perl

use Person;

$object = new Person( "Mohammad", "Saleem", 23234345); # Get first name which is set using constructor. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

# Now Set first name using helper function.
$object->setFirstName( "Mohd." ); # Now get first name set by helper function. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

Wenn wir das obige Programm ausführen, wird das folgende Ergebnis erzeugt:

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
Before Setting First Name is : Mohammad
Before Setting First Name is : Mohd.

Erbe

Objektorientierte Programmierung hat ein sehr gutes und nützliches Konzept, das als Vererbung bezeichnet wird. Vererbung bedeutet einfach, dass Eigenschaften und Methoden einer übergeordneten Klasse den untergeordneten Klassen zur Verfügung stehen. Sie müssen also nicht immer wieder denselben Code schreiben, sondern können einfach eine übergeordnete Klasse erben.

Zum Beispiel können wir eine Klasse Employee haben, die von Person erbt. Dies wird als "isa" -Beziehung bezeichnet, da ein Mitarbeiter eine Person ist. Perl hat eine spezielle Variable, @ISA, um dabei zu helfen. @ISA regelt die (Methoden-) Vererbung.

Im Folgenden sind die wichtigen Punkte aufgeführt, die bei der Verwendung der Vererbung zu beachten sind:

Perl durchsucht die Klasse des angegebenen Objekts nach der angegebenen Methode oder dem angegebenen Attribut, dh nach der Variablen.
Perl durchsucht die im @ ISO-Array der Objektklasse definierten Klassen.
Wenn in Schritt 1 oder 2 keine Methode gefunden wird, verwendet Perl eine AUTOLOAD-Unterroutine, sofern eine im @ISA-Baum gefunden wird.
Wenn eine passende Methode immer noch nicht gefunden werden kann, sucht Perl nach der Methode in der UNIVERSAL-Klasse (Paket), die Teil der Standard-Perl-Bibliothek ist.
Wenn die Methode immer noch nicht gefunden wurde, gibt Perl auf und löst eine Laufzeitausnahme aus.

Um eine neue Employee-Klasse zu erstellen, die Methoden und Attribute von unserer Person-Klasse erbt, codieren wir einfach wie folgt: Behalten Sie diesen Code in Employee.pm bei.

#!/usr/bin/perl

package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # inherits from Person

Jetzt verfügt die Mitarbeiterklasse über alle Methoden und Attribute, die von der Personenklasse geerbt wurden, und Sie können sie wie folgt verwenden: Verwenden Sie die Datei main.pl, um sie zu testen -

#!/usr/bin/perl

use Employee;

$object = new Employee( "Mohammad", "Saleem", 23234345); # Get first name which is set using constructor. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

# Now Set first name using helper function.
$object->setFirstName( "Mohd." ); # Now get first name set by helper function. $firstName = $object->getFirstName(); print "After Setting First Name is : $firstName\n";

Wenn wir das obige Programm ausführen, wird das folgende Ergebnis erzeugt:

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
Before Setting First Name is : Mohammad
Before Setting First Name is : Mohd.

Überschreiben der Methode

Die untergeordnete Klasse Employee erbt alle Methoden von der übergeordneten Klasse Person. Wenn Sie diese Methoden in Ihrer untergeordneten Klasse überschreiben möchten, können Sie dies tun, indem Sie Ihre eigene Implementierung angeben. Sie können Ihre zusätzlichen Funktionen in der untergeordneten Klasse hinzufügen oder die Funktionalität einer vorhandenen Methode in der übergeordneten Klasse hinzufügen oder ändern. Dies kann wie folgt erfolgen: Ändern Sie die Datei Employee.pm.

#!/usr/bin/perl

package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # inherits from Person

# Override constructor
sub new {
   my ($class) = @_; # Call the constructor of the parent class, Person. my $self = $class->SUPER::new( $_[1], $_[2], $_[3] );
   # Add few more attributes
   $self->{_id} = undef; $self->{_title} = undef;
   bless $self, $class;
   return $self; } # Override helper function sub getFirstName { my( $self ) = @_;
   # This is child class function.
   print "This is child class helper function\n";
   return $self->{_firstName}; } # Add more methods sub setLastName{ my ( $self, $lastName ) = @_; $self->{_lastName} = $lastName if defined($lastName);
   return $self->{_lastName}; } sub getLastName { my( $self ) = @_;
   return $self->{_lastName};
}

1;

Versuchen wir nun erneut, das Employee-Objekt in unserer Datei main.pl zu verwenden und auszuführen.

#!/usr/bin/perl

use Employee;

$object = new Employee( "Mohammad", "Saleem", 23234345);
# Get first name which is set using constructor.
$firstName = $object->getFirstName();

print "Before Setting First Name is : $firstName\n"; # Now Set first name using helper function. $object->setFirstName( "Mohd." );

# Now get first name set by helper function.
$firstName = $object->getFirstName();
print "After Setting First Name is : $firstName\n";

Wenn wir das obige Programm ausführen, wird das folgende Ergebnis erzeugt:

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
This is child class helper function
Before Setting First Name is : Mohammad
This is child class helper function
After Setting First Name is : Mohd.

Standard-Autoloading

Perl bietet eine Funktion, die Sie in keiner anderen Programmiersprache finden würden: eine Standard-Unterroutine. Das heißt, wenn Sie eine aufgerufene Funktion definierenAUTOLOAD(),Alle Aufrufe undefinierter Unterprogramme rufen dann automatisch die Funktion AUTOLOAD () auf. Der Name der fehlenden Unterroutine ist in dieser Unterroutine als $ AUTOLOAD verfügbar.

Die Standardfunktion zum automatischen Laden ist sehr nützlich für die Fehlerbehandlung. Hier ist ein Beispiel für die Implementierung von AUTOLOAD. Sie können diese Funktion auf Ihre eigene Weise implementieren.

sub AUTOLOAD {
   my $self = shift; my $type = ref ($self) || croak "$self is not an object";
   my $field = $AUTOLOAD;
   $field =~ s/.*://; unless (exists $self->{$field}) { croak "$field does not exist in object/class $type"; } if (@_) { return $self->($name) = shift; } else { return $self->($name);
   }
}

Zerstörer und Müllabfuhr

Wenn Sie zuvor mit objektorientierter Programmierung programmiert haben, sind Sie sich der Notwendigkeit bewusst, eine zu erstellen destructorum den dem Objekt zugewiesenen Speicher freizugeben, wenn Sie es nicht mehr verwenden. Perl erledigt dies automatisch für Sie, sobald das Objekt den Gültigkeitsbereich verlässt.

Wenn Sie Ihren Destruktor implementieren möchten, der sich um das Schließen von Dateien oder eine zusätzliche Verarbeitung kümmern soll, müssen Sie eine spezielle Methode mit dem Namen definieren DESTROY. Diese Methode wird für das Objekt aufgerufen, kurz bevor Perl den ihm zugewiesenen Speicher freigibt. Im Übrigen ist die DESTROY-Methode wie jede andere Methode, und Sie können jede gewünschte Logik in diese Methode implementieren.

Eine Destruktormethode ist einfach eine Elementfunktion (Unterroutine) namens DESTROY, die in den folgenden Fällen automatisch aufgerufen wird:

Wenn die Variable der Objektreferenz den Gültigkeitsbereich verlässt.
Wenn die Variable der Objektreferenz nicht definiert ist.
Wenn das Skript beendet wird
Wenn der Perl-Interpreter beendet wird

Zum Beispiel können Sie einfach die folgende Methode DESTROY in Ihre Klasse einfügen:

package MyClass;
...
sub DESTROY {
   print "MyClass::DESTROY called\n";
}

Objektorientiertes Perl-Beispiel

Hier ist ein weiteres schönes Beispiel, das Ihnen hilft, objektorientierte Konzepte von Perl zu verstehen. Fügen Sie diesen Quellcode in eine beliebige Perl-Datei ein und führen Sie ihn aus.

#!/usr/bin/perl

# Following is the implementation of simple Class.
package MyClass;

sub new {
   print "MyClass::new called\n";
   my $type = shift;            # The package/type name
   my $self = {}; # Reference to empty hash return bless $self, $type; } sub DESTROY { print "MyClass::DESTROY called\n"; } sub MyMethod { print "MyClass::MyMethod called!\n"; } # Following is the implemnetation of Inheritance. package MySubClass; @ISA = qw( MyClass ); sub new { print "MySubClass::new called\n"; my $type = shift;            # The package/type name
   my $self = MyClass->new; # Reference to empty hash return bless $self, $type; } sub DESTROY { print "MySubClass::DESTROY called\n"; } sub MyMethod { my $self = shift;
   $self->SUPER::MyMethod(); print " MySubClass::MyMethod called!\n"; } # Here is the main program using above classes. package main; print "Invoke MyClass method\n"; $myObject = MyClass->new();
$myObject->MyMethod(); print "Invoke MySubClass method\n"; $myObject2 = MySubClass->new();
$myObject2->MyMethod(); print "Create a scoped object\n"; { my $myObject2 = MyClass->new();
}
# Destructor is called automatically here

print "Create and undef an object\n";
$myObject3 = MyClass->new(); undef $myObject3;

print "Fall off the end of the script...\n";
# Remaining destructors are called automatically here

Wenn wir das obige Programm ausführen, wird das folgende Ergebnis erzeugt:

Invoke MyClass method
MyClass::new called
MyClass::MyMethod called!
Invoke MySubClass method
MySubClass::new called
MyClass::new called
MyClass::MyMethod called!
MySubClass::MyMethod called!
Create a scoped object
MyClass::new called
MyClass::DESTROY called
Create and undef an object
MyClass::new called
MyClass::DESTROY called
Fall off the end of the script...
MyClass::DESTROY called
MySubClass::DESTROY called

In diesem Kapitel erfahren Sie, wie Sie in Ihrem Perl-Skript auf eine Datenbank zugreifen. Ab Perl 5 ist es sehr einfach geworden, Datenbankanwendungen mit zu schreibenDBIModul. DBI steht fürDatabase Independent Interface Für Perl bedeutet dies, dass DBI eine Abstraktionsschicht zwischen dem Perl-Code und der zugrunde liegenden Datenbank bereitstellt, sodass Sie die Datenbankimplementierungen ganz einfach wechseln können.

Das DBI ist ein Datenbankzugriffsmodul für die Programmiersprache Perl. Es bietet eine Reihe von Methoden, Variablen und Konventionen, die unabhängig von der tatsächlich verwendeten Datenbank eine konsistente Datenbankschnittstelle bieten.

Architektur einer DBI-Anwendung

DBI ist unabhängig von jeder im Backend verfügbaren Datenbank. Sie können DBI verwenden, unabhängig davon, ob Sie mit Oracle, MySQL oder Informix usw. arbeiten. Dies geht aus dem folgenden Architekturdiagramm hervor.

Hier ist DBI dafür verantwortlich, alle SQL-Befehle über die API (dh die Anwendungsprogrammierschnittstelle) zu führen und sie zur tatsächlichen Ausführung an den entsprechenden Treiber zu senden. Und schließlich ist DBI dafür verantwortlich, die Ergebnisse vom Fahrer zu übernehmen und an den anrufenden Scritp zurückzugeben.

Notation und Konventionen

In diesem Kapitel werden die folgenden Notationen verwendet, und es wird empfohlen, dass Sie dieselbe Konvention befolgen.

$dsn Database source name $dbh    Database handle object
$sth Statement handle object $h      Any of the handle types above ($dbh, $sth, or $drh) $rc     General Return Code  (boolean: true=ok, false=error)
$rv General Return Value (typically an integer) @ary List of values returned from the database. $rows   Number of rows processed (if available, else -1)
$fh     A filehandle
undef   NULL values are represented by undefined values in Perl
\%attr  Reference to a hash of attribute values passed to methods

Datenbankverbindung

Angenommen, wir werden mit der MySQL-Datenbank arbeiten. Stellen Sie vor dem Herstellen einer Verbindung zu einer Datenbank Folgendes sicher. Sie können unser MySQL-Tutorial nutzen, falls Sie nicht wissen, wie Sie Datenbanken und Tabellen in der MySQL-Datenbank erstellen.

Sie haben eine Datenbank mit dem Namen TESTDB erstellt.
Sie haben in TESTDB eine Tabelle mit dem Namen TEST_TABLE erstellt.
Diese Tabelle enthält die Felder FIRST_NAME, LAST_NAME, AGE, SEX und INCOME.
Die Benutzer-ID "testuser" und das Kennwort "test123" sind für den Zugriff auf TESTDB festgelegt.
Perl Module DBI ist ordnungsgemäß auf Ihrem Computer installiert.
Sie haben das MySQL-Tutorial durchgearbeitet, um die MySQL-Grundlagen zu verstehen.

Es folgt das Beispiel für die Verbindung mit der MySQL-Datenbank "TESTDB" -

#!/usr/bin/perl

use DBI
use strict;

my $driver = "mysql"; 
my $database = "TESTDB"; my $dsn = "DBI:$driver:database=$database";
my $userid = "testuser"; my $password = "test123";

my $dbh = DBI->connect($dsn, $userid, $password ) or die $DBI::errstr;

Wenn eine Verbindung mit der Datenquelle hergestellt wird, wird ein Datenbankhandle zurückgegeben und zur weiteren Verwendung in $ dbh gespeichert. Andernfalls wird $ dbh auf den Wert undef gesetzt und $ DBI :: errstr gibt eine Fehlerzeichenfolge zurück.

INSERT-Betrieb

Die INSERT-Operation ist erforderlich, wenn Sie einige Datensätze in einer Tabelle erstellen möchten. Hier verwenden wir die Tabelle TEST_TABLE, um unsere Datensätze zu erstellen. Sobald unsere Datenbankverbindung hergestellt ist, können wir Datensätze in TEST_TABLE erstellen. Im Folgenden wird beschrieben, wie Sie einen einzelnen Datensatz in TEST_TABLE erstellen. Mit demselben Konzept können Sie beliebig viele Datensätze erstellen.

Die Datensatzerstellung umfasst die folgenden Schritte:

SQL-Anweisung mit INSERT-Anweisung vorbereiten. Dies erfolgt mitprepare() API.
Ausführen einer SQL-Abfrage, um alle Ergebnisse aus der Datenbank auszuwählen. Dies erfolgt mitexecute() API.
Stattement-Griff loslassen. Dies erfolgt mitfinish() API.
Wenn alles gut geht, dann commit diese Operation können Sie sonst rollbackTransaktion abschließen. Commit und Rollback werden in den nächsten Abschnitten erläutert.

my $sth = $dbh->prepare("INSERT INTO TEST_TABLE
                       (FIRST_NAME, LAST_NAME, SEX, AGE, INCOME )
                         values
                       ('john', 'poul', 'M', 30, 13000)");
$sth->execute() or die $DBI::errstr;
$sth->finish(); $dbh->commit or die $DBI::errstr;

Bindungswerte verwenden

Es kann vorkommen, dass die einzugebenden Werte nicht im Voraus angegeben werden. Sie können also Bindevariablen verwenden, die zur Laufzeit die erforderlichen Werte annehmen. Perl-DBI-Module verwenden anstelle des tatsächlichen Werts ein Fragezeichen, und dann werden die tatsächlichen Werte zur Laufzeit über die execute () -API übergeben. Es folgt das Beispiel -

my $first_name = "john";
my $last_name = "poul"; my $sex = "M";
my $income = 13000; my $age = 30;
my $sth = $dbh->prepare("INSERT INTO TEST_TABLE
                        (FIRST_NAME, LAST_NAME, SEX, AGE, INCOME )
                          values
                        (?,?,?,?)");
$sth->execute($first_name,$last_name,$sex, $age, $income) 
          or die $DBI::errstr; $sth->finish();
$dbh->commit or die $DBI::errstr;

LESEN Betrieb

READ Operation für eine beliebige Datenbank bedeutet, dass einige nützliche Informationen aus der Datenbank abgerufen werden, dh ein oder mehrere Datensätze aus einer oder mehreren Tabellen. Sobald unsere Datenbankverbindung hergestellt ist, können wir eine Abfrage in diese Datenbank durchführen. Im Folgenden wird beschrieben, wie alle Datensätze mit einem Alter von mehr als 20 Jahren abgefragt werden. Dies umfasst vier Schritte:

Vorbereiten der SQL SELECT-Abfrage basierend auf den erforderlichen Bedingungen. Dies erfolgt mitprepare() API.
Ausführen einer SQL-Abfrage, um alle Ergebnisse aus der Datenbank auszuwählen. Dies erfolgt mitexecute() API.
Abrufen aller Ergebnisse nacheinander und Drucken dieser Ergebnisse. Dies erfolgt mit fetchrow_array() API.
Stattement-Griff loslassen. Dies erfolgt mitfinish() API.

my $sth = $dbh->prepare("SELECT FIRST_NAME, LAST_NAME
                        FROM TEST_TABLE 
                        WHERE AGE > 20");
$sth->execute() or die $DBI::errstr;
print "Number of rows found :" + $sth->rows; while (my @row = $sth->fetchrow_array()) {
   my ($first_name, $last_name ) = @row;
   print "First Name = $first_name, Last Name = $last_name\n";
}
$sth->finish();

Bindungswerte verwenden

Es kann vorkommen, dass die Bedingung nicht im Voraus gegeben wird. Sie können also Bindevariablen verwenden, die zur Laufzeit die erforderlichen Werte annehmen. Perl-DBI-Module verwenden anstelle des tatsächlichen Werts ein Fragezeichen. Anschließend werden die tatsächlichen Werte zur Laufzeit über die API execute () übergeben. Es folgt das Beispiel -

$age = 20;
my $sth = $dbh->prepare("SELECT FIRST_NAME, LAST_NAME
                        FROM TEST_TABLE
                        WHERE AGE > ?");
$sth->execute( $age ) or die $DBI::errstr; print "Number of rows found :" + $sth->rows;
while (my @row = $sth->fetchrow_array()) { my ($first_name, $last_name ) = @row; print "First Name = $first_name, Last Name = $last_name\n"; } $sth->finish();

UPDATE-Betrieb

UPDATE Operation für eine beliebige Datenbank bedeutet, einen oder mehrere Datensätze zu aktualisieren, die bereits in den Datenbanktabellen verfügbar sind. Im Folgenden wird beschrieben, wie Sie alle Datensätze mit SEX als 'M' aktualisieren. Hier werden wir das ALTER aller Männchen um ein Jahr erhöhen. Dies dauert drei Schritte -

Vorbereiten der SQL-Abfrage basierend auf den erforderlichen Bedingungen. Dies erfolgt mitprepare() API.
Ausführen einer SQL-Abfrage, um alle Ergebnisse aus der Datenbank auszuwählen. Dies erfolgt mitexecute() API.
Stattement-Griff loslassen. Dies erfolgt mitfinish() API.
Wenn alles gut geht, dann commit diese Operation können Sie sonst rollbackTransaktion abschließen. Im nächsten Abschnitt finden Sie Commit- und Rollback-APIs.

my $sth = $dbh->prepare("UPDATE TEST_TABLE
                        SET   AGE = AGE + 1 
                        WHERE SEX = 'M'");
$sth->execute() or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

Bindungswerte verwenden

$sex = 'M'; my $sth = $dbh->prepare("UPDATE TEST_TABLE SET AGE = AGE + 1 WHERE SEX = ?"); $sth->execute('$sex') or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

In einigen Fällen möchten Sie einen Wert festlegen, der nicht im Voraus angegeben wird, damit Sie den verbindlichen Wert wie folgt verwenden können. In diesem Beispiel wird das Einkommen aller Männer auf 10000 festgelegt.

$sex = 'M'; $income = 10000;
my $sth = $dbh->prepare("UPDATE TEST_TABLE
                        SET   INCOME = ?
                        WHERE SEX = ?");
$sth->execute( $income, '$sex') or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();

DELETE-Betrieb

Der Vorgang LÖSCHEN ist erforderlich, wenn Sie einige Datensätze aus Ihrer Datenbank löschen möchten. Im Folgenden wird beschrieben, wie Sie alle Datensätze aus TEST_TABLE löschen, wobei AGE gleich 30 ist. Dieser Vorgang führt die folgenden Schritte aus.

Vorbereiten der SQL-Abfrage basierend auf den erforderlichen Bedingungen. Dies erfolgt mitprepare() API.
Ausführen einer SQL-Abfrage zum Löschen der erforderlichen Datensätze aus der Datenbank. Dies erfolgt mitexecute() API.
Stattement-Griff loslassen. Dies erfolgt mitfinish() API.
Wenn alles gut geht, dann commit diese Operation können Sie sonst rollback Transaktion abschließen.

$age = 30; my $sth = $dbh->prepare("DELETE FROM TEST_TABLE WHERE AGE = ?"); $sth->execute( $age ) or die $DBI::errstr;
print "Number of rows deleted :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

Do-Anweisung verwenden

Wenn Sie UPDATE, INSERT oder DELETE ausführen, werden keine Daten aus der Datenbank zurückgegeben. Daher gibt es eine Verknüpfung, um diesen Vorgang auszuführen. Sie können verwendendo Anweisung, um einen der Befehle wie folgt auszuführen.

$dbh->do('DELETE FROM TEST_TABLE WHERE age =30');

doGibt einen wahren Wert zurück, wenn dies erfolgreich war, und einen falschen Wert, wenn dies fehlgeschlagen ist. Wenn dies erfolgreich ist, wird die Anzahl der betroffenen Zeilen zurückgegeben. Im Beispiel wird die Anzahl der tatsächlich gelöschten Zeilen zurückgegeben.

COMMIT-Betrieb

Commit ist die Operation, die der Datenbank ein grünes Signal gibt, um die Änderungen abzuschließen. Nach dieser Operation kann keine Änderung mehr in ihre ursprüngliche Position zurückgesetzt werden.

Hier ist ein einfaches Beispiel zum Aufrufen commit API.

$dbh->commit or die $dbh->errstr;

ROLLBACK-Betrieb

Wenn Sie mit allen Änderungen nicht zufrieden sind oder zwischen den Vorgängen ein Fehler auftritt, können Sie diese Änderungen auf die Verwendung zurücksetzen rollback API.

Hier ist ein einfaches Beispiel zum Aufrufen rollback API.

$dbh->rollback or die $dbh->errstr;

Transaktion starten

Viele Datenbanken unterstützen Transaktionen. Dies bedeutet, dass Sie eine ganze Reihe von Abfragen durchführen können, die die Datenbanken ändern würden, aber keine der Änderungen tatsächlich vorgenommen wird. Am Ende geben Sie dann die spezielle SQL-Abfrage ausCOMMITund alle Änderungen werden gleichzeitig vorgenommen. Alternativ können Sie die Abfrage ROLLBACK ausgeben. In diesem Fall werden alle Änderungen verworfen und die Datenbank bleibt unverändert.

Perl DBI-Modul zur Verfügung gestellt begin_workAPI, die Transaktionen (durch Deaktivieren von AutoCommit) bis zum nächsten Aufruf zum Festschreiben oder Zurücksetzen ermöglicht. Nach dem nächsten Commit oder Rollback wird AutoCommit automatisch wieder aktiviert.

$rc  = $dbh->begin_work or die $dbh->errstr;

AutoCommit-Option

Wenn Ihre Transaktionen einfach sind, können Sie sich die Mühe ersparen, viele Commits ausführen zu müssen. Wenn Sie den Verbindungsaufruf tätigen, können Sie eine angebenAutoCommitOption, die nach jeder erfolgreichen Abfrage einen automatischen Festschreibungsvorgang ausführt. So sieht es aus -

my $dbh = DBI->connect($dsn, $userid, $password,
              {AutoCommit => 1}) 
              or die $DBI::errstr;

Hier kann AutoCommit den Wert 1 oder 0 annehmen, wobei 1 bedeutet, dass AutoCommit aktiviert ist und 0 bedeutet, dass AutoCommit deaktiviert ist.

Automatische Fehlerbehandlung

Wenn Sie den Verbindungsaufruf tätigen, können Sie eine RaiseErrors-Option angeben, die Fehler automatisch für Sie behandelt. Wenn ein Fehler auftritt, bricht DBI Ihr Programm ab, anstatt einen Fehlercode zurückzugeben. Wenn Sie das Programm nur aufgrund eines Fehlers abbrechen möchten, kann dies praktisch sein. So sieht es aus -

my $dbh = DBI->connect($dsn, $userid, $password, {RaiseError => 1}) or die $DBI::errstr;

Hier kann RaiseError den Wert 1 oder 0 annehmen.

Datenbank trennen

Verwenden Sie zum Trennen der Datenbankverbindung disconnect API wie folgt -

$rc = $dbh->disconnect  or warn $dbh->errstr;

Das Transaktionsverhalten der Trennungsmethode ist leider undefiniert. Einige Datenbanksysteme (wie Oracle und Ingres) übernehmen automatisch alle ausstehenden Änderungen, andere (wie Informix) setzen alle ausstehenden Änderungen zurück. Anwendungen, die AutoCommit nicht verwenden, sollten Commit oder Rollback explizit aufrufen, bevor sie Disconnect aufrufen.

Verwenden von NULL-Werten

Undefinierte Werte oder undef werden verwendet, um NULL-Werte anzugeben. Sie können Spalten mit einem NULL-Wert wie einen Nicht-NULL-Wert einfügen und aktualisieren. In diesen Beispielen wird das Spaltenalter eingefügt und mit einem NULL-Wert aktualisiert.

$sth = $dbh->prepare(qq { INSERT INTO TEST_TABLE (FIRST_NAME, AGE) VALUES (?, ?) }); $sth->execute("Joe", undef);

Hier qq{} wird verwendet, um eine Zeichenfolge in Anführungszeichen zurückzugeben prepareAPI. Bei der Verwendung von NULL-Werten in einer WHERE-Klausel ist jedoch Vorsicht geboten. Betrachten Sie -

SELECT FIRST_NAME FROM TEST_TABLE WHERE age = ?

Durch das Binden eines undef (NULL) an den Platzhalter werden keine Zeilen ausgewählt, die ein NULL-Alter haben! Zumindest für Datenbankmodule, die dem SQL-Standard entsprechen. Die Gründe hierfür finden Sie im SQL-Handbuch für Ihre Datenbank-Engine oder in einem SQL-Buch. Um NULL explizit auszuwählen, müssen Sie "WHERE age IS NULL" sagen.

Ein häufiges Problem besteht darin, dass ein Codefragment zur Laufzeit einen Wert verarbeitet, der entweder definiert oder undef (nicht NULL oder NULL) sein kann. Eine einfache Technik besteht darin, die entsprechende Anweisung nach Bedarf vorzubereiten und Nicht-NULL-Fälle durch den Platzhalter zu ersetzen.

$sql_clause = defined $age? "age = ?" : "age IS NULL";
$sth = $dbh->prepare(qq {
         SELECT FIRST_NAME FROM TEST_TABLE WHERE $sql_clause }); $sth->execute(defined $age ? $age : ());

Einige andere DBI-Funktionen

verfügbare_Treiber

@ary = DBI->available_drivers;
@ary = DBI->available_drivers($quiet);

Gibt eine Liste aller verfügbaren Treiber zurück, indem in den Verzeichnissen in @INC nach DBD :: * -Modulen gesucht wird. Standardmäßig wird eine Warnung ausgegeben, wenn einige Treiber in früheren Verzeichnissen von anderen mit demselben Namen ausgeblendet werden. Wenn Sie einen wahren Wert für $ quiet übergeben, wird die Warnung deaktiviert.

installierte_Treiber

%drivers = DBI->installed_drivers();

Gibt eine Liste von Treibernamen- und Treiberhandle-Paaren für alle im aktuellen Prozess 'installierten' (geladenen) Treiber zurück. Der Treibername enthält nicht das Präfix 'DBD ::'.

Datenquellen

@ary = DBI->data_sources($driver);

Gibt eine Liste der Datenquellen (Datenbanken) zurück, die über den genannten Treiber verfügbar sind. Wenn $ driver leer oder undef ist, wird der Wert der Umgebungsvariablen DBI_DRIVER verwendet.

Zitat

$sql = $dbh->quote($value); $sql = $dbh->quote($value, $data_type);

Zitieren Sie ein Zeichenfolgenliteral zur Verwendung als Literalwert in einer SQL-Anweisung, indem Sie alle in der Zeichenfolge enthaltenen Sonderzeichen (z. B. Anführungszeichen) maskieren und den erforderlichen Typ der äußeren Anführungszeichen hinzufügen.

$sql = sprintf "SELECT foo FROM bar WHERE baz = %s",
                $dbh->quote("Don't");

Bei den meisten Datenbanktypen würde das Anführungszeichen "Nicht" (einschließlich der äußeren Anführungszeichen) zurückgeben. Es ist gültig, dass die quote () -Methode einen SQL-Ausdruck zurückgibt, der die gewünschte Zeichenfolge ergibt. Zum Beispiel -

$quoted = $dbh->quote("one\ntwo\0three")

may produce results which will be equivalent to

CONCAT('one', CHAR(12), 'two', CHAR(0), 'three')

Allen Handles gemeinsame Methoden

irren

$rv = $h->err; or $rv = $DBI::err or $rv = $h->err

Gibt den Fehlercode des nativen Datenbankmoduls von der zuletzt aufgerufenen Treibermethode zurück. Der Code ist normalerweise eine Ganzzahl, aber das sollten Sie nicht annehmen. Dies entspricht $ DBI :: err oder $ h-> err.

errstr

$str = $h->errstr; or $str = $DBI::errstr or $str = $h->errstr

Returns the native database engine error message from the last DBI method called. This has the same lifespan issues as the "err" method described above. This is equivalent to $DBI::errstr or $h->errstr.

rows

$rv = $h->rows; or $rv = $DBI::rows

This returns the number of rows effected by previous SQL statement and equivalent to $DBI::rows.

trace

$h->trace($trace_settings);

DBI sports an extremely useful ability to generate runtime tracing information of what it's doing, which can be a huge time-saver when trying to track down strange problems in your DBI programs. You can use different values to set trace level. These values varies from 0 to 4. The value 0 means disable trace and 4 means generate complete trace.

Interpolated Statements are Prohibited

It is highly recommended not to use interpolated statements as follows −

while ($first_name = <>) { my $sth = $dbh->prepare("SELECT * FROM TEST_TABLE WHERE FIRST_NAME = '$first_name'");
   $sth->execute();
   # and so on ...
}

Thus don't use interpolated statement instead use bind value to prepare dynamic SQL statement.

What is CGI ?

A Common Gateway Interface, or CGI, is a set of standards that defines how information is exchanged between the web server and a custom script.
The CGI specs are currently maintained by the NCSA and NCSA defines CGI is as follows −
The Common Gateway Interface, or CGI, is a standard for external gateway programs to interface with information servers such as HTTP servers.
The current version is CGI/1.1 and CGI/1.2 is under progress.

Web Browsing

To understand the concept of CGI, lets see what happens when we click a hyper link available on a web page to browse a particular web page or URL.

Your browser contacts web server using HTTP protocol and demands for the URL, i.e., web page filename.
Web Server will check the URL and will look for the filename requested. If web server finds that file then it sends the file back to the browser without any further execution otherwise sends an error message indicating that you have requested a wrong file.
Web browser takes response from web server and displays either the received file content or an error message in case file is not found.

However, it is possible to set up HTTP server in such a way so that whenever a file in a certain directory is requested that file is not sent back; instead it is executed as a program, and whatever that program outputs as a result, that is sent back for your browser to display. This can be done by using a special functionality available in the web server and it is called Common Gateway Interface or CGI and such programs which are executed by the server to produce final result, are called CGI scripts. These CGI programs can be a PERL Script, Shell Script, C or C++ program, etc.

CGI Architecture Diagram

Web Server Support and Configuration

Before you proceed with CGI Programming, make sure that your Web Server supports CGI functionality and it is configured to handle CGI programs. All the CGI programs to be executed by the web server are kept in a pre-configured directory. This directory is called CGI directory and by convention it is named as /cgi-bin. By convention Perl CGI files will have extention as .cgi.

First CGI Program

Here is a simple link which is linked to a CGI script called hello.cgi. This file has been kept in /cgi-bin/ directory and it has the following content. Before running your CGI program, make sure you have change mode of file using chmod 755 hello.cgi UNIX command.

#!/usr/bin/perl

print "Content-type:text/html\r\n\r\n";
print '<html>';
print '<head>';
print '<title>Hello Word - First CGI Program</title>';
print '</head>';
print '<body>';
print '<h2>Hello Word! This is my first CGI program</h2>';
print '</body>';
print '</html>';

1;

Now if you click hello.cgi link then request goes to web server who search for hello.cgi in /cgi-bin directory, execute it and whatever result got generated, web server sends that result back to the web browser, which is as follows −

Hello Word! This is my first CGI program

This hello.cgi script is a simple Perl script which is writing its output on STDOUT file, i.e., screen. There is one important and extra feature available which is first line to be printed Content-type:text/html\r\n\r\n. This line is sent back to the browser and specifies the content type to be displayed on the browser screen. Now you must have undertood basic concept of CGI and you can write many complicated CGI programs using Perl. This script can interact with any other exertnal system also to exchange information such as a database, web services, or any other complex interfaces.

Understanding HTTP Header

The very first line Content-type:text/html\r\n\r\n is a part of HTTP header, which is sent to the browser so that browser can understand the incoming content from server side. All the HTTP header will be in the following form −

HTTP Field Name: Field Content

For Example −

Content-type:text/html\r\n\r\n

There are few other important HTTP headers, which you will use frequently in your CGI Programming.

Sr.No.	Header & Description
1	Content-type: String A MIME string defining the format of the content being returned. Example is Content-type:text/html
2	Expires: Date String The date when the information becomes invalid. This should be used by the browser to decide when a page needs to be refreshed. A valid date string should be in the format 01 Jan 1998 12:00:00 GMT.
3	Location: URL String The URL that should be returned instead of the URL requested. You can use this filed to redirect a request to any other location.
4	Last-modified: String The date of last modification of the file.
5	Content-length: String The length, in bytes, of the data being returned. The browser uses this value to report the estimated download time for a file.
6	Set-Cookie: String Set the cookie passed through the string

CGI Environment Variables

All the CGI program will have access to the following environment variables. These variables play an important role while writing any CGI program.

Sr.No.	Variables Names & Description
1	CONTENT_TYPE The data type of the content. Used when the client is sending attached content to the server. For example file upload, etc.
2	CONTENT_LENGTH The length of the query information. It's available only for POST requests
3	HTTP_COOKIE Returns the set cookies in the form of key & value pair.
4	HTTP_USER_AGENT The User-Agent request-header field contains information about the user agent originating the request. Its name of the web browser.
5	PATH_INFO The path for the CGI script.
6	QUERY_STRING The URL-encoded information that is sent with GET method request.
7	REMOTE_ADDR The IP address of the remote host making the request. This can be useful for logging or for authentication purpose.
8	REMOTE_HOST The fully qualified name of the host making the request. If this information is not available then REMOTE_ADDR can be used to get IR address.
9	REQUEST_METHOD The method used to make the request. The most common methods are GET and POST.
10	SCRIPT_FILENAME The full path to the CGI script.
11	SCRIPT_NAME The name of the CGI script.
12	SERVER_NAME The server's hostname or IP Address.
13	SERVER_SOFTWARE The name and version of the software the server is running.

Here is a small CGI program to list down all the CGI variables supported by your Web server. Click this link to see the result Get Environment

#!/usr/bin/perl

print "Content-type: text/html\n\n";
print "<font size=+1>Environment</font>\n";
foreach (sort keys %ENV) {
   print "<b>$_</b>: $ENV{$_}<br>\n";
}

1;

Raise a "File Download" Dialog Box?

Sometime it is desired that you want to give option where a user will click a link and it will pop up a "File Download" dialogue box to the user instead of displaying actual content. This is very easy and will be achived through HTTP header.

This HTTP header will be different from the header mentioned in previous section. For example, if you want to make a FileName file downloadable from a given link then it's syntax will be as follows −

#!/usr/bin/perl

# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";

# Actual File Content will go hear.
open( FILE, "<FileName" );
while(read(FILE, $buffer, 100) ) { print("$buffer");
}

GET and POST Methods

You must have come across many situations when you need to pass some information from your browser to the web server and ultimately to your CGI Program handling your requests. Most frequently browser uses two methods to pass this information to the web server. These methods are GET Method and POST Method. Let's check them one by one.

Passing Information using GET Method

The GET method sends the encoded user information appended to the page URL itself. The page and the encoded information are separated by the ? character as follows −

http://www.test.com/cgi-bin/hello.cgi?key1=value1&key2=value2

The GET method is the defualt method to pass information from a browser to the web server and it produces a long string that appears in your browser's Location:box. You should never use GET method if you have password or other sensitive information to pass to the server. The GET method has size limitation: only 1024 characters can be passed in a request string.

This information is passed using QUERY_STRING header and will be accessible in your CGI Program through QUERY_STRING environment variable which you can parse and use in your CGI program.

You can pass information by simply concatenating key and value pairs alongwith any URL or you can use HTML <FORM> tags to pass information using GET method.

Simple URL Example: Get Method

Here is a simple URL which will pass two values to hello_get.cgi program using GET method.

http://www.tutorialspoint.com/cgi-bin/hello_get.cgi?first_name=ZARA&last_name=ALI

Below is hello_get.cgi script to handle input given by web browser.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM);
# Read in text
$ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/; if ($ENV{'REQUEST_METHOD'} eq "GET") {
   $buffer = $ENV{'QUERY_STRING'};
}
# Split information into name/value pairs
@pairs = split(/&/, $buffer); foreach $pair (@pairs) {
   ($name, $value) = split(/=/, $pair); $value =~ tr/+/ /;
   $value =~ s/%(..)/pack("C", hex($1))/eg;
   $FORM{$name} = $value; } $first_name = $FORM{first_name}; $last_name  = $FORM{last_name}; print "Content-type:text/html\r\n\r\n"; print "<html>"; print "<head>"; print "<title>Hello - Second CGI Program</title>"; print "</head>"; print "<body>"; print "<h2>Hello $first_name $last_name - Second CGI Program</h2>";
print "</body>";
print "</html>";

1;

Simple FORM Example: GET Method

Here is a simple example, which passes two values using HTML FORM and submit button. We are going to use the same CGI script hello_get.cgi to handle this input.

<FORM action = "/cgi-bin/hello_get.cgi" method = "GET">
First Name: <input type = "text" name = "first_name">  <br>

Last Name: <input type = "text" name = "last_name">
<input type = "submit" value = "Submit">
</FORM>

Here is the actual output of the above form coding. Now you can enter First and Last Name and then click submit button to see the result.

Passing Information using POST Method

A more reliable method of passing information to a CGI program is the POST method. This packages the information in exactly the same way as GET methods, but instead of sending it as a text string after a ? in the URL, it sends it as a separate message as a part of HTTP header. Web server provides this message to the CGI script in the form of the standard input.

Below is the modified hello_post.cgi script to handle input given by the web browser. This script will handle GET as well as POST method.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$first_name = $FORM{first_name};
$last_name = $FORM{last_name};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Hello - Second CGI Program</title>";
print "</head>";
print "<body>";
print "<h2>Hello $first_name $last_name - Second CGI Program</h2>";
print "</body>";
print "</html>";

1;

Let us take again same examle as above, which passes two values using HTML FORM and submit button. We are going to use CGI script hello_post.cgi to handle this input.

<FORM action = "/cgi-bin/hello_post.cgi" method = "POST">
First Name: <input type = "text" name = "first_name">  <br>

Last Name: <input type = "text" name = "last_name">

<input type = "submit" value = "Submit">
</FORM>

Here is the actual output of the above form coding, You enter First and Last Name and then click submit button to see the result.

Passing Checkbox Data to CGI Program

Checkboxes are used when more than one option is required to be selected. Here is an example HTML code for a form with two checkboxes.

<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" value = "on"> Maths
<input type = "checkbox" name = "physics" value = "on"> Physics
<input type = "submit" value = "Select Subject">
</form>

The result of this code is the following form −

Below is checkbox.cgi script to handle input given by web browser for radio button.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM);
# Read in text
$ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/; if ($ENV{'REQUEST_METHOD'} eq "POST") {
   read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'});
} else {
   $buffer = $ENV{'QUERY_STRING'};
}
# Split information into name/value pairs
@pairs = split(/&/, $buffer); foreach $pair (@pairs) {
   ($name, $value) = split(/=/, $pair); $value =~ tr/+/ /;
   $value =~ s/%(..)/pack("C", hex($1))/eg;
   $FORM{$name} = $value; } if( $FORM{maths} ) {
   $maths_flag ="ON"; } else { $maths_flag ="OFF";
}
if( $FORM{physics} ) { $physics_flag ="ON";
} else {
   $physics_flag ="OFF"; } print "Content-type:text/html\r\n\r\n"; print "<html>"; print "<head>"; print "<title>Checkbox - Third CGI Program</title>"; print "</head>"; print "<body>"; print "<h2> CheckBox Maths is : $maths_flag</h2>";
print "<h2> CheckBox Physics is : $physics_flag</h2>";
print "</body>";
print "</html>";

1;

Passing Radio Button Data to CGI Program

Radio Buttons are used when only one option is required to be selected. Here is an example HTML code for a form with two radio button −

<form action = "/cgi-bin/radiobutton.cgi" method = "POST" target = "_blank">
<input type = "radio" name = "subject" value = "maths"> Maths
<input type = "radio" name = "subject" value = "physics"> Physics
<input type = "submit" value = "Select Subject">
</form>

The result of this code is the following form −

Below is radiobutton.cgi script to handle input given by the web browser for radio button.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$subject = $FORM{subject};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Radio - Fourth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Selected Subject is $subject</h2>";
print "</body>";
print "</html>";

1;

Passing Text Area Data to CGI Program

A textarea element is used when multiline text has to be passed to the CGI Program. Here is an example HTML code for a form with a TEXTAREA box −

<form action = "/cgi-bin/textarea.cgi" method = "POST" target = "_blank">
<textarea name = "textcontent" cols = 40 rows = 4>
Type your text here...
</textarea>
<input type = "submit" value = "Submit">
</form>

The result of this code is the following form −

Below is the textarea.cgi script to handle input given by the web browser.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$text_content = $FORM{textcontent};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Entered Text Content is $text_content</h2>";
print "</body>";
print "</html>";

1;

Passing Drop Down Box Data to CGI Program

A drop down box is used when we have many options available but only one or two will be selected. Here is example HTML code for a form with one drop down box

<form action = "/cgi-bin/dropdown.cgi" method = "POST" target = "_blank">
<select name = "dropdown">
<option value = "Maths" selected>Maths</option>
<option value = "Physics">Physics</option>
</select>
<input type = "submit" value = "Submit">
</form>

The result of this code is the following form −

Below is the dropdown.cgi script to handle input given by web browser.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$subject = $FORM{dropdown};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Dropdown Box - Sixth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Selected Subject is $subject</h2>";
print "</body>";
print "</html>";

1;

Verwenden von Cookies in CGI

Das HTTP-Protokoll ist ein zustandsloses Protokoll. Für eine kommerzielle Website ist es jedoch erforderlich, Sitzungsinformationen zwischen verschiedenen Seiten zu verwalten. Beispielsweise endet eine Benutzerregistrierung nach Transaktionen, die sich über mehrere Seiten erstrecken. Aber wie können die Sitzungsinformationen des Benutzers auf allen Webseiten verwaltet werden?

In vielen Situationen ist die Verwendung von Cookies die effizienteste Methode, um Einstellungen, Einkäufe, Provisionen und andere Informationen zu speichern und zu verfolgen, die für eine bessere Besuchererfahrung oder Site-Statistiken erforderlich sind.

Wie es funktioniert

Ihr Server sendet einige Daten in Form eines Cookies an den Browser des Besuchers. Der Browser akzeptiert möglicherweise das Cookie. In diesem Fall wird es als Nur-Text-Datensatz auf der Festplatte des Besuchers gespeichert. Wenn der Besucher nun auf einer anderen Seite Ihrer Website ankommt, kann das Cookie abgerufen werden. Nach dem Abrufen weiß Ihr Server, was gespeichert wurde.

Cookies sind ein Nur-Text-Datensatz mit 5 Feldern variabler Länge.

Expires- Das Datum, an dem der Cookie abläuft. Wenn dies leer ist, läuft das Cookie ab, wenn der Besucher den Browser verlässt.
Domain - Der Domainname Ihrer Site.
Path- Der Pfad zu dem Verzeichnis oder der Webseite, in dem das Cookie gesetzt wurde. Dies kann leer sein, wenn Sie das Cookie aus einem beliebigen Verzeichnis oder einer beliebigen Seite abrufen möchten.
Secure- Wenn dieses Feld das Wort "sicher" enthält, kann das Cookie nur mit einem sicheren Server abgerufen werden. Wenn dieses Feld leer ist, besteht keine solche Einschränkung.
Name = Value - Cookies werden in Form von Schlüssel- und Wertepaaren gesetzt und erneut angezeigt.

Cookies einrichten

Es ist sehr einfach, Cookies an den Browser zu senden. Diese Cookies werden zusammen mit dem HTTP-Header gesendet. Angenommen, Sie möchten Benutzer-ID und Kennwort als Cookies festlegen. So wird es wie folgt gemacht -

#!/usr/bin/perl

print "Set-Cookie:UserID = XYZ;\n";
print "Set-Cookie:Password = XYZ123;\n";
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT";\n";
print "Set-Cookie:Domain = www.tutorialspoint.com;\n";
print "Set-Cookie:Path = /perl;\n";
print "Content-type:text/html\r\n\r\n";
...........Rest of the HTML Content goes here....

Hier haben wir verwendet Set-CookieHTTP-Header zum Setzen von Cookies. Es ist optional, Cookie-Attribute wie Expires, Domain und Path festzulegen. Es ist wichtig zu beachten, dass Cookies gesetzt werden, bevor eine magische Linie gesendet wird"Content-type:text/html\r\n\r\n.

Cookies abrufen

Es ist sehr einfach, alle gesetzten Cookies abzurufen. Cookies werden in der CGI-Umgebungsvariablen HTTP_COOKIE gespeichert und haben die folgende Form.

key1 = value1;key2 = value2;key3 = value3....

Hier ist ein Beispiel zum Abrufen von Cookies.

#!/usr/bin/perl
$rcvd_cookies = $ENV{'HTTP_COOKIE'}; @cookies = split /;/, $rcvd_cookies;
foreach $cookie ( @cookies ) { ($key, $val) = split(/=/, $cookie); # splits on the first =.
   $key =~ s/^\s+//; $val =~ s/^\s+//;
   $key =~ s/\s+$//;
   $val =~ s/\s+$//;
   if( $key eq "UserID" ) { $user_id = $val; } elsif($key eq "Password") {
      $password = $val;
   }
}
print "User ID  = $user_id\n"; print "Password = $password\n";

Dies führt zu folgendem Ergebnis, vorausgesetzt, die oben genannten Cookies wurden gesetzt, bevor das Skript zum Abrufen von Cookies aufgerufen wurde.

User ID = XYZ
Password = XYZ123

CGI-Module und Bibliotheken

Über das Internet finden Sie viele integrierte Module, die Ihnen direkte Funktionen zur Verwendung in Ihrem CGI-Programm bieten. Im Folgenden sind die wichtigen einmal aufgeführt.

CGI-Modul
Berkeley cgi-lib.pl

Was sind Pakete?

Das packageDie Anweisung wechselt den aktuellen Namenskontext in einen angegebenen Namespace (Symboltabelle). Also -

Ein Paket ist eine Code-Sammlung, die in einem eigenen Namespace lebt.
Ein Namespace ist eine benannte Sammlung eindeutiger Variablennamen (auch als Symboltabelle bezeichnet).
Namespaces verhindern Kollisionen von Variablennamen zwischen Paketen.
Pakete ermöglichen die Erstellung von Modulen, die bei Verwendung keine Variablen und Funktionen außerhalb des eigenen Namespace des Moduls blockieren.
Das Paket bleibt in Kraft, bis entweder eine andere Paketanweisung aufgerufen wird oder bis das Ende des aktuellen Blocks oder der aktuellen Datei erreicht ist.
Mit dem können Sie explizit auf Variablen innerhalb eines Pakets verweisen :: Paketqualifizierer.

Es folgt ein Beispiel mit Haupt- und Foo-Paketen in einer Datei. Hier wurde die spezielle Variable __PACKAGE__ verwendet, um den Paketnamen zu drucken.

#!/usr/bin/perl

# This is main package
$i = 1; print "Package name : " , __PACKAGE__ , " $i\n"; 

package Foo;
# This is Foo package
$i = 10; print "Package name : " , __PACKAGE__ , " $i\n"; 

package main;
# This is again main package
$i = 100; print "Package name : " , __PACKAGE__ , " $i\n"; 
print "Package name : " , __PACKAGE__ ,  " $Foo::i\n"; 

1;

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Package name : main 1
Package name : Foo 10
Package name : main 100
Package name : main 10

BEGIN- und END-Blöcke

Sie können eine beliebige Anzahl von Codeblöcken mit den Namen BEGIN und END definieren, die als Konstruktoren bzw. Destruktoren fungieren.

BEGIN { ... }
END { ... }
BEGIN { ... }
END { ... }

Jeder BEGIN Der Block wird ausgeführt, nachdem das Perl-Skript geladen und kompiliert wurde, aber bevor eine andere Anweisung ausgeführt wird.
Jeder END-Block wird unmittelbar vor dem Beenden des Perl-Interpreters ausgeführt.
Die BEGIN- und END-Blöcke sind besonders nützlich beim Erstellen von Perl-Modulen.

Das folgende Beispiel zeigt seine Verwendung -

#!/usr/bin/perl

package Foo;
print "Begin and Block Demo\n";

BEGIN { 
   print "This is BEGIN Block\n" 
}

END { 
   print "This is END Block\n" 
}

1;

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

This is BEGIN Block
Begin and Block Demo
This is END Block

Was sind Perl-Module?

Ein Perl-Modul ist ein wiederverwendbares Paket, das in einer Bibliotheksdatei definiert ist, deren Name mit dem Namen des Pakets mit der Erweiterung .pm als Erweiterung übereinstimmt.

Eine Perl-Moduldatei mit dem Namen Foo.pm könnte Aussagen wie diese enthalten.

#!/usr/bin/perl

package Foo;
sub bar { 
   print "Hello $_[0]\n" 
}

sub blat { 
   print "World $_[0]\n" 
}
1;

Einige wichtige Punkte zu Perl-Modulen

Die Funktionen require und use lädt ein Modul.
Beide verwenden die Liste der Suchpfade in @INC um das Modul zu finden.
Beide Funktionen require und use Ruf den eval Funktion zum Verarbeiten des Codes.
Das 1; unten bewirkt, dass eval auf TRUE bewertet wird (und somit nicht fehlschlägt).

Die Require-Funktion

Ein Modul kann durch Aufrufen von geladen werden require Funktion wie folgt -

#!/usr/bin/perl

require Foo;

Foo::bar( "a" );
Foo::blat( "b" );

Sie müssen bemerkt haben, dass die Unterprogrammnamen vollständig qualifiziert sein müssen, um sie aufzurufen. Es wäre schön, das Unterprogramm zu aktivierenbar und blat um in unseren eigenen Namespace importiert zu werden, müssen wir nicht das Foo :: Qualifier verwenden.

Die Use-Funktion

Ein Modul kann durch Aufrufen von geladen werden use Funktion.

#!/usr/bin/perl

use Foo;

bar( "a" );
blat( "b" );

Beachten Sie, dass wir die Funktionsnamen des Pakets nicht vollständig qualifizieren mussten. Dasuse Die Funktion exportiert eine Liste von Symbolen aus einem Modul, wobei einige zusätzliche Anweisungen innerhalb eines Moduls hinzugefügt werden.

require Exporter;
@ISA = qw(Exporter);

Stellen Sie dann eine Liste mit Symbolen (Skalare, Listen, Hashes, Unterprogramme usw.) bereit, indem Sie die benannte Listenvariable ausfüllen @EXPORT: Zum Beispiel -

package Module;

require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(bar blat);

sub bar { print "Hello $_[0]\n" }
sub blat { print "World $_[0]\n" } sub splat { print "Not $_[0]\n" }  # Not exported!

1;

Erstellen Sie den Perl-Modulbaum

Wenn Sie bereit sind, Ihr Perl-Modul zu versenden, gibt es eine Standardmethode zum Erstellen eines Perl-Modulbaums. Dies geschieht mith2xsNützlichkeit. Dieses Dienstprogramm wird zusammen mit Perl geliefert. Hier ist die Syntax zur Verwendung von h2xs -

$h2xs -AX -n  ModuleName

Zum Beispiel, wenn Ihr Modul in verfügbar ist Person.pm Datei, dann geben Sie einfach den folgenden Befehl ein -

$h2xs -AX -n Person

Dies führt zu folgendem Ergebnis:

Writing Person/lib/Person.pm
Writing Person/Makefile.PL
Writing Person/README
Writing Person/t/Person.t
Writing Person/Changes
Writing Person/MANIFEST

Hier ist die Beschreibung dieser Optionen -

-A lässt den Autoloader-Code weg (am besten von Modulen verwendet, die eine große Anzahl selten verwendeter Unterprogramme definieren).
-X lässt XS-Elemente weg (eXternal Subroutine, wobei eXternal außerhalb von Perl bedeutet, dh C).
-n Gibt den Namen des Moduls an.

Der obige Befehl erstellt also die folgende Struktur im Personenverzeichnis. Das tatsächliche Ergebnis ist oben dargestellt.

Changes
Makefile.PL
MANIFEST (enthält die Liste aller Dateien im Paket)
README
t / (Testdateien)
lib / (Aktueller Quellcode finden Sie hier

Also endlich du tarDiese Verzeichnisstruktur in eine Datei Person.tar.gz und Sie können es versenden. Sie müssen die README-Datei mit den richtigen Anweisungen aktualisieren. Sie können auch einige Testbeispieldateien im Verzeichnis t bereitstellen.

Perl-Modul installieren

Laden Sie ein Perl-Modul in der Form tar.gz herunter. Verwenden Sie die folgende Reihenfolge, um ein Perl-Modul zu installierenPerson.pm welches in heruntergeladen wurde als Person.tar.gz Datei.

tar xvfz Person.tar.gz
cd Person
perl Makefile.PL
make
make install

Der Perl-Interpreter verfügt über eine Liste von Verzeichnissen, in denen er nach Modulen sucht (globales Array @INC).

Sie können Perl auf verschiedene Arten verwenden, um neue Prozesse gemäß Ihren Anforderungen zu erstellen. In diesem Tutorial werden einige wichtige und am häufigsten verwendete Methoden zum Erstellen und Verwalten von Perl-Prozessen aufgeführt.

Sie können spezielle Variablen verwenden $$ oder $PROCESS_ID um die aktuelle Prozess-ID abzurufen.
Jeder Prozess, der mit einer der genannten Methoden erstellt wurde, verwaltet seine eigene virtuelle Umgebung mit In %ENV Variable.
Das exit() Die Funktion beendet immer nur den untergeordneten Prozess, der diese Funktion ausführt, und der Hauptprozess als Ganzes wird erst beendet, wenn alle laufenden untergeordneten Prozesse beendet wurden.
Alle geöffneten Handles werden in untergeordneten Prozessen mit dup () versehen, sodass das Schließen von Handles in einem Prozess keine Auswirkungen auf die anderen hat.

Backstick-Bediener

Diese einfachste Art, einen Unix-Befehl auszuführen, ist die Verwendung des Backstick-Operators. Sie geben Ihren Befehl einfach in den Backstick-Operator ein, wodurch der Befehl ausgeführt wird und das Ergebnis zurückgegeben wird, das wie folgt gespeichert werden kann:

#!/usr/bin/perl

@files = `ls -l`;

foreach $file (@files) { print $file;
}

1;

Wenn der obige Code ausgeführt wird, werden alle im aktuellen Verzeichnis verfügbaren Dateien und Verzeichnisse aufgelistet.

drwxr-xr-x 3 root root 4096 Sep 14 06:46 9-14
drwxr-xr-x 4 root root 4096 Sep 13 07:54 android
-rw-r--r-- 1 root root  574 Sep 17 15:16 index.htm
drwxr-xr-x 3  544  401 4096 Jul  6 16:49 MIME-Lite-3.01
-rw-r--r-- 1 root root   71 Sep 17 15:16 test.pl
drwx------ 2 root root 4096 Sep 17 15:11 vAtrJdy

Die system () Funktion

Sie können auch verwenden system()Funktion zum Ausführen eines Unix-Befehls, dessen Ausgabe an die Ausgabe des Perl-Skripts geht. Standardmäßig ist dies der Bildschirm, dh STDOUT, aber Sie können ihn mit dem Umleitungsoperator> - in eine beliebige Datei umleiten

#!/usr/bin/perl

system( "ls -l")

1;

Wenn der obige Code ausgeführt wird, werden alle im aktuellen Verzeichnis verfügbaren Dateien und Verzeichnisse aufgelistet.

drwxr-xr-x 3 root root 4096 Sep 14 06:46 9-14
drwxr-xr-x 4 root root 4096 Sep 13 07:54 android
-rw-r--r-- 1 root root  574 Sep 17 15:16 index.htm
drwxr-xr-x 3  544  401 4096 Jul  6 16:49 MIME-Lite-3.01
-rw-r--r-- 1 root root   71 Sep 17 15:16 test.pl
drwx------ 2 root root 4096 Sep 17 15:11 vAtrJdy

Seien Sie vorsichtig, wenn Ihr Befehl Shell-Umgebungsvariablen wie enthält $PATH or $ZUHAUSE. Versuchen Sie die folgenden drei Szenarien:

#!/usr/bin/perl

$PATH = "I am Perl Variable"; system('echo $PATH');  # Treats $PATH as shell variable system("echo $PATH");  # Treats $PATH as Perl variable system("echo \$PATH"); # Escaping $ works.

1;

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt, abhängig davon, was in der Shell-Variablen $ PATH festgelegt ist.

/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin
I am Perl Variable
/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin

Die fork () Funktion

Perl bietet eine fork()Funktion, die dem gleichnamigen Unix-Systemaufruf entspricht. Auf den meisten Unix-ähnlichen Plattformen, auf denen der Systemaufruf fork () verfügbar ist, ruft Perls fork () ihn einfach auf. Auf einigen Plattformen wie Windows, auf denen der Systemaufruf fork () nicht verfügbar ist, kann Perl so erstellt werden, dass fork () auf Interpreterebene emuliert wird.

Die Funktion fork () wird verwendet, um einen aktuellen Prozess zu klonen. Dieser Aufruf erstellt einen neuen Prozess, in dem dasselbe Programm am selben Punkt ausgeführt wird. Es gibt die untergeordnete PID an den übergeordneten Prozess zurück, 0 an den untergeordneten Prozess oder undef, wenn der Fork nicht erfolgreich ist.

Sie können verwenden exec() Funktion innerhalb eines Prozesses zum Starten der angeforderten ausführbaren Datei, die in einem separaten Prozessbereich ausgeführt wird und exec () wartet, bis sie abgeschlossen ist, bevor sie mit demselben Beendigungsstatus wie dieser Prozess beendet wird.

#!/usr/bin/perl

if(!defined($pid = fork())) { # fork returned undef, so unsuccessful die "Cannot fork a child: $!";
} elsif ($pid == 0) { print "Printed by child process\n"; exec("date") || die "can't exec date: $!";
  
} else {
   # fork returned 0 nor undef
   # so this branch is parent
   print "Printed by parent process\n";
   $ret = waitpid($pid, 0);
   print "Completed process id: $ret\n";

}

1;

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Printed by parent process
Printed by child process
Tue Sep 17 15:41:08 CDT 2013
Completed process id: 17777

Das wait() und waitpid()kann als Pseudoprozess-ID übergeben werden, die von fork () zurückgegeben wird. Diese Aufrufe warten ordnungsgemäß auf die Beendigung des Pseudoprozesses und geben seinen Status zurück. Wenn Sie gabeln, ohne jemals darauf zu warten, dass Ihre Kinder es benutzenwaitpid()Funktion, werden Sie Zombies ansammeln. Auf Unix-Systemen können Sie dies vermeiden, indem Sie $ SIG {CHLD} wie folgt auf "IGNORE" setzen -

#!/usr/bin/perl

local $SIG{CHLD} = "IGNORE"; if(!defined($pid = fork())) {
   # fork returned undef, so unsuccessful
   die "Cannot fork a child: $!"; } elsif ($pid == 0) {
   print "Printed by child process\n";
   exec("date") || die "can't exec date: $!"; } else { # fork returned 0 nor undef # so this branch is parent print "Printed by parent process\n"; $ret = waitpid($pid, 0); print "Completed process id: $ret\n";

}

1;

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Printed by parent process
Printed by child process
Tue Sep 17 15:44:07 CDT 2013
Completed process id: -1

Die Funktion kill ()

Perl kill('KILL', (Process List)) Die Funktion kann verwendet werden, um einen Pseudoprozess zu beenden, indem ihm die von fork () zurückgegebene ID übergeben wird.

Beachten Sie, dass die Verwendung von kill ('KILL', (Prozessliste)) für einen Pseudoprozess () normalerweise zu Speicherverlusten führen kann, da der Thread, der den Pseudoprozess implementiert, keine Chance erhält, seine Ressourcen zu bereinigen.

Sie können verwenden kill() Die Funktion zum Senden eines anderen Signals an Zielprozesse, z. B. das folgende, sendet SIGINT an die Prozess-IDs 104 und 102 -

#!/usr/bin/perl

kill('INT', 104, 102);
 
1;

Sie können die Pod-Dokumentation (Plain Old Text) in Ihre Perl-Module und -Skripte einbetten. Im Folgenden finden Sie die Regel für die Verwendung eingebetteter Dokumentation in Ihrem Perl-Code:

Beginnen Sie Ihre Dokumentation mit einer leeren Zeile, a =head1 Befehl am Anfang und beenden Sie ihn mit einem =cut

Perl ignoriert den Pod-Text, den Sie in den Code eingegeben haben. Im Folgenden finden Sie ein einfaches Beispiel für die Verwendung eingebetteter Dokumentation in Ihrem Perl-Code:

#!/usr/bin/perl

print "Hello, World\n";

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
=cut

print "Hello, Universe\n";

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hello, World
Hello, Universe

Wenn Sie Ihren Pod am Ende der Datei platzieren und eine __END__- oder __DATA__- Schnittmarke verwenden, stellen Sie sicher, dass vor dem ersten Pod-Befehl wie folgt eine leere Zeile eingefügt wird, andernfalls ohne vorherige leere Zeile das =head1Viele Übersetzer hätten das = nicht erkannthead1 als Start eines Pod-Blocks.

#!/usr/bin/perl

print "Hello, World\n";

while(<DATA>) {
  print $_;
}

__END__

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hello, World

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Nehmen wir noch ein Beispiel für denselben Code, ohne den DATA-Teil zu lesen -

#!/usr/bin/perl

print "Hello, World\n";

__END__

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Wenn der obige Code ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hello, World

Was ist POD?

Pod ist eine einfach zu verwendende Auszeichnungssprache, mit der Dokumentation für Perl-, Perl-Programme und Perl-Module geschrieben wird. Für die Konvertierung von Pod in verschiedene Formate wie Nur-Text, HTML, Manpages und mehr stehen verschiedene Übersetzer zur Verfügung. Das Pod-Markup besteht aus drei grundlegenden Arten von Absätzen:

Ordinary Paragraph - Sie können Formatierungscodes in normalen Absätzen für Fettdruck, Kursivschrift, Codestil, Hyperlinks und mehr verwenden.
Verbatim Paragraph - Wörtliche Absätze werden normalerweise zum Präsentieren eines Codeblocks oder eines anderen Textes verwendet, für den keine spezielle Analyse oder Formatierung erforderlich ist und der nicht umbrochen werden sollte.
Command Paragraph- Ein Befehlsabsatz wird zur speziellen Behandlung ganzer Textblöcke verwendet, normalerweise als Überschriften oder Teile von Listen. Alle Befehlsabsätze beginnen mit =, gefolgt von einem Bezeichner, gefolgt von einem beliebigen Text, den der Befehl nach Belieben verwenden kann. Derzeit erkannte Befehle sind -

=pod
=head1 Heading Text
=head2 Heading Text
=head3 Heading Text
=head4 Heading Text
=over indentlevel
=item stuff
=back
=begin format
=end format
=for format text...
=encoding type
=cut

POD-Beispiele

Betrachten Sie den folgenden POD -

=head1 SYNOPSIS
Copyright 2005 [TUTORIALSOPOINT].
=cut

Sie können verwenden pod2html Unter Linux verfügbares Dienstprogramm zum Konvertieren des obigen POD in HTML, sodass das folgende Ergebnis erzielt wird:

Betrachten Sie als nächstes das folgende Beispiel:

=head2 An Example List

=over 4
=item * This is a bulleted list.
=item * Here's another item.
=back
=begin html
<p>
Here's some embedded HTML.  In this block I can
include images, apply <span style="color: green">
styles</span>, or do anything else I can do with
HTML.  pod parsers that aren't outputting HTML will
completely ignore it.
</p>

=end html

Wenn Sie den obigen POD mit pod2html in HTML konvertieren, wird das folgende Ergebnis angezeigt:

An Example List
   This is a bulleted list.
   Here's another item.
Here's some embedded HTML. In this block I can include images, apply 
styles, or do anything else I can do with HTML. pod parsers that aren't 
outputting HTML will completely ignore it.

Hier ist die Liste aller wichtigen Funktionen, die von Standard Perl unterstützt werden.

abs - Absolutwertfunktion
accept - Akzeptiere eine eingehende Socket-Verbindung
Alarm - Planen Sie ein SIGALRM
atan2 - Arkustangens von Y / X im Bereich -PI bis PI
bind - bindet eine Adresse an einen Socket
binmode - Bereiten Sie Binärdateien für E / A vor
segne - erstelle ein Objekt
Aufrufer - Kontext des aktuellen Unterprogrammaufrufs abrufen
chdir - Ändern Sie Ihr aktuelles Arbeitsverzeichnis
chmod - Ändert die Berechtigungen für eine Liste von Dateien
chomp - Entfernen Sie ein nachfolgendes Datensatztrennzeichen aus einer Zeichenfolge
chop - entferne das letzte Zeichen aus einer Zeichenkette
chown - Ändern Sie die Eigentümerschaft in einer Liste von Dateien
chr - get Zeichen, das diese Zahl darstellt
chroot - Verzeichnis neu erstellen für Pfadsuche
Schließen - Schließen Sie den Datei- (oder Rohr- oder Muffen-) Griff
geschlossenes - Verzeichnishandle schließen
Verbinden - Verbinden Sie sich mit einer Remote-Buchse
weiter - optionaler nachlaufender Block in einer Weile oder für jeden
cos - cosine Funktion
crypt - Einweg-Passwd-Verschlüsselung
dbmclose - Unterbricht die Bindung an eine gebundene DBM-Datei
dbmopen - Erstellen Sie eine Bindung für eine gebundene DBM-Datei
defined - Testet, ob ein Wert, eine Variable oder eine Funktion definiert ist oder nicht
delete - löscht einen Wert aus einem Hash
sterben - eine Ausnahme auslösen oder aussteigen
do - verwandle einen BLOCK in einen BEGRIFF
Dump - Erstellen Sie einen sofortigen Core-Dump
jedes - ruft das nächste Schlüssel / Wert-Paar aus einem Hash ab
endgrent - wird mit einer Gruppendatei durchgeführt
endhostent - wird mit der Hosts-Datei durchgeführt
endnetent - erfolgt über die Netzwerkdatei
endprotoent - wird mit der Protokolldatei durchgeführt
endpwent - wird mit der passwd-Datei durchgeführt
Endservent - wird mithilfe der Servicedatei ausgeführt
eof - Testen Sie ein Dateihandle auf sein Ende
eval - Ausnahmen abfangen oder Code kompilieren und ausführen
exec - Verlassen Sie dieses Programm, um ein anderes auszuführen
existiert - teste, ob ein Hash-Schlüssel vorhanden ist
exit - Beenden Sie dieses Programm
exp - erhöhe ich zu einer Macht
fcntl - Dateisteuerungssystemaufruf
fileno - gibt den Dateideskriptor vom Dateihandle zurück
Flock - Sperren Sie eine gesamte Datei mit einem Hinweisschloss
Gabel - erstelle einen neuen Prozess wie diesen
format - Deklariert ein Bildformat mit der Funktion write ()
formline - interne Funktion für Formate
getc - holt das nächste Zeichen aus dem Dateihandle
getgrent - nächsten Gruppendatensatz abrufen
getgrgid - Gruppendatensatz mit Gruppenbenutzer-ID abrufen
getgrnam - Gruppendatensatz mit gegebenem Gruppennamen abrufen
gethostbyaddr - Host-Datensatz mit seiner Adresse abrufen
gethostbyname - Host-Datensatz mit Vornamen abrufen
gethostent - Holen Sie sich den nächsten Host-Datensatz
getlogin - gibt zurück, wer sich bei diesem tty angemeldet hat
getnetbyaddr - Netzwerkdatensatz mit seiner Adresse abrufen
getnetbyname - Get Network Record Vorname
getnetent - nächsten Netzwerkdatensatz abrufen
getpeername - Finden Sie das andere Ende einer Socket-Verbindung
getpgrp - Prozessgruppe abrufen
getppid - Abrufen der übergeordneten Prozess-ID
getpriority - Holen Sie sich den aktuellen Wert
getprotobyname - Protokolldatensatz mit Vornamen abrufen
getprotobynumber - Protokollprotokoll numerisches Protokoll abrufen
getprotoent - nächsten Protokolldatensatz abrufen
getpwent - nächsten passwd-Datensatz abrufen
getpwnam - Passwd- Datensatz unter Angabe des Benutzernamen erhalten
getpwuid - Passwd- Datensatz unter Angabe der Benutzer-ID abrufen
getervbyname - Dienstdatensatz mit seinem Namen abrufen
getervbyport - Ruft den Dienstdatensatz mit dem angegebenen numerischen Port ab
getervent - Holen Sie sich den nächsten Service-Datensatz
getockname - Ruft den Sockaddr für einen bestimmten Socket ab
getockopt - Socket-Optionen für einen bestimmten Socket abrufen
glob - Dateinamen mit Platzhaltern erweitern
gmtime - Konvertiert die UNIX-Zeit im Greenwich-Zeitformat in einen Datensatz oder eine Zeichenfolge.
gehe zu - erstelle Spaghetti-Code
grep - Finde Elemente in einem Listentest, der anhand eines bestimmten Kriteriums wahr ist
hex - Konvertiert eine Zeichenfolge in eine Hexadezimalzahl
importieren - Patchen Sie den Namespace eines Moduls in Ihren eigenen
index - Finde einen Teilstring innerhalb eines Strings
int - Ermittelt den ganzzahligen Teil einer Zahl
ioctl - Systemabhängiger Aufruf des Gerätesteuerungssystems
join - Verbinde eine Liste mit einem Trennzeichen zu einer Zeichenfolge
Schlüssel - Ruft eine Liste der Indizes aus einem Hash ab
kill - sendet ein Signal an einen Prozess oder eine Prozessgruppe
last - Block vorzeitig verlassen
lc - gibt eine Kleinbuchstabenversion eines Strings zurück
lcfirst - gibt eine Zeichenfolge mit nur dem nächsten Buchstaben in Kleinbuchstaben zurück
Länge - Gibt die Anzahl der Bytes in einer Zeichenfolge zurück
Link - Erstellen Sie einen festen Link im Dateisystem
listen - Registrieren Sie Ihren Socket als Server
lokal - Erstellen Sie einen temporären Wert für eine globale Variable (dynamisches Scoping).
Ortszeit - Konvertiert die UNIX-Zeit mithilfe der Ortszeit in einen Datensatz oder eine Zeichenfolge
lock - Ruft eine Thread-Sperre für eine Variable, ein Unterprogramm oder eine Methode ab
log - Ruft den natürlichen Logarithmus für eine Zahl ab
lstat - stat eine symbolische Verbindung
m - eine Zeichenfolge mit einem Muster für reguläre Ausdrücke abgleichen
map - Wendet eine Änderung auf eine Liste an, um eine neue Liste mit den Änderungen wiederherzustellen
mkdir - Erstelle ein Verzeichnis
msgctl - SysV IPC-Nachrichtensteuerungsvorgänge
msgget - SysV IPC-Nachrichtenwarteschlange abrufen
msgrcv - Empfängt eine SysV IPC-Nachricht aus einer Nachrichtenwarteschlange
msgsnd - Sendet eine SysV-IPC-Nachricht an eine Nachrichtenwarteschlange
my - deklariere und weise eine lokale Variable zu (lexikalisches Scoping)
next - iteriere einen Block vorzeitig
no - Importieren Sie einige Modul-Symbole oder -Semantiken zur Kompilierungszeit nicht
oct - Konvertiert eine Zeichenfolge in eine Oktalzahl
Öffnen - Öffnen Sie eine Datei, eine Pipe oder einen Deskriptor
opendir - öffne ein Verzeichnis
ord - finde die numerische Darstellung eines Zeichens
our - deklariert und weist eine Paketvariable zu (lexikalisches Scoping)
pack - konvertiert eine Liste in eine binäre Darstellung
package - Deklariert einen separaten globalen Namespace
Rohr - Öffnen Sie ein Paar angeschlossener Dateihandles
pop - entferne das letzte Element aus einem Array und gib es zurück
pos - finde oder setze den Offset für die letzte / nächste m // g Suche
print - Gibt eine Liste in ein Dateihandle aus
printf - gibt eine formatierte Liste in ein Dateihandle aus
Prototyp - Holen Sie sich den Prototyp (falls vorhanden) eines Unterprogramms
push - Hänge ein oder mehrere Elemente an ein Array an
q - zitieren Sie einfach eine Zeichenfolge
qq - zitiere doppelt einen String
qr - Muster kompilieren
quotemeta - zitiere magische Zeichen mit regulären Ausdrücken
qw - zitiere eine Liste von Wörtern
qx - backquote zitiert einen String
rand - ruft die nächste Pseudozufallszahl ab
read - gepufferte Eingabe mit fester Länge von einem Dateihandle
readdir - Ruft ein Verzeichnis aus einem Verzeichnishandle ab
readline - holt einen Datensatz aus einer Datei
readlink - Bestimmen Sie, wohin ein symbolischer Link zeigt
readpipe - führt einen Systembefehl aus und sammelt die Standardausgabe
recv - eine Nachricht über einen Socket empfangen
Wiederholen - Starten Sie diese Schleifeniteration erneut
ref - Finden Sie heraus, auf welche Art von Dingen verwiesen wird
umbenennen - Ändern Sie einen Dateinamen
require - Laden Sie zur Laufzeit externe Funktionen aus einer Bibliothek
Zurücksetzen - Löscht alle Variablen eines bestimmten Namens
Rückkehr - Verlassen Sie eine Funktion frühzeitig
umgekehrt - einen String oder eine Liste umdrehen
rewinddir - Verzeichnishandle zurücksetzen
rindex - Suche nach Teilzeichenfolgen von rechts nach links
rmdir - entferne ein Verzeichnis
s - Ersetzen Sie ein Muster durch eine Zeichenfolge
Skalar - Erzwingt einen skalaren Kontext
seek - Dateizeiger für E / A mit wahlfreiem Zugriff neu positionieren
seekdir - Verzeichniszeiger neu positionieren
select - Standardausgang zurücksetzen oder E / A-Multiplexing durchführen
semctl - SysV-Semaphorsteuerungsoperationen
semget - Setze eine Reihe von SysV-Semaphoren
semop - SysV-Semaphoroperationen
Senden - Senden Sie eine Nachricht über einen Socket
setgrent - Gruppendatei für die Verwendung vorbereiten
sethostent - Hosts-Datei für die Verwendung vorbereiten
setnetent - Netzwerkdatei für die Verwendung vorbereiten
setpgrp - Legt die Prozessgruppe eines Prozesses fest
setpriority - Setzt den netten Wert eines Prozesses
setprotoent - Protokolldatei für die Verwendung vorbereiten
setpwent - Passwd- Datei für die Verwendung vorbereiten
setservent - Bereiten Sie die Servicedatei für die Verwendung vor
setsockopt - Setzt einige Socket-Optionen
shift - Entfernen Sie das erste Element eines Arrays und geben Sie es zurück
shmctl - Shared Memory-Operationen von SysV
shmget - SysV Shared Memory Segment Identifier abrufen
shmread - SysV Shared Memory lesen
shmwrite - SysV Shared Memory schreiben
Herunterfahren - Schließen Sie nur die Hälfte einer Socket-Verbindung
sin - gib den Sinus einer Zahl zurück
Schlafblock für einige Sekunden
Socket - Erstellen Sie einen Socket
Socketpair - Erstellen Sie ein Paar Sockets
sort - sortiert eine Liste von Werten
Spleißen - Fügen Sie Elemente an einer beliebigen Stelle in einem Array hinzu oder entfernen Sie sie
split - Teilen Sie eine Zeichenfolge mit einem Regexp-Trennzeichen auf
sprintf - formatierter Druck in eine Zeichenfolge
sqrt - Quadratwurzelfunktion
srand - Start des Zufallszahlengenerators
stat - Statusinformationen einer Datei abrufen
Studie - Optimieren Sie die Eingabedaten für wiederholte Suchvorgänge
Unter - festzustellen , das ein Unterprogramm, möglicherweise anonym
Teil - einen Teil einer Stirng bekommen oder verändern
symlink - Erstellt einen symbolischen Link zu einer Datei
syscall - führt einen beliebigen Systemaufruf aus
sysopen - Öffnen Sie eine Datei, eine Pipe oder einen Deskriptor
sysread - ungepufferte Eingabe mit fester Länge von einem Dateihandle
sysseek - Positioniert den E / A-Zeiger auf dem Handle, der mit sysread und syswrite verwendet wird
System - Führen Sie ein separates Programm aus
syswrite - ungepufferte Ausgabe mit fester Länge an ein Dateihandle
tell - aktuellen Suchzeiger auf einem Dateihandle abrufen
telldir - Aktuellen Suchzeiger für ein Verzeichnishandle abrufen
tie - Bindet eine Variable an eine Objektklasse
gebunden - Ruft einen Verweis auf das Objekt ab, das einer gebundenen Variablen zugrunde liegt
time - return Anzahl der Sekunden seit 1970
times - Verstrichene Zeit für Selbst- und Kinderprozesse zurückgeben
tr - eine Zeichenfolge transliterieren
abschneiden - eine Datei kürzen
uc - Gibt eine Großbuchstabenversion eines Strings zurück
ucfirst - gibt eine Zeichenfolge mit nur dem nächsten Buchstaben in Großbuchstaben zurück
umask - Festlegen der Maske für den Dateierstellungsmodus
undef - Entferne eine Variablen- oder Funktionsdefinition
unlink - Entfernen Sie einen Link zu einer Datei
entpacken - Konvertiert die Binärstruktur in normale Perl-Variablen
Verschieben - Stellen Sie weitere Elemente an den Anfang einer Liste
lösen - brechen Sie eine Bindung, die an eine Variable gebunden ist
use - Laden zur Kompilierungszeit in ein Modul
utime - Legt den letzten Zugriff einer Datei fest und ändert die Zeiten
Werte - Gibt eine Liste der Werte in einem Hash zurück
vec - teste oder setze bestimmte Bits in einer Zeichenfolge
Warten - Warten Sie, bis ein untergeordneter Prozess beendet ist
waitpid - Warten Sie, bis ein bestimmter untergeordneter Prozess beendet ist
wantarray - get void vs scalar vs list context des aktuellen Unterprogrammaufrufs
warn - Debugging-Informationen drucken
Schreiben - Drucken Sie eine Bildaufzeichnung
-X - ein Dateitest (-r, -x usw.)
y - eine Zeichenfolge transliterieren

Sr.Nr.	Beispiel & Beschreibung
1	python\|perl Entspricht "Python" oder "Perl"
2	rub(y\|le)) Entspricht "Rubin" oder "Rubel"
3	Python(!+\|\?) "Python" gefolgt von einem oder mehreren! oder einer?