Versteckte Funktionen von Perl?

Was sind einige wirklich nützliche, aber esoterische Sprachfunktionen in Perl, die Sie tatsächlich einsetzen konnten, um nützliche Arbeit zu leisten?

Richtlinien:

• Versuchen Sie, die Antworten auf den Perl-Kern und nicht auf CPAN zu beschränken
• Bitte geben Sie ein Beispiel und eine kurze Beschreibung

Versteckte Funktionen finden Sie auch in den versteckten Funktionen anderer Sprachen:

(Dies sind alles aus Corions Antwort )

• C.
  • Duffs Gerät
  • Portabilität und Standardität
• C #
  • Anführungszeichen für durch Leerzeichen getrennte Listen und Zeichenfolgen
  • Aliasable Namespaces
• Java
  • Statische Initialisierer
• JavaScript
  • Funktionen sind Bürger erster Klasse
  • Blockumfang und Verschluss
  • Indirekter Aufruf von Methoden und Accessoren über eine Variable
• Rubin
  • Methoden durch Code definieren
• PHP
  • Durchdringende Online-Dokumentation
  • Magische Methoden
  • Symbolische Referenzen
• Python
  • Ein Zeilenwert tauschen
  • Möglichkeit, auch Kernfunktionen durch eigene Funktionen zu ersetzen

Andere versteckte Funktionen:

Betreiber:

• Der Bool-Quasi-Operator
• Der Flip-Flop-Operator
  • Wird auch für die Listenerstellung verwendet
• Die ++und unäre -Operatoren arbeiten an Zeichenfolgen
• Der Wiederholungsoperator
• Der Raumschiffbetreiber
• Die || operator (und // operator), um aus einer Reihe von Auswahlmöglichkeiten auszuwählen
• Der Diamantoperator
• Sonderfälle des m//Betreibers
• Der Tilde-Tilde "Operator"

Konstrukte zitieren:

• Der qw-Operator
• Buchstaben können als Anführungszeichen in q {} -ähnlichen Konstrukten verwendet werden
• Angebotsmechanismen

Syntax und Namen:

• Nach einem Siegel kann ein Leerzeichen stehen
• Sie können numerische Namen mit symbolischen Referenzen angeben
• Rechtliche nachgestellte Kommas
• Gruppierte Integer-Literale
• Hash-Scheiben
• Auffüllen von Schlüsseln eines Hash aus einem Array

Module, Pragmas und Befehlszeilenoptionen:

• Verwenden Sie strenge und Warnungen
• Verschmutzungsprüfung
• Esoterische Verwendung von -n und -p
• CPAN
• overload::constant
• IO :: Handle-Modul
• Sichere Fächer
• Attribute

Variablen:

• Autovivifizierung
• Die $[Variable
• Krawatte
• Dynamisches Scoping
• Variablentausch mit einer einzigen Anweisung

Schleifen und Flusskontrolle:

• Magie gehe
• for auf eine einzelne Variable
• Fortsetzungsklausel
• Verzweiflungsmodus

Reguläre Ausdrücke:

• Der \GAnker
• (?{}) und '(?? {}) `in regulären Ausdrücken

Andere Eigenschaften:

• Der Debugger
• Spezielle Codeblöcke wie BEGIN, CHECK und END
• Der DATABlock
• Neue Blockoperationen
• Quellfilter
• Signalhaken
• Karte ( zweimal )
• Integrierte Funktionen einschließen
• Die eofFunktion
• Die dbmopenFunktion
• Warnungen in Fehler verwandeln

Andere Tricks und Meta-Antworten:

• Katzendateien, gzips bei Bedarf dekomprimieren
• Perl-Tipps

Siehe auch:

• Versteckte Funktionen von C.
• Versteckte Funktionen von C #
• Versteckte Funktionen von C ++
• Versteckte Funktionen von Java
• Versteckte Funktionen von JavaScript
• Versteckte Funktionen von Ruby
• Versteckte Funktionen von PHP
• Versteckte Funktionen von Python
• Versteckte Funktionen von Clojure

Der Flip-Flop-Operator ist nützlich, um die erste Iteration zu überspringen, wenn Sie die von einem Dateihandle zurückgegebenen Datensätze (normalerweise Zeilen) durchlaufen, ohne eine Flag-Variable zu verwenden:

while(<$fh>)
{
  next if 1..1; # skip first record
  ...
}

Führen Sie aus perldoc perlopund suchen Sie nach "Flip-Flop" für weitere Informationen und Beispiele.

Es gibt viele nicht offensichtliche Funktionen in Perl.

Wussten Sie zum Beispiel, dass nach einem Siegel ein Leerzeichen stehen kann?

 $ perl -wle 'my $x = 3; print $ x'
 3

Oder dass Sie untergeordnete numerische Namen vergeben können, wenn Sie symbolische Referenzen verwenden?

$ perl -lwe '*4 = sub { print "yes" }; 4->()' 
yes

Es gibt auch den Quasi-Operator "bool", der 1 für wahre Ausdrücke und die leere Zeichenfolge für false zurückgibt:

$ perl -wle 'print !!4'
1
$ perl -wle 'print !!"0 but true"'
1
$ perl -wle 'print !!0'
(empty line)

Andere interessante Dinge: Mit können use overloadSie String-Literale und Zahlen überladen (und zum Beispiel BigInts oder was auch immer machen).

Viele dieser Dinge sind tatsächlich irgendwo dokumentiert oder folgen logisch den dokumentierten Funktionen, aber einige sind nicht sehr bekannt.

Update : Noch ein schönes. Im Folgenden wurden die q{...}zitierenden Konstrukte erwähnt, aber wussten Sie, dass Sie Buchstaben als Trennzeichen verwenden können?

$ perl -Mstrict  -wle 'print q bJet another perl hacker.b'
Jet another perl hacker.

Ebenso können Sie reguläre Ausdrücke schreiben:

m xabcx
# same as m/abc/

Unterstützung für komprimierte Dateien über Magic ARGV hinzufügen :

s{ 
    ^            # make sure to get whole filename
    ( 
      [^'] +     # at least one non-quote
      \.         # extension dot
      (?:        # now either suffix
          gz
        | Z 
       )
    )
    \z           # through the end
}{gzcat '$1' |}xs for @ARGV;

(Anführungszeichen um $ _, die erforderlich sind, um Dateinamen mit Shell-Metazeichen in zu verarbeiten)

Jetzt <>dekomprimiert die Funktion alle @ARGVDateien, die mit ".gz" oder ".Z" enden:

while (<>) {
    print;
}

Eine meiner Lieblingsfunktionen in Perl ist die Verwendung des Booleschen ||Operators, um zwischen einer Reihe von Auswahlmöglichkeiten zu wählen.

 $x = $a || $b;

 # $x = $a, if $a is true.
 # $x = $b, otherwise

Das heißt, man kann schreiben:

 $x = $a || $b || $c || 0;

den ersten wahren Wert nehmen aus $a, $bund $c, oder einen Standardwert von 0sonst.

In Perl 5.10 gibt es auch den //Operator, der die linke Seite zurückgibt, wenn sie definiert ist, und die rechte Seite, wenn sie definiert ist. Die folgenden wählt der erste definierte Wert aus $a, $b, $c, oder 0anders:

$ x = $ a // $ b // $ c // 0;

Diese können auch mit ihren Kurzformblättern verwendet werden, die für die Bereitstellung von Standardeinstellungen sehr nützlich sind:

$ x || = 0; # Wenn $ x falsch war, hat es jetzt den Wert 0.

$ x // = 0; # Wenn $ x undefiniert war, hat es jetzt den Wert Null.

Cheerio,

Paul

Die Operatoren ++ und unary - arbeiten nicht nur mit Zahlen, sondern auch mit Zeichenfolgen.

my $_ = "a"
print -$_

druckt -a

print ++$_

Drucke b

$_ = 'z'
print ++$_

druckt aa

Da Perl fast alle "esoterischen" Teile aus den anderen Listen hat, werde ich Ihnen das eine sagen, was Perl nicht kann:

Das einzige, was Perl nicht tun kann, ist, bloße beliebige URLs in Ihrem Code zu haben, da der //Operator für reguläre Ausdrücke verwendet wird.

Für den Fall, dass Ihnen nicht klar war, welche Funktionen Perl bietet, finden Sie hier eine Auswahlliste der möglicherweise nicht ganz offensichtlichen Einträge:

Duffs Gerät - in Perl

Portabilität und Standardität - Es gibt wahrscheinlich mehr Computer mit Perl als mit einem C-Compiler

Eine Datei- / Pfadmanipulationsklasse - File :: Find funktioniert unter noch mehr Betriebssystemen als .Net

Anführungszeichen für durch Leerzeichen getrennte Listen und Zeichenfolgen - Mit Perl können Sie nahezu beliebige Anführungszeichen für Ihre Listen- und Zeichenfolgenbegrenzer auswählen

Aliasable Namespaces - Perl hat diese durch Glob-Zuweisungen:

*My::Namespace:: = \%Your::Namespace

Statische Initialisierer - Perl kann Code in fast jeder Phase der Kompilierung und Objektinstanziierung ausführen, von BEGIN(Code-Analyse) über CHECK(nach Code-Analyse) bis import(beim Modulimport) bis new(Objekt-Instanziierung) bis DESTROY(Objektzerstörung) bis END(Programm-Exit).

Funktionen sind erstklassige Bürger - genau wie in Perl

Blockumfang und Verschluss - Perl hat beides

Indirekter Aufruf von Methoden und Accessoren über eine Variable - Perl macht das auch:

my $method = 'foo';
my $obj = My::Class->new();
$obj->$method( 'baz' ); # calls $obj->foo( 'baz' )

Methoden durch Code definieren - Perl erlaubt das auch :

*foo = sub { print "Hello world" };

Durchdringende Online-Dokumentation - Die Perl-Dokumentation ist online und wahrscheinlich auch auf Ihrem System

Magische Methoden , die aufgerufen werden, wenn Sie eine "nicht vorhandene" Funktion aufrufen - Perl implementiert dies in der AUTOLOAD-Funktion

Symbolische Hinweise - Sie sollten sich von diesen fernhalten. Sie werden deine Kinder essen. Aber natürlich können Sie mit Perl Ihren Kindern blutrünstige Dämonen anbieten.

Einzeiliger Wertaustausch - Perl ermöglicht die Listenzuweisung

Möglichkeit, auch Kernfunktionen durch eigene Funktionen zu ersetzen

use subs 'unlink'; 
sub unlink { print 'No.' }

oder

BEGIN{
    *CORE::GLOBAL::unlink = sub {print 'no'}
};

unlink($_) for @ARGV

Autovivifizierung . AFAIK keine andere Sprache hat es .

Es ist einfach, fast jede Art von seltsamer Zeichenfolge in Perl zu zitieren.

my $url = q{http://my.url.com/any/arbitrary/path/in/the/url.html};

Tatsächlich sind die verschiedenen Zitiermechanismen in Perl sehr interessant. Mit den Perl-Regex-ähnlichen Anführungszeichen können Sie alles unter Angabe der Trennzeichen zitieren. Sie können fast jedes Sonderzeichen wie #, / oder Open / Close-Zeichen wie (), [] oder {} verwenden. Beispiele:

my $var  = q#some string where the pound is the final escape.#;
my $var2 = q{A more pleasant way of escaping.};
my $var3 = q(Others prefer parens as the quote mechanism.);

Angebotsmechanismen:

q: wörtliches Zitat; Das einzige Zeichen, das maskiert werden muss, ist das Endzeichen. qq: ein interpretiertes Zitat; verarbeitet Variablen und Escapezeichen. Ideal für Zeichenfolgen, die Sie zitieren müssen:

my $var4 = qq{This "$mechanism" is broken.  Please inform "$user" at "$email" about it.};

qx: Funktioniert wie qq, führt es dann aber nicht interaktiv als Systembefehl aus. Gibt den gesamten vom Standard ausgegebenen Text zurück. (Die Umleitung wird, sofern sie im Betriebssystem unterstützt wird, ebenfalls ausgegeben.) Wird auch mit Anführungszeichen (das Zeichen `) ausgeführt.

my $output  = qx{type "$path"};      # get just the output
my $moreout = qx{type "$path" 2>&1}; # get stuff on stderr too

qr: Interpretiert wie qq, kompiliert es dann aber als regulären Ausdruck. Funktioniert auch mit den verschiedenen Optionen auf dem regulären Ausdruck. Sie können den regulären Ausdruck jetzt als Variable weitergeben:

sub MyRegexCheck {
    my ($string, $regex) = @_;
    if ($string)
    {
       return ($string =~ $regex);
    }
    return; # returns 'null' or 'empty' in every context
}

my $regex = qr{http://[\w]\.com/([\w]+/)+};
@results = MyRegexCheck(q{http://myurl.com/subpath1/subpath2/}, $regex);

qw: Ein sehr, sehr nützlicher Anführungszeichenoperator. Verwandelt einen zitierten Satz von durch Leerzeichen getrennten Wörtern in eine Liste. Ideal zum Ausfüllen von Daten in einem Unit-Test.

   my @allowed = qw(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 { });
   my @badwords = qw(WORD1 word2 word3 word4);
   my @numbers = qw(one two three four 5 six seven); # works with numbers too
   my @list = ('string with space', qw(eight nine), "a $var"); # works in other lists
   my $arrayref = [ qw(and it works in arrays too) ]; 

Sie sind großartig, wenn sie die Dinge klarer machen. Für qx, qq und q verwende ich höchstwahrscheinlich die Operatoren {}. Die häufigste Gewohnheit von Menschen, die qw verwenden, ist normalerweise der Operator (), aber manchmal sehen Sie auch qw //.

Nicht wirklich versteckt, aber viele Perl-Programmierer wissen jeden Tag nichts über CPAN . Dies gilt insbesondere für Personen, die keine Vollzeitprogrammierer sind oder nicht in Vollzeit in Perl programmieren.

Die "for" -Anweisung kann genauso verwendet werden wie "with" in Pascal:

for ($item)
{
    s/&‎nbsp;/ /g;
    s/<.*?>/ /g;
    $_ = join(" ", split(" ", $_));
}

Sie können eine Folge von s /// Operationen usw. auf dieselbe Variable anwenden, ohne den Variablennamen wiederholen zu müssen.

HINWEIS: In dem nicht unterbrechenden Bereich darüber (& nbsp;) ist Unicode versteckt, um den Markdown zu umgehen. Nicht kopieren, einfügen :)

Der Zitatwortoperator ist eines meiner Lieblingssachen. Vergleichen Sie:

my @list = ('abc', 'def', 'ghi', 'jkl');

und

my @list = qw(abc def ghi jkl);

Viel weniger Lärm, schont das Auge. Eine andere wirklich schöne Sache an Perl, die man beim Schreiben von SQL wirklich vermisst, ist, dass ein nachfolgendes Komma legal ist:

print 1, 2, 3, ;

Das sieht seltsam aus, aber nicht, wenn Sie den Code anders einrücken:

print
    results_of_foo(),
    results_of_xyzzy(),
    results_of_quux(),
    ;

Wenn Sie dem Funktionsaufruf ein zusätzliches Argument hinzufügen, müssen Sie nicht mit Kommas in vorherigen oder nachfolgenden Zeilen herumspielen. Die Änderung einer einzelnen Linie hat keine Auswirkungen auf die umgebenden Linien.

Dies macht es sehr angenehm, mit verschiedenen Funktionen zu arbeiten. Dies ist möglicherweise eine der am meisten unterbewerteten Funktionen von Perl.

Die Möglichkeit, Daten zu analysieren, die direkt in einen DATA- Block eingefügt wurden . Sie müssen nicht in einer Testdatei speichern, um sie im Programm oder ähnlichem zu öffnen. Beispielsweise:

my @lines = <DATA>;
for (@lines) {
    print if /bad/;
}

__DATA__
some good data
some bad data
more good data 
more good data 

Neue Blockoperationen

Ich würde sagen, dass die Möglichkeit, die Sprache zu erweitern und Pseudoblockoperationen zu erstellen, eine ist.

1. Sie deklarieren den Prototyp für ein Sub, der angibt, dass zuerst eine Code-Referenz erforderlich ist:

   sub do_stuff_with_a_hash (&\%) {
       my ( $block_of_code, $hash_ref ) = @_;
       while ( my ( $k, $v ) = each %$hash_ref ) { 
           $block_of_code->( $k, $v );
       }
   }

2. Sie können es dann im Körper so nennen

   use Data::Dumper;
   
   do_stuff_with_a_hash {
       local $Data::Dumper::Terse = 1;
       my ( $k, $v ) = @_;
       say qq(Hey, the key   is "$k"!);
       say sprintf qq(Hey, the value is "%v"!), Dumper( $v );
   
   } %stuff_for
   ;

((Data::Dumper::Dumper ist ein weiteres halb verstecktes Juwel.) Beachten Sie, dass Sie das subSchlüsselwort vor dem Block oder das Komma vor dem Hash nicht benötigen . Es sieht am Ende sehr ähnlich aus wie:map { } @list

Quellfilter

Es gibt auch Quellfilter. Wo Perl Ihnen den Code übergibt, damit Sie ihn bearbeiten können. Sowohl dies als auch die Blockoperationen sind so ziemlich Dinge, die man nicht zu Hause ausprobieren sollte.

Ich habe einige nette Dinge mit Quellfiltern gemacht, zum Beispiel das Erstellen einer sehr einfachen Sprache zum Überprüfen der Uhrzeit, die kurze Perl-Einzeiler für einige Entscheidungen zulässt:

perl -MLib::DB -MLib::TL -e 'run_expensive_database_delete() if $hour_of_day < AM_7';

Lib::TL Ich würde nur nach den "Variablen" und den Konstanten suchen, sie erstellen und sie nach Bedarf ersetzen.

Auch hier können Quellfilter chaotisch sein, sind aber leistungsstark. Aber sie können Debugger etwas Schreckliches durcheinander bringen - und sogar Warnungen können mit den falschen Zeilennummern gedruckt werden. Ich habe aufgehört, Damians Schalter zu benutzen weil der Debugger nicht mehr in der Lage war, mir zu sagen, wo ich wirklich war. Ich habe jedoch festgestellt, dass Sie den Schaden minimieren können, indem Sie kleine Codeabschnitte ändern und sie in derselben Zeile halten.

Signalhaken

Es wird oft genug gemacht, aber es ist nicht so offensichtlich. Hier ist ein Würfelführer, der sich auf den alten stützt.

my $old_die_handler = $SIG{__DIE__};
$SIG{__DIE__}       
    = sub { say q(Hey! I'm DYIN' over here!); goto &$old_die_handler; }
    ;

Das heißt, wenn ein anderes Modul im Code sterben möchte, muss es zu Ihnen kommen (es sei denn, jemand anderes führt ein destruktives Überschreiben durch $SIG{__DIE__} ). Und Sie können benachrichtigt werden, dass jemand etwas falsch macht.

Natürlich können Sie für genügend Dinge nur einen END { }Block verwenden, wenn Sie nur aufräumen möchten.

overload::constant

Sie können Literale eines bestimmten Typs in Paketen überprüfen, die Ihr Modul enthalten. Wenn Sie dies beispielsweise in Ihrem importSub verwenden:

overload::constant 
    integer => sub { 
        my $lit = shift;
        return $lit > 2_000_000_000 ? Math::BigInt->new( $lit ) : $lit 
    };

Dies bedeutet, dass jede Ganzzahl, die größer als 2 Milliarden in den aufrufenden Paketen ist, in ein Math::BigIntObjekt geändert wird. (Siehe Überladung :: Konstante ).

Gruppierte Integer-Literale

Während wir dabei sind. Mit Perl können Sie große Zahlen in dreistellige Gruppen aufteilen und trotzdem eine analysierbare Ganzzahl daraus erhalten. Anmerkung 2_000_000_000oben für 2 Milliarden.

Binäres "x" ist der Wiederholungsoperator :

print '-' x 80;     # print row of dashes

Es funktioniert auch mit Listen:

print for (1, 4, 9) x 3; # print 149149149

Verschmutzungsprüfung. Wenn die Verschmutzungsprüfung aktiviert ist, stirbt Perl (oder warnt mit-tWenn die ), wenn Sie versuchen, verdorbene Daten (grob gesagt Daten von außerhalb des Programms) an eine unsichere Funktion zu übergeben (Öffnen einer Datei, Ausführen eines externen Befehls usw.). Dies ist sehr hilfreich, wenn Sie Setuid-Skripte oder CGIs schreiben oder wenn das Skript über größere Berechtigungen verfügt als die Person, die es mit Daten versorgt.

Magie gehe. goto &subführt einen optimierten Tail Call durch.

Der Debugger.

use strictund use warnings. Diese können Sie vor einer Reihe von Tippfehlern bewahren.

Basierend auf der Art "-n"und Weise der und"-p" Schalter in Perl 5 implementiert sind, können Sie ein scheinbar falsches Programm schreiben, einschließlich }{:

ls |perl -lne 'print $_; }{ print "$. Files"'

welches intern in diesen Code konvertiert wird:

LINE: while (defined($_ = <ARGV>)) {
    print $_; }{ print "$. Files";
}

Beginnen wir einfach mit dem Raumschiff-Operator .

$a = 5 <=> 7;  # $a is set to -1
$a = 7 <=> 5;  # $a is set to 1
$a = 6 <=> 6;  # $a is set to 0

Dies ist eine Meta-Antwort, aber die Perl-Tipps Archive enthalten alle möglichen interessanten Tricks, die mit Perl ausgeführt werden können. Das Archiv der vorherigen Tipps ist online zum Durchsuchen und kann über eine Mailingliste oder einen Atom-Feed abonniert werden.

Einige meiner besten Tipps umfassen den Aufbau Executables mit PAR , mit autodie Ausnahmen automatisch zu werfen , und die Verwendung der Schalter und Smart-match - Konstrukte in Perl 5.10.

Offenlegung: Ich bin einer der Autoren und Betreuer von Perl-Tipps, daher schätze ich sie offensichtlich sehr. ;)

map - nicht nur, weil es den eigenen Code ausdrucksvoller macht, sondern weil es mir den Impuls gab, ein bisschen mehr über diese "funktionale Programmierung" zu lesen.

Die continue-Klausel für Schleifen. Es wird am Ende jeder Schleife ausgeführt, auch bei den nächsten.

while( <> ){
  print "top of loop\n";
  chomp;

  next if /next/i;
  last if /last/i;

  print "bottom of loop\n";
}continue{
  print "continue\n";
}

Meine Stimme würde für die Gruppen (? {}) Und (?? {}) in Perls regulären Ausdrücken gehen. Der erste führt Perl-Code aus, wobei der Rückgabewert ignoriert wird, der zweite führt Code aus und verwendet den Rückgabewert als regulären Ausdruck.

while(/\G(\b\w*\b)/g) {
     print "$1\n";
}

der \ G Anker. Es ist heiß .

Der m//Bediener hat einige obskure Sonderfälle:

• Wenn Sie ?als Trennzeichen verwenden, stimmt es nur einmal überein, es sei denn, Sie rufen an reset.
• Wenn Sie 'als Trennzeichen verwenden, wird das Muster nicht interpoliert.
• Wenn das Muster leer ist, wird das Muster aus der letzten erfolgreichen Übereinstimmung verwendet.

Der Null-Dateihandle- Diamantoperator <> hat seinen Platz beim Erstellen von Befehlszeilenwerkzeugen. Es verhält sich wie <FH>das Lesen aus einem Handle, mit der Ausnahme, dass es auf magische Weise auswählt, was zuerst gefunden wird: Befehlszeilendateinamen oder STDIN. Entnommen aus Perlop:

while (<>) {
...         # code for each line
}

Spezielle Codeblöcke wie BEGIN, CHECKund END. Sie kommen von Awk, funktionieren aber in Perl anders, weil es nicht auf Aufzeichnungen basiert.

Der BEGINBlock kann verwendet werden, um Code für die Analysephase anzugeben. Es wird auch ausgeführt, wenn Sie die Syntax- und Variablenprüfung durchführen perl -c. Zum Laden von Konfigurationsvariablen:

BEGIN {
    eval {
        require 'config.local.pl';
    };
    if ($@) {
        require 'config.default.pl';
    }
}

rename("$_.part", $_) for "data.txt";

benennt data.txt.part in data.txt um, ohne mich wiederholen zu müssen.

Ein bisschen dunkel ist der Tilde-Tilde- "Operator", der den skalaren Kontext erzwingt.

print ~~ localtime;

ist das gleiche wie

print scalar localtime;

und anders als

print localtime;

tie, die variable Bindungsschnittstelle.

Der "Verzweiflungsmodus" von Perls Schleifensteuerungskonstrukten, der sie veranlasst, den Stapel nachzuschlagen, um ein passendes Etikett zu finden, ermöglicht einige merkwürdige Verhaltensweisen, die Test :: More zum Guten oder Schlechten ausnutzt.

SKIP: {
    skip() if $something;

    print "Never printed";
}

sub skip {
    no warnings "exiting";
    last SKIP;
}

Es gibt die wenig bekannte PMC-Datei. "use Foo" sucht in FIN.pmc in @INC vor Foo.pm. Dies sollte ermöglichen, dass zuerst kompilierter Bytecode geladen wird, aber Module :: Compile nutzt dies jedoch, um quellgefilterte Module für schnellere Ladezeiten und einfacheres Debuggen zwischenzuspeichern.

Die Fähigkeit, Warnungen in Fehler umzuwandeln.

local $SIG{__WARN__} = sub { die @_ };
$num = "two";
$sum = 1 + $num;
print "Never reached";

Das ist es, woran ich denken kann, was nicht erwähnt wurde.

Der Ziegenbetreiber *:

$_ = "foo bar";
my $count =()= /[aeiou]/g; #3

oder

sub foo {
    return @_;
}

$count =()= foo(qw/a b c d/); #4

Dies funktioniert, weil die Listenzuweisung im skalaren Kontext die Anzahl der Elemente in der Liste ergibt, die zugewiesen werden.

* Beachten Sie, nicht wirklich ein Operator