¿Qué pseudo-operadores existen en Perl 5?

Actualmente estoy documentando todos los operadores de Perl 5 (vea el proyecto perlopref GitHub) y he decidido incluir los pseudo-operadores de Perl 5 también. Para mí, un pseudo-operador en Perl es cualquier cosa que se parece a un operador, pero en realidad es más de un operador o una pieza de syntax. Ya documenté los cuatro con los que estoy familiarizado:

  • ()= el operador de conteo
  • =()= el operador de cabras / conteo
  • ~~ el operador de contexto escalar
  • }{ el operador Eskimo-kiss

¿Qué otros nombres existen para estos pseudooperadores, y conoces algún pseudooperador que me haya perdido?

 =head1 Pseudo-operators There are idioms in Perl 5 that appear to be operators, but are really a combination of several operators or pieces of syntax. These pseudo-operators have the precedence of the constituent parts. =head2 ()= X =head3 Description This pseudo-operator is the list assignment operator (aka the countof operator). It is made up of two items C, and C. In scalar context it returns the number of items in the list X. In list context it returns an empty list. It is useful when you have something that returns a list and you want to know the number of items in that list and don't care about the list's contents. It is needed because the comma operator returns the last item in the sequence rather than the number of items in the sequence when it is placed in scalar context. It works because the assignment operator returns the number of items available to be assigned when its left hand side has list context. In the following example there are five values in the list being assigned to the list C, so C is assigned C. my $count = my ($x, $y, $z) = qw/abcde/; The empty list (the C part of the pseudo-operator) triggers this behavior. =head3 Example sub f { return qw/abcde/ } my $count = ()= f(); #$count is now 5 my $string = "cat cat dog cat"; my $cats = ()= $string =~ /cat/g; #$cats is now 3 print scalar( ()= f() ), "\n"; #prints "5\n" =head3 See also L and L =head2 X =()= Y This pseudo-operator is often called the goatse operator for reasons better left unexamined; it is also called the list assignment or countof operator. It is made up of three items C, C, and C. When X is a scalar variable, the number of items in the list Y is returned. If X is an array or a hash it it returns an empty list. It is useful when you have something that returns a list and you want to know the number of items in that list and don't care about the list's contents. It is needed because the comma operator returns the last item in the sequence rather than the number of items in the sequence when it is placed in scalar context. It works because the assignment operator returns the number of items available to be assigned when its left hand side has list context. In the following example there are five values in the list being assigned to the list C, so C is assigned C. my $count = my ($x, $y, $z) = qw/abcde/; The empty list (the C part of the pseudo-operator) triggers this behavior. =head3 Example sub f { return qw/abcde/ } my $count =()= f(); #$count is now 5 my $string = "cat cat dog cat"; my $cats =()= $string =~ /cat/g; #$cats is now 3 =head3 See also L and L =head2 ~~X =head3 Description This pseudo-operator is named the scalar context operator. It is made up of two bitwise negation operators. It provides scalar context to the expression X. It works because the first bitwise negation operator provides scalar context to X and performs a bitwise negation of the result; since the result of two bitwise negations is the original item, the value of the original expression is preserved. With the addition of the Smart match operator, this pseudo-operator is even more confusing. The C function is much easier to understand and you are encouraged to use it instead. =head3 Example my @a = qw/abcd/; print ~~@a, "\n"; #prints 4 =head3 See also L, L, and L =head2 X }{ Y =head3 Description This pseudo-operator is called the Eskimo-kiss operator because it looks like two faces touching noses. It is made up of an closing brace and an opening brace. It is used when using C as a command-line program with the C or C options. It has the effect of running X inside of the loop created by C or C and running Y at the end of the program. It works because the closing brace closes the loop created by C or C and the opening brace creates a new bare block that is closed by the loop's original ending. You can see this behavior by using the L module. Here is the command C deparsed: LINE: while (defined($_ = )) { print $_; } Notice how the original code was wrapped with the C loop. Here is the deparsing of C: LINE: while (defined($_ = )) { ++$count if /foo/; } { print "$count\n"; } Notice how the C loop is closed by the closing brace we added and the opening brace starts a new bare block that is closed by the closing brace that was originally intended to close the C loop. =head3 Example # count unique lines in the file FOO perl -nle '$seen{$_}++ }{ print "$_ => $seen{$_}" for keys %seen' FOO # sum all of the lines until the user types control-d perl -nle '$sum += $_ }{ print $sum' =head3 See also L and L =cut 

Buen proyecto, aquí hay algunos:

 scalar x!! $value # conditional scalar include operator (list) x!! $value # conditional list include operator 'string' x/pattern/ # conditional include if pattern "@{[ list ]}" # interpolate list expression operator "${\scalar}" # interpolate scalar expression operator !! $scalar # scalar -> boolean operator +0 # cast to numeric operator .'' # cast to string operator { ($value or next)->depends_on_value() } # early bail out operator # aka using next/last/redo with bare blocks to avoid duplicate variable lookups # might be a stretch to call this an operator though... sub{\@_}->( list ) # list capture "operator", like [ list ] but with aliases 

En Perl, estos se conocen generalmente como “operadores secretos”.

Aquí puede encontrar una lista parcial de “operadores secretos”. La mejor y más completa lista probablemente esté en posesión de Philippe Bruhad, alias BooK y sus Operadores Secretos de Perl, pero no sé de dónde está disponible. Podrías preguntarle. Probablemente puedas obtener más información de Ofuscación, Golf y Operadores Secretos .

No olvide Flaming X-Wing =<>=~ .

La lista de correo de Fun With Perl será útil para su investigación.

Los operadores “va a” y “se le acerca”

 $x = 10; say $x while $x --> 4; # prints 9 through 4 $x = 10; say $x while 4 < -- $x; # prints 9 through 5 

No son exclusivos de Perl.

A partir de esta pregunta , descubrí el operador %{{}} para lanzar una lista como hash. Útil en contextos donde se requiere un argumento hash (y no una asignación hash).

 @list = (a,1,b,2); print values @list; # arg 1 to values must be hash (not array dereference) print values %{@list} # prints nothing print values (%temp=@list) # arg 1 to values must be hash (not list assignment) print values %{{@list}} # success: prints 12 

Si @list no contiene ninguna clave duplicada (elementos impares), este operador también proporciona una forma de acceder a los elementos impares o pares de una lista:

 @even_elements = keys %{{@list}} # @list[0,2,4,...] @odd_elements = values %{{@list}} # @list[1,3,5,...] 

Los operadores secretos de Perl ahora tienen algunos documentos de referencia (casi oficiales, pero son “secretos”) sobre CPAN: perlsecret