# Από Sed σε Perl

Ξέρετε το `sed`. Σκέφτεστε με όρους `s/old/new/`, στοχεύετε γραμμές με `/pattern/` και `$`, καταφεύγετε στο `-n` και στο `p` για επιλεκτική εκτύπωση, και στο `-i` για επιτόπια επεξεργασία αρχείων. Αυτός ο οδηγός αντιστοιχίζει καθεμία από αυτές τις συνήθειες στην Perl, ώστε να κρατήσετε κάθε αντανακλαστικό που έχετε και να αποκτήσετε τα πράγματα που το sed κάνει δύσκολα.

Η μία ιδέα που πρέπει να κρατήσετε από την πρώτη γραμμή: **η Perl είναι σχεδόν υπερσύνολο του sed για εργασίες κειμένου.** Ό,τι κάνει το sed, το κάνει και η Perl - συνήθως με την  *ίδια* σύνταξη `s///` - συν μια πραγματική μηχανή regex, πραγματικές μεταβλητές και αυθαίρετο κώδικα στην αντικατάσταση. Οι δύσχρηστες γωνιές του sed (ο χώρος συγκράτησης, τα κόλπα πολλαπλών γραμμών, οτιδήποτε μοιάζει με αριθμητική) γίνονται συνηθισμένη Perl που θα γράφατε χωρίς σκέψη. Αυτός ο οδηγός ξεκινά με τις ένα-προς-ένα αντιστοιχίσεις και στη συνέχεια δείχνει πού η Perl απλώς αφαιρεί έναν περιορισμό του sed.

Every runnable example here was executed on `pperl`, a Rust
reimplementation of Perl 5.42; the `# ...` comments
show its real output. Start scripts with:

```perl
use v5.42;
```

Αυτή η μία γραμμή ενεργοποιεί το `strict`, τα `warnings` και την ενσωματωμένη `say` (μια `print` με τελική νέα γραμμή), το σύγχρονο σύνολο χαρακτηριστικών που χρησιμοποιείται παντού.

#### NOTE
Διακόπτες one-liner σε αυτό το build του pperl Ο φυσικός δίδυμος του sed στην Perl είναι το one-liner: `perl -ne` και `perl -pe`. Αυτοί οι διακόπτες είναι **σωστή perl5 5.42** και εμφανίζονται σε όλον αυτόν τον οδηγό ως η ιδιωματική μορφή. Όμως η οικογένεια διακοπτών έμμεσου βρόχου (`-n`, `-p`, `-a`, `-F`, `-i`, `-l`) **δεν αναγνωρίζεται ακόμη από αυτό το build του `pperl`** - μόνο το `-e` αναγνωρίζεται. Έτσι τα παραδείγματα one-liner παρακάτω εμφανίζονται  *χωρίς* έξοδο, και καθένα συνοδεύεται από μια μορφή πλήρους σεναρίου με ρητό βρόχο (`while (<$fh>) { ... }`) που **όντως** τρέχει στο `pperl` σήμερα και φέρει την επαληθευμένη έξοδο. Χρησιμοποιήστε τη μορφή πλήρους σεναρίου μέχρι να προστεθούν οι διακόπτες.

## Πώς να το διαβάσετε

- [Ο κύκλος γραμμής]() - ο έμμεσος βρόχος του sed γίνεται `while (<$fh>)` και `$_`.
- [Αντικατάσταση: `s///`]() - ο ίδιος χειριστής, με πραγματικό regex.
- [Μεταγραμματισμός: το `y///` γίνεται `tr///`]() - η εντολή `y`, μετονομασμένη.
- [Διευθύνσεις και εύρη]() - αριθμοί γραμμών, μοτίβα και `/a/ .. /b/`.
- [Διαγραφή, εκτύπωση, έξοδος: `d`, `p`, `q`]() - `next`, `print`, `last`.
- [Ο χώρος συγκράτησης γίνεται μεταβλητή]() - εκεί που το sed είναι δύσκολο και η Perl τετριμμένη.
- [Επιτόπια επεξεργασία και I/O]() - `-i`, ανάγνωση αρχείων, σωληνώσεις.
- [One-liners και διακόπτες]() - `-n`, `-p`, `-e`, `BEGIN`/`END`.
- [Παγίδες ερχόμενοι από το sed]() - ρίξτε μια ματιά πριν γράψετε.

## Ο κύκλος γραμμής

Το sed τρέχει το σενάριό σας μία φορά ανά γραμμή εισόδου, με την τρέχουσα γραμμή στον χώρο μοτίβου του, και εκτυπώνει τον χώρο μοτίβου στο τέλος του κύκλου (εκτός αν δοθεί `-n`). Το αντίστοιχο της Perl είναι ένας ρητός βρόχος με τη γραμμή στο `$_`, την έμμεση μεταβλητή θέματος. Ο διακόπτης `-p` αναπαράγει το «αυτόματη εκτύπωση κάθε γραμμής»· το `-n` αναπαράγει το «μην εκτυπώσεις τίποτα εκτός αν το πω».

```sed
sed 's/bar/BAR/' input.txt
```

```perl
perl -pe 's/bar/BAR/' input.txt
```

Η εκτελέσιμη μορφή πλήρους σεναρίου του ίδιου βρόχου - αυτή που τρέχει στο `pperl` σήμερα - ανοίγει το αρχείο και το διατρέχει ρητά. Το `$_` είναι η τρέχουσα γραμμή, ακριβώς όπως ο χώρος μοτίβου του sed:

```perl
use v5.42;
open my $fh, '<', '/tmp/data.txt' or die "open: $!";
while (<$fh>) {           # each line lands in $_
    s/a/A/g;              # operate on $_ by default
    print;               # print $_ (note: keeps the newline)
}
# Apple
# bAnAnA
# cherry
```

(Το αρχείο εισόδου περιείχε `apple`, `banana`, `cherry`.) Η παγίδα: μια γραμμή που διαβάζεται με `<$fh>` κρατά την τελική νέα γραμμή της, ακριβώς όπως ο χώρος μοτίβου του sed. Η `print` χωρίς όρισμα εκτυπώνει το `$_` συμπεριλαμβανομένης αυτής της νέας γραμμής, οπότε μεταφέρεται καθαρά· κάντε `chomp` μόνο όταν σκοπεύετε να την αφαιρέσετε. Ο αριθμός γραμμής βρίσκεται στο `$.`, το αντίστοιχο στο sed του μετρητή γραμμών στον οποίο καταφεύγετε με το `$=` σε σενάρια GNU sed.

## Αντικατάσταση: `s///`

Αυτός είναι ο τίτλος: **το `s///` του sed και το `s///` της Perl είναι ο ίδιος χειριστής.** Και οι σημαίες ταιριάζουν - το `g` είναι καθολικό, το `i` αγνοεί πεζά/κεφαλαία - και η Perl προσθέτει σημαίες για τις οποίες το sed δεν έχει αντίστοιχο.

```sed
sed 's/colou\?r/COLOR/g' input.txt
```

```perl
perl -pe 's/colou?r/COLOR/g' input.txt
```

Εξ ορισμού το `s///` επεξεργάζεται τον στόχο του επιτόπια και επιστρέφει το πλήθος των αντικαταστάσεων. Οι ομάδες σύλληψης είναι `$1`, `$2`, … και μπορείτε να εκτελέσετε **αυθαίρετο κώδικα** στην αντικατάσταση με τη σημαία `/e` - κάτι που το sed δεν μπορεί να κάνει καθόλου:

```perl
use v5.42;
my $s = "items: 3 and 4";
(my $t = $s) =~ s/(\d+)/$1 * 10/ge;   # /e: replacement is Perl code
say $t;                               # items: 30 and 40
```

Για να αναδιατάξετε συλλήψεις (τις οπισθοαναφορές `\1`, `\2` του sed στην αντικατάσταση), χρησιμοποιήστε `$1`, `$2` και, όταν θέλετε μια  *νέα* συμβολοσειρά αντί για επιτόπια επεξεργασία, τη σημαία `/r`, η οποία επιστρέφει το αποτέλεσμα και αφήνει το πρωτότυπο ανέγγιχτο:

```perl
use v5.42;
my $date = "2026-06-21";
my $us = $date =~ s{(\d+)-(\d+)-(\d+)}{$2/$3/$1}r;   # /r: return a copy
say $us;                                             # 06/21/2026
say $date;                                           # 2026-06-21
```

Η παγίδα: το γυμνό `s///` τροποποιεί τον στόχο του και επιστρέφει ένα  *πλήθος*, όχι τη νέα συμβολοσειρά. Γι” αυτό τα παραπάνω παραδείγματα είτε αντιγράφουν πρώτα (`(my $t = $s) =~ s/.../.../`) είτε χρησιμοποιούν το `/r`. Γράφοντας `my $new = ($s =~ s/a/b/)` βάζετε το πλήθος των αντικαταστάσεων στο `$new`, όχι την επεξεργασμένη συμβολοσειρά - μια κλασική έκπληξη της πρώτης μέρας. Σημειώστε επίσης ότι οι οριοθέτες της Perl είναι ελεύθεροι: τα `s{...}{...}` και `s#...#...#` αποφεύγουν τις ανάποδες καθέτους στις καθέτους ενός μοτίβου διαδρομής.

## Μεταγραμματισμός: το `y///` γίνεται `tr///`

Το `y/abc/xyz/` του sed είναι το `tr/abc/xyz/` της Perl. Η Perl κρατά το `y///` ως ακριβές ψευδώνυμο, οπότε το `y/a-z/A-Z/` λειτουργεί αυτολεξεί, αλλά το `tr` είναι το όνομα που θα δείτε γραμμένο στον κώδικα Perl.

```sed
sed 'y/abc/xyz/' input.txt
```

```perl
use v5.42;
my $s = "hello";
(my $t = $s) =~ tr/a-z/A-Z/;   # uppercase, like y/a-z/A-Z/
say $t;                        # HELLO
```

Το `tr` κάνει επίσης πράγματα που το `y` δεν μπορεί. Με κενή αντικατάσταση  *μετρά* αντιστοιχίες, και ο τροποποιητής `s` συμπτύσσει διαδοχές ενός χαρακτήρα - το συνηθισμένο ιδίωμα `tr -s`:

```perl
use v5.42;
my $s = "hello";
my $vowels = ($s =~ tr/aeiou//);   # count, replacement empty
say $vowels;                       # 2

my $dots = "a....b...c";
(my $squeezed = $dots) =~ tr/././s; # squeeze repeats
say $squeezed;                      # a.b.c
```

Η παγίδα: το `tr///` **δεν** είναι regex - η αριστερή πλευρά είναι ένα κυριολεκτικό σύνολο χαρακτήρων, το ίδιο με το `y` του sed. Το `tr/a-z//` σημαίνει το εύρος `a` έως `z`, αλλά το `tr/.*//` σημαίνει τους δύο κυριολεκτικούς χαρακτήρες `.` και `*`, όχι «οποιαδήποτε συμβολοσειρά». Για εργασία με μοτίβα, καταφύγετε στο `s///`. Και όπως το `s///`, το `tr///` επεξεργάζεται επιτόπια και επιστρέφει ένα πλήθος, οπότε αντιγράψτε πρώτα ή χρησιμοποιήστε τη σημαία `/r` για έναν μη καταστροφικό μεταγραμματισμό.

## Διευθύνσεις και εύρη

Μια εντολή sed μπορεί να έχει πρόθεμα μια διεύθυνση: έναν αριθμό γραμμής, `$` για την τελευταία γραμμή, ένα `/pattern/`, ή ένα εύρος `addr1,addr2`. Στην Perl μια διεύθυνση είναι απλώς μια συνθήκη στην εντολή - ένα μεταθεματικό `if`. Ο αριθμός γραμμής είναι `$.`· ο έλεγχος μοτίβου είναι `/pat/` έναντι του `$_`· η τελευταία γραμμή είναι `eof`.

```sed
sed -n '2p' input.txt              # print line 2
sed -n '/banana/p' input.txt       # print matching lines
```

```perl
use v5.42;
open my $fh, '<', '/tmp/data.txt' or die "open: $!";
while (<$fh>) {
    print if $. == 2;              # sed -n '2p'
}
# banana
```

Ένα εύρος sed `/start/,/end/` γίνεται ο χειριστής εύρους **flip-flop** της Perl `/start/ .. /end/`, ο οποίος είναι αληθής από τη γραμμή που ταιριάζει με το αριστερό μοτίβο έως τη γραμμή που ταιριάζει με το δεξί, συμπεριλαμβανομένων:

```perl
use v5.42;
open my $fh, '<', '/tmp/data.txt' or die "open: $!";
while (<$fh>) {
    print if /banana/ .. /cherry/;  # sed '/banana/,/cherry/p' with -n
}
# banana
# cherry
```

Η παγίδα: σε έναν λογικό έλεγχο το `..` είναι ο χειριστής flip-flop (εύρους), **όχι** ο χειριστής εύρους λίστας (που είναι το `1 .. 10` που χτίζει μια λίστα). Η Perl τα ξεχωρίζει βάσει περιβάλλοντος - στη βαθμωτή/λογική θέση ενός `if`, το `..` είναι ο επιλογέας εύρους γραμμών που αντικατοπτρίζει το `addr1,addr2` του sed. Είναι με κατάσταση: θυμάται αν έχει δει το μοτίβο εκκίνησης, οπότε κάνει ακριβώς ό,τι κάνει ένα εύρος sed κατά μήκος του βρόχου.

## Διαγραφή, εκτύπωση, έξοδος: `d`, `p`, `q`

Οι μονογράμματες εντολές κύκλου του sed αντιστοιχίζονται σε δεσμευμένες λέξεις βρόχου της Perl. Το `d` (διαγραφή χώρου μοτίβου, μετάβαση στον επόμενο κύκλο) είναι `next`. Το `q` (έξοδος) είναι `last`. Το `p` (εκτύπωση) είναι `print`. Επειδή ο βρόχος της Perl είναι ρητός, διαβάζονται ακριβώς ως αυτό που κάνουν.

```sed
sed '/banana/d' input.txt          # drop matching lines
sed '/banana/q' input.txt          # stop after the match
```

```perl
use v5.42;
open my $fh, '<', '/tmp/data.txt' or die "open: $!";
while (<$fh>) {
    next if /banana/;              # sed '/banana/d'
    print;
}
# apple
# cherry
```

```perl
use v5.42;
open my $fh, '<', '/tmp/data.txt' or die "open: $!";
while (<$fh>) {
    print;
    last if /banana/;              # sed '/banana/q'
}
# apple
# banana
```

Η παγίδα: υπό την αυτόματη εκτύπωση τύπου `-p` του sed, το `d` πρέπει να παρακάμψει την αυτόματη εκτύπωση, κάτι που το κάνει ματαιώνοντας τον κύκλο. Σε έναν ρητό βρόχο Perl ελέγχετε εσείς την εκτύπωση, οπότε η «διαγραφή» είναι απλώς το  *να μην εκτυπώσετε* τη γραμμή - `next if /pat/` πριν την `print`, ή φυλάξτε την `print` με `unless`. Δεν υπάρχει κρυφή αυτόματη εκτύπωση να αντιπαλέψετε· ό,τι εκτυπώνετε με `print` είναι ό,τι βγαίνει.

## Ο χώρος συγκράτησης γίνεται μεταβλητή

Αυτή είναι η ενότητα όπου το sed παύει να είναι βολικό και η Perl παύει να είναι δύσκολη. Το sed έχει ακριβώς έναν βοηθητικό ενταμιευτή - τον χώρο συγκράτησης - και μετακινεί δεδομένα σε αυτόν με `h`, `H`, `g`, `G`, `x`. Οτιδήποτε χρειάζεται δύο κομμάτια αποθηκευμένης κατάστασης μετατρέπεται σε ακροβατικά χώρου συγκράτησης. Στην Perl απλώς δηλώνετε μια μεταβλητή. Ή έναν πίνακα. Ή έναν κατακερματισμό.

Η κατεξοχήν άσκηση χώρου συγκράτησης είναι η αντιστροφή ενός αρχείου (`tac`), που στο sed είναι ένα αδιαφανές ξόρκι `1!G;h;$!d`. Στην Perl είναι μία προφανής γραμμή:

```sed
sed -n '1!G;h;$!d' input.txt       # reverse the file (tac)
```

```perl
use v5.42;
open my $fh, '<', '/tmp/data.txt' or die "open: $!";
my @hold;                          # the "hold space" is just an array
while (<$fh>) {
    unshift @hold, $_;             # newest line to the front
}
print @hold;
# cherry
# banana
# apple
```

Η παγίδα: δεν υπάρχει παγίδα - αυτό ακριβώς είναι το νόημα. Μόλις έχετε πραγματικές μεταβλητές, εξαφανίζεται ολόκληρη η κατηγορία προβλημάτων του sed που υπάρχουν μόνο επειδή υπάρχει ένας μοναδικός χώρος συγκράτησης. Χρειάζεται να θυμάστε την προηγούμενη γραμμή; `my $prev`. Χρειάζεστε ένα τρέχον άθροισμα; `my $sum`. Χρειάζεται να αφαιρέσετε διπλότυπα; Ένας κατακερματισμός `my %seen`. Όταν ένα σενάριο sed καταφεύγει στα `h`/`H`/`x`, η μετάφραση σε Perl είναι σχεδόν πάντα «εισάγετε μια επώνυμη μεταβλητή και γράψτε το προφανές».

## Επιτόπια επεξεργασία και I/O

Το `-i` του sed ξαναγράφει ένα αρχείο επιτόπια. Η ιδιωματική Perl είναι ο ίδιος διακόπτης σε ένα one-liner `-p`. Η ανάγνωση πολλών αρχείων είναι η προεπιλογή του sed· η Perl το γράφει `<>`, ο χειριστής διαμαντιού, ο οποίος διαβάζει με τη σειρά κάθε αρχείο που ονομάζεται στο `@ARGV`.

```sed
sed -i 's/red/crimson/' file.txt   # edit in place
```

```perl
perl -i -pe 's/red/crimson/' file.txt
```

Το εκτελέσιμο αντίστοιχο σήμερα είναι μια ρητή ανάγνωση-τροποποίηση-εγγραφή: ρουφήξτε τις γραμμές, μετασχηματίστε τις, γράψτε τις πίσω. Αυτό ακριβώς κάνει το `-i` στο παρασκήνιο, και τρέχει στο `pperl` τώρα:

```perl
use v5.42;
my $path = '/tmp/inplace_data.txt';   # holds: red green blue

open my $in, '<', $path or die "read: $!";
my @lines = <$in>;                    # slurp all lines (list context)
close $in;

s/e/E/g for @lines;                   # transform each line's $_

open my $out, '>', $path or die "write: $!";
print {$out} @lines;                  # write them back
close $out;
# file now holds:
# rEd
# grEEn
# bluE
```

Για σωληνώσεις - sed στη μέση μιας σωλήνωσης κελύφους - η Perl ανοίγει έναν περιγραφέα σωλήνωσης απευθείας: το `open my $fh, '-|', 'ls', '-l'` διαβάζει την έξοδο μιας εντολής, και το `open my $fh, '|-', 'sort'` γράφει στην είσοδο μιας εντολής. Η παγίδα: η `open` επιστρέφει ψευδές σε αποτυχία αντί να εγείρει σφάλμα, οπότε το ιδίωμα `or die "...: $!"` είναι υποχρεωτικό - το `$!` είναι η συμβολοσειρά σφάλματος του συστήματος, η σιωπηλή αποτυχία του sed γινόμενη ρητή. Και η ανάγνωση πολλών αρχείων με `<>` μηδενίζει το `$.` ανά αρχείο μόνο αν ελέγξετε ρητά το `eof`· το σκέτο `$.` συνεχίζει να μετρά σε όλο το συνενωμένο ρεύμα.

## One-liners και διακόπτες

Το one-liner είναι το οικείο έδαφος του sed, και της Perl επίσης. Η οικογένεια διακοπτών που το κάνει να λειτουργεί: το `-e` παρέχει το πρόγραμμα, το `-n` το τυλίγει σε έναν βρόχο χωρίς αυτόματη εκτύπωση (το `-n` του sed), το `-p` το τυλίγει σε έναν βρόχο με αυτόματη εκτύπωση (η προεπιλογή του sed), το `-i` επεξεργάζεται επιτόπια, το `-l` χειρίζεται τα τέλη γραμμών, και τα `-a`/`-F` αυτοδιαχωρίζουν κάθε γραμμή σε `@F` (έδαφος του awk, χρήσιμο εδώ για επεξεργασίες πεδίων). Τα μπλοκ `BEGIN { }` και `END { }` τρέχουν πριν και μετά τον βρόχο, το άμεσο αντίστοιχο των κόλπων αρχικοποίησης-και-τερματισμού `1i`/`$a` του sed.

```sed
sed -n '/error/p' log.txt                  # print error lines
sed 's/[0-9]\+/N/g' input.txt              # mask numbers
```

```perl
perl -ne 'print if /error/' log.txt        # print error lines
perl -pe 's/\d+/N/g' input.txt             # mask numbers
perl -nE 'END { say $n } $n++ if /error/' log.txt   # count, BEGIN/END
```

Αυτά εμφανίζονται χωρίς έξοδο επειδή οι διακόπτες έμμεσου βρόχου δεν αναγνωρίζονται ακόμη από αυτό το build του `pperl` (δείτε τη σημείωση στην αρχή). Καθένας αντιστοιχίζεται σε μια επαληθευμένη μορφή ρητού βρόχου: το `perl -ne 'CODE'` είναι `while (<$fh>) { CODE }`, και το `perl -pe 'CODE'` είναι το ίδιο με μια τελική `print`. Η εκτελέσιμη μορφή «μέτρησε γραμμές σφάλματος»:

```perl
use v5.42;
open my $fh, '<', '/tmp/data.txt' or die "open: $!";
my $n = 0;
while (<$fh>) {
    $n++ if /banana/;          # the body of -ne
}
say $n;                        # 1
```

Η παγίδα: μέχρι να προστεθούν οι διακόπτες στο `pperl`, γράψτε τον ρητό βρόχο (τρέχει σήμερα και είναι ούτως ή άλλως αυτό στο οποίο αναπτύσσονται οι διακόπτες), και συμβουλευτείτε τον [οδηγό One-Liners](../oneliner/index.md) για τον πλήρη κατάλογο διακοπτών και δεκάδες συνταγές - είναι το πιο αποδοτικό πράγμα που μπορείτε να διαβάσετε ερχόμενοι από υπόβαθρο sed. Η Perl έχει επίσης πλήρεις υπορουτίνες, αναφορές, αρθρώματα και OO αν το σενάριό σας ξεπεράσει ένα one-liner· δείτε τον [οδηγό Αντικειμενοστραφούς Προγραμματισμού](../oop/index.md) για αυτήν την πλευρά της γλώσσας.

## Παγίδες ερχόμενοι από το sed

Οι παγίδες, συγκεντρωμένες για μια τελική ματιά πριν γράψετε:

- **Το `s///` επιστρέφει ένα πλήθος, όχι τη νέα συμβολοσειρά.** Το `my $x = $s =~ s/a/b/` βάζει το  *πλήθος* αντικαταστάσεων στο `$x`. Αντιγράψτε πρώτα (`(my $t = $s) =~ s/.../.../`) ή χρησιμοποιήστε τη σημαία `/r` για να πάρετε μια νέα συμβολοσειρά.
- **Το `tr///` (το `y` του sed) είναι ένα κυριολεκτικό σύνολο χαρακτήρων, όχι regex.** Το `tr/.*//` ταιριάζει τους δύο χαρακτήρες `.` και `*`. Για μοτίβα, χρησιμοποιήστε `s///`.
- **Το `..` σε λογικό περιβάλλον είναι το εύρος flip-flop, όχι εύρος λίστας.** Σε ένα `if`, το `/a/ .. /b/` είναι ο επιλογέας `addr1,addr2` του sed· το `1 .. 10` σε περιβάλλον λίστας χτίζει μια λίστα. Ίδιος χειριστής, που αποφασίζεται βάσει περιβάλλοντος.
- **Το `<$fh>` κρατά την τελική νέα γραμμή,** όπως ο χώρος μοτίβου του sed. Η `print` τη μεταφέρει· κάντε `chomp` μόνο όταν εννοείτε να την αφαιρέσετε.
- **Δεν υπάρχει κρυφή αυτόματη εκτύπωση.** Η προεπιλογή `-p` του sed είναι κάτι που γράφετε εσείς οι ίδιοι με `print`. Το «διέγραψε μια γραμμή» είναι απλώς το να μην την εκτυπώσετε (`next if /pat/`), όχι μια ειδική εντολή.
- **Η `open` δεν εγείρει σφάλμα σε αποτυχία.** Χρησιμοποιήστε `open my $fh, '<', $path or die "...: $!"`. Το `$!` είναι η συμβολοσειρά σφάλματος του συστήματος.
- **Ο χώρος συγκράτησης χάθηκε - χρησιμοποιήστε μια μεταβλητή.** Κάθε σενάριο sed που καταφεύγει στα `h`/`H`/`x` μεταφράζεται σε μια επώνυμη μεταβλητή, πίνακα ή κατακερματισμό της Perl. Αυτό είναι απλοποίηση, όχι απώλεια.
- **Οι διακόπτες έμμεσου βρόχου (`-n`/`-p`/`-a`/`-F`/`-i`/`-l`) δεν αναγνωρίζονται ακόμη από αυτό το build του `pperl`.** Μόνο το `-e` λειτουργεί σήμερα. Γράψτε τον ρητό βρόχο `while (<$fh>) { ... }`, που είναι ακριβώς αυτό στο οποίο αναπτύσσονται οι διακόπτες, μέχρι να προστεθούν.