Substitusi

Operator s/// memasangkan kekuatan pencocokan pola dengan penggantian teks, sehingga bagian string yang cocok tidak hanya ditemukan, tetapi juga ditulis ulang. Topik ini membahas bentuk dasar s///, flag /g untuk mengganti seluruh kemunculan, flag /i serta pemakaian capture pada bagian penggantian, pemilihan delimiter lain, dan penyuntingan berkas langsung di tempat dengan perl -i.

Penggantian dengan s///#

Operator s/pola/pengganti/ mencari kecocokan pertama dari pola pada variabel di sebelah kiri operator =~, lalu menggantinya dengan teks pengganti. Berbeda dengan m// yang hanya menguji, s/// mengubah isi variabelnya secara langsung. Nilai kembaliannya berupa jumlah penggantian yang dilakukan, sehingga hasilnya dapat digunakan untuk menghitung seberapa sering pola ditemukan. Pemanggilan tanpa flag hanya menyentuh kecocokan pertama, dan perilaku menyeluruh pada string membutuhkan flag tersendiri yang dibahas tepat setelah ini. Skrip berikut memperlihatkan keduanya:

#!/usr/bin/env perl
use strict;
use warnings;

my $jadwal = "piket Senin di ruang 204";

# s/// mengganti kecocokan pertama pada variabel di kiri
$jadwal =~ s/Senin/Kamis/;
print "Setelah diganti: $jadwal\n";

# nilai kembalian s/// berupa jumlah penggantian
my $teks = "kopi dan kopi";
my $jumlah = ($teks =~ s/kopi/jus/);
print "Jumlah penggantian: $jumlah\n";
print "Isi teks: $teks\n";

Setelah diganti: piket Kamis di ruang 204
Jumlah penggantian: 1
Isi teks: jus dan kopi

Kata Senin tergantikan oleh Kamis dan sisanya dibiarkan utuh. Pada pengujian kedua, s/kopi/jus/ hanya mengganti kemunculan pertama meskipun kata kopi muncul dua kali, dan nilai kembalian 1 mencatat hal itu. Pola di bagian pencari boleh memuat metakarakter seperti pada m//, sehingga substitusi mewarisi seluruh kemampuan pencocokan pola yang sudah dibahas sebelumnya.

Apabila pola tidak ditemukan sama sekali, variabel di sebelah kiri tidak berubah dan nilai kembaliannya 0. Perilaku ini membuat pengujian jumlah penggantian menjadi cara ringkas untuk memastikan pola memang pernah ditemukan sebelum data diproses. Bentuk s/// juga menerima flag setelah delimiter penutupnya, dan flag-flag itulah yang dibahas pada bagian-bagian berikutnya.

Flag /g untuk seluruh kemunculan#

Tanpa tambahan, s/// berhenti setelah penggantian pertama. Flag /g (global) mengubah perilakunya menjadi mengganti seluruh kemunculan yang ditemukan. Flag ini ditulis setelah delimiter penutup, sehingga bentuknya s/kopi/jus/g. Skrip berikut membandingkan kedua perilaku tersebut pada string yang sama:

#!/usr/bin/env perl
use strict;
use warnings;

my $kalimat = "kopi, teh, kopi lagi, susu";

# tanpa /g hanya kecocokan pertama yang diganti
my $satu = $kalimat;
$satu =~ s/kopi/jus/;
print "Tanpa /g : $satu\n";

# flag /g mengganti seluruh kemunculan
my $semua = $kalimat;
$semua =~ s/kopi/jus/g;
print "Dengan /g: $semua\n";

Tanpa /g : jus, teh, kopi lagi, susu
Dengan /g: jus, teh, jus lagi, susu

Pada baris pertama, kemunculan kedua kopi tetap ada karena pencocokan berhenti lebih awal. Flag /g menggantikan keduanya sekaligus. Flag /g dapat digabung dengan flag lain seperti /i, sehingga s/Kopi/jus/gi mengganti seluruh kemunculan tanpa memandang huruf besar atau kecilnya.

Di balik layar, flag /g membuat mesin pencocokan melanjutkan pemindaian dari tempat kecocokan terakhir berakhir, dan bukan mengulang dari awal string. Perlu dicatat bahwa flag /g hanya mengubah banyaknya penggantian, sedangkan teks penggantinya tetap sama untuk setiap kemunculan. Bila setiap kemunculan membutuhkan pengganti yang berbeda, capture dan kode penggantian yang lebih kompleks diperlukan, seperti pada bagian berikutnya.

Nilai kembalian s/// dengan flag /g berupa jumlah seluruh penggantian yang dilakukan, sehingga s/kopi/jus/g pada skrip di atas mengembalikan angka dua. Angka ini sekaligus menjadi indikator keberhasilan, karena nilai nol berarti tidak ada satu pun kemunculan yang ditemukan. Perilaku tanpa /g yang berhenti setelah penggantian pertama membuat string dengan banyak kemunculan harus diproses berulang kali, sedangkan satu kali pemanggilan dengan /g sudah menyelesaikan seluruh string.

Flag /i dan capture pada penggantian#

Flag /i membuat pencocokan tidak peka huruf besar dan kecil, sehingga pola ali tetap menemukan ALI. Pada bagian penggantian, variabel capture $1, $2, dan seterusnya dari topik grup dan capture dapat digunakan ulang, sehingga potongan yang dicocokkan dapat disusun ulang menjadi bentuk baru. Kombinasi keduanya lazim pada perapian teks, misalnya mengubah penulisan nama yang kapitalisasinya tidak konsisten menjadi satu bentuk baku. Skrip berikut menggunakan keduanya untuk merapikan penulisan:

#!/usr/bin/env perl
use strict;
use warnings;

my $baris = "Piket: ALI";

# /i membuat pencocokan tidak peka huruf besar kecil
$baris =~ s/ali/Dewi/i;
print "Flag /i : $baris\n";

my $tanggal = "tanggal 09-11-2026";

# $1 hingga $3 dipakai kembali di bagian penggantian
$tanggal =~ s/(\d+)-(\d+)-(\d+)/$3-$2-$1/;
print "Format baru : $tanggal\n";

Flag /i : Piket: Dewi
Format baru : tanggal 2026-11-09

Pola tanggal menangkap tiga kelompok digit, lalu bagian penggantian $3-$2-$1 menyusunnya dari belakang ke depan, sehingga 09-11-2026 menjadi 2026-11-09. Bagian penggantian memperlakukan variabel tersebut seperti interpolasi string biasa.

Flag /i memperlakukan huruf besar dan kecil sebagai sama, sehingga pola ali menemukan ALI, Ali, maupun ali. Flag ini dapat ditumpuk dengan flag lain dalam satu urutan, misalnya /gi yang menggabungkan sifat global dan ketidakpekaan huruf. Pada bagian penggantian, teks di luar variabel capture ditulis apa adanya, sedangkan $1 dan kawan-kawannya diinterpolasi sebelum hasil penggantian ditempelkan. Bila string baru dibutuhkan tanpa mengubah variabel aslinya, flag /r mengembalikan hasil penggantian sebagai nilai kembalian:

# flag /r menghasilkan string baru tanpa mengubah variabel aslinya
perl -e 'use strict; use warnings; my $asal = "ruang 204"; my $baru = $asal =~ s/204/305/r; print "Asal: $asal\n"; print "Baru: $baru\n"' 2>&1

Asal: ruang 204
Baru: ruang 305

Delimiter lain#

Garis miring bukan satu-satunya delimiter yang diizinkan, dan s/// menerima delimiter apa pun selama ketiganya sama, misalnya s#...#...#. Bentuk yang paling sering digunakan untuk penggantian adalah s{...}{...}, yaitu pasangan kurung kurawal dengan pencari dan pengganti di tempat terpisah. Bentuk ini berguna ketika teks yang diperiksa memuat garis miring, seperti alamat jalur (path), karena garis miring tidak perlu di-escape satu per satu. Delimiter yang dipilih tidak memengaruhi makna polanya, sehingga pemilihannya murni pertimbangan keterbacaan berdasarkan karakter apa yang paling jarang muncul pada teks yang diperiksa:

# delimiter kurung kurawal menghindari escape pada garis miring
perl -e 'use strict; use warnings; my $path = "/usr/local/bin/perl"; $path =~ s{/usr/local}{/opt}; print "$path\n"' 2>&1

/opt/bin/perl

Dengan delimiter s{...}{...}, pola /usr/local ditulis tanpa satu pun garis miring terbalik. Bentuk yang sama dengan s/// harus ditulis s/\/usr\/local/\/opt/, yang jauh lebih sulit dibaca. Pemilihan delimiter adalah keputusan keterbacaan, dan bukan perubahan perilaku pencocokan.

Ketiga bentuk delimiter itu bekerja dengan aturan pencocokan yang sama. Delimiter tunggal seperti s#...#...# juga sah untuk kasus serupa, misalnya ketika teks yang diperiksa memuat tanda pagar. Satu program boleh menggunakan beberapa delimiter berbeda sesuai kebutuhan polanya, karena delimiter tidak memengaruhi hasil pencocokan sama sekali.

Penyuntingan berkas di tempat#

Kombinasi perl -i dengan s/// menyunting berkas teks langsung di tempat (in-place editing). Opsi -i membuat Perl memperlakukan setiap berkas dalam argumen sebagai masukan, lalu menulis kembali hasilnya ke berkas yang sama, sedangkan opsi -p mencetak setiap baris setelah dikerjakan. Dengan opsi -i.bak, isi asli tersimpan sebagai cadangan sebelum ditimpa, sehingga penyuntingan yang keliru masih dapat diperiksa dan dipulihkan. Blok berikut membuat berkas contoh, menjalankan penyuntingan, lalu menampilkan isinya:

# membuat berkas contoh daftar belanja
cat > belanja.txt <<'EOF'
3 beras
2 minyak goreng
5 gula
EOF

# perl -i -pe menyunting setiap baris berkas langsung di tempat
perl -i -pe 'use strict; use warnings; s/minyak goreng/minyak kelapa/' belanja.txt

# menampilkan isi berkas setelah penyuntingan
cat belanja.txt

3 beras
2 minyak kelapa
5 gula

Baris 2 minyak goreng berubah menjadi 2 minyak kelapa, dan perubahan itu tertulis permanen pada belanja.txt. Cara ini menjadi alternatif praktis untuk penyuntingan massal yang biasanya dilakukan di penyunting teks. Opsi -p membungkus skrip di dalam perulangan yang membaca setiap baris, mengerjakannya, lalu mencetaknya kembali, sehingga s/// cukup ditulis tanpa perulangan sendiri. Opsi -i juga menerima argumen akhiran, misalnya -i.bak, yang menyimpan salinan asli ke belanja.txt.bak sebelum menimpa berkas utama, sehingga menjadi pilihan yang lebih aman untuk berkas yang sulit dibuat ulang.

Ringkasan#

• s/pola/pengganti/ mengganti kecocokan pertama pada variabel kiri =~ dan mengembalikan jumlah penggantian.
• Flag /g mengganti seluruh kemunculan, sedangkan /i membuat pencocokan tidak peka huruf besar dan kecil.
• Capture $1 dan seterusnya dapat digunakan di bagian penggantian untuk menyusun ulang teks, dan flag /r mengembalikan hasil sebagai string baru.
• Delimiter dapat diganti, dengan s{...}{...} sebagai bentuk yang paling nyaman ketika teks memuat garis miring.
• perl -i -pe 's/.../.../' berkas menyunting berkas teks langsung di tempat dan hasilnya tertulis permanen.

Referensi#

• perlop — Perl documentation — Dokumentasi resmi operator s///, flag /g, /i, /r, dan delimiter lainnya.
• perlretut — Perl documentation — Tutorial resmi yang membahas substitusi dan pemakaian capture pada penggantian.
• perlrun — Perl documentation — Dokumentasi opsi -i dan -p untuk penyuntingan berkas di tempat.