Ukryte cechy Perla?

Jakie są naprawdę przydatne, ale ezoteryczne funkcje językowe w Perlu, które faktycznie udało ci się wykorzystać do wykonania pożytecznej pracy?

Wytyczne:

• Spróbuj ograniczyć odpowiedzi do rdzenia Perla, a nie do CPAN
• Proszę podać przykład i krótki opis

Ukryte funkcje można znaleźć również w ukrytych funkcjach innych języków:

(To wszystko z odpowiedzi Coriona )

• do
  • Urządzenie Duffa
  • Przenośność i standardowość
• DO#
  • Cudzysłowy dla list i ciągów znaków rozdzielanych spacjami
  • Aliasable przestrzeni nazw
• Jawa
  • Statyczne inicjatory
• JavaScript
  • Funkcjonariusze są obywatelami pierwszej klasy
  • Zakres blokowy i zamknięcie
  • Wywoływanie metod i metod dostępu pośrednio przez zmienną
• Rubin
  • Definiowanie metod za pomocą kodu
• PHP
  • Wszechstronna dokumentacja online
  • Metody magiczne
  • Symboliczne odniesienia
• Pyton
  • Zamiana wartości w jednym wierszu
  • Możliwość zastąpienia nawet podstawowych funkcji własną funkcjonalnością

Inne ukryte funkcje:

Operatorzy:

• Quasi-operator bool
• Operator przerzutnika
  • Używany również do tworzenia list
• Te ++i unarne -operatorzy działają na sznurkach
• Operator powtórzeń
• Operator statku kosmicznego
• || operator (i operator //), aby wybrać z zestawu opcji
• Operator diamentu
• Specjalne przypadki m//operatora
• „Operator” tyldy tyldy

Cytowanie konstrukcji:

• Operator qw
• Litery mogą być używane jako ograniczniki cudzysłowów w konstrukcjach typu q {}
• Mechanizmy cytowania

Składnia i nazwy:

• Po sigilu może być spacja
• Możesz nadać subskrybentom nazwy numeryczne z symbolicznymi odniesieniami
• Prawne przecinki końcowe
• Zgrupowane literały całkowite
• plastry haszyszu
• Wypełnianie kluczy hasha z tablicy

Moduły, Pragmy i opcje wiersza poleceń:

• używaj surowych i ostrzeżeń
• Sprawdzanie skazy
• Ezoteryczne użycie -n i -p
• CPAN
• overload::constant
• Moduł IO :: Handle
• Bezpieczne przegrody
• Atrybuty

Zmienne:

• Autowifikacja
• $[zmienna
• wiązanie
• Dynamiczne określanie zakresu
• Zamiana zmiennych za pomocą jednej instrukcji

Pętle i kontrola przepływu:

• Magic goto
• for na jednej zmiennej
• klauzula kontynuacji
• Tryb desperacji

Wyrażenia regularne:

• \Gkotwica
• (?{}) i '(?? {}) `w wyrażeniach regularnych

Inne funkcje:

• Debugger
• Specjalne bloki kodu, takie jak BEGIN, CHECK i END
• DATAblok
• Nowe operacje blokowe
• Filtry źródłowe
• Signal Hooks
• mapa ( dwukrotnie )
• Zawijanie wbudowanych funkcji
• Plik eoffunkcja
• dbmopenfunkcja
• Przekształcanie ostrzeżeń w błędy

Inne sztuczki i meta-odpowiedzi:

• cat, w razie potrzeby dekompresując gzips
• Porady Perla

Zobacz też:

• Ukryte funkcje C
• Ukryte funkcje języka C #
• Ukryte funkcje C ++
• Ukryte funkcje Java
• Ukryte funkcje JavaScript
• Ukryte funkcje Rubiego
• Ukryte funkcje PHP
• Ukryte funkcje Pythona
• Ukryte funkcje Clojure

Operator flip-flop jest przydatny do pomijania pierwszej iteracji podczas przeglądania rekordów (zwykle linii) zwracanych przez uchwyt pliku, bez użycia zmiennej flag:

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

Uruchom perldoc perlopi wyszukaj „flip-flop”, aby uzyskać więcej informacji i przykładów.

W Perlu jest wiele nieoczywistych funkcji.

Na przykład, czy wiesz, że po sigilu może być spacja?

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

Albo że możesz podać nazwy numeryczne subskrybentów, jeśli używasz odniesień symbolicznych?

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

Istnieje również operator quasi „bool”, który zwraca 1 dla prawdziwych wyrażeń i pusty ciąg dla fałszu:

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

Inne interesujące rzeczy: za pomocą use overloadmożesz przeciążać literały ciągów i liczby (i na przykład uczynić je BigInts lub cokolwiek innego).

Wiele z tych rzeczy jest gdzieś udokumentowanych lub logicznie wynika z udokumentowanych cech, niemniej jednak niektóre nie są zbyt dobrze znane.

Aktualizacja : Kolejna fajna. Poniżej wymieniono q{...}konstrukcje cytowania, ale czy wiesz, że możesz używać liter jako separatorów?

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

Podobnie możesz pisać wyrażenia regularne:

m xabcx
# same as m/abc/

Dodaj obsługę skompresowanych plików przez Magic ARGV :

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;

(cytuje wokół $ _ niezbędne do obsługi nazw plików z metaznakami powłoki w)

Teraz <>funkcja zdekompresuje wszystkie @ARGVpliki kończące się na „.gz” lub „.Z”:

while (<>) {
    print;
}

Jedną z moich ulubionych funkcji w Perlu jest używanie ||operatora boolowskiego do wybierania między zestawem opcji.

 $x = $a || $b;

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

Oznacza to, że można napisać:

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

aby podjąć pierwszą prawdziwą wartość z $a, $bi $c, lub domyślna0 inaczej.

W Perlu 5.10 jest również //operator, który zwraca lewą stronę, jeśli jest zdefiniowana, lub prawą, jeśli jest inaczej. Następujące wybiera pierwszy określono wartość z $a, $b, $club 0inaczej:

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

Można ich również używać z ich krótkimi formularzami, które są bardzo przydatne przy podawaniu wartości domyślnych:

$ x || = 0; # Jeśli $ x było fałszem, teraz ma wartość 0.

$ x // = 0; # Jeśli $ x było niezdefiniowane, ma teraz wartość zero.

Cheerio,

Paweł

Operatory ++ i jednoargumentowe - działają nie tylko na liczbach, ale także na łańcuchach.

my $_ = "a"
print -$_

wydruki -a

print ++$_

wydruki b

$_ = 'z'
print ++$_

drukuje aa

Ponieważ Perl ma prawie wszystkie „ezoteryczne” części z innych list, powiem ci jedną rzecz, której Perl nie może:

Jedyną rzeczą, której Perl nie może zrobić, jest posiadanie w kodzie gołych dowolnych adresów URL, ponieważ //operator jest używany do wyrażeń regularnych.

Na wypadek, gdybyś nie wiedział, jakie funkcje oferuje Perl, oto wybrana lista być może nie do końca oczywistych wpisów:

Urządzenie Duffa - w Perlu

Przenośność i standardowość - prawdopodobnie jest więcej komputerów z Perlem niż z kompilatorem C.

Klasa manipulacji plikami / ścieżkami - File :: Find działa w jeszcze większej liczbie systemów operacyjnych niż .Net

Cytaty dla list i ciągów znaków rozdzielanych spacjami - Perl pozwala wybrać prawie dowolne cudzysłowy dla listy i ograniczników ciągów

Przestrzenie nazw z możliwością aliasów - Perl ma je poprzez przypisania globalne :

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

Inicjatory statyczne - Perl może uruchamiać kod w prawie każdej fazie kompilacji i tworzenia instancji obiektu, od BEGIN(analiza kodu) do CHECK(po przeanalizowaniu kodu) do import(przy imporcie modułu) do new(instancja obiektu) do DESTROY(zniszczenie obiektu) do END(wyjście programu)

Funkcje są obywatelami pierwszej klasy - tak jak w Perlu

Zakres blokowy i zamknięcie - Perl ma jedno i drugie

Wywoływanie metod i akcesorów pośrednio przez zmienną - Perl też to robi:

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

Definiowanie metod za pomocą kodu - Perl również na to pozwala :

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

Wszechstronna dokumentacja online - dokumentacja Perla jest dostępna online i prawdopodobnie również w Twoim systemie

Magiczne metody wywoływane za każdym razem, gdy wywołasz „nieistniejącą” funkcję - Perl implementuje ją w funkcji AUTOLOAD

Symboliczne odniesienia - radzimy trzymać się od nich z daleka. Zjedzą twoje dzieci. Ale oczywiście Perl pozwala ci ofiarować swoje dzieci żądnym krwi demonom.

Zamiana wartości w jednym wierszu - Perl umożliwia przypisanie listy

Możliwość zastąpienia nawet podstawowych funkcji własną funkcjonalnością

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

lub

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

unlink($_) for @ARGV

Autowifikacja . AFAIK nie ma go żaden inny język .

W Perlu można łatwo zacytować prawie każdy dziwny ciąg znaków.

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

W rzeczywistości różne mechanizmy cytowania w Perlu są dość interesujące. Mechanizmy cytowania podobne do wyrażeń regularnych Perla pozwalają na cytowanie wszystkiego, z podaniem ograniczników. Możesz użyć prawie każdego znaku specjalnego, takiego jak #, /, lub znaków otwarcia / zamknięcia, takich jak (), [] lub {}. Przykłady:

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.);

Mechanizmy cytowania:

q: dosłowny cudzysłów; jedyną postacią, której trzeba zmienić, jest znak końcowy. qq: zinterpretowany cytat; przetwarza zmienne i znaki ucieczki. Świetne do ciągów, które musisz zacytować:

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

qx: Działa jak qq, ale następnie wykonuje je jako polecenie systemowe, nie interaktywnie. Zwraca cały tekst wygenerowany ze standardowego wyjścia. (Przekierowanie, jeśli jest obsługiwane w systemie operacyjnym, również pojawia się) Również wykonane z cudzysłowami wstecznymi (znak `).

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

qr: interpretuje jak qq, ale następnie kompiluje jako wyrażenie regularne. Działa również z różnymi opcjami wyrażenia regularnego. Możesz teraz przekazać wyrażenie regularne jako zmienną:

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: Bardzo, bardzo przydatny operator cytatów. Zamienia zestaw słów oddzielonych spacjami w cudzysłowy w listę. Doskonały do ​​wypełniania danych w teście jednostkowym.

   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) ]; 

Świetnie się z nich korzysta, gdy tylko wszystko staje się jaśniejsze. Dla qx, qq i q najprawdopodobniej używam operatorów {}. Najczęstszym nawykiem osób używających qw jest zwykle operator (), ale czasami pojawia się również qw //.

Niezupełnie ukryte, ale wielu programistów Perla na co dzień nie wie o CPAN . Dotyczy to szczególnie osób, które nie są programistami na pełny etat lub nie programują w pełnym wymiarze czasu w Perlu.

Instrukcja „for” może być używana w ten sam sposób, w jaki „with” jest używane w Pascalu:

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

Możesz zastosować sekwencję operacji s /// itp. Do tej samej zmiennej bez konieczności powtarzania nazwy zmiennej.

UWAGA: nierozdzielająca spacja powyżej (& nbsp;) ukryła w niej Unicode, aby obejść Markdown. Nie kopiuj, wklej go :)

Operator słowa cudzysłowu to jedna z moich ulubionych rzeczy. Porównać:

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

i

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

Dużo mniej hałasu, przyjemniejszy dla oka. Kolejną bardzo fajną rzeczą w Perlu, której naprawdę brakuje podczas pisania SQL, jest to, że końcowy przecinek jest legalny:

print 1, 2, 3, ;

Wygląda to dziwnie, ale nie, jeśli w kodzie wciśniesz w inny sposób:

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

Dodanie dodatkowego argumentu do wywołania funkcji nie wymaga majstrowania przy przecinkach w poprzednich lub końcowych wierszach. Zmiana pojedynczej linii nie ma wpływu na otaczające ją linie.

Dzięki temu praca z różnymi funkcjami jest bardzo przyjemna. Jest to prawdopodobnie jedna z najbardziej niedocenianych funkcji Perla.

Możliwość analizowania danych bezpośrednio wklejanych do bloku DATA . Nie ma potrzeby zapisywania do pliku testowego, aby otworzyć go w programie lub podobnym. Na przykład:

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

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

Nowe operacje blokowe

Powiedziałbym, że jedną z nich jest możliwość rozszerzenia języka, tworzenia pseudobloków.

1. Deklarujesz prototyp dla sub, wskazując, że najpierw pobiera odwołanie do kodu:

   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. Możesz wtedy tak to nazwać w ciele

   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::Dumperto kolejny pół-ukryty klejnot.) Zwróć uwagę, że nie potrzebujesz subsłowa kluczowego przed blokiem ani przecinka przed hashem. Kończy się bardzo podobnie do:map { } @list

Filtry źródłowe

Istnieją również filtry źródłowe. Gdzie Perl przekaże Ci kod, abyś mógł nim manipulować. Zarówno to, jak i operacje blokowe, są w zasadzie rzeczy typu „nie próbuj tego w domu”.

Zrobiłem kilka fajnych rzeczy z filtrami źródłowymi, na przykład stworzyłem bardzo prosty język do sprawdzania czasu, zezwalając na krótkie jednowierszowe Perl do podejmowania decyzji:

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

Lib::TL po prostu przeszukałby zarówno „zmienne”, jak i stałe, utworzył je i zastąpił w razie potrzeby.

Ponownie, filtry źródłowe mogą być nieuporządkowane, ale są potężne. Ale mogą zepsuć debuggery coś strasznego - a nawet ostrzeżenia mogą być drukowane z niewłaściwymi numerami linii. Przestałem używać Switcha Damiana ponieważ debugger straciłby wszelkie możliwości powiedzenia mi, gdzie naprawdę jestem. Ale odkryłem, że możesz zminimalizować szkody, modyfikując małe fragmenty kodu, utrzymując je w tej samej linii.

Signal Hooks

Często się to robi, ale nie jest to wcale takie oczywiste. Oto osoba obsługująca kości, która wraca do starego.

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

Oznacza to, że za każdym razem, gdy jakiś inny moduł w kodzie chce umrzeć, musi do ciebie przyjść (chyba że ktoś inny dokona destrukcyjnego nadpisania $SIG{__DIE__} ). I możesz zostać powiadomiony, że ktoś coś zrobi z błędem.

Oczywiście w przypadku wystarczającej liczby rzeczy możesz po prostu użyć END { }bloku, jeśli wszystko, co chcesz zrobić, to posprzątać.

overload::constant

Możesz sprawdzić literały określonego typu w pakietach, które zawierają Twój moduł. Na przykład, jeśli używasz tego w swoim importsub:

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

będzie to oznaczać, że każda liczba całkowita większa niż 2 miliardy w wywoływanych pakietach zostanie zamieniona na Math::BigIntobiekt. (Zobacz overload :: constant ).

Zgrupowane literały całkowite

Skoro już przy tym jesteśmy. Perl pozwala ci podzielić duże liczby na grupy po trzy cyfry i nadal uzyskać z nich parsowalną liczbę całkowitą. Uwaga 2_000_000_000powyżej za 2 miliardy.

Binarny „x” jest operatorem powtórzenia :

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

Działa również z listami:

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

Sprawdzanie skazy. Po włączeniu sprawdzania skażeń perl umrze (lub ostrzeże, z-t ), jeśli spróbujesz przekazać skażone dane (z grubsza, dane spoza programu) do niebezpiecznej funkcji (otwarcie pliku, uruchomienie polecenia zewnętrznego itp.). Jest to bardzo pomocne przy pisaniu skryptów setuid lub CGI lub czegokolwiek, gdzie skrypt ma większe uprawnienia niż osoba przekazująca mu dane.

Magic goto. goto &subwykonuje zoptymalizowane wywołanie ogonowe.

Debugger.

use stricti use warnings. To może uchronić Cię przed wieloma literówkami.

Bazując na sposobie implementacji przełączników "-n"i "-p"w Perlu 5, możesz napisać pozornie niepoprawny program zawierający }{:

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

który jest wewnętrznie konwertowany na ten kod:

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

Zacznijmy łatwo od operatora statku kosmicznego .

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

To jest meta-odpowiedź, ale archiwa Perl Tips zawierają różnego rodzaju interesujące sztuczki, które można wykonać za pomocą Perla. Archiwum wcześniejszych wskazówek jest dostępne w trybie on-line do przeglądania i można je subskrybować za pośrednictwem listy mailingowej lub kanału Atom.

Niektóre z moich ulubionych wskazówek obejmują budowanie plików wykonywalnych za pomocą PAR-a , używanie autodie do automatycznego generowania wyjątków oraz używanie konstrukcji przełącznika i inteligentnego dopasowania w Perlu 5.10.

Ujawnienie: Jestem jednym z autorów i opiekunów Perl Tips, więc oczywiście bardzo wysoko o nich myślę. ;)

map - nie tylko dlatego, że czyni swój kod bardziej wyrazistym, ale dlatego, że dała mi impuls do poczytania czegoś więcej o tym „programowaniu funkcjonalnym”.

Klauzula continue w pętlach. Zostanie wykonany na dole każdej pętli, nawet tych następnych.

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

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

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

Mój głos skierowałby się na grupy (? {}) I (?? {}) w wyrażeniach regularnych Perla. Pierwsza wykonuje kod Perla, ignorując zwracaną wartość, druga wykonuje kod, używając wartości zwracanej jako wyrażenia regularnego.

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

kotwica \ G. Jest gorąco .

m//Operator ma jakieś niejasne przypadki szczególne:

• Jeśli używasz ?jako separatora, pasuje on tylko raz, chyba że zadzwonisz reset.
• Jeśli używasz 'jako separatora, wzór nie jest interpolowany.
• Jeśli wzorzec jest pusty, używa wzorca z ostatniego udanego dopasowania.

Operator diamentu uchwytu pliku o wartości null <> ma swoje miejsce w tworzeniu narzędzi wiersza poleceń. Działa jak <FH>czytanie z uchwytu, z tym wyjątkiem, że w magiczny sposób wybiera to, co zostanie znalezione jako pierwsze: nazwy plików w wierszu poleceń lub STDIN. Zaczerpnięte z Perlop:

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

Specjalne bloki kodu , takich jak BEGIN, CHECKi END. Pochodzą z Awk, ale działają inaczej w Perlu, ponieważ nie jest oparty na rekordach.

BEGINBlok może być użyta do określenia kodu dla fazy analizowania; jest również wykonywana podczas sprawdzania składni i zmiennych perl -c. Na przykład, aby załadować zmienne konfiguracyjne:

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

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

zmienia nazwę data.txt.part na data.txt bez konieczności powtarzania tego.

Nieco niejasny jest "operator" tylda-tylda, który wymusza kontekst skalarny.

print ~~ localtime;

jest taki sam jak

print scalar localtime;

i inny niż

print localtime;

tie, zmienny interfejs wiązania.

„Tryb desperacji” konstrukcji sterujących pętli Perla, który powoduje, że przeszukują stos w celu znalezienia pasującej etykiety, pozwala na kilka ciekawych zachowań, które Test :: More wykorzystuje, na lepsze lub gorsze.

SKIP: {
    skip() if $something;

    print "Never printed";
}

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

Jest mało znany plik .pmc. „użyj Foo” będzie szukał Foo.pmc w @INC przed Foo.pm. Miało to na celu umożliwienie pierwszego załadowania skompilowanego kodu bajtowego, ale Module :: Compile wykorzystuje to do buforowania modułów filtrowanych według źródła w celu skrócenia czasu ładowania i łatwiejszego debugowania.

Możliwość zmiany ostrzeżeń w błędy.

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

To jest to, co przychodzi mi do głowy z głowy, o czym nie wspomniałem.

Operator kóz *:

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

lub

sub foo {
    return @_;
}

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

Działa, ponieważ przypisanie listy w kontekście skalarnym daje liczbę elementów na przypisanej liście.

* Uwaga, nie jest to operator