perlrequick - Online di Cloud

PROGRAM:

NAMA

perlrequick - Perl ekspresi reguler mulai cepat

DESKRIPSI

Halaman ini mencakup dasar-dasar pemahaman, pembuatan, dan penggunaan ekspresi reguler
('regex') di Perl.

Panduan

Sederhana kata sesuai
Regex paling sederhana hanyalah sebuah kata, atau lebih umum, serangkaian karakter. Sebuah ekspresi reguler
terdiri dari kata yang cocok dengan string apa pun yang berisi kata itu:

"Halo Dunia" =~ /Dunia/; # pertandingan

Dalam pernyataan ini, "Dunia" adalah regex dan "//" melampirkan "/ Dunia/" memberitahu Perl untuk
mencari string untuk kecocokan. Operator "=~" mengaitkan string dengan kecocokan regex
dan menghasilkan nilai true jika regex cocok, atau false jika regex tidak cocok. Di dalam
kasus kami, "Dunia" cocok dengan kata kedua dalam "Halo Dunia", jadi ekspresinya benar.
Ide ini memiliki beberapa variasi.

Ekspresi seperti ini berguna dalam conditional:

print "Ini cocok\n" jika "Halo Dunia" =~ /Dunia/;

Arti kecocokan dapat dibalik dengan menggunakan operator "!~":

print "Tidak cocok\n" jika "Halo Dunia" !~ /Dunia/;

String literal dalam regex dapat diganti dengan variabel:

$salam = "Dunia";
print "Cocok\n" if "Halo Dunia" =~ /$greeting/;

Jika Anda mencocokkan dengan $_, bagian "$_ =~" dapat dihilangkan:

$_ = "Halo Dunia";
print "Ini cocok\n" jika /Dunia/;

Terakhir, pembatas default "//" untuk pertandingan dapat diubah menjadi pembatas arbitrer dengan
menempatkan 'm' di depan:

"Halo Dunia" =~ m!Dunia!; # kecocokan, dipisahkan dengan '!'
"Halo Dunia" =~ m{Dunia}; # cocok, perhatikan '{}' yang cocok
"/usr/bin/Perl" =~ m"/perl"; # cocok setelah '/ usr / bin',
# '/' menjadi karakter biasa

Regex harus cocok dengan bagian dari string persis agar pernyataan menjadi benar:

"Halo Dunia" =~ /dunia/; # tidak cocok, peka huruf besar/kecil
"Halo Dunia" =~ /o W/; # cocok, ' ' adalah karakter biasa
"Halo Dunia" =~ /Dunia /; # tidak cocok, tidak ada '' di akhir

Perl akan selalu cocok pada titik sedini mungkin dalam string:

"Halo Dunia" =~ /o/; # cocok dengan 'o' di 'Halo'
"Topi itu berwarna merah" =~ /hat/; # cocok dengan 'topi' di 'Itu'

Tidak semua karakter bisa digunakan 'apa adanya' dalam pertandingan. Beberapa karakter, disebut
karakter meta, dicadangkan untuk digunakan dalam notasi regex. Metakarakter tersebut adalah

{}[]()^$.|*+?

Metakarakter dapat dicocokkan dengan meletakkan garis miring terbalik di depannya:

"2+2=4" =~ /2+2/; # tidak cocok, + adalah metakarakter
"2+2=4" =~ /2\+2/; # cocok, \+ diperlakukan seperti + . biasa
'C:\WIN32' =~ /C:\\WIN/; # pertandingan
"/usr/bin/Perl" =~ // usr/tempat sampah\/perl/; # pertandingan

Pada regex terakhir, garis miring '/' juga menjadi garis miring terbalik, karena digunakan untuk
membatasi regex.

Karakter ASCII yang tidak dapat dicetak diwakili oleh melarikan diri urutan. Contoh umum adalah
"\t" untuk tab, "\n" untuk baris baru, dan "\r" untuk carriage return. Byte sewenang-wenang adalah
diwakili oleh urutan escape oktal, misalnya, "\033", atau urutan escape heksadesimal,
misalnya, "\x1B":

"1000\t2000" =~ m(0\t2) # cocok
"cat" =~ /\143\x61\x74/ # cocok dengan ASCII, tapi
# cara aneh mengeja kucing

Regex diperlakukan sebagian besar sebagai string yang dikutip ganda, sehingga substitusi variabel berfungsi:

$foo = 'rumah';
'cathouse' =~ /cat$foo/; # pertandingan
'housecat' =~ /${foo}cat/; # pertandingan

Dengan semua regex di atas, jika regex cocok di mana saja dalam string, itu adalah
dianggap cocok. Untuk menentukan dimana itu harus cocok, kita akan menggunakan jangkar
metakarakter "^" dan "$". Jangkar "^" berarti cocok di awal string dan
jangkar "$" berarti cocok di akhir string, atau sebelum baris baru di akhir
rangkaian. Beberapa contoh:

"pembantu rumah tangga" =~ /penjaga/; # pertandingan
"pembantu rumah tangga" =~ /^penjaga/; # tidak cocok
"pembantu rumah tangga" =~ /keeper$/; # pertandingan
"pengurus rumah\n" =~ /keeper$/; # pertandingan
"pembantu rumah tangga" =~ /^pembantu rumah tangga$/; # pertandingan

Menggunakan karakter kelas-kelas
A karakter kelas memungkinkan satu set karakter yang mungkin, bukan hanya satu
karakter, untuk mencocokkan pada titik tertentu dalam regex. Kelas karakter dilambangkan dengan
kurung "[...]", dengan set karakter yang mungkin cocok di dalamnya. Berikut adalah beberapa
contoh:

/kucing/; # cocok dengan 'kucing'
/[bcr]di/; # cocok dengan 'kelelawar', 'kucing', atau 'tikus'
"abc" =~ /[taksi]/; # cocok dengan 'a'

Dalam pernyataan terakhir, meskipun 'c' adalah karakter pertama di kelas, yang paling awal
titik di mana regex bisa cocok adalah 'a'.

/[yY][eE][sS]/; # cocokkan 'ya' dengan cara yang tidak peka huruf besar-kecil
# 'ya', 'Ya', 'YA', dll.
/ya saya; # juga cocokkan 'ya' dengan cara yang tidak peka huruf besar-kecil

Contoh terakhir menunjukkan kecocokan dengan 'i' pengubah, yang membuat kasus pertandingan-
tidak peka.

Kelas karakter juga memiliki karakter biasa dan khusus, tetapi kumpulan karakter biasa dan
karakter khusus di dalam kelas karakter berbeda dari yang di luar karakter
kelas. Karakter khusus untuk kelas karakter adalah "-]\^$" dan dicocokkan menggunakan
melarikan diri:

/[\]c]def/; # cocok dengan ']def' atau 'cdef'
$x = 'bcr';
/[$x]di/; # cocok dengan 'kelelawar, 'kucing', atau 'tikus'
/[\$x]di/; # cocok dengan '$at' atau 'xat'
/[\\$x]di/; # cocok dengan '\at', 'kelelawar, 'kucing', atau 'tikus'

Karakter khusus '-' bertindak sebagai operator rentang dalam kelas karakter, sehingga
berat "[0123456789]" dan "[abc...xyz]" menjadi langsing "[0-9]" dan "[az]":

/item[0-9]/; # cocok dengan 'item0' atau ... atau 'item9'
/[0-9a-fA-F]/; # cocok dengan digit heksadesimal

Jika '-' adalah karakter pertama atau terakhir dalam kelas karakter, itu diperlakukan sebagai biasa
karakter.

Karakter khusus "^" di posisi pertama kelas karakter menunjukkan a dinegasikan
karakter kelas, yang cocok dengan karakter apa pun kecuali yang ada di dalam tanda kurung. Berdua dan
"[^...]" harus cocok dengan karakter, atau kecocokan akan gagal. Kemudian

/[^a]di/; # tidak cocok dengan 'aat' atau 'at', tetapi cocok
# semua 'kelelawar', 'kucing, '0at', '%at', dll.
/[^0-9]/; # cocok dengan karakter non-numerik
/[a^]di/; # cocok dengan 'aat' atau '^at'; di sini '^' biasa saja

Perl memiliki beberapa singkatan untuk kelas karakter umum. (Definisi ini adalah
yang digunakan Perl dalam mode aman ASCII dengan pengubah "/ a". Kalau tidak, mereka bisa menandingi banyak
lebih banyak karakter Unicode non-ASCII juga. Lihat "Urutan garis miring terbalik" di perlrecharclass
untuk detail.)

· \d adalah angka dan mewakili

[0-9]

· \s adalah karakter spasi putih dan mewakili

[\ \t\r\n\f]

· \w adalah karakter kata (alfanumerik atau _) dan mewakili

[0-9a-zA-Z_]

· \D adalah \d yang dinegasikan; itu mewakili karakter apa pun kecuali digit

[^0-9]

· \S adalah \s yang dinegasikan; itu mewakili karakter non-spasi apa pun

[^\s]

· \W adalah \w yang dinegasikan; itu mewakili karakter non-kata apa pun

[^\w]

· Periode '.' cocok dengan karakter apa pun kecuali "\n"

Singkatan "\d\s\w\D\S\W" dapat digunakan baik di dalam maupun di luar kelas karakter.
Berikut adalah beberapa yang digunakan:

/\d\d:\d\d:\d\d/; # cocok dengan format waktu jj:mm:dd
/[\d\s]/; # cocok dengan digit atau karakter spasi apa pun
/\w\W\w/; # cocok dengan kata char, diikuti oleh a
# char non-kata, diikuti oleh kata char
/..rt/; # cocok dengan dua karakter apa pun, diikuti oleh 'rt'
/akhir\./; # cocok dengan 'akhir'.
/akhir[.]/; # hal yang sama, cocok dengan 'akhir'.

kata jangkar "\b" cocok dengan batas antara karakter kata dan karakter non-kata
"\w\W" atau "\W\w":

$x = "Housecat mengkategorikan rumah dan kucing";
$x =~ /\bcat/; # cocok dengan kucing di 'catenates'
$x =~ /cat\b/; # cocok dengan kucing di 'housecat'
$x =~ /\bcat\b/; # cocok dengan 'kucing' di akhir string

Dalam contoh terakhir, akhir string dianggap sebagai batas kata.

Untuk pemrosesan bahasa alami (sehingga, misalnya, apostrof dimasukkan dalam kata-kata),
gunakan sebagai gantinya "\b{wb}"

"jangan" =~ / .+? \b{wb} /x; # cocok dengan seluruh string

Sesuai ini or bahwa
Kami dapat mencocokkan string karakter yang berbeda dengan alternasi karakter meta '|'. Untuk mencocokkan
"anjing" atau "kucing", kami membentuk regex "anjing|kucing". Seperti sebelumnya, Perl akan mencoba mencocokkan regex
pada titik sedini mungkin dalam string. Di setiap posisi karakter, Perl akan terlebih dahulu
coba cocokkan alternatif pertama, "anjing". Jika "anjing" tidak cocok, Perl akan mencoba
alternatif berikutnya, "kucing". Jika "kucing" tidak cocok, maka pertandingan gagal dan Perl
bergerak ke posisi berikutnya dalam string. Beberapa contoh:

"kucing dan anjing" =~ /kucing|anjing|burung/; # cocok dengan "kucing"
"kucing dan anjing" =~ /anjing|kucing|burung/; # cocok dengan "kucing"

Meskipun "anjing" adalah alternatif pertama di regex kedua, "kucing" dapat menandingi
sebelumnya dalam string.

"kucing" =~ /c|ca|kucing|kucing/; # cocok dengan "c"
"kucing" =~ /kucing|kucing|ca|c/; # cocok dengan "kucing"

Pada posisi karakter tertentu, alternatif pertama yang memungkinkan regex cocok untuk
berhasil akan menjadi salah satu yang cocok. Di sini, semua alternatif cocok pada string pertama
posisi, jadi pertandingan pertama.

Pengelompokan hal dan hirarkis sesuai
pengelompokan metacharacters "()" memungkinkan bagian dari regex diperlakukan sebagai satu unit.
Bagian dari regex dikelompokkan dengan melampirkannya dalam tanda kurung. ekspresi reguler
"house(cat|keeper)" berarti "rumah" yang cocok diikuti oleh "kucing" atau "penjaga". Lebih lagi
contohnya adalah

/(a|b)b/; # cocok dengan 'ab' atau 'bb'
/(^a|b)c/; # cocok dengan 'ac' di awal string atau 'bc' di mana saja

/rumah(kucing|)/; # cocok dengan 'housecat' atau 'house'
/rumah(kucing(s|)|)/; # cocok dengan 'housecats' atau 'housecat' atau
# 'rumah'. Grup catatan dapat disarangkan.

"20" =~ /(19|20|)\d\d/; # cocok dengan alternatif nol '()\d\d',
# karena '20\d\d' tidak cocok

Ekstraksi korek api
Metakarakter pengelompokan "()" juga memungkinkan ekstraksi bagian-bagian string yang
cocok. Untuk setiap pengelompokan, bagian yang cocok di dalamnya masuk ke variabel khusus
$1, $2, dll. Mereka dapat digunakan sebagai variabel biasa:

# ekstrak jam, menit, detik
$waktu =~ /(\d\d):(\d\d):(\d\d)/; # cocok dengan format jj:mm:dd
$jam = $1;
$menit = $2;
$detik = $3;

Dalam konteks daftar, kecocokan "/ regex/" dengan pengelompokan akan mengembalikan daftar nilai yang cocok
"($1,$2,...)". Jadi kita bisa menulis ulang sebagai

($jam, $menit, $detik) = ($waktu =~ /(\d\d):(\d\d):(\d\d)/);

Jika pengelompokan dalam regex bersarang, $1 mendapatkan grup dengan pembukaan paling kiri
kurung, $2 kurung buka berikutnya, dll. Misalnya, berikut adalah ekspresi reguler yang kompleks
dan variabel yang cocok ditunjukkan di bawahnya:

/(ab(cd|ef)((gi)|j))/;
1 2 34

Terkait dengan variabel yang cocok $1, $2, ... adalah referensi balik "\g1", "\g2",
... Referensi balik adalah variabel yang cocok yang dapat digunakan dalam sebuah ekspresi reguler:

/(\w\w\w)\s\g1/; # temukan urutan seperti 'the' dalam string

$1, $2, ... hanya boleh digunakan di luar regex, dan "\g1", "\g2", ... hanya di dalam a
ekspresi reguler

Sesuai pengulangan
pembilang metakarakter "?", "*", "+", dan "{}" memungkinkan kita untuk menentukan jumlah
pengulangan sebagian dari regex yang kami anggap cocok. Kuantifier diletakkan
segera setelah karakter, kelas karakter, atau pengelompokan yang ingin kita tentukan.
Mereka memiliki arti sebagai berikut:

· "A?" = cocokkan 'a' 1 atau 0 kali

· "a*" = mencocokkan 'a' 0 kali atau lebih, yaitu berapa kali

· "a+" = mencocokkan 'a' 1 kali atau lebih, yaitu, setidaknya sekali

· "a{n,m}" = cocok setidaknya "n" kali, tetapi tidak lebih dari "m" kali.

· "a{n,}" = cocokkan setidaknya "n" atau lebih

· "a{n}" = sama persis dengan "n" kali

Berikut adalah beberapa contoh:

/[az]+\s+\d*/; # cocok dengan kata huruf kecil, setidaknya beberapa spasi, dan
# sejumlah digit
/(\w+)\s+\g1/; # cocokkan kata-kata ganda dengan panjang sewenang-wenang
$tahun =~ /^\d{2,4}$/; # pastikan tahun minimal 2 tetapi tidak lebih
# dari 4 digit
$tahun =~ /^\d{4}$|^\d{2}$/; # pertandingan yang lebih baik; buang tanggal 3 digit

Kuantifier ini akan mencoba mencocokkan sebanyak mungkin string, sambil tetap
memungkinkan regex untuk mencocokkan. Jadi kita punya

$x = 'kucing bertopi';
$x =~ /^(.*)(at)(.*)$/; # pertandingan,
# $1 = 'kucing di h'
# $2 = 'di'
# $3 = '' (0 cocok)

Kuantifier pertama ".*" mengambil string sebanyak mungkin sambil tetap memiliki
pertandingan ekspresi reguler. Kuantifier kedua ".*" tidak memiliki string tersisa, sehingga cocok 0 kali.

More sesuai
Ada beberapa hal lagi yang mungkin ingin Anda ketahui tentang operator pencocokan. Global
pengubah "//g" memungkinkan operator yang cocok untuk mencocokkan dalam string sebanyak
mungkin. Dalam konteks skalar, kecocokan berturut-turut terhadap string akan memiliki lompatan "//g"
dari pertandingan ke pertandingan, melacak posisi dalam string saat berjalan. Kamu bisa
dapatkan atau atur posisi dengan fungsi "pos()". Sebagai contoh,

$x = "rumah anjing kucing"; # 3 kata
sementara ($x =~ /(\w+)/g) {
print "Kata adalah $1, berakhir di posisi ", pos $x, "\n";
}

cetakan

Kata adalah kucing, berakhir di posisi 3
Word is dog, berakhir di posisi 7
Kata adalah rumah, berakhir di posisi 13

Kecocokan yang gagal atau mengubah string target mengatur ulang posisi. Jika Anda tidak ingin
reset posisi setelah gagal mencocokkan, tambahkan "//c", seperti pada "/ regex/gc".

Dalam konteks daftar, "//g" mengembalikan daftar pengelompokan yang cocok, atau jika tidak ada pengelompokan,
daftar kecocokan dengan seluruh regex. Jadi

@kata = ($x =~ /(\w+)/g); # pertandingan,
# $word[0] = 'kucing'
# $kata[1] = 'anjing'
# $kata[2] = 'rumah'

Cari dan menggantikan
Pencarian dan penggantian dilakukan menggunakan "s/regex/replacement/modifiers". Penggantian"
adalah string kutip ganda Perl yang menggantikan string apa pun yang cocok dengan
"regex". Operator "=~" juga digunakan di sini untuk mengaitkan string dengan "s///". Jika
cocok dengan $_, "$_ =~" dapat dihapus. Jika ada kecocokan, "s///" mengembalikan
jumlah pergantian pemain yang dilakukan; jika tidak, ia mengembalikan false. Berikut adalah beberapa contoh:

$x = "Waktunya memberi makan kucing!";
$x =~ s/cat/hacker/; # $x berisi "Waktunya memberi makan peretas!"
$y = "'kata-kata yang dikutip'";
$y =~ s/^'(.*)'$/$1/; # strip tanda kutip tunggal,
# $y berisi "kata-kata yang dikutip"

Dengan operator "s///", variabel yang cocok $1, $2, dll. segera tersedia
untuk digunakan dalam ekspresi pengganti. Dengan pengubah global, "s///g" akan mencari dan
ganti semua kemunculan regex dalam string:

$x = "Saya memukul 4 untuk 4";
$x =~ s/4/empat/; # $x berisi "Saya memukul empat untuk 4"
$x = "Saya memukul 4 untuk 4";
$x =~ s/4/empat/g; # $x berisi "Saya memukul empat untuk empat"

Pengubah non-destruktif "s///r" menyebabkan hasil substitusi dikembalikan
alih-alih memodifikasi $_ (atau variabel apa pun yang terikat dengan pengganti dengan "=~"):

$x = "Saya suka anjing.";
$y = $x =~ s/anjing/kucing/r;
print "$x $y\n"; # mencetak "Saya suka anjing. Saya suka kucing."

$x = "Kucing itu hebat.";
print $x =~ s/Kucing/Anjing/r =~ s/Anjing/Katak/r =~
s/Katak/Landak/r, "\n";
# mencetak "Landak itu hebat."

@foo = peta { s/[az]/X/r } qw(abc 1 2 3);
# @foo sekarang qw(XXX 1 2 3)

Pengubah evaluasi "s///e" membungkus "eval{...}" di sekitar string pengganti dan
hasil yang dievaluasi diganti dengan substring yang cocok. Beberapa contoh:

# membalikkan semua kata dalam sebuah string
$x = "kucing bertopi";
$x =~ s/(\w+)/balik $1/ge; # $x berisi "eht tac ni eht tah"

# konversi persentase ke desimal
$x = "Tingkat hit 39%";
$x =~ s!(\d+)%!$1/100!e; # $x berisi "Tingkat hit 0.39"

Contoh terakhir menunjukkan bahwa "s///" dapat menggunakan pembatas lain, seperti "s!!!" dan S{}{}",
dan bahkan "s{}//". Jika tanda kutip tunggal digunakan "s'''", maka ekspresi reguler dan penggantinya adalah
diperlakukan sebagai string yang dikutip tunggal.

membagi operator
"split /regex/, string" membagi "string" ke dalam daftar substring dan mengembalikan daftar itu.
Regex menentukan urutan karakter yang "string" dibagi sehubungan dengan. Untuk
contoh, untuk membagi string menjadi kata-kata, gunakan

$x = "Calvin dan Hobbes";
@kata = split /\s+/, $x; # $word[0] = 'Calvin'
# $kata[1] = 'dan'
# $word[2] = 'Hobbes'

Untuk mengekstrak daftar angka yang dipisahkan koma, gunakan

$x = "1.618,2.718, 3.142";
@const = split /,\s*/, $x; # $const[0] = '1.618'
# $const[1] = '2.718'
# $const[2] = '3.142'

Jika regex kosong "//" digunakan, string dipecah menjadi karakter individual. jika
regex memiliki pengelompokan, maka daftar yang dihasilkan berisi substring yang cocok dari
pengelompokan juga:

$x = "/ usr / bin";
@bagian = split m!(/)!, $x; # $parts[0] = ''
# $bagian[1] = '/'
# $parts[2] = 'usr'
# $bagian[3] = '/'
# $bagian[4] = 'tempat sampah'

Karena karakter pertama $x cocok dengan regex, "split" diawali dengan inisial kosong
elemen ke daftar.

"menggunakan re 'ketat'"
Baru di v5.22, ini menerapkan aturan yang lebih ketat daripada yang lain saat mengkompilasi ekspresi reguler
pola. Ia dapat menemukan hal-hal yang, meskipun legal, mungkin tidak sesuai dengan keinginan Anda.

Lihat 'ketat' di re.

Gunakan perlrequick online menggunakan layanan onworks.net