¿Características ocultas de Perl?

¿Cuáles son algunas de las características de lenguaje realmente útiles pero esotéricas en Perl que realmente has podido emplear para hacer un trabajo útil?

Pautas:

• Intente limitar las respuestas al núcleo de Perl y no a CPAN
• Por favor da un ejemplo y una breve descripción

Las características ocultas también se encuentran en las características ocultas de otros idiomas:

(Todo esto es de la respuesta de Corion )

• C
  • Dispositivo de Duff
  • Portabilidad y Estandaridad
• C#
  • Cotizaciones para listas y cadenas delimitadas por espacios en blanco
  • Espacios de nombres aliables
• Java
  • Initalizadores Estáticos
• JavaScript
  • Las funciones son ciudadanos de primera clase.
  • Bloqueo de alcance y cierre
  • Llamando métodos y accesos indirectamente a través de una variable
• Rubí
  • Definiendo métodos a través del código
• PHP
  • Documentación en línea generalizada
  • Métodos mágicos
  • Referencias simbólicas
• Pitón
  • Intercambio de valor de una línea
  • Capacidad para reemplazar incluso las funciones principales con su propia funcionalidad

Otras características ocultas:

Operadores:

• El cuasi-operador bool
• El operador de flip-flop
  • También se usa para la construcción de listas
• Los ++operadores y unarios -trabajan en cadenas
• El operador de repetición.
• El operador de la nave espacial
• El || operador (y // operador) para seleccionar de un conjunto de opciones
• El operador de diamantes
• Casos especiales del m//operador
• El "operador" tilde-tilde

Citando construcciones:

• El operador qw
• Las letras se pueden usar como delimitadores de comillas en q {} - como construcciones
• Mecanismos de cotización

Sintaxis y Nombres:

• Puede haber un espacio después de un sigilo
• Puede dar nombres numéricos subs con referencias simbólicas
• Comas legales finales
• Literales enteros agrupados
• rodajas de picadillo
• Rellenar claves de un hash desde una matriz

Módulos, pragmas y opciones de línea de comandos:

• usar advertencias estrictas y advertencias
• Comprobación de contaminación
• Uso esotérico de -n y -p
• CPAN
• overload::constant
• IO :: Módulo de manija
• Compartimentos seguros
• Atributos

Variables:

• Autovivificación
• La $[variable
• Corbata
• Alcance dinámico
• Intercambio variable con una sola declaración

Bucles y control de flujo:

• Goto mágico
• for en una sola variable
• continuar cláusula
• Modo de desesperación

Expresiones regulares:

• El \Gancla
• (?{}) y '(?? {}) `en expresiones regulares

Otras características:

• El depurador
• Bloques de código especiales como BEGIN, CHECK y END
• El DATAbloque
• Nuevas operaciones de bloque
• Filtros de origen
• Ganchos de señal
• mapa ( dos veces )
• Ajuste de funciones integradas
• La eoffunción
• La dbmopenfunción
• Convertir advertencias en errores

Otros trucos y meta respuestas:

• archivos cat, descomprimiendo gzips si es necesario
• Consejos Perl

Ver también:

• Características ocultas de C
• Características ocultas de C #
• Características ocultas de C ++
• Características ocultas de Java
• Características ocultas de JavaScript
• Características ocultas de Ruby
• Características ocultas de PHP
• Características ocultas de Python
• Características ocultas de Clojure

El operador de flip-flop es útil para omitir la primera iteración al recorrer los registros (generalmente líneas) devueltos por un identificador de archivo, sin usar una variable de indicador:

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

Ejecute perldoc perlopy busque "flip-flop" para obtener más información y ejemplos.

Hay muchas características no obvias en Perl.

Por ejemplo, ¿sabías que puede haber un espacio después de un sigilo?

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

¿O que puede dar nombres numéricos subs si usa referencias simbólicas?

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

También está el cuasi operador "bool", que devuelve 1 para expresiones verdaderas y la cadena vacía para falsas:

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

Otras cosas interesantes: con use overloadusted puede sobrecargar los literales de cadena y los números (y, por ejemplo, hacerlos BigInts o lo que sea).

Muchas de estas cosas están realmente documentadas en alguna parte, o se siguen lógicamente de las características documentadas, pero no obstante, algunas no son muy conocidas.

Actualización : otra buena. A continuación se q{...}mencionaron las construcciones de comillas, pero ¿sabía que puede usar letras como delimitadores?

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

Del mismo modo, puede escribir expresiones regulares:

m xabcx
# same as m/abc/

Agregue soporte para archivos comprimidos a través de 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;

(cita alrededor de $ _ necesario para manejar nombres de archivos con metacaracteres de shell)

Ahora la <>función descomprimirá cualquier @ARGVarchivo que termine con ".gz" o ".Z":

while (<>) {
    print;
}

Una de mis características favoritas en Perl es usar el ||operador booleano para seleccionar entre un conjunto de opciones.

 $x = $a || $b;

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

Esto significa que uno puede escribir:

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

para dar el primer valor verdadero de $a, $by $c, o un incumplimiento de 0lo contrario.

En Perl 5.10, también está el //operador, que devuelve el lado izquierdo si está definido, y el lado derecho de lo contrario. Los siguientes selecciona la primera definido valor de $a, $b, $c, o 0de otro modo:

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

Estos también se pueden usar con sus formas abreviadas, que son muy útiles para proporcionar valores predeterminados:

$ x || = 0; # Si $ x era falso, ahora tiene un valor de 0.

$ x // = 0; # Si $ x no estaba definido, ahora tiene un valor de cero.

Cheerio

Pablo

Los operadores ++ y unario: no solo funcionan en números, sino también en cadenas.

my $_ = "a"
print -$_

impresiones -a

print ++$_

impresiones b

$_ = 'z'
print ++$_

imprime aa

Como Perl tiene casi todas las partes "esotéricas" de las otras listas, le diré una cosa que Perl no puede:

Lo único que Perl no puede hacer es tener URL arbitrarias desnudas en su código, porque el //operador se usa para expresiones regulares.

En caso de que no fuera obvio para usted qué características ofrece Perl, aquí hay una lista selectiva de las entradas quizás no totalmente obvias:

Dispositivo de Duff - en Perl

Portabilidad y estandarización : es probable que haya más computadoras con Perl que con un compilador de C

Una clase de manipulación de archivos / rutas : File :: Find funciona incluso en más sistemas operativos que .Net

Cotizaciones para listas y cadenas delimitadas por espacios en blanco : Perl le permite elegir citas casi arbitrarias para su lista y delimitadores de cadena

Espacios de nombres aliables : Perl los tiene mediante asignaciones globales:

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

Inicializadores estáticos : Perl puede ejecutar código en casi todas las fases de compilación y creación de instancias de objetos, desde BEGIN(análisis de código) a CHECK(después del análisis de código) a import(en la importación del módulo) a new(creación de objetos) a DESTROY(destrucción de objetos) a END(salida del programa)

Las funciones son ciudadanos de primera clase , como en Perl

Bloqueo de alcance y cierre : Perl tiene ambas

Llamando métodos y accesores indirectamente a través de una variable : Perl también lo hace:

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

Definición de métodos a través del código : Perl también lo permite :

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

Documentación en línea omnipresente - documentación de Perl está en línea y probablemente en su sistema demasiado

Métodos mágicos que se llaman cada vez que se llama una función "no existente": Perl implementa eso en la función AUTOLOAD

Referencias simbólicas : se recomienda mantenerse alejado de ellas. Se comerán a tus hijos. Pero, por supuesto, Perl le permite ofrecer a sus hijos demonios sedientos de sangre.

Intercambio de valores de una línea : Perl permite la asignación de listas

Capacidad para reemplazar incluso las funciones principales con su propia funcionalidad

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

o

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

unlink($_) for @ARGV

Autovivification . AFAIK no tiene otro idioma .

Es simple citar casi cualquier tipo de cadena extraña en Perl.

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

De hecho, los diversos mecanismos de cotización en Perl son bastante interesantes. Los mecanismos de comillas tipo Regex de Perl le permiten citar cualquier cosa, especificando los delimitadores. Puede usar casi cualquier carácter especial como #, / o caracteres de apertura / cierre como (), [] o {}. Ejemplos:

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 cotización:

q: cita literal; El único personaje que necesita escapar es el personaje final. qq: una cita interpretada; procesa variables y caracteres de escape. Ideal para cadenas que necesita citar:

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

qx: funciona como qq, pero luego lo ejecuta como un comando del sistema, no de forma interactiva. Devuelve todo el texto generado a partir de la salida estándar. (La redirección, si es compatible con el sistema operativo, también sale) También se hace con comillas inversas (el carácter `).

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, pero luego lo compila como una expresión regular. Funciona con las diversas opciones en la expresión regular también. Ahora puede pasar la expresión regular como una variable:

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 operador de cotizaciones muy, muy útil. Convierte un conjunto de palabras separadas por espacios en blanco en una lista. Excelente para completar datos en una prueba unitaria.

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

Son geniales para usarlos cada vez que aclara las cosas. Para qx, qq y q, lo más probable es que use los operadores {}. El hábito más común de las personas que usan qw suele ser el operador (), pero a veces también se ve qw //.

No está realmente oculto, pero muchos programadores de Perl no saben todos los días acerca de CPAN . Esto se aplica especialmente a las personas que no son programadores a tiempo completo o que no programan en Perl a tiempo completo.

La declaración "for" se puede usar de la misma manera que "with" se usa en Pascal:

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

Puede aplicar una secuencia de s /// operaciones, etc. a la misma variable sin tener que repetir el nombre de la variable.

NOTA: el espacio que no se rompe arriba (& nbsp;) ha ocultado Unicode para evitar el Markdown. No copie y pegue :)

El operador quoteword es una de mis cosas favoritas. Comparar:

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

y

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

Mucho menos ruido, más fácil para la vista. Otra cosa realmente buena de Perl, que uno realmente echa de menos cuando escribe SQL, es que una coma final es legal:

print 1, 2, 3, ;

Eso parece extraño, pero no si sangra el código de otra manera:

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

Agregar un argumento adicional a la llamada a la función no requiere que juegues con comas en líneas anteriores o finales. El cambio de una sola línea no tiene impacto en sus líneas circundantes.

Esto hace que sea muy agradable trabajar con funciones variadas. Esta es quizás una de las características más subestimadas de Perl.

La capacidad de analizar datos directamente pegados en un bloque DATA . No es necesario guardar en un archivo de prueba para abrirlo en el programa o similar. Por ejemplo:

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

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

Nuevas operaciones de bloque

Yo diría que la capacidad de expandir el lenguaje, crear operaciones de pseudobloque es una.

1. Declaras el prototipo de un sub que indica que primero toma una referencia de código:

   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. Entonces puedes llamarlo así en el cuerpo

   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::Dumperes otra gema semi-oculta). Observe cómo no necesita la subpalabra clave frente al bloque o la coma antes del hash. Termina pareciéndose mucho a:map { } @list

Filtros de origen

Además, hay filtros de origen. Donde Perl te pasará el código para que puedas manipularlo. Tanto esto como las operaciones de bloque son prácticamente cosas que no se intentan en casa.

He hecho algunas cosas interesantes con filtros de origen, por ejemplo, crear un lenguaje muy simple para verificar el tiempo, permitiendo breves frases de Perl para tomar decisiones:

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

Lib::TL simplemente buscaría las "variables" y las constantes, las crearía y las sustituiría según fuera necesario.

Una vez más, los filtros de origen pueden ser desordenados, pero son potentes. Pero pueden confundir a los depuradores con algo terrible, e incluso las advertencias se pueden imprimir con los números de línea incorrectos. Dejé de usar Damian's Switch porque el depurador perdería toda capacidad de decirme dónde estaba realmente. Pero descubrí que puede minimizar el daño modificando pequeñas secciones de código, manteniéndolos en la misma línea.

Ganchos de señal

A menudo se hace lo suficiente, pero no es tan obvio. Aquí hay un manipulador de dados que se apoya en el viejo.

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

Eso significa que siempre que algún otro módulo en el código quiera morir, tienen que acudir a usted (a menos que alguien más realice una sobrescritura destructiva $SIG{__DIE__}). Y se le puede notificar que alguien piensa que algo es un error.

Por supuesto, para suficientes cosas puedes usar un END { }bloque, si todo lo que quieres hacer es limpiar.

overload::constant

Puede inspeccionar literales de cierto tipo en paquetes que incluyen su módulo. Por ejemplo, si usa esto en su importsub:

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

significará que cada entero mayor de 2 mil millones en los paquetes de llamadas se cambiará a un Math::BigIntobjeto. (Ver sobrecarga :: constante ).

Literales enteros agrupados

Mientras estamos en eso. Perl le permite dividir grandes números en grupos de tres dígitos y aún así obtener un número entero analizable. Nota 2_000_000_000arriba por 2 mil millones.

La "x" binaria es el operador de repetición :

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

También funciona con listas:

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

Comprobación de contaminación. Con la comprobación de contaminación habilitada, Perl morirá (o advertirá, con-t ) si intenta pasar datos contaminados (en términos generales, datos desde fuera del programa) a una función insegura (abrir un archivo, ejecutar un comando externo, etc.). Es muy útil al escribir scripts de setuid o CGI o cualquier cosa en la que el script tenga mayores privilegios que la persona que lo alimenta.

Goto mágico goto &subhace una cola optimizada.

El depurador.

use stricty use warnings. Estos pueden salvarte de un montón de errores tipográficos.

Según la forma en que se implementan los interruptores "-n"y "-p"en Perl 5, puede escribir un programa aparentemente incorrecto que incluya }{:

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

que se convierte internamente a este código:

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

Comencemos fácil con el operador de la 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 es una meta respuesta, pero los archivos de Consejos de Perl contienen todo tipo de trucos interesantes que se pueden hacer con Perl. El archivo de consejos anteriores está en línea para navegar, y se puede suscribir a través de una lista de correo o un feed de átomos.

Algunos de mis consejos favoritos incluyen la construcción de ejecutables con PAR , el uso de autodie para lanzar excepciones automáticamente y el uso del interruptor y las construcciones de coincidencia inteligente en Perl 5.10.

Divulgación: Soy uno de los autores y mantenedores de Perl Tips, por lo que obviamente los considero muy bien. ;)

map - no solo porque hace que el código sea más expresivo, sino porque me dio el impulso de leer un poco más sobre esta "programación funcional".

La cláusula continue en bucles. Se ejecutará en la parte inferior de cada bucle, incluso en los siguientes.

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

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

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

Mi voto sería para los grupos (? {}) Y (?? {}) en las expresiones regulares de Perl. El primero ejecuta el código Perl, ignorando el valor de retorno, el segundo ejecuta el código, utilizando el valor de retorno como una expresión regular.

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

El ancla \ G. Es caliente .

El m//operador tiene algunos casos especiales oscuros:

• Si lo usa ?como delimitador, solo coincide una vez, a menos que llame reset.
• Si lo usa 'como delimitador, el patrón no se interpola.
• Si el patrón está vacío, usa el patrón de la última coincidencia exitosa.

El operador de null filehandle diamond<> tiene su lugar en la construcción de herramientas de línea de comandos. Actúa como si se <FH>leyera desde un identificador, excepto que selecciona mágicamente lo que se encuentre primero: nombres de archivo de línea de comando o STDIN. Tomado de perlop:

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

Bloques de código especiales comoBEGIN , CHECKy END. Vienen de Awk, pero funcionan de manera diferente en Perl, porque no está basado en registros.

El BEGINbloque se puede usar para especificar algún código para la fase de análisis; también se ejecuta cuando realiza la verificación de sintaxis y variable perl -c. Por ejemplo, para cargar variables de configuración:

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

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

renombra data.txt.part a data.txt sin tener que repetirme.

Un poco oscuro es el "operador" tilde-tilde que fuerza el contexto escalar.

print ~~ localtime;

es lo mismo que

print scalar localtime;

y diferente de

print localtime;

empate, la interfaz de vinculación variable.

El "modo de desesperación" de las construcciones de control de bucle de Perl que hace que busquen en la pila para encontrar una etiqueta coincidente permite algunos comportamientos curiosos que Test :: More aprovecha, para bien o para mal.

SKIP: {
    skip() if $something;

    print "Never printed";
}

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

Ahí está el poco conocido archivo .pmc. "use Foo" buscará Foo.pmc en @INC antes de Foo.pm. Esto tenía la intención de permitir que el bytecode compilado se cargara primero, pero Module :: Compile aprovecha esto para almacenar en caché los módulos filtrados de origen para tiempos de carga más rápidos y una depuración más fácil.

La capacidad de convertir las advertencias en errores.

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

Eso es lo que puedo pensar en la parte superior de mi cabeza que no se ha mencionado.

El operador de cabra *:

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

o

sub foo {
    return @_;
}

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

Funciona porque la asignación de listas en contexto escalar produce el número de elementos en la lista que se asigna.

* Tenga en cuenta que no es realmente un operador