Caratteristiche nascoste di Perl?

Quali sono alcune funzioni del linguaggio davvero utili ma esoteriche in Perl che sei stato effettivamente in grado di impiegare per fare un lavoro utile?

Linee guida:

• Cerca di limitare le risposte al core Perl e non a CPAN
• Fornisci un esempio e una breve descrizione

Funzionalità nascoste si trovano anche nelle funzionalità nascoste di altre lingue:

(Questi sono tutti dalla risposta di Corion )

• C
  • Dispositivo di Duff
  • Portabilità e standardità
• C #
  • Preventivi per liste e stringhe delimitate da spazi bianchi
  • Spazi dei nomi aliasable
• Giava
  • Inattivizzatori statici
• JavaScript
  • Le funzioni sono cittadini di prima classe
  • Portata e chiusura del blocco
  • Chiamare metodi e accessori indirettamente tramite una variabile
• Rubino
  • Definizione dei metodi tramite codice
• PHP
  • Pervasiva documentazione online
  • Metodi magici
  • Riferimenti simbolici
• Pitone
  • Scambio di un valore di riga
  • Possibilità di sostituire anche le funzioni principali con le proprie funzionalità

Altre caratteristiche nascoste:

operatori:

• Il quasi-operatore bool
• L'operatore flip-flop
  • Utilizzato anche per la costruzione di elenchi
• Gli operatori ++unari e -lavorano sulle stringhe
• L'operatore di ripetizione
• L'operatore dell'astronave
• Il || operatore (e // operatore) per selezionare da una serie di scelte
• L'operatore del diamante
• Casi speciali m//dell'operatore
• L '"operatore" tilde-tilde

Citazione costrutti:

• L'operatore qw
• Le lettere possono essere usate come delimitatori di virgolette in costrutti simili a q {}
• Meccanismi di citazione

Sintassi e nomi:

• Può esserci uno spazio dopo un sigillo
• È possibile assegnare nomi numerici ai sottotitoli con riferimenti simbolici
• Virgole finali legali
• Letterali interi raggruppati
• fette di hash
• Popolamento delle chiavi di un hash da un array

Moduli, pragmi e opzioni della riga di comando:

• usare avvertenze rigorose e usare
• Controllo della contaminazione
• Uso esoterico di -n e -p
• CPAN
• overload::constant
• IO :: Modulo maniglia
• Scomparti sicuri
• attributi

variabili:

• autovivificazione
• La $[variabile
• cravatta
• Scoping dinamico
• Scambio di variabili con una singola istruzione

Loop e controllo del flusso:

• Goto magico
• for su una singola variabile
• continua la clausola
• Modalità disperazione

Espressioni regolari:

• L' \Gancora
• (?{}) e '(?? {}) `in regex

Altre caratteristiche:

• Il debugger
• Blocchi di codice speciali come BEGIN, CHECK ed END
• Il DATAblocco
• Nuove operazioni di blocco
• Filtri sorgente
• Hook di segnale
• mappa ( due volte )
• Avvolgimento delle funzioni integrate
• La eoffunzione
• La dbmopenfunzione
• Trasformare gli avvisi in errori

Altri trucchi e meta-risposte:

• file cat, decompressione decompressione se necessario
• Suggerimenti Perl

Guarda anche:

• Caratteristiche nascoste di C
• Funzionalità nascoste di C #
• Funzionalità nascoste di C ++
• Funzionalità nascoste di Java
• Funzionalità nascoste di JavaScript
• Caratteristiche nascoste di Ruby
• Funzionalità nascoste di PHP
• Funzionalità nascoste di Python
• Caratteristiche nascoste di Clojure

L'operatore flip-flop è utile per saltare la prima iterazione durante il ciclo tra i record (di solito le righe) restituiti da un handle di file, senza usare una variabile flag:

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

Esegui perldoc perlope cerca "flip-flop" per ulteriori informazioni ed esempi.

Ci sono molte caratteristiche non ovvie in Perl.

Ad esempio, sapevi che può esserci uno spazio dopo un sigillo?

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

O che puoi dare nomi numerici ai sottotitoli se usi riferimenti simbolici?

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

C'è anche l'operatore quasi "bool", che restituisce 1 per le espressioni vere e la stringa vuota per false:

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

Altre cose interessanti: con use overloadte puoi sovraccaricare letterali e numeri di stringa (e ad esempio renderli BigInts o altro).

Molte di queste cose sono in realtà documentate da qualche parte, o seguono logicamente dalle funzionalità documentate, ma alcune non sono molto conosciute.

Aggiornamento : un altro bello. Di seguito q{...}sono stati menzionati i costrutti di citazione, ma sapevi che puoi usare le lettere come delimitatori?

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

Allo stesso modo puoi scrivere espressioni regolari:

m xabcx
# same as m/abc/

Aggiungi il supporto per i file compressi tramite 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;

(virgolette intorno a $ _ necessarie per gestire i nomi di file con metacaratteri della shell in)

Ora la <>funzione decomprimerà tutti i @ARGVfile che terminano con ".gz" o ".Z":

while (<>) {
    print;
}

Una delle mie funzioni preferite in Perl sta usando l' ||operatore booleano per selezionare tra una serie di scelte.

 $x = $a || $b;

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

Questo significa che si può scrivere:

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

a prendere il primo valore vero dal $a, $be $c, o di un default di 0altrimenti.

In Perl 5.10, c'è anche l' //operatore, che restituisce il lato sinistro se definito, e il lato destro altrimenti. I seguenti seleziona la prima definito valore $a, $b, $c, o 0altrimenti:

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

Questi possono anche essere usati con le loro forme abbreviate, che sono molto utili per fornire le impostazioni predefinite:

$ x || = 0; # Se $ x era falso, ora ha un valore di 0.

$ x // = 0; # Se $ x non era definito, ora ha un valore pari a zero.

Cheerio,

Paolo

Gli operatori ++ e unario - non funzionano solo sui numeri, ma anche sulle stringhe.

my $_ = "a"
print -$_

stampe -a

print ++$_

stampe b

$_ = 'z'
print ++$_

stampe aa

Poiché Perl ha quasi tutte le parti "esoteriche" delle altre liste, ti dirò l'unica cosa che Perl non può:

L'unica cosa che Perl non può fare è avere URL arbitrari nudi nel codice, poiché l' //operatore viene utilizzato per le espressioni regolari.

Nel caso in cui non fosse ovvio per te quali funzionalità offre Perl, ecco un elenco selettivo delle voci forse non del tutto ovvie:

Dispositivo di Duff - in Perl

Portabilità e standardità - Probabilmente ci sono più computer con Perl che con un compilatore C.

Una classe di manipolazione di file / percorsi - File :: Find funziona su un numero ancora maggiore di sistemi operativi rispetto a .Net

Virgolette per elenchi e stringhe delimitati da spazi bianchi - Perl consente di scegliere virgolette quasi arbitrarie per l'elenco e i delimitatori di stringhe

Spazi dei nomi aliasable - Perl ha questi attraverso assegnazioni glob:

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

Inizializzatori statici - Perl può eseguire il codice in quasi tutte le fasi della compilazione e dell'istanza dell'oggetto, da BEGIN(analisi del codice) a CHECK(dopo l'analisi del codice import) a new(all'istanza del modulo) a (istanza dell'oggetto) a DESTROY(distruzione dell'oggetto) a END(uscita programma)

Le funzioni sono cittadini di prima classe, proprio come in Perl

Portata e chiusura del blocco - Perl ha entrambe

Chiamare metodi e accessori indirettamente tramite una variabile - Anche Perl lo fa:

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

Definizione dei metodi tramite il codice - Perl consente anche questo :

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

Pervasive documentazione in linea - la documentazione Perl è in linea e probabilmente sul vostro sistema troppo

Metodi magici che vengono chiamati ogni volta che chiami una funzione "inesistente" - Perl lo implementa nella funzione AUTOLOAD

Riferimenti simbolici - si consiglia vivamente di starne alla larga. Mangeranno i tuoi figli. Ma, naturalmente, Perl ti consente di offrire ai tuoi figli demoni assetati di sangue.

Scambio di un valore di riga : Perl consente l'assegnazione dell'elenco

Possibilità di sostituire anche le funzioni principali con le proprie funzionalità

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

o

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

unlink($_) for @ARGV

Autovivificazione . AFAIK nessun'altra lingua ce l'ha .

È semplice citare quasi ogni tipo di strana stringa in Perl.

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

In effetti, i vari meccanismi di quotazione in Perl sono piuttosto interessanti. I meccanismi di quotazione simili a regex del Perl consentono di citare qualsiasi cosa, specificando i delimitatori. Puoi usare quasi tutti i caratteri speciali come #, / o apri / chiudi caratteri come (), [] o {}. Esempi:

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

Meccanismi di citazione:

q: citazione letterale; l'unico personaggio che deve essere evaso è il carattere finale. qq: una citazione interpretata; elabora le variabili e scappa i caratteri. Ottimo per le stringhe che devi citare:

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

qx: funziona come qq, ma poi lo esegue come comando di sistema, in modo non interattivo. Restituisce tutto il testo generato dallo standard. (Anche il reindirizzamento, se supportato nel sistema operativo, viene rilasciato) Anche con virgolette (il carattere `).

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

qr: interpreta come qq, ma poi lo compila come espressione regolare. Funziona anche con le varie opzioni su regex. Ora puoi passare la regex come variabile:

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: un operatore di quotazioni molto, molto utile. Trasforma un insieme citato di parole separate da spazi bianchi in un elenco. Ottimo per compilare i dati in un test unitario.

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

Sono fantastici da usarli ogni volta che rende le cose più chiare. Per qx, qq e q, molto probabilmente uso gli operatori {}. L'abitudine più comune delle persone che usano qw è di solito l'operatore (), ma a volte vedi anche qw //.

Non proprio nascosto, ma molti programmatori Perl ogni giorno non conoscono CPAN . Ciò vale soprattutto per le persone che non sono programmatori a tempo pieno o che non programmano in Perl a tempo pieno.

L'istruzione "for" può essere utilizzata nello stesso modo in cui "con" è utilizzato in Pascal:

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

È possibile applicare una sequenza di operazioni s ///, ecc. Alla stessa variabile senza dover ripetere il nome della variabile.

NOTA: lo spazio non interrotto sopra (& nbsp;) ha nascosto Unicode in esso per aggirare il Markdown. Non copiarlo incollalo :)

L'operatore quoteword è una delle mie cose preferite. Confrontare:

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

e

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

Molto meno rumore, più facile per gli occhi. Un'altra cosa davvero bella di Perl, che manca davvero quando si scrive SQL, è che una virgola finale è legale:

print 1, 2, 3, ;

Sembra strano, ma non se indenti il ​​codice in un altro modo:

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

L'aggiunta di un argomento aggiuntivo alla chiamata di funzione non richiede di armeggiare con virgole su righe precedenti o finali. Il cambio di linea singola non ha alcun impatto sulle linee circostanti.

Questo rende molto piacevole lavorare con funzioni variadiche. Questa è forse una delle caratteristiche più sottovalutate di Perl.

La possibilità di analizzare i dati direttamente incollati in un blocco DATA . Non è necessario salvare in un file di prova per essere aperto nel programma o simile. Per esempio:

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

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

Nuove operazioni di blocco

Direi che la possibilità di espandere la lingua, creando operazioni di pseudo blocco è una di queste.

1. Dichiarate il prototipo per un sub indicando che accetta prima un riferimento di codice:

   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. Puoi quindi chiamarlo nel corpo in questo modo

   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è un'altra gemma semi-nascosta.) Nota come non hai bisogno della subparola chiave davanti al blocco o della virgola prima dell'hash. Finisce per assomigliare molto a:map { } @list

Filtri sorgente

Inoltre, ci sono filtri di origine. Dove Perl ti passerà il codice in modo che tu possa manipolarlo. Sia questo, sia le operazioni di blocco, sono praticamente cose da non provare a casa.

Ho fatto alcune cose pulite con i filtri di origine, ad esempio come creare un linguaggio molto semplice per controllare il tempo, consentendo brevi battute Perl per alcuni processi decisionali:

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

Lib::TL dovrebbe solo cercare sia le "variabili" che le costanti, crearle e sostituirle secondo necessità.

Ancora una volta, i filtri di origine possono essere disordinati, ma sono potenti. Ma possono rovinare qualcosa di terribile nei debugger e persino gli avvisi possono essere stampati con numeri di riga errati. Ho smesso di usare Damian's Switch perché il debugger perderebbe tutta la capacità di dirmi dove ero veramente. Ma ho scoperto che puoi minimizzare il danno modificando piccole sezioni di codice, mantenendole sulla stessa linea.

Hook di segnale

Spesso è abbastanza fatto, ma non è poi così ovvio. Ecco un gestore di dadi che si rifugia su quello vecchio.

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

Ciò significa che ogni qualvolta un altro modulo nel codice vuole morire, devono venire da te (a meno che qualcun altro non esegua una sovrascrittura distruttiva $SIG{__DIE__}). E puoi essere avvisato che qualcuno fa qualcosa che è un errore.

Certo, per abbastanza cose puoi semplicemente usare un END { }blocco, se tutto ciò che vuoi fare è ripulire.

overload::constant

Puoi ispezionare letterali di un certo tipo in pacchetti che includono il tuo modulo. Ad esempio, se lo usi nel tuo importsub:

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

significherà che ogni numero intero superiore a 2 miliardi nei pacchetti chiamanti verrà modificato in un Math::BigIntoggetto. (Vedi sovraccarico :: costante ).

Letterali interi raggruppati

Mentre ci siamo. Perl ti permette di dividere grandi numeri in gruppi di tre cifre e ottenere comunque un intero analizzabile da esso. Nota 2_000_000_000sopra per 2 miliardi.

La "x" binaria è l' operatore di ripetizione :

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

Funziona anche con elenchi:

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

Controllo della contaminazione. Con il controllo della contaminazione abilitato, perl morirà (o avviserà, con -t) se si tenta di passare i dati contaminati (approssimativamente parlando, dati dall'esterno del programma) a una funzione non sicura (apertura di un file, esecuzione di un comando esterno, ecc.). È molto utile quando si scrivono script setuid o CGI o qualsiasi cosa in cui lo script abbia privilegi maggiori rispetto alla persona che lo fornisce.

Goto magico. goto &subeffettua una chiamata di coda ottimizzata.

Il debugger.

use stricte use warnings. Questi possono salvarti da un mucchio di errori di battitura.

In base al modo in cui gli switch "-n"e "-p"sono implementati in Perl 5, puoi scrivere un programma apparentemente errato che include }{:

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

che viene convertito internamente in questo codice:

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

Cominciamo facilmente con l' operatore dell'astronave .

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

Questa è una meta-risposta, ma gli archivi Perl Tips contengono tutti i tipi di trucchi interessanti che possono essere fatti con Perl. L'archivio dei suggerimenti precedenti è on-line per la navigazione e può essere sottoscritto tramite mailing list o atom feed.

Alcuni dei miei consigli preferiti includono la creazione di file eseguibili con PAR , l' utilizzo di autodie per generare automaticamente eccezioni e l'uso dello switch e dei costrutti smart-match in Perl 5.10.

Divulgazione: sono uno degli autori e manutentori di Perl Tips, quindi ovviamente penso molto bene a loro. ;)

mappa - non solo perché rende il proprio codice più espressivo, ma perché mi ha dato l'impulso di leggere qualcosa in più su questa "programmazione funzionale".

La clausola continue sui loop. Verrà eseguito nella parte inferiore di ogni loop, anche quelli che verranno seguiti.

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

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

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

Il mio voto andrebbe per i gruppi (? {}) E (?? {}) nelle espressioni regolari di Perl. Il primo esegue il codice Perl, ignorando il valore restituito, il secondo esegue il codice, usando il valore restituito come espressione regolare.

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

l'ancora \ G. Fa caldo .

L' m//operatore ha alcuni casi speciali oscuri:

• Se lo usi ?come delimitatore, corrisponde solo una volta, a meno che non chiami reset.
• Se si utilizza 'come delimitatore il modello non viene interpolato.
• Se il modello è vuoto, utilizza il modello dell'ultima corrispondenza corretta.

L' operatore Null Filehandle Diamond<> ha il suo posto nella costruzione di strumenti da riga di comando. Si comporta come <FH>leggere da un handle, tranne per il fatto che seleziona magicamente quello che si trova per primo: i nomi dei file della riga di comando o STDIN. Tratto da perlop:

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

Blocchi di codice speciali come BEGIN, CHECKe END. Provengono da Awk, ma funzionano in modo diverso in Perl, perché non è basato su record.

Il BEGINblocco può essere utilizzato per specificare del codice per la fase di analisi; viene anche eseguito quando si esegue il controllo della sintassi e della variabile perl -c. Ad esempio, per caricare le variabili di configurazione:

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

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

rinomina data.txt.part in data.txt senza ripetere me stesso.

Un po 'oscuro è l' "operatore" tilde-tilde che forza il contesto scalare.

print ~~ localtime;

equivale a

print scalar localtime;

e diverso da

print localtime;

pareggio, l'interfaccia di legatura variabile.

La "modalità disperazione" dei costrutti di controllo del loop di Perl che li induce a cercare nello stack per trovare un'etichetta corrispondente consente alcuni comportamenti curiosi di cui Test :: More trae vantaggio, nel bene e nel male.

SKIP: {
    skip() if $something;

    print "Never printed";
}

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

C'è il file .pmc poco conosciuto. "usa Foo" cercherà Foo.pmc in @INC prima di Foo.pm. Lo scopo era quello di consentire il caricamento iniziale del bytecode compilato, ma Module :: Compile ne approfitta per memorizzare nella cache i moduli filtrati di origine per tempi di caricamento più rapidi e debug più semplice.

La possibilità di trasformare gli avvisi in errori.

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

Questo è ciò a cui riesco a pensare dalla cima della mia testa che non è stato menzionato.

L'operatore capra *:

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

o

sub foo {
    return @_;
}

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

Funziona perché l'assegnazione dell'elenco nel contesto scalare produce il numero di elementi nell'elenco che viene assegnato.

* Nota, non proprio un operatore