Recursos ocultos do Perl?

Quais são alguns recursos de linguagem realmente úteis, mas esotéricos, no Perl que você realmente conseguiu empregar para fazer um trabalho útil?

Diretrizes:

• Tente limitar as respostas ao núcleo do Perl e não ao CPAN
• Por favor, dê um exemplo e uma breve descrição

Recursos ocultos também encontrados nos recursos ocultos de outros idiomas:

(Estes são todos da resposta de Corion )

• C
  • Dispositivo de Duff
  • Portabilidade e Normalidade
• C #
  • Cotações para listas e cadeias delimitadas por espaço em branco
  • Namespaces aliasable
• Java
  • Initalizadores estáticos
• Javascript
  • Funções são cidadãos de primeira classe
  • Escopo e fechamento do bloco
  • Chamando métodos e acessadores indiretamente por meio de uma variável
• Rubi
  • Definindo métodos através do código
• PHP
  • Documentação on-line abrangente
  • Métodos mágicos
  • Referências simbólicas
• Pitão
  • Troca de um valor de linha
  • Capacidade de substituir até funções principais por sua própria funcionalidade

Outros recursos ocultos:

Operadores:

• O operador quase bool
• O operador de flip-flop
  • Também usado para construção de lista
• Os ++operadores e unários -trabalham em strings
• O operador de repetição
• O operador da nave espacial
• O || operador (e // operador) para selecionar um conjunto de opções
• O operador de diamantes
• Casos especiais do m//operador
• O "operador" til-til

Citando construções:

• O operador qw
• As letras podem ser usadas como delimitadores de aspas em construções semelhantes a q {}
• Mecanismos de cotação

Sintaxe e nomes:

• Pode haver um espaço após um sigilo
• Você pode dar nomes numéricos secundários com referências simbólicas
• Vírgulas finais legais
• Literais Inteiros Agrupados
• fatias de hash
• Preenchendo chaves de um hash de uma matriz

Módulos, Pragmas e opções de linha de comando:

• use avisos estritos e use
• Verificação de manchas
• Uso esotérico de -n e -p
• CPAN
• overload::constant
• IO :: Módulo de pega
• Compartimentos seguros
• Atributos

Variáveis:

• Autovivificação
• A $[variável
• gravata
• Escopo Dinâmico
• Troca de variáveis ​​com uma única instrução

Loops e controle de fluxo:

• Magic goto
• for em uma única variável
• cláusula continue
• Modo de desespero

Expressões regulares:

• A \Gâncora
• (?{}) e '(?? {}) `em expressões regulares

Outras características:

• O depurador
• Blocos de código especiais, como BEGIN, CHECK e END
• O DATAbloco
• Novas operações de bloco
• Filtros de origem
• Ganchos de sinal
• mapa ( duas vezes )
• Agrupando funções internas
• A eoffunção
• A dbmopenfunção
• Transformando avisos em erros

Outros truques e meta-respostas:

• arquivos cat, descompactando gzips, se necessário
• Dicas Perl

Veja também:

• Recursos ocultos de C
• Recursos ocultos do C #
• Recursos ocultos do C ++
• Recursos ocultos do Java
• Recursos ocultos do JavaScript
• Recursos ocultos do Ruby
• Recursos ocultos do PHP
• Recursos ocultos do Python
• Recursos ocultos do Clojure

O operador flip-flop é útil para pular a primeira iteração ao fazer um loop pelos registros (geralmente linhas) retornados por um identificador de arquivo, sem usar uma variável de flag:

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

Execute perldoc perlope pesquise "flip-flop" para obter mais informações e exemplos.

Existem muitos recursos não óbvios no Perl.

Por exemplo, você sabia que pode haver um espaço após um sigilo?

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

Ou que você pode dar nomes numéricos secundários se usar referências simbólicas?

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

Há também o operador quase bool "bool", que retorna 1 para expressões verdadeiras e a string vazia para false:

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

Outras coisas interessantes: use overloadvocê pode sobrecarregar literais e números de strings (e, por exemplo, torná-los BigInts ou o que for).

Muitas dessas coisas são realmente documentadas em algum lugar ou seguem logicamente a partir dos recursos documentados, mas mesmo assim algumas não são muito conhecidas.

Atualização : Outra boa. Abaixo, as q{...}construções de citação foram mencionadas, mas você sabia que pode usar letras como delimitadores?

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

Da mesma forma, você pode escrever expressões regulares:

m xabcx
# same as m/abc/

Adicione suporte para arquivos compactados via ARGV mágico :

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;

(aspas em torno de $ _ necessárias para manipular nomes de arquivos com metacaracteres de shell em)

Agora, o <>recurso descompactará qualquer @ARGVarquivo que termine com ".gz" ou ".Z":

while (<>) {
    print;
}

Um dos meus recursos favoritos no Perl é usar o ||operador booleano para selecionar entre um conjunto de opções.

 $x = $a || $b;

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

Isso significa que se pode escrever:

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

para dar o primeiro verdadeiro valor de $a, $be $c, ou um padrão de 0outra forma.

No Perl 5.10, há também o //operador, que retorna o lado esquerdo, se definido, e o lado direito, caso contrário. Os seguintes seleciona o primeiro definido valor de $a, $b, $c, ou 0de outra forma:

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

Eles também podem ser usados ​​com seus formulários abreviados, que são muito úteis para fornecer padrões:

$ x || = 0; # Se $ x era falso, agora ele tem o valor 0.

$ x // = 0; # Se $ x não tiver sido definido, agora ele tem um valor zero.

Cheerio,

Paulo

Os operadores ++ e unary - não funcionam apenas em números, mas também em strings.

my $_ = "a"
print -$_

imprime -a

print ++$_

imprime b

$_ = 'z'
print ++$_

imprime aa

Como o Perl tem quase todas as partes "esotéricas" das outras listas, vou lhe dizer uma coisa que o Perl não pode:

A única coisa que o Perl não pode fazer é ter URLs arbitrárias vazias no seu código, porque o //operador é usado para expressões regulares.

Para o caso de não ser óbvio para você quais recursos o Perl oferece, aqui está uma lista seletiva das entradas talvez não totalmente óbvias:

Dispositivo de Duff - em Perl

Portabilidade e Normalidade - Provavelmente há mais computadores com Perl do que com um compilador C

Uma classe de manipulação de arquivo / caminho - File :: Find funciona em ainda mais sistemas operacionais do que o .Net

Cotações para listas delimitadas por espaço em branco e cadeias - O Perl permite escolher cotações quase arbitrárias para os delimitadores de lista e cadeia de caracteres

Namespaces aliasable - O Perl possui estes através de atribuições glob:

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

Inicializadores estáticos - o Perl pode executar código em quase todas as fases de compilação e instanciação de objetos, de BEGIN(análise de código) a CHECK(após análise de código) a import(na importação do módulo) a new(instanciação de objeto) a DESTROY(destruição de objeto) a END( destruição de objeto) a (saída do programa)

Funções são cidadãos de primeira classe - assim como em Perl

Escopo e fechamento do bloco - o Perl possui

Chamando métodos e acessadores indiretamente por meio de uma variável - o Perl também faz isso:

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

Definindo métodos através do código - o Perl também permite isso :

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

Documentação on-line abrangente - a documentação do Perl está on-line e provavelmente também no seu sistema

Métodos mágicos que são chamados sempre que você chama uma função "inexistente" - o Perl implementa isso na função AUTOLOAD

Referências simbólicas - é aconselhável ficar longe delas. Eles vão comer seus filhos. Mas é claro que Perl permite que você ofereça seus filhos a demônios sedentos de sangue.

Troca de um valor de linha - Perl permite a atribuição de listas

Capacidade de substituir até funções principais por sua própria funcionalidade

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

ou

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

unlink($_) for @ARGV

Autovivificação . AFAIK nenhum outro idioma possui .

É simples citar quase todo tipo de string estranha no Perl.

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

De fato, os vários mecanismos de citação no Perl são bastante interessantes. Os mecanismos de cotação do tipo regex do Perl permitem que você cite qualquer coisa, especificando os delimitadores. Você pode usar quase qualquer caractere especial como #, /, ou abrir / fechar caracteres como (), [] ou {}. Exemplos:

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

Mecanismos de citação:

q: citação literal; único caractere que precisa ser escapado é o caractere final. qq: uma cotação interpretada; processa variáveis ​​e caracteres de escape. Ótimo para strings que você precisa citar:

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

qx: funciona como qq, mas o executa como um comando do sistema, não interativamente. Retorna todo o texto gerado a partir da saída padrão. (Redirecionamento, se suportado no sistema operacional, também sai) Também feito com aspas (o caracter `).

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

qr: interpreta como qq, mas depois o compila como uma expressão regular. Também trabalha com as várias opções no regex. Agora você pode passar a regex como uma variável:

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: um operador de cotação muito, muito útil. Transforma um conjunto de palavras separadas por espaços em branco em uma lista. Ótimo para preencher dados em um teste de unidade.

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

Eles são ótimos para usá-los sempre que isso torna as coisas mais claras. Para qx, qq eq, provavelmente utilizo os operadores {}. O hábito mais comum das pessoas que usam qw geralmente é o operador (), mas às vezes você também vê qw //.

Não é realmente oculto, mas muitos programadores Perl todos os dias não conhecem o CPAN . Isso se aplica especialmente a pessoas que não são programadores em período integral ou não programam em Perl em período integral.

A instrução "for" pode ser usada da mesma maneira que "with" é usada no Pascal:

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

Você pode aplicar uma sequência de operações s /// etc. à mesma variável sem precisar repetir o nome da variável.

NOTA: o espaço ininterrupto acima (& nbsp;) ocultou o Unicode para contornar o Markdown. Não copie e cole :)

O operador de palavra-chave é uma das minhas coisas favoritas. Comparar:

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

e

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

Muito menos ruído, mais fácil para os olhos. Outra coisa muito legal sobre o Perl, que realmente falta quando se escreve SQL, é que uma vírgula à direita é legal:

print 1, 2, 3, ;

Isso parece estranho, mas não se você recuar o código de outra maneira:

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

A adição de um argumento adicional à chamada de função não exige que você use vírgulas nas linhas anteriores ou finais. A mudança de linha única não afeta as linhas adjacentes.

Isso torna muito agradável trabalhar com funções variadas. Este é talvez um dos recursos mais subestimados do Perl.

A capacidade de analisar dados colados diretamente em um bloco DATA . Não há necessidade de salvar em um arquivo de teste para ser aberto no programa ou similar. Por exemplo:

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

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

Novas operações de bloco

Eu diria que a capacidade de expandir o idioma, criando operações de pseudo-bloco, é uma delas.

1. Você declara o protótipo para um sub indicando que ele recebe uma referência de código primeiro:

   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. Você pode chamá-lo no corpo assim

   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é outra jóia semi-oculta.) Observe como você não precisa dasub palavra chave na frente do bloco ou da vírgula antes do hash. Ele acaba parecendo muito com:map { } @list

Filtros de origem

Além disso, existem filtros de origem. Onde o Perl passará o código para você poder manipulá-lo. Tanto isso quanto as operações de bloco são basicamente coisas do tipo não tente fazer isso em casa.

Fiz algumas coisas bacanas com os filtros de origem, por exemplo, como criar uma linguagem muito simples para verificar o tempo, permitindo linhas curtas de Perl para algumas tomadas de decisão:

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

Lib::TL iria apenas procurar as "variáveis" e as constantes, criá-las e substituí-las conforme necessário.

Novamente, os filtros de origem podem ser confusos, mas são poderosos. Mas eles podem atrapalhar os depuradores com algo terrível - e até avisos podem ser impressos com os números de linha incorretos. Eu parei de usar o Switch de Damian porque o depurador perderia toda a capacidade de me dizer onde eu realmente estava. Mas descobri que você pode minimizar o dano modificando pequenas seções do código, mantendo-os na mesma linha.

Ganchos de sinal

Muitas vezes é feito o suficiente, mas não é tão óbvio. Aqui está um manipulador de matrizes que apóia o antigo.

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

Isso significa que sempre que algum outro módulo do código quer morrer, eles precisam chegar até você (a menos que alguém faça uma substituição destrutiva em $SIG{__DIE__} ). E você pode ser notificado de que alguém coloca algo em erro.

Obviamente, para coisas suficientes, você pode usar apenas um END { }bloco, se tudo o que você quer fazer é limpar.

overload::constant

Você pode inspecionar literais de um determinado tipo em pacotes que incluem seu módulo. Por exemplo, se você usar isso em seu importsub:

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

isso significa que todo número inteiro maior que 2 bilhões nos pacotes de chamada será alterado para um Math::BigIntobjeto. (Veja sobrecarga :: constante ).

Literais Inteiros Agrupados

Enquanto estamos nisso. O Perl permite dividir grandes números em grupos de três dígitos e ainda assim obter um número inteiro analisável. Nota 2_000_000_000acima para 2 bilhões.

Binário "x" é o operador de repetição :

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

Também funciona com listas:

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

Verificação de contaminação. Com a verificação de contaminação ativada, o perl morre (ou avisa, com-t ) se você tentar passar dados contaminados (grosso modo, dados de fora do programa) para uma função não segura (abrir um arquivo, executar um comando externo, etc.). É muito útil ao escrever scripts setuid ou CGIs ou qualquer coisa em que o script tenha maiores privilégios do que a pessoa que os alimenta.

Magic goto. goto &subfaz uma chamada de cauda otimizada.

O depurador.

use stricte use warnings. Isso pode salvá-lo de vários erros de digitação.

Com base na maneira como os switches "-n"e "-p"são implementados no Perl 5, você pode escrever um programa aparentemente incorreto, incluindo }{:

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

que é convertido internamente para este código:

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

Vamos começar com facilidade com o operador de nave espacial .

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

Esta é uma meta-resposta, mas o Perl Tips arquivos contêm todos os tipos de truques interessantes que podem ser feitos com o Perl. O arquivo das dicas anteriores está on-line para navegação e pode ser assinado via lista de discussão ou feed Atom.

Algumas das minhas dicas favoritas incluem a criação de executáveis ​​com o PAR , o uso de autodie para gerar exceções automaticamente e o uso dos comutadores e construções de correspondência inteligente no Perl 5.10.

Divulgação: sou um dos autores e mantenedores do Perl Tips, então obviamente penso muito bem neles. ;)

mapa - não apenas porque torna o código mais expressivo, mas porque me deu um impulso de ler um pouco mais sobre essa "programação funcional".

A cláusula continue nos loops. Ele será executado na parte inferior de cada loop, mesmo nos próximos.

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

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

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

Meu voto seria para os grupos (? {}) E (?? {}) nas expressões regulares do Perl. O primeiro executa o código Perl, ignorando o valor de retorno, o segundo executa o código, usando o valor de retorno como uma expressão regular.

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

a âncora \ G. Está quente .

O m//operador tem alguns casos especiais obscuros:

• Se você usar ?como delimitador, ele corresponderá apenas uma vez, a menos que você chamereset .
• Se você usar ' como delimitador, o padrão não será interpolado.
• Se o padrão estiver vazio, ele usará o padrão da última correspondência bem-sucedida.

O operador de diamante nulo filehandle <>tem seu lugar na construção de ferramentas de linha de comando. Ele age como <FH>leitura de um identificador, exceto que ele seleciona magicamente o que for encontrado primeiro: nomes de arquivos de linha de comando ou STDIN. Retirado de perlop:

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

Blocos de código especiais como BEGIN, CHECKe END. Eles vêm do Awk, mas funcionam de maneira diferente no Perl, porque não é baseado em registros.

O BEGINbloco pode ser usado para especificar algum código para a fase de análise; também é executado quando você faz a verificação de sintaxe e variável perl -c. Por exemplo, para carregar variáveis ​​de configuração:

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

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

renomeia data.txt.part para data.txt sem ter que me repetir.

Um pouco obscuro é o operador "til-til" que força o contexto escalar.

print ~~ localtime;

é o mesmo que

print scalar localtime;

e diferente de

print localtime;

tie, a interface de vinculação variável.

O "modo de desespero" das construções de controle de loop do Perl, que faz com que eles procurem na pilha para encontrar um rótulo correspondente, permite alguns comportamentos curiosos dos quais o Test :: More tira proveito, para o bem ou para o mal.

SKIP: {
    skip() if $something;

    print "Never printed";
}

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

Existe o pouco conhecido arquivo .pmc. "use Foo" procurará Foo.pmc no @INC antes de Foo.pm. O objetivo era permitir que o bytecode compilado fosse carregado primeiro, mas o Module :: Compile tira vantagem disso para armazenar em cache os módulos filtrados de origem para tempos de carregamento mais rápidos e depuração mais fácil.

A capacidade de transformar avisos em erros.

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

É nisso que consigo pensar em cima da minha cabeça que não foi mencionado.

O operador de cabra *:

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

ou

sub foo {
    return @_;
}

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

Funciona porque a atribuição de lista no contexto escalar gera o número de elementos na lista que está sendo atribuída.

* Observe que não é realmente um operador