Perl Language
Cuerdas y métodos de citar.

Observaciones

Cotizaciones literales de cuerdas

Los literales de cadena no implican escape o interpolación (con la excepción de citar terminadores de cadena)

print 'This is a string literal\n'; # emits a literal \ and n to terminal

print 'This literal contains a \'postraphe '; # emits the ' but not its preceding \

Puedes usar mecanismos de cotización alternativos para evitar choques:

print q/This is is a literal \' <-- 2 characters /;  # prints both \ and '
print q^This is is a literal \' <-- 2 characters ^;  # also

Ciertos caracteres de comillas elegidos son "equilibrados"

print q{ This is a literal and I contain { parens! } }; # prints inner { }

Doble cita

Las cadenas de comillas dobles utilizan la interpolación y el escape , a diferencia de las cadenas de comillas simples. Para citar una cadena, use comillas dobles " o el operador qq .

my $greeting = "Hello!\n";
print $greeting;
# => Hello! (followed by a linefeed)

my $bush = "They misunderestimated me."
print qq/As Bush once said: "$bush"\n/;
# => As Bush once said: "They misunderestimated me." (with linefeed)

El qq es útil aquí, para evitar tener que escapar de las comillas. Sin él, tendríamos que escribir ...

print "As Bush once said: \"$bush\"\n";

... lo que no es tan bonito.

Perl no lo limita a la utilización de una barra / con qq ; Puedes usar cualquier caracter (visible).

use feature 'say';

say qq/You can use slashes.../;
say qq{...or braces...};
say qq^...or hats...^;
say qq|...or pipes...|;
# say qq ...but not whitespace. ;

También puede interpolar arrays en cadenas.

use feature 'say';

my @letters = ('a', 'b', 'c');
say "I like these letters: @letters.";
# => I like these letters: a b c.

Por defecto, los valores están separados por espacios, porque la variable especial $" predeterminada en un solo espacio. Esto, por supuesto, se puede cambiar.

use feature 'say';

my @letters = ('a', 'b', 'c');
{local $" = ", "; say "@letters"; }    # a, b, c

Si lo prefiere, tiene la opción de use English y cambiar $LIST_SEPARATOR en $LIST_SEPARATOR lugar:

use v5.18; # English should be avoided on older Perls
use English;

my @letters = ('a', 'b', 'c');
{ local $LIST_SEPARATOR = "\n"; say "My favourite letters:\n\n@letters" }

Para algo más complejo que esto, debes usar un bucle en su lugar.

say "My favourite letters:";
say;
for my $letter (@letters) {
  say " - $letter";
}

La interpolación no funciona con hashes.

use feature 'say';

my %hash = ('a', 'b', 'c', 'd');
say "This doesn't work: %hash"         # This doesn't work: %hash

Algunos códigos abusan de la interpolación de referencias - evítalo .

use feature 'say';

say "2 + 2 == @{[ 2 + 2 ]}";           # 2 + 2 = 4 (avoid this)
say "2 + 2 == ${\( 2 + 2 )}";          # 2 + 2 = 4 (avoid this)

El llamado "operador de carro" hace que perl se elimine la referencia @{ ... } la referencia de la matriz que contiene la [ ... ] expresión que desea interpolar, 2 + 2 . Cuando usas este truco, Perl construye una matriz anónima, luego la desactualiza y la descarta.

La versión ${\( ... )} es algo menos desperdiciadora, pero aún requiere asignar memoria y es aún más difícil de leer.

En su lugar, considere escribir:

• say "2 + 2 == " . 2 + 2;
• my $result = 2 + 2; say "2 + 2 == $result"

Heredocs

Las cadenas grandes de líneas múltiples son gravosas para escribir.

my $variable = <<'EOF';
this block of text is interpreted literally,
no \'quotes matter, they're just text
only the trailing left-aligned EOF matters.
EOF

NB: asegúrese de ignorar el resaltador de sintaxis de la pila de desbordamientos: está muy mal.

Y los Heredocs Interpolados funcionan de la misma manera.

my $variable = <<"I Want it to End";
this block of text is interpreted.
quotes\nare interpreted, and $interpolations
get interpolated... 
but still, left-aligned "I Want it to End" matters.
I Want it to End

Pendiente en 5.26.0 * es una sintaxis "Heredoc con sangría" que recorta el relleno izquierdo para usted

my $variable = <<~"MuchNicer";
    this block of text is interpreted.
    quotes\nare interpreted, and $interpolations
    get interpolated... 
    but still, left-aligned "I Want it to End" matters.
MuchNicer

Eliminando nuevas líneas finales

La función chomp eliminará un carácter de nueva línea, si está presente, de cada escalar que se le pasa. chomp mutará la cadena original y devolverá el número de caracteres eliminados

my $str = "Hello World\n\n";
my $removed = chomp($str);
print $str;     # "Hello World\n"
print $removed; # 1    

# chomp again, removing another newline
$removed = chomp $str;
print $str;     # "Hello World"
print $removed; # 1    

# chomp again, but no newline to remove
$removed = chomp $str;
print $str;     # "Hello World"
print $removed; # 0    

También puedes chomp más de una cadena a la vez:

my @strs = ("Hello\n", "World!\n\n"); # one newline in first string, two in second

my $removed = chomp(@strs); # @strs is now  ("Hello", "World!\n")
print $removed;             # 2

$removed = chomp(@strs); # @strs is now ("Hello", "World!")
print $removed;          # 1  

$removed = chomp(@strs); # @strs is still ("Hello", "World!")
print $removed;          # 0

Pero por lo general, a nadie le preocupa la cantidad de nuevas líneas que se eliminaron, por lo que chomp generalmente se ve en un contexto vacío, y generalmente debido a que se leyeron las líneas de un archivo:

while (my $line = readline $fh)
{
    chomp $line;

    # now do something with $line
}

my @lines = readline $fh2;

chomp (@lines); # remove newline from end of each line