Perl Language
Chaînes et méthodes de citation

Remarques

Citation littérale de chaîne

Les littéraux de chaîne n'impliquent aucune fuite ou interpolation (à l'exception des guillemets de fin de chaîne)

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 \

Vous pouvez utiliser d'autres mécanismes de citation pour éviter les conflits:

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

Certains caractères de citation choisis sont "équilibrés"

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

Double cotation

Les chaînes entre guillemets doubles utilisent l' interpolation et l' échappement , contrairement aux chaînes entre guillemets simples. Pour citer une chaîne entre guillemets, utilisez des guillemets doubles " ou l'opérateur 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)

Le qq est utile ici pour éviter de devoir échapper aux guillemets. Sans elle, il faudrait écrire ...

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

... ce qui n'est pas si beau

Perl ne vous limite pas à utiliser une barre oblique / avec qq ; vous pouvez utiliser n'importe quel caractère (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. ;

Vous pouvez également interpoler des tableaux en chaînes.

use feature 'say';

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

Par défaut, les valeurs sont séparées par des espaces - car la variable spéciale $" utilise par défaut un seul espace. Cela peut bien sûr être modifié.

use feature 'say';

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

Si vous préférez, vous avez la possibilité d' use English et de modifier $LIST_SEPARATOR place:

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" }

Pour quelque chose de plus complexe que cela, vous devriez utiliser une boucle à la place.

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

L'interpolation ne fonctionne pas avec les hachages.

use feature 'say';

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

Certains codes abusent de l'interpolation des références - évitez-le .

use feature 'say';

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

Le soi-disant "opérateur de panier" amène perl à déréférencer @{ ... } la référence de tableau qui [ ... ] contient l'expression que vous voulez interpoler, 2 + 2 . Lorsque vous utilisez cette astuce, Perl construit un tableau anonyme, puis le déréférencera et le supprimera.

La version ${\( ... )} est un peu moins coûteuse, mais il faut quand même allouer de la mémoire et la lecture est encore plus difficile.

Au lieu de cela, envisagez d'écrire:

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

Heredocs

Les grandes chaînes multi-lignes sont lourdes à écrire.

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: Assurez-vous d'ignorer le surligneur de syntaxe de dépassement de pile: c'est très faux.

Et Interpolated Heredocs fonctionne de la même manière.

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

En attente dans 5.26.0 * est une syntaxe "Indented Heredoc" qui coupe le remplissage à gauche pour vous

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

Supprimer les nouvelles lignes

La fonction chomp supprime un caractère de nouvelle ligne, s'il est présent, de chaque scalaire qui lui est transmis. chomp mutera la chaîne d'origine et retournera le nombre de caractères supprimés

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    

Vous pouvez également chomp plusieurs chaînes à la fois:

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

Mais généralement, personne ne s'inquiète du nombre de lignes supprimées, donc chomp est généralement vu dans un contexte vide et généralement dû à la lecture des lignes d'un fichier:

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