Regex atau ungkapan biasa menakutkan untuk pemula, tetapi penting untuk mana-mana pengaturcara. Mari kita fahami ungkapan biasa menggunakan 5 contoh mudah dengan JavaScript.

Jika anda mempunyai masalah dan anda akan menyelesaikannya dengan ungkapan biasa, anda kini mempunyai dua masalah. Ada pepatah. Ungkapan biasa yang terdapat dalam kod kadangkala menyebabkan ketakutan dan kebencian pada orang yang tidak biasa dengannya.

Tetapi sebenarnya, mana-mana regex hanyalah ungkapan templat yang boleh menyelesaikan masalah keseluruhan fungsi dalam satu baris. Walau bagaimanapun, untuk membina ungkapan biasa, anda perlu mengambil kira satu set peraturan ketat yang seorang pemula boleh keliru dan membuat kesilapan.

Perwatakan yang sepadan

Ungkapan biasa yang paling asas ialah yang sepadan dengan aksara tunggal. Berikut adalah peraturan mereka:

1. Noktah (.) sepadan dengan mana-mana aksara. Jika anda perlu mencari titik tertentu, anda mesti melarikan diri menggunakan aksara “\” (\.).

2. Tanda soal (?) menunjukkan bahawa aksara sebelumnya adalah pilihan. Untuk mencari tanda soal itu sendiri dalam rentetan, ia juga mesti dilepaskan dengan "\" (\?).

var text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit lest. Donec convallis dignissim ligula, and rutrum est elat vistibulum eu."; // Kedua-dua "elit" dan "elat" akan berjaya. Titik itu bermakna Mana-mana akan lakukan simbol. var regex = /el.t/g; console.log(text.match(regex)); // "est" dan "lest" akan berfungsi dengan baik. Tanda soal menjadikan "l" sebagai pilihan. var regex2 = /l?est/g; console.log(text.match(regex2));

var text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit lest. Donec convallis dignissim ligula, and rutrum est elat vistibulum eu." ; // Kedua-dua "elit" dan "elat" akan berjaya. Titik bermakna sebarang simbol akan berfungsi. var regex = /el.t/g ; konsol. log(teks. padanan(regex)); // "est" dan "lest" akan berfungsi dengan baik. Tanda soal menjadikan "l" sebagai pilihan. var regex2 = /l?est/g ; konsol. log(teks. padankan(regex2));

Padankan berbilang aksara

Set ialah satu atau lebih aksara yang disertakan dalam kurungan, contohnya . Ungkapan sedemikian hanya akan mencari set aksara ini dalam rentetan - dalam dalam contoh ini hanya a, b atau c. Sebaliknya, anda boleh mencari kemunculan sebarang simbol kecuali menggunakan simbol “^”. [^abc] akan sepadan dengan mana-mana aksara yang bukan a, b atau c. Anda juga boleh menentukan julat aksara atau nombor, contohnya , .

Terdapat set aksara terbina dalam yang memudahkan untuk menulis ungkapan biasa. Mereka dipanggil singkatan atau trengkas. Sebagai contoh, anda boleh menulis \D sebaliknya. Terdapat singkatan untuk aksara lain (termasuk nombor dan garis bawah) - \w dan \W, serta untuk ruang - \s dan \S.

// Hanya "kucing" dan "can" akan berfungsi, bukan "kereta". var text = "kereta kucing boleh"; console.log(text.match(/ca/g)); // Semuanya akan berlalu kecuali kucing dan boleh (terdapat simbol ^) console.log(text.match(/ca[^tn]/g)); // Contoh lain di mana hanya nombor akan menghantar teks = "Saya ingin 8 cawan kopi, sila."; console.log("Berapa banyak cawan: " + text.match(//g)); // Cara lebih mudah menggunakan pintasan \d console.log("Berapa banyak cawan: " + text.match(/\d/g)); // Melepasi semua kecuali nombor console.log(text.match(/\D/g));

// Hanya "kucing" dan "can" akan berfungsi, bukan "kereta". var text = "kereta kucing boleh" ; konsol. log(teks. padankan(/ca/g)); // Melepasi segala-galanya kecuali kucing dan tin (terdapat simbol ^) konsol. log (teks . padankan (/ca[^tn]/g ) ); // Contoh lain di mana hanya nombor akan lulus text = "Saya ingin 8 cawan kopi, sila." ; konsol. log ("Berapa banyak cawan: " + teks . padankan (//g ) ); // Cara yang lebih mudah menggunakan pintasan \d konsol. log("Berapa banyak cawan: " + teks . padankan (/\d/g ) ); // Semuanya akan berlalu kecuali nombor konsol. log(teks. padankan(/\D/g));

Perkataan yang sepadan

Dalam kebanyakan kes anda perlu mencari keseluruhan perkataan dan bukannya watak individu. Ini dilakukan menggunakan pengubah suai (+) dan (-), yang mengulang aksara atau set aksara.

Menambah (X) menentukan bilangan ulangan yang tepat, (x, y) – julat (x dan y ialah nombor).

Selain itu, terdapat corak khas \b yang sepadan dengan sempadan di hujung perkataan.

var text = "Hello orang tahun 1974. Saya datang dari masa depan. Pada tahun 2014 kami mempunyai senjata laser, papan hover dan hidup di bulan!"; // Akan mencari tahun. \d+ akan memadankan satu atau lebih aksara var yearRegex = /\d+/g; console.log("Tahun: ", text.match(yearRegex)); // Mencari semua ayat. Ayat kita bermula dengan huruf besar dan diakhiri dengan noktah atau tanda seru. var sentenceRegex = /.+?(\.|!)/g; console.log("Ayat: ", text.match(sentenceRegex)); // Mencari semua perkataan yang bermula dengan "h". Kedua-dua huruf besar dan huruf kecil sesuai untuk kami, jadi kami menggunakan pengubah i // \b untuk mentakrifkan sempadan perkataan. var hWords = /\bh\w+/ig; console.log("H Words: ", text.match(hWords)); // Mencari semua perkataan daripada 4 hingga 6 aksara var findWords = /\b\w(4,6)\b/g; console.log("Perkataan antara 4 dan 6 aksara: ", text.match(findWords)); // Cari perkataan yang lebih panjang daripada 5 aksara console.log("Perkataan 5 aksara atau lebih panjang: ", text.match(/\b\w(5,)\b/g)); // Mencari perkataan tepat 6 aksara panjang console.log("Perkataan tepat 6 aksara panjang: ", text.match(/\b\w(6)\b/g));

var text = "Hello orang tahun 1974. Saya datang dari masa depan. Pada tahun 2014 kami mempunyai senapang laser, papan hover dan hidup di bulan!" ; // Akan mencari tahun. \d+ sepadan dengan satu atau lebih aksara var yearRegex = /\d+/g ; konsol. log ( "Tahun: " , teks . padanan ( yearRegex ) ); // Mencari semua ayat. Ayat kita bermula dengan huruf besar dan diakhiri dengan noktah atau tanda seru. var sentenceRegex = /.+?(\.|!)/g ; konsol. log("Ayat: ", text. match(sentenceRegex)); // Mencari semua perkataan yang bermula dengan "h". Kedua-dua huruf besar dan huruf kecil sesuai untuk kami, jadi kami menggunakan pengubah suai i // \b untuk menentukan sempadan perkataan. var hWords = /\bh\w+/i g ; konsol. log ( "H Perkataan: " , teks . padankan ( hWords ) ); // Mencari semua perkataan dari 4 hingga 6 aksara var findWords = /\b\w(4,6)\b/g ; konsol. log("Perkataan antara 4 dan 6 aksara: ", teks. padankan(cariKata)); // Cari perkataan yang lebih panjang daripada 5 aksara konsol. log ("Perkataan 5 aksara atau lebih panjang: " , teks . padankan (/\b\w(5,)\b/g ) ); // Cari perkataan sepanjang 6 aksara konsol. log ("Perkataan tepat 6 aksara panjang: " , teks . padankan (/\b\w(6)\b/g ) );

Pengesahan rentetan keseluruhan

Dalam JavaScript, ungkapan tersebut boleh digunakan untuk mengesahkan input pengguna daripada medan teks. Untuk mengesahkan rentetan, ungkapan biasa biasa digunakan, terikat pada permulaan dan penghujung serpihan teks, menggunakan ungkapan ^ (permulaan baris) dan $ (akhir baris) untuk tujuan ini. Simbol-simbol ini memastikan bahawa corak yang anda tulis merangkumi keseluruhan panjang teks dan bukan hanya sepadan dengan sebahagian daripadanya.

Selain itu, dalam kes ini, kami menggunakan kaedah test() objek regex, yang mengembalikan benar atau salah apabila menguji sama ada ungkapan biasa sepadan dengan rentetan.

// Kami mempunyai tatasusunan rentetan, mari cari pautan..com/", "123461", "https://site/?s=google", "http://not a valid url", "abc http: / /invalid.url/" ]; var regex = /^https?:\/\/[\w\/?.&-=]+$/; var url = ; for(var i = 0; i< strings.length; i++){ if(regex.test(strings[i])){ // Валидная ссылка urls.push(strings[i]); } } console.log("Valid URLs: ", urls);

// Kami mempunyai pelbagai rentetan, mari cari pautan. rentetan var = [ "https://site/" , "ini bukan URL" , "https://google.com/" , "123461" , "https://site/?s=google" , "http://bukan url yang sah" , "abc http://invalid.url/" var regex = / ^ https ? : \ / \ / [ \ w \ / ? . & -= ] + $ / ; var url = ; untuk (var i = 0 ; i< strings . length ; i ++ ) { if (ujian regex . (rentetan [ i ] ) ) ( url. tolak(rentetan[i]); konsol. log("URL yang sah: ", url);

Cari dan ganti

Satu lagi tugas biasa, yang difasilitasi oleh penggunaan ungkapan biasa, sedang mencari dan menggantikan teks.

Pengubah suai

Simbol tolak (-) diletakkan di sebelah pengubah suai (kecuali U) mencipta penolakannya.

Watak istimewa Penerangan Analog

()		subcorak, ungkapan bersarang
		kad bebas
(a,b)		bilangan kejadian daripada "a" hingga "b"
|		logik "atau", dalam kes penggunaan alternatif aksara tunggal
\		melarikan diri watak istimewa
.		sebarang watak kecuali suapan baris
\d		digit perpuluhan
\D	[^\d]	sebarang aksara selain daripada digit perpuluhan
\f		akhir (pemecahan halaman)
\n		terjemahan baris
\pL		huruf dalam pengekodan UTF-8 apabila menggunakan pengubah suai u
\r		pemulangan pengangkutan
\s	[\t\v\r\n\f]	watak angkasa
\S	[^\s]	sebarang simbol kecuali yang berkelip
\t		penjadualan
\w		sebarang nombor, huruf atau garis bawah
\W	[^\w]	sebarang aksara selain daripada nombor, huruf atau garis bawah
\v		tab menegak

Aksara khas dalam kelas aksaraPosition dalam rentetan Contoh Penerangan Pematuhan

^	^a	aaaaaa	permulaan baris
$	a$	aaa aaa	hujung baris
\A	\Aa	aaaaaa aaa aaa	permulaan teks
\z	a\z	aaa aaa aaa aaa	akhir teks
\b	a\b \ba	aaa aaa a aa aa	sempadan perkataan, pernyataan: watak sebelumnya adalah lisan, tetapi yang seterusnya tidak, atau sebaliknya
\B	\Ba\B	aa aa aa	tiada sempadan perkataan
\G	\Ga	aaa aaa	Pencarian berjaya sebelum ini, carian berhenti di kedudukan ke-4 - di mana a tidak ditemui

Muat turun dalam PDF, PNG. Anchors

Sauh dalam ungkapan biasa menunjukkan permulaan atau akhir sesuatu. Contohnya, baris atau perkataan. Mereka dibentangkan watak-watak tertentu. Sebagai contoh, corak yang sepadan dengan rentetan yang bermula dengan nombor akan kelihatan seperti ini:

Di sini aksara ^ menandakan permulaan baris. Tanpa itu, corak akan sepadan dengan mana-mana rentetan yang mengandungi digit.

Kelas watak

Kelas aksara dalam ungkapan biasa sepadan dengan set aksara tertentu sekaligus. Sebagai contoh, \d memadankan sebarang nombor daripada 0 hingga 9 termasuk, \w memadankan huruf dan nombor dan \W memadankan semua aksara selain huruf dan nombor. Corak mengenal pasti huruf, nombor dan ruang kelihatan seperti ini:

POSIX

POSIX ialah tambahan yang agak baharu kepada keluarga ekspresi biasa. Ideanya, seperti kelas aksara, adalah menggunakan pintasan yang mewakili beberapa kumpulan aksara.

Kenyataan

Hampir semua orang menghadapi masalah memahami peneguhan pada mulanya, tetapi apabila anda semakin mengenalinya, anda akan mendapati diri anda sering menggunakannya. Penegasan menyediakan cara untuk mengatakan, "Saya ingin mencari setiap perkataan dalam dokumen ini yang mengandungi huruf "q" dan tidak diikuti dengan "werty".

[^\s]*q(?!werty)[^\s]*

Kod di atas bermula dengan mencari sebarang aksara selain daripada ruang ([^\s]*) diikuti dengan q . Penghurai kemudiannya mencapai penegasan yang berpandangan ke hadapan. Ini secara automatik menjadikan elemen sebelumnya (watak, kumpulan atau kelas aksara) bersyarat—ia akan sepadan dengan corak hanya jika pernyataan itu benar. Dalam kes kita, pernyataan itu negatif (?!), iaitu, ia akan menjadi benar jika apa yang dicari di dalamnya tidak dijumpai.

Jadi, penghurai menyemak beberapa aksara seterusnya terhadap corak yang dicadangkan (werty). Jika mereka ditemui, maka pernyataan itu adalah palsu, yang bermaksud aksara q akan "diabaikan", iaitu, ia tidak akan sepadan dengan corak. Jika werty tidak dijumpai, maka pernyataan itu adalah benar, dan semuanya teratur dengan q. Kemudian carian diteruskan untuk sebarang aksara selain daripada ruang ([^\s]*).

Pengkuantiti

Pengkuantiti membolehkan anda menentukan bahagian corak yang mesti diulang beberapa kali berturut-turut. Contohnya, jika anda ingin mengetahui sama ada dokumen mengandungi rentetan 10 hingga 20 (termasuk) huruf "a", maka anda boleh menggunakan corak ini:

A(10,20)

Secara lalai, pengkuantiti adalah "tamak". Oleh itu, pengkuantiti +, bermaksud "satu atau lebih kali," akan sepadan dengan nilai maksimum yang mungkin. Kadang-kadang ini menyebabkan masalah, di mana anda boleh memberitahu pengkuantiti untuk berhenti menjadi tamak (menjadi "malas") dengan menggunakan pengubah suai khas. Lihat kod ini:

".*"

Corak ini sepadan dengan teks yang disertakan dalam petikan berganda. Walau bagaimanapun, talian sumber anda mungkin seperti ini:

Hai dunia

Templat di atas akan menemui subrentetan berikut dalam baris ini:

"helloworld.htm" title="Hello World" !}

Dia ternyata terlalu tamak, meraih sekeping teks terbesar yang dia boleh.

".*?"

Corak ini juga sepadan dengan mana-mana aksara yang disertakan dalam petikan berganda. Tetapi versi malas (perhatikan pengubah suai?) mencari kemungkinan kejadian terkecil, dan oleh itu akan mencari setiap subrentetan petikan dua secara individu:

"helloworld.htm" "Hello World"

Melarikan diri dalam ungkapan biasa

Ungkapan biasa menggunakan aksara tertentu untuk mewakili bahagian corak yang berlainan. Walau bagaimanapun, masalah timbul jika anda perlu mencari salah satu daripada aksara ini dalam rentetan, sama seperti watak biasa. Titik, sebagai contoh, dalam ungkapan biasa bermaksud "sebarang aksara selain daripada pemisah baris." Jika anda perlu mencari titik dalam rentetan, anda tidak boleh menggunakan " . » sebagai templat - ini akan membawa kepada mencari hampir semua perkara. Jadi, anda perlu memberitahu penghurai bahawa titik ini harus dianggap sebagai titik biasa dan bukan "sebarang watak". Ini dilakukan menggunakan tanda melarikan diri.

Watak melarikan diri mendahului watak seperti titik menyebabkan penghurai mengabaikan fungsinya dan menganggapnya sebagai watak biasa. Terdapat beberapa aksara yang memerlukan pelarian sedemikian dalam kebanyakan templat dan bahasa. Anda boleh menemuinya di penjuru kanan sebelah bawah helaian tipu (“Simbol Meta”).

Corak untuk mencari titik ialah:

\.

Watak istimewa lain dalam ungkapan biasa sepadan dengan elemen luar biasa dalam teks. Pemisahan baris dan tab, sebagai contoh, boleh ditaip pada papan kekunci tetapi berkemungkinan mengelirukan bahasa pengaturcaraan. Watak melarikan diri digunakan di sini untuk memberitahu penghurai supaya menganggap watak seterusnya sebagai istimewa dan bukannya surat biasa atau nombor.

Watak khas melarikan diri dalam ungkapan biasa Penggantian rentetan

Penggantian rentetan diterangkan secara terperinci dalam perenggan seterusnya, "Kumpulan dan Julat", tetapi kewujudan kumpulan "pasif" harus disebut di sini. Ini adalah kumpulan yang diabaikan semasa penggantian, yang sangat berguna jika anda ingin menggunakan keadaan "atau" dalam corak, tetapi tidak mahu kumpulan itu mengambil bahagian dalam penggantian.

Kumpulan dan Julat

Kumpulan dan julat sangat, sangat berguna. Mungkin lebih mudah untuk bermula dengan julat. Mereka membenarkan anda untuk menentukan satu set aksara yang sesuai. Sebagai contoh, untuk menyemak sama ada rentetan mengandungi digit heksadesimal (0 hingga 9 dan A hingga F), anda akan menggunakan julat berikut:

Untuk menyemak sebaliknya, gunakan julat negatif, yang dalam kes kami sesuai dengan mana-mana aksara kecuali nombor dari 0 hingga 9 dan huruf dari A hingga F:

[^A-Fa-f0-9]

Kumpulan paling kerap digunakan apabila keadaan "atau" diperlukan dalam corak; apabila anda perlu merujuk kepada sebahagian daripada templat daripada bahagian lain daripadanya; dan juga apabila menggantikan rentetan.

Menggunakan "atau" adalah sangat mudah: corak berikut mencari "ab" atau "bc":

Jika dalam ungkapan biasa adalah perlu untuk merujuk kepada mana-mana kumpulan sebelumnya, anda harus menggunakan \n , di mana bukannya n menggantikan nombor kumpulan yang dikehendaki. Anda mungkin mahu corak yang sepadan dengan huruf "aaa" atau "bbb" diikuti dengan nombor dan kemudian tiga huruf yang sama. Corak ini dilaksanakan menggunakan kumpulan:

(aaa|bbb)+\1

Bahagian pertama corak mencari "aaa" atau "bbb", menggabungkan huruf yang ditemui ke dalam kumpulan. Ini diikuti dengan carian untuk satu atau lebih digit (+), dan akhirnya \1. Bahagian terakhir corak merujuk kepada kumpulan pertama dan mencari perkara yang sama. Ia mencari padanan dengan teks yang telah ditemui oleh bahagian pertama corak, bukan padanan dengannya. Jadi "aaa123bbb" tidak akan memenuhi corak di atas kerana \1 akan mencari "aaa" selepas nombor.

Salah satu yang paling alat yang berguna dalam ungkapan biasa ialah penggantian rentetan. Apabila menggantikan teks, anda boleh merujuk kumpulan yang ditemui menggunakan $n . Katakan anda ingin menyerlahkan semua perkataan "ingin" dalam teks dalam huruf tebal. Untuk melakukan ini, anda harus menggunakan fungsi ganti ungkapan biasa, yang mungkin kelihatan seperti ini:

Ganti (corak, penggantian, subjek)

Parameter pertama adalah seperti ini (anda mungkin memerlukan beberapa aksara tambahan untuk fungsi tertentu ini):

([^A-Za-z0-9])(ingin)([^A-Za-z0-9])

Ia akan menemui sebarang kemunculan perkataan "ingin" bersama-sama dengan aksara sebelumnya dan seterusnya, selagi ia bukan huruf atau nombor. Kemudian penggantian anda boleh menjadi seperti ini:

$1$2$3

Ia akan menggantikan keseluruhan rentetan yang ditemui menggunakan corak. Kami mula menggantikan dengan aksara pertama yang ditemui (iaitu bukan huruf atau nombor), menandakannya $1 . Tanpa ini, kami hanya akan mengeluarkan watak ini daripada teks. Perkara yang sama berlaku untuk penghujung penggantian ($3). Di tengah kami menambah tag HTML untuk huruf tebal (sudah tentu, anda boleh menggunakan CSS atau sebaliknya), menonjolkan kumpulan kedua yang ditemui daripada templat ($2).

Ungkapan Biasa

Ungkapan biasa ialah objek yang menerangkan corak aksara. Kelas RegExp dalam JavaScript mewakili ungkapan biasa, dan objek kelas String dan RegExp mentakrifkan kaedah yang menggunakan ungkapan biasa untuk melaksanakan padanan corak dan carian teks dan operasi penggantian. Tatabahasa ungkapan biasa dalam JavaScript mengandungi subset yang agak lengkap bagi sintaks ungkapan biasa yang digunakan dalam Perl 5, jadi jika anda mempunyai pengalaman dengan bahasa Perl, anda boleh menerangkan corak dalam program JavaScript dengan mudah.

Ciri ungkapan biasa Perl yang tidak disokong dalam ECMAScript termasuk bendera s (mod baris tunggal) dan x (sintaks lanjutan); jujukan melarikan diri \a, \e, \l, \u, \L, \U, \E, \Q, \A, \Z, \z dan \G dan binaan lanjutan lain bermula dengan (?.

Mentakrifkan Ungkapan Biasa

DALAM JavaScript biasa ungkapan diwakili oleh objek RegExp. Objek RegExp boleh dibuat menggunakan pembina RegExp(), tetapi lebih kerap ia dicipta menggunakan sintaks khas literal. Sama seperti literal rentetan ditentukan sebagai aksara yang dikelilingi oleh tanda petikan, literal ungkapan biasa ditentukan sebagai aksara yang dikelilingi oleh sepasang aksara slash (/). Jadi kod JavaScript anda mungkin mengandungi baris seperti ini:

Corak Var = /s$/;

Baris ini mencipta objek baru RegExp dan berikannya kepada pembolehubah corak. Objek ini RegExp mencari sebarang rentetan yang berakhir dengan "s". Ungkapan biasa yang sama boleh ditakrifkan menggunakan pembina RegExp() :

Corak Var = RegExp baharu("s$");

Spesifikasi corak ungkapan biasa terdiri daripada urutan aksara. Kebanyakan aksara, termasuk semua abjad angka, secara literal menerangkan aksara yang mesti ada. Iaitu, ungkapan biasa /java/ sepadan dengan semua baris yang mengandungi subrentetan "java".

Watak-watak lain dalam ungkapan biasa tidak bertujuan untuk digunakan untuk mencari persamaan yang tepat, tetapi mempunyai makna khas. Contohnya, ungkapan biasa /s$/ mengandungi dua aksara. Aksara pertama s menandakan pencarian untuk aksara literal. Kedua, $ ialah metacharacter khas yang menandakan penghujung baris. Jadi ungkapan biasa ini sepadan dengan mana-mana rentetan yang berakhir dengan aksara s.

Bahagian berikut menerangkan pelbagai aksara dan aksara meta yang digunakan dalam ungkapan biasa dalam JavaScript.

Watak literal

Seperti yang dinyatakan sebelum ini, semua aksara abjad dan nombor dalam ungkapan biasa sepadan dengan diri mereka sendiri. Sintaks ungkapan biasa dalam JavaScript juga menyokong keupayaan untuk menentukan aksara bukan abjad tertentu menggunakan jujukan melarikan diri bermula dengan aksara garis miring ke belakang (\). Contohnya, urutan \n sepadan dengan aksara baris baharu. Simbol-simbol ini disenaraikan dalam jadual di bawah:

Beberapa tanda baca mempunyai makna istimewa dalam ungkapan biasa:

^ $ . * + ? = ! : | \ / () { } -

Maksud simbol ini dijelaskan dalam bahagian berikut. Sesetengah daripadanya mempunyai makna istimewa hanya dalam konteks ungkapan biasa tertentu, manakala dalam konteks lain ia ditafsirkan secara literal. Walau bagaimanapun, secara amnya, untuk menyertakan mana-mana aksara ini secara literal dalam ungkapan biasa, anda mesti mendahuluinya dengan aksara sengkang ke belakang. Watak lain, seperti petikan dan @, tidak mempunyai makna yang istimewa dan hanya memadankan diri mereka dalam ungkapan biasa.

Jika anda tidak dapat mengingati dengan tepat aksara yang harus didahului oleh \, anda boleh meletakkan garis miring ke belakang dengan selamat di hadapan mana-mana aksara. Walau bagaimanapun, perlu diingat bahawa banyak huruf dan nombor mempunyai makna istimewa apabila digabungkan dengan aksara garis miring, jadi huruf dan nombor yang anda cari sebenarnya tidak boleh didahului oleh aksara \. Untuk menyertakan aksara garisan belakang itu sendiri dalam ungkapan biasa, anda mesti mendahuluinya dengan watak garisan belakang yang lain. Sebagai contoh, ungkapan biasa berikut sepadan dengan mana-mana rentetan yang mengandungi aksara sengkang ke belakang: /\\/.

Kelas watak

Aksara literal individu boleh digabungkan ke dalam kelas aksara dengan melampirkannya dalam kurungan segi empat sama. Kelas aksara sepadan dengan mana-mana aksara yang terkandung dalam kelas itu. Oleh itu, ungkapan biasa // sepadan dengan salah satu aksara a, b, atau c.

Kelas aksara negatif juga boleh ditakrifkan untuk memadankan mana-mana aksara kecuali yang dinyatakan dalam kurungan. Kelas aksara penolakan ditentukan oleh aksara ^ sebagai aksara pertama berikutan kurungan kiri. Ungkapan biasa /[^abc]/ sepadan dengan mana-mana aksara selain daripada a, b atau c. Dalam kelas aksara, julat aksara boleh ditentukan menggunakan tanda sempang. Cari semua aksara abjad Latin V huruf kecil dilakukan menggunakan ungkapan //, dan sebarang huruf atau nombor daripada set aksara Latin boleh didapati menggunakan ungkapan //.

Kelas aksara tertentu adalah perkara biasa, jadi sintaks ungkapan biasa dalam JavaScript termasuk aksara khas dan urutan melarikan diri untuk mewakilinya. Oleh itu, \s sepadan dengan ruang, tab dan mana-mana aksara ruang putih Unicode, dan \S sepadan dengan mana-mana aksara ruang putih bukan Unikod.

Jadual di bawah menyediakan senarai aksara khas ini dan sintaks kelas aksara. (Perhatikan bahawa beberapa jujukan pelarian kelas aksara hanya sepadan dengan aksara ASCII dan tidak diperluaskan untuk berfungsi dengan aksara Unikod. Anda boleh mentakrifkan kelas aksara Unikod anda sendiri secara eksplisit, contohnya /[\u0400-\u04FF]/ sepadan dengan mana-mana aksara abjad Cyrillic .)

Kelas Aksara Ungkapan Biasa JavaScript Surat Menyurat Simbol

[...]	Mana-mana watak yang ditunjukkan dalam kurungan
[^...]	Mana-mana aksara yang tidak disenaraikan dalam kurungan
.	Sebarang aksara selain daripada baris baharu atau pembatas baris Unicode lain
\w	Sebarang aksara teks ASCII. Bersamaan
\W	Sebarang aksara yang bukan aksara teks ASCII. Bersamaan dengan [^a-zA-Z0-9_]
\s	Sebarang aksara ruang putih daripada set Unicode
\S	Sebarang aksara bukan ruang putih daripada set Unicode. Sila ambil perhatian bahawa aksara \w dan \S bukanlah perkara yang sama
\d	Mana-mana nombor ASCII. Bersamaan
\D	Sebarang aksara selain daripada nombor ASCII. Bersamaan dengan [^0-9]
[\b]	Aksara ruang belakang literal

Ambil perhatian bahawa urutan pelarian watak khas kelas boleh disertakan dalam kurungan segi empat sama. \s sepadan dengan mana-mana aksara ruang putih dan \d sepadan dengan mana-mana digit, oleh itu /[\s\d]/ sepadan dengan mana-mana aksara atau digit ruang putih.

Pengulangan

Memandangkan pengetahuan tentang sintaks ungkapan biasa yang diperoleh setakat ini, kita boleh menerangkan nombor dua digit sebagai /\d\d/ atau nombor empat digit sebagai /\d\d\d\d/, tetapi kita tidak boleh, contohnya , huraikan nombor yang terdiri daripada sebarang nombor digit, atau rentetan tiga huruf diikuti dengan digit pilihan. Corak yang lebih kompleks ini menggunakan sintaks ungkapan biasa untuk menentukan bilangan kali unsur ini ekspresi biasa.

Simbol ulang sentiasa mengikut corak yang digunakan. Beberapa jenis ulangan digunakan agak kerap, dan simbol khas tersedia untuk menunjukkan kes ini. Sebagai contoh, + sepadan dengan satu atau beberapa tika corak sebelumnya. Jadual berikut menyediakan ringkasan sintaks pengulangan:

Baris berikut menunjukkan beberapa contoh:

Corak Var = /\d(2,4)/; // Memadankan nombor yang mengandungi pola dua hingga empat digit = /\w(3)\d?/; // Padankan betul-betul tiga aksara perkataan dan satu corak digit pilihan = /\s+java\s+/; // Memadankan perkataan "java" dengan satu atau lebih ruang // sebelum dan selepasnya corak = /[^(]*/; // Memadankan sifar atau lebih aksara selain daripada kurungan pembukaan

Berhati-hati apabila menggunakan aksara ulangan * dan ?. Mereka boleh memadankan ketiadaan corak yang dinyatakan sebelum mereka dan oleh itu ketiadaan aksara. Sebagai contoh, ungkapan biasa /a*/ sepadan dengan rentetan "bbbb" kerana ia tidak mengandungi aksara a.

Aksara pengulangan yang disenaraikan dalam jadual mewakili bilangan pengulangan maksimum yang mungkin yang membolehkan bahagian seterusnya bagi ungkapan biasa dipadankan. Kami mengatakan ini adalah pengulangan tamak. Ia juga mungkin untuk melaksanakan pengulangan yang dilakukan dengan cara yang tidak tamak. Ia cukup untuk menunjukkan tanda soal selepas simbol pengulangan (atau simbol): ??, +?, *? atau pun (1.5)?.

Sebagai contoh, ungkapan biasa /a+/ sepadan dengan satu atau lebih contoh huruf a. Digunakan pada rentetan "aaa", ia sepadan dengan ketiga-tiga huruf. Sebaliknya, ungkapan /a+?/ sepadan dengan satu atau lebih contoh huruf a dan memilih bilangan aksara terkecil yang mungkin. Digunakan pada rentetan yang sama, corak ini hanya sepadan dengan huruf pertama a.

Pengulangan "tidak tamak" tidak selalu memberikan hasil yang diharapkan. Pertimbangkan corak /a+b/, yang sepadan dengan satu atau lebih a diikuti oleh b. Apabila digunakan pada rentetan "aaab", ia sepadan dengan keseluruhan rentetan.

Sekarang mari kita semak versi "tidak tamak" /a+?b/. Seseorang mungkin berfikir bahawa ia akan sepadan dengan a b didahului oleh hanya satu a. Jika digunakan pada rentetan yang sama, "aaab" dijangka sepadan dengan aksara tunggal a dan aksara terakhir b. Walau bagaimanapun, corak ini sebenarnya sepadan dengan keseluruhan rentetan, sama seperti versi tamak. Hakikatnya ialah carian corak ungkapan biasa dilakukan dengan mencari kedudukan pertama dalam rentetan, bermula dari mana padanan menjadi mungkin. Memandangkan padanan mungkin bermula dari aksara pertama rentetan, padanan yang lebih pendek bermula dari aksara berikutnya tidak dipertimbangkan.

Alternatif, Pengumpulan dan Pautan

Tatabahasa ungkapan biasa termasuk aksara khas untuk menentukan alternatif, mengumpulkan subungkapan dan rujukan kepada subungkapan sebelumnya. Simbol paip | berfungsi untuk memisahkan alternatif. Contohnya, /ab|cd|ef/ sepadan sama ada rentetan "ab", atau rentetan "cd", atau rentetan "ef", dan corak /\d(3)|(4)/ sepadan sama ada tiga digit atau empat huruf kecil.

Ambil perhatian bahawa alternatif diproses dari kiri ke kanan sehingga padanan ditemui. Jika padanan ditemui dengan alternatif kiri, yang kanan diabaikan, walaupun perlawanan "lebih baik" boleh dicapai. Oleh itu, apabila corak /a|ab/ digunakan pada rentetan "ab", ia hanya akan sepadan dengan aksara pertama.

Tanda kurung mempunyai pelbagai makna dalam ungkapan biasa. Salah satunya ialah berkumpulan elemen individu menjadi satu subungkapan, supaya unsur-unsur apabila menggunakan aksara khas |, *, +, ? dan yang lain dianggap sebagai satu keseluruhan. Sebagai contoh, corak /java(skrip)?/ sepadan dengan perkataan "java" diikuti dengan perkataan pilihan "skrip", dan /(ab|cd)+|ef)/ sepadan sama ada rentetan "ef" atau satu atau lebih pengulangan satu daripada rentetan "ab" atau "cd".

Satu lagi penggunaan kurungan dalam ungkapan biasa adalah untuk menentukan subcorak dalam corak. Apabila padanan ungkapan biasa ditemui dalam rentetan sasaran, bahagian rentetan sasaran yang sepadan dengan mana-mana subcorak tertentu yang disertakan dalam kurungan boleh diekstrak.

Katakan anda ingin mencari satu atau lebih huruf kecil diikuti dengan satu atau lebih nombor. Untuk melakukan ini, anda boleh menggunakan templat /+\d+/. Tetapi mari kita anggap juga bahawa kita hanya mahu nombor pada akhir setiap perlawanan. Jika kita meletakkan bahagian corak ini dalam kurungan (/+(\d+)/), kita boleh mengekstrak nombor daripada mana-mana padanan yang kita temui. Bagaimana ini dilakukan akan diterangkan di bawah.

Penggunaan subungkapan kurungan yang berkaitan adalah merujuk kepada subungkapan daripada bahagian sebelumnya bagi ungkapan biasa yang sama. Ini dicapai dengan menentukan satu atau lebih digit selepas aksara \. Nombor merujuk kepada kedudukan subungkapan dalam kurungan dalam ungkapan biasa. Sebagai contoh, \1 merujuk kepada subungkapan pertama, dan \3 merujuk kepada yang ketiga. Ambil perhatian bahawa subungkapan boleh bersarang antara satu sama lain, jadi kedudukan kurungan kiri digunakan semasa mengira. Sebagai contoh, dalam ungkapan biasa berikut, rujukan subungkapan (kript) bersarang akan kelihatan seperti \2:

/(ava(cript)?)\sis\s(seronok\w*)/

Rujukan kepada subungkapan sebelumnya tidak menunjuk kepada corak subungkapan itu, tetapi kepada teks yang ditemui yang sepadan dengan corak tersebut. Oleh itu, rujukan boleh digunakan untuk mengenakan kekangan yang memilih bahagian rentetan yang mengandungi aksara yang sama. Sebagai contoh, ungkapan biasa berikut sepadan dengan sifar atau lebih aksara dalam satu atau petikan berganda. Walau bagaimanapun, ia tidak memerlukan petikan pembukaan dan penutup sepadan antara satu sama lain (iaitu, kedua-dua petikan adalah tunggal atau berganda):

/[""][^""]*[""]/

Kami boleh meminta tanda petikan untuk dipadankan menggunakan rujukan seperti ini:

Di sini \1 sepadan dengan subungkapan pertama. Dalam contoh ini, pautan mengenakan kekangan yang memerlukan tanda petikan penutup untuk sepadan dengan tanda petikan pembukaan. Ungkapan biasa ini tidak membenarkan petikan tunggal di dalam petikan berganda, dan sebaliknya.

Ia juga mungkin untuk mengumpulkan elemen dalam ungkapan biasa tanpa membuat rujukan bernombor kepada elemen tersebut. Daripada hanya mengumpulkan elemen antara ( dan ), mulakan kumpulan dengan simbol (?: dan akhiri dengan simbol). Pertimbangkan, sebagai contoh, corak berikut:

/(ava(?:cript)?)\sis\s(seronok\w*)/

Di sini subungkapan (?:cript) hanya diperlukan untuk pengelompokan supaya aksara pengulangan ? boleh digunakan pada kumpulan. Tanda kurung yang diubah suai ini tidak membuat pautan, jadi dalam ungkapan biasa ini, \2 merujuk kepada teks yang sepadan dengan corak (seronok\w*).

Jadual berikut menyenaraikan operator pemilihan, pengelompokan dan rujukan dalam ungkapan biasa:

Simbol ungkapan biasa untuk memilih daripada alternatif, kumpulan dan pautan JavaScriptMakna Simbol

|	Alternatif. Padan sama ada subungkapan di sebelah kiri atau subungkapan di sebelah kanan.
(...)	Pengelompokan. Himpunkan elemen ke dalam satu unit yang boleh digunakan dengan aksara *, +, ?, | dan sebagainya. Juga mengingati aksara yang sepadan dengan kumpulan ini untuk digunakan dalam rujukan seterusnya.
(?:...)	Hanya berkumpulan. Himpunkan elemen ke dalam satu unit, tetapi tidak ingat aksara yang sepadan dengan kumpulan ini.
\nombor	Memadankan aksara yang sama yang ditemui semasa memadankan nombor nombor kumpulan. Kumpulan ialah subungkapan di dalam kurungan (mungkin bersarang). Nombor kumpulan diberikan dengan mengira kurungan kiri dari kiri ke kanan. Kumpulan yang dibentuk menggunakan simbol (?:) tidak bernombor.

Menentukan Kedudukan Padanan

Seperti yang diterangkan sebelum ini, banyak elemen ungkapan biasa sepadan dengan satu aksara dalam rentetan. Sebagai contoh, \s sepadan dengan satu aksara ruang putih. Unsur ungkapan biasa yang lain sepadan dengan kedudukan antara aksara dan bukannya watak itu sendiri. Sebagai contoh, \b memadankan sempadan perkataan—sempadan antara \w (karakter teks ASCII) dan \W (karakter bukan teks), atau sempadan antara aksara teks ASCII dan permulaan atau akhir baris.

Elemen seperti \b tidak menyatakan sebarang aksara yang mesti ada dalam rentetan yang dipadankan, tetapi ia menyatakan kedudukan yang sah untuk dipadankan. Unsur ini kadangkala dipanggil elemen penambat ungkapan biasa kerana ia menambat corak pada kedudukan tertentu dalam rentetan. Elemen penambat yang paling biasa digunakan ialah ^ dan $, yang masing-masing memaut corak ke permulaan dan penghujung baris.

Sebagai contoh, perkataan "JavaScript" pada barisnya sendiri boleh didapati menggunakan ungkapan biasa /^JavaScript$/. Untuk mencari perkataan tunggal "Java" (bukan awalan seperti "JavaScript"), anda boleh cuba menggunakan corak /\sJava\s/, yang memerlukan ruang sebelum dan selepas perkataan.

Tetapi penyelesaian sedemikian menimbulkan dua masalah. Pertama, ia hanya akan mencari perkataan "Java" jika ia dikelilingi oleh ruang pada kedua-dua belah, dan tidak akan dapat mencarinya pada permulaan atau penghujung baris. Kedua, apabila corak ini sepadan, rentetan yang dipulangkan akan mengandungi ruang hadapan dan belakang, yang bukan seperti yang kita mahukan. Jadi daripada menggunakan corak yang sepadan dengan aksara ruang putih \s, kami akan menggunakan corak (atau sauh) yang sepadan dengan sempadan perkataan \b. Hasilnya ialah ungkapan berikut: /\bJava\b/.

Elemen penambat \B sepadan dengan kedudukan yang bukan sempadan perkataan. Iaitu, corak /\Bcript/ akan sepadan dengan perkataan "JavaScript" dan "postscript" dan tidak akan sepadan dengan perkataan "script" atau "Scripting".

Ungkapan biasa arbitrari juga boleh berfungsi sebagai syarat utama. Jika anda meletakkan ungkapan antara aksara (?= dan), ia menjadi ujian padanan hadapan terhadap aksara seterusnya, yang memerlukan aksara tersebut sepadan dengan corak yang ditentukan tetapi tidak disertakan dalam rentetan padanan.

Contohnya, untuk memadankan nama bahasa pengaturcaraan biasa diikuti dengan titik bertindih, anda boleh menggunakan ungkapan /ava(cript)?(?=\:)/. Corak ini sepadan dengan perkataan "JavaScript" dalam rentetan "JavaScript: The Definitive Guide", tetapi ia tidak akan sepadan dengan perkataan "Java" dalam rentetan "Java in a Nutshell" kerana ia tidak diikuti dengan titik bertindih.

Jika anda memasukkan syarat (?!), maka ini akan menjadi semakan hadapan negatif untuk aksara seterusnya, yang memerlukan aksara berikut tidak sepadan dengan corak yang ditentukan. Contohnya, corak /Java(?!Script)(\w* )/ sepadan dengan subrentetan "Java", diikuti dengan huruf besar dan sebarang bilangan aksara teks ASCII, dengan syarat subrentetan "Java" tidak diikuti oleh subrentetan "Skrip" Ia akan sepadan dengan rentetan "JavaBeans" tetapi bukan rentetan "Javanese" akan sepadan dengan rentetan "JavaScrip" ", tetapi tidak akan sepadan dengan rentetan "JavaScript" atau "JavaScripter".

Jadual di bawah menyediakan senarai aksara utama ungkapan biasa:

Watak utama ungkapan biasa Makna Simbol

^	Padan dengan permulaan ungkapan rentetan atau permulaan baris dalam carian berbilang baris.
$	Memadankan penghujung ungkapan rentetan atau penghujung baris dalam carian berbilang baris.
\b	Memadankan sempadan perkataan, i.e. sepadan dengan kedudukan antara aksara \w dan aksara \W, atau antara aksara \w dan permulaan atau penghujung baris. (Walau bagaimanapun, ambil perhatian bahawa [\b] sepadan dengan aksara ruang belakang.)
\B	Padan dengan kedudukan yang bukan sempadan perkataan.
(?=p)	Semakan pandangan ke hadapan positif untuk aksara seterusnya. Memerlukan aksara seterusnya untuk memadankan corak p, tetapi tidak memasukkan aksara tersebut dalam rentetan yang dipadankan.
(?!p)	Semakan hadapan negatif untuk aksara seterusnya. Memerlukan aksara berikut tidak sepadan dengan corak p.

Bendera

Dan satu elemen terakhir tatabahasa ungkapan biasa. Bendera ungkapan biasa menentukan peraturan padanan corak peringkat tinggi. Tidak seperti tatabahasa ungkapan biasa yang lain, bendera tidak ditentukan antara aksara miring, tetapi selepas aksara kedua. JavaScript menyokong tiga bendera.

Bendera i menyatakan bahawa padanan corak hendaklah tidak peka huruf besar dan kecil, dan bendera g- bahawa carian harus global, i.e. semua padanan dalam rentetan mesti dijumpai. Bendera m melakukan carian corak dalam mod berbilang baris. Jika ungkapan rentetan yang dicari mengandungi baris baharu, maka dalam mod ini aksara sauh ^ dan $, selain daripada memadankan permulaan dan penghujung keseluruhan ungkapan rentetan, juga sepadan dengan permulaan dan penghujung setiap rentetan teks. Contohnya, corak /java$/im sepadan dengan kedua-dua "java" dan "Java\nis fun".

Bendera ini boleh digabungkan dalam sebarang kombinasi. Contohnya, untuk mencari kemunculan pertama perkataan "java" (atau "Java", "JAVA", dsb.) dalam cara tidak peka huruf besar-besaran, anda boleh menggunakan ungkapan biasa tidak sensitif huruf besar/kecil /\bjava\b/ i. Dan untuk mencari semua kemunculan perkataan ini dalam rentetan, anda boleh menambah bendera g: /\bjava\b/gi.

Kaedah Rentetan kelas untuk mencari mengikut corak

Sehingga tahap ini, kami telah membincangkan tatabahasa ungkapan biasa yang kami cipta, tetapi kami belum melihat cara ungkapan biasa tersebut sebenarnya boleh digunakan dalam skrip JavaScript. DALAM bahagian ini Kami akan membincangkan kaedah objek String yang menggunakan ungkapan biasa untuk padanan corak dan carian dengan penggantian. Dan kemudian kami akan meneruskan perbualan kami tentang padanan corak dengan ungkapan biasa dengan melihat objek RegExp dan kaedah serta sifatnya.

Strings menyokong empat kaedah menggunakan ungkapan biasa. Yang paling mudah ialah kaedah carian(). Ia memerlukan ungkapan biasa sebagai hujah dan mengembalikan sama ada kedudukan aksara pertama subrentetan yang dipadankan, atau -1 jika tiada padanan ditemui. Sebagai contoh, panggilan berikut akan mengembalikan 4:

Var result = "JavaScript".search(/script/i); // 4

Jika hujah kepada kaedah search() bukan ungkapan biasa, ia mula-mula ditukar dengan menghantarnya kepada pembina RegExp. Kaedah search() tidak menyokong carian global dan mengabaikan bendera g dalam hujahnya.

Kaedah replace() menjalankan operasi carian dan ganti. Ia memerlukan ungkapan biasa sebagai hujah pertamanya dan rentetan gantian sebagai yang kedua. Kaedah ini mencari baris di mana ia dipanggil untuk padanan dengan corak yang ditentukan.

Jika ungkapan biasa mengandungi bendera g, kaedah replace() menggantikan semua padanan yang ditemui dengan rentetan gantian. Jika tidak, ia hanya menggantikan padanan pertama yang ditemui. Jika argumen pertama kaedah replace() ialah rentetan dan bukannya ungkapan biasa, maka kaedah melakukan carian literal untuk rentetan dan bukannya menukarnya kepada ungkapan biasa menggunakan pembina RegExp() seperti yang dilakukan oleh kaedah search().

Sebagai contoh, kita boleh menggunakan kaedah replace() untuk penempatan seragam huruf besar dalam perkataan "JavaScript" untuk keseluruhan baris teks:

// Tanpa mengira kes aksara, kami menggantikannya dengan perkataan dalam kes yang diperlukan var result = "javascript".replace(/JavaScript/ig, "JavaScript");

Kaedah replace() adalah lebih alat yang berkuasa daripada contoh ini akan mencadangkan. Biar saya ingatkan anda bahawa subungkapan dalam kurungan dalam ungkapan biasa diberi nombor dari kiri ke kanan dan ungkapan biasa mengingati teks yang sepadan dengan setiap subungkapan. Jika rentetan gantian mengandungi tanda $ diikuti dengan nombor, kaedah replace() menggantikan dua aksara tersebut dengan teks yang sepadan dengan subungkapan yang ditentukan. Ini sangat peluang yang berguna. Kita boleh menggunakannya, sebagai contoh, untuk menggantikan petikan lurus dalam rentetan dengan petikan tipografi, yang disimulasikan oleh aksara ASCII:

// Petikan ialah petikan diikuti oleh sebarang bilangan aksara // selain daripada petikan (yang kita ingat), diikuti petikan lain // petikan var = /"([^"]*)"/g; // Gantikan petikan lurus dengan tipografi dan biarkan "$1" tidak berubah // kandungan petikan yang disimpan dalam $1 var text = ""JavaScript" ialah bahasa pengaturcaraan yang ditafsirkan."; var result = text.replace(petikan, ""$1"" ); // "JavaScript" ialah bahasa pengaturcaraan yang ditafsirkan.

Perkara penting yang perlu diperhatikan ialah hujah kedua untuk replace() boleh menjadi fungsi yang mengira rentetan gantian secara dinamik.

Kaedah padanan() ialah kaedah kelas String yang paling biasa yang menggunakan ungkapan biasa. Ia memerlukan ungkapan biasa sebagai satu-satunya hujahnya (atau menukar hujahnya kepada ungkapan biasa dengan menghantarnya kepada pembina RegExp()) dan mengembalikan tatasusunan yang mengandungi hasil carian. Jika bendera g ditetapkan dalam ungkapan biasa, kaedah tersebut mengembalikan tatasusunan semua padanan yang terdapat dalam rentetan. Sebagai contoh:

// akan mengembalikan ["1", "2", "3"] var result = "1 tambah 2 sama dengan 3".match(/\d+/g);

Jika ungkapan biasa tidak mengandungi bendera g, kaedah padanan() tidak melakukan carian global; ia hanya mencari perlawanan pertama. Walau bagaimanapun, match() mengembalikan tatasusunan walaupun kaedah itu tidak melakukan carian global. Dalam kes ini, elemen pertama tatasusunan ialah subrentetan yang ditemui, dan semua elemen yang tinggal ialah subungkapan bagi ungkapan biasa. Oleh itu, jika match() mengembalikan arr tatasusunan, maka arr akan mengandungi keseluruhan rentetan yang ditemui, arr subrentetan sepadan dengan subungkapan pertama, dsb. Melukis selari dengan kaedah replace(), kita boleh mengatakan bahawa kandungan $n dimasukkan ke dalam arr[n].

Sebagai contoh, lihat perkara berikut kod program yang menghuraikan URL:

Var url = /(\w+):\/\/([\w.]+)\/(\S*)/; var text = "Lawati laman web kami http://www..php"; var result = text.match(url); if (result != null) ( var fullurl = result; // Mengandungi "http://www..php" var protocol = result; // Mengandungi "http" var host = result; // Mengandungi "www..php " )

Perlu diingatkan bahawa untuk ungkapan biasa yang tidak mempunyai set bendera g carian global, kaedah padanan() mengembalikan nilai yang sama seperti kaedah exec() ungkapan biasa: tatasusunan yang dikembalikan mempunyai sifat indeks dan input, seperti yang diterangkan dalam perbincangan kaedah exec() di bawah.

Kaedah terakhir objek String yang menggunakan ungkapan biasa ialah split(). Kaedah ini membahagikan rentetan yang mana ia dipanggil ke dalam tatasusunan subrentetan, menggunakan hujah sebagai pembatas. Sebagai contoh:

"123,456,789".split(","); // Kembali ["123","456","789"]

Kaedah split() juga boleh mengambil ungkapan biasa sebagai hujah. Ini menjadikan kaedah lebih berkuasa. Sebagai contoh, anda boleh menentukan pemisah yang membenarkan nombor sewenang-wenangnya ruang putih di kedua-dua belah:

"1, 2, 3 , 4 , 5".split(/\s*,\s*/); // Kembalikan ["1","2","3","4","5"]

objek RegExp

Seperti yang dinyatakan, ungkapan biasa diwakili sebagai objek RegExp. Sebagai tambahan kepada pembina RegExp(), objek RegExp menyokong tiga kaedah dan beberapa sifat.

Pembina RegExp() mengambil satu atau dua argumen rentetan dan mencipta objek RegExp baharu. Hujah pertama kepada pembina ialah rentetan yang mengandungi badan ungkapan biasa, i.e. teks yang mesti muncul antara aksara garis miring dalam literal ungkapan biasa. Ambil perhatian bahawa literal rentetan dan ungkapan biasa menggunakan aksara \ untuk mewakili jujukan melarikan diri, jadi apabila menghantar ungkapan biasa sebagai literal rentetan kepada pembina RegExp(), anda mesti menggantikan setiap aksara dengan sepasang aksara \\.

Argumen kedua untuk RegExp() mungkin tiada. Jika dinyatakan, ia mentakrifkan bendera ungkapan biasa. Ia mestilah salah satu daripada aksara g, i, m atau gabungan aksara ini. Sebagai contoh:

// Mencari semua nombor lima digit dalam rentetan. Perhatikan // penggunaan simbol dalam contoh ini \\ var zipcode = new RegExp("\\d(5)", "g");

Pembina RegExp() berguna apabila ungkapan biasa dijana secara dinamik dan oleh itu tidak boleh diwakili menggunakan sintaks literal ungkapan biasa. Contohnya, untuk mencari rentetan yang dimasukkan oleh pengguna, anda perlu mencipta ungkapan biasa pada masa jalan menggunakan RegExp().

Hartanah RegExp

Setiap objek RegExp mempunyai lima sifat. Sifat sumber ialah rentetan baca sahaja yang mengandungi teks ungkapan biasa. Sifat global ialah nilai boolean baca sahaja yang menentukan sama ada bendera g hadir dalam ungkapan biasa. Sifat ignoreCase ialah nilai boolean baca sahaja yang menentukan sama ada bendera i hadir dalam ungkapan biasa. Sifat berbilang baris ialah nilai boolean baca sahaja yang menentukan sama ada bendera m hadir dalam ungkapan biasa. Dan sifat terakhir, lastIndex, ialah integer yang boleh dibaca dan ditulis. Untuk corak dengan bendera g, sifat ini mengandungi nombor kedudukan dalam baris di mana carian seterusnya harus bermula. Seperti yang diterangkan di bawah, ia digunakan oleh kaedah exec() dan test().

Kaedah RegExp

Objek RegExp mentakrifkan dua kaedah yang melaksanakan padanan corak; mereka berkelakuan serupa dengan kaedah kelas String yang diterangkan di atas. Kaedah utama kelas RegExp yang digunakan untuk padanan corak ialah exec() . Ia serupa dengan kaedah padanan() kelas String yang dinyatakan sebelum ini, kecuali kaedah kelas RegExp yang mengambil rentetan sebagai hujah, dan bukannya kaedah kelas String yang mengambil hujah RegExp.

Kaedah exec() melaksanakan ungkapan biasa untuk rentetan yang ditentukan, i.e. mencari padanan dalam rentetan. Jika tiada padanan ditemui, kaedah mengembalikan null. Walau bagaimanapun, jika padanan ditemui, ia mengembalikan tatasusunan yang sama seperti tatasusunan yang dikembalikan oleh kaedah padanan() untuk mencari tanpa bendera g. Elemen sifar tatasusunan mengandungi rentetan yang sepadan dengan ungkapan biasa, dan semua unsur-unsur seterusnya- subrentetan sepadan dengan semua subungkapan. Di samping itu, harta indeks mengandungi nombor kedudukan watak yang serpihan yang sepadan bermula, dan sifat input merujuk kepada baris yang dicari.

Tidak seperti padanan(), kaedah exec() mengembalikan tatasusunan yang strukturnya tidak bergantung pada kehadiran bendera g dalam ungkapan biasa. Biar saya ingatkan anda bahawa apabila menghantar ungkapan biasa global, kaedah match() mengembalikan tatasusunan padanan yang ditemui. Dan exec() sentiasa mengembalikan satu padanan, tetapi memberikan maklumat mengenainya maklumat penuh. Apabila exec() dipanggil pada ungkapan biasa yang mengandungi bendera g, kaedah menetapkan sifat lastIndex bagi objek ungkapan biasa kepada nombor kedudukan aksara serta-merta mengikuti subrentetan yang ditemui.

Apabila exec() dipanggil kali kedua pada ungkapan biasa yang sama, ia memulakan carian pada aksara yang kedudukannya ditentukan dalam sifat lastIndex. Jika exec() tidak menemui padanan, sifat lastIndex ditetapkan kepada 0. (Anda juga boleh menetapkan lastIndex kepada sifar pada bila-bila masa, yang perlu dilakukan dalam semua kes di mana carian berakhir sebelum perlawanan terakhir dalam satu baris adalah dijumpai, dan carian bermula pada baris lain dengan objek RegExp yang sama.) Tingkah laku istimewa ini membolehkan exec() dipanggil berulang kali untuk melelar ke atas semua padanan ungkapan biasa dalam baris. Sebagai contoh:

Corak Var = /Java/g; var text = "JavaScript lebih menyeronokkan daripada Java!"; hasil var; while((result = pattern.exec(text)) != null) ( console.log("Found "" + result + """ + " at position " + result.index + "; carian seterusnya akan bermula pada " + corak .lastIndex); )

Kaedah lain bagi objek RegExp ialah test() , yang lebih banyak lagi kaedah yang lebih mudah exec(). Ia memerlukan rentetan dan mengembalikan benar jika rentetan itu sepadan dengan ungkapan biasa:

Corak Var = /java/i; pattern.test("JavaScript"); // Kembalikan benar

Memanggil test() adalah bersamaan dengan memanggil exec(), yang mengembalikan true jika exec() mengembalikan sesuatu selain null. Atas sebab ini, kaedah test() berkelakuan dengan cara yang sama seperti kaedah exec() apabila dipanggil pada ungkapan biasa global: ia mula mencari rentetan yang ditentukan pada kedudukan yang ditentukan oleh sifat lastIndex, dan jika ia menemui padanan , menetapkan sifat lastIndex kepada nombor kedudukan aksara terus di sebelah padanan yang ditemui. Oleh itu, menggunakan kaedah test(), anda boleh mencipta gelung traversal baris dengan cara yang sama seperti menggunakan kaedah exec().

Sintaks ungkapan biasa agak kompleks dan memerlukan usaha yang serius untuk dipelajari. Petunjuk yang terbaik Buku hari ini mengenai ungkapan biasa ialah buku J. Friedl "Ungkapan Biasa", yang membolehkan, menurut pengarang, "belajar berfikir dalam ungkapan biasa."

Konsep asas

Ungkapan biasa ialah cara memproses rentetan atau urutan aksara yang mentakrifkan corak teks.

Pengubah suai - bertujuan untuk "mengarahkan" ungkapan biasa.

Metacharacters ialah aksara khas yang berfungsi sebagai arahan dalam bahasa ungkapan biasa.

Ungkapan biasa ditetapkan sebagai pembolehubah biasa, hanya garis miring digunakan dan bukannya petikan, contohnya: var reg=/reg_expression/

Dengan templat paling mudah yang kami maksudkan adalah templat yang tidak memerlukan sebarang aksara khas.

Katakan tugas kita ialah menggantikan semua huruf "r" (kecil dan besar) dengan Latin huruf besar"R" dalam frasa Ungkapan Biasa.

Cipta templat var reg=/р/ dan gunakan kaedah menggantikan kami melaksanakan rancangan kami

var reg=/р/

document.write(hasil)

Akibatnya, kami mendapat garis - Ungkapan biasa, penggantian berlaku hanya pada kejadian pertama huruf "p", dengan mengambil kira kes itu.

Tetapi keputusan ini tidak sesuai dengan syarat tugas kami... Di sini kami memerlukan pengubah "g" dan "i", yang boleh digunakan secara berasingan dan bersama-sama. Pengubah suai ini diletakkan pada penghujung corak ungkapan biasa, selepas garis miring, dan mempunyai nilai berikut:

pengubah "g" - menetapkan carian dalam baris sebagai "global", i.e. dalam kes kami, penggantian akan berlaku untuk semua kemunculan huruf "p". Sekarang templat kelihatan seperti ini: var reg=/р/g , menggantikannya dalam kod kami

var str="Ungkapan biasa"
var reg=/р/g
var result=str.replace(reg, "R")
document.write(hasil)

kita mendapat rentetan - Ungkapan biasa.

pengubah "i" - menentukan carian tidak peka huruf besar-kecil dalam rentetan. Dengan menambahkan pengubah suai ini pada templat var reg=/р/gi kami, selepas melaksanakan skrip, kami akan mendapat hasil yang diingini untuk tugas kami - ungkapan biasa.

Watak khas (metacharacter)

Metacharacters menentukan jenis aksara rentetan carian, cara rentetan carian dikelilingi dalam teks, serta bilangan aksara jenis berasingan dalam teks yang dilihat. Oleh itu, metacharacter boleh dibahagikan kepada tiga kumpulan:

• Metacharacter untuk mencari padanan.
• Metakarakter kuantitatif.
• Kedudukan metakarakter.

Metacharacter untuk pemadanan

	Maknanya	Penerangan
	sempadan perkataan	menentukan keadaan di mana corak harus dilaksanakan pada permulaan atau akhir perkataan	/\ber/ padanan ralat, tidak sepadan wira atau dengan pemain /er/ perlawanan pemain, tidak sepadan wira atau dengan ralat /\ber\b/ tidak sepadan wira atau dengan pemain atau dengan ralat, hanya boleh bertepatan dengan eh
	bukan had perkataan	menentukan keadaan di mana corak tidak dilaksanakan pada permulaan atau akhir perkataan	/\Ber/ sepadan wira atau dengan pemain, tidak sepadan ralat /er\B/ padanan ralat atau dengan pemain, tidak sepadan wira /\Ber\B/ padanan wira, tidak sepadan pemain atau dengan ralat
	nombor dari 0 hingga 9		/\d\d\d\d/ sepadan dengan mana-mana nombor empat digit
			/\D\D\D\D/ tidak akan sepadan 2005 atau 05.g atau №126 dan lain-lain.
	watak kosong tunggal	sepadan dengan watak ruang	Padanan \over\sbyte\ sahaja lebih bait
	watak tunggal bukan kosong	mana-mana aksara tunggal kecuali ruang	\over\Sbyte\ padanan lebih-bait atau dengan over_bait, tidak sepadan lebih bait atau lebih-bait
	huruf, nombor atau garis bawah		/A\w/ padanan A1 atau dengan AB, tidak sepadan A+
	bukan huruf, nombor atau garis bawah		/A\W/ tidak sepadan A1 atau dengan AB, bertepatan dengan A+
	sebarang watak	sebarang tanda, huruf, nombor, dsb.	/.../ sepadan dengan mana-mana tiga aksara ABC atau !@4 atau 1 q
	set watak	menentukan keadaan di mana corak mesti dilaksanakan untuk mana-mana padanan aksara yang disertakan dalam kurungan segi empat sama	/WERTY/ perlawanan QWERTY, Dengan AWERTY
	set aksara tidak disertakan	menentukan keadaan di mana corak tidak boleh dilaksanakan untuk mana-mana padanan aksara yang disertakan dalam kurungan segi empat sama	/[^QA]WERTY/ tidak sepadan QWERTY, Dengan AWERTY

Aksara yang disenaraikan dalam jadual "Match Search Metacharacters" tidak boleh dikelirukan dengan jujukan aksara melarikan diri yang digunakan dalam rentetan, seperti \\t - tab, \\n - baris baharu, dsb.

Metakarakter kuantitatif

	Bilangan kebetulan
	Sifar dan Kuantiti yang besar sekali	/Ja*vaScript/ padanan JavaScript atau dengan JavaScript atau dengan JavaScript, tidak sepadan JovaScript
	Sifar atau satu kali	/Ja?vaScript/ padanan sahaja JavaScript atau dengan JavaScript
	Satu atau lebih kali	/Ja+vaScript/ padanan JavaScript atau dengan JavaScript atau dengan JavaScript, tidak sepadan JavaScript
	tepat n kali	/Ja(2)vaScript/ padanan sahaja JavaScript
	n atau lebih kali	/Ja(2,)vaScript/ padanan JavaScript atau dengan JavaScript, tidak sepadan JavaScript atau dengan JavaScript
	Oleh sekurang-kurangnya, n kali, tetapi tidak lebih daripada m kali	/Ja(2,3)vaScript/ padanan sahaja JavaScript atau dengan JavaScript

Setiap aksara yang disenaraikan dalam jadual Metacharacters Kuantitatif digunakan pada satu aksara atau metacharacter sebelumnya dalam ungkapan biasa.

Kedudukan metakarakter

Set terakhir metacharacters bertujuan untuk menunjukkan tempat untuk melihat (jika penting) untuk subrentetan pada permulaan baris atau pada akhir.

Beberapa kaedah untuk bekerja dengan templat

menggantikan - kaedah ini kami sudah menggunakannya pada awal artikel, ia direka untuk mencari corak dan menggantikan subrentetan yang ditemui dengan subrentetan baharu.

exec - kaedah ini melakukan padanan rentetan terhadap corak yang ditentukan oleh templat. Jika padanan corak gagal, ia akan kembali nilai nol. Jika tidak, hasilnya ialah tatasusunan subrentetan yang sepadan dengan corak yang diberikan. /*Elemen pertama tatasusunan akan sama dengan rentetan asal yang memenuhi corak yang diberikan*/

Sebagai contoh:

var reg=/(\d+).(\d+).(\d+)/
var arr=reg.exec("Saya dilahirkan pada 15 September 1980")
document.write("Tarikh lahir: ", arr, "< br>")
document.write("Hari Lahir: ", arr, "< br>")
document.write("Bulan lahir: ", arr, "< br>")
document.write("Tahun lahir: ", arr, "< br>")

Akibatnya, kami mendapat empat baris:
Tarikh lahir: 15/09/1980
Hari lahir: 15
Bulan lahir: 09
Tahun lahir: 1980

Kesimpulan

Artikel itu tidak menunjukkan semua keupayaan dan keseronokan ungkapan biasa; untuk kajian yang lebih mendalam tentang isu ini, saya menasihati anda untuk mengkaji objek RegExp. Saya juga ingin menarik perhatian anda kepada fakta bahawa sintaks ungkapan biasa tidak berbeza dalam kedua-dua JavaScript dan PHP. Contohnya, untuk menyemak sama ada e-mel dimasukkan dengan betul, ungkapan biasa untuk kedua-dua JavaScript dan PHP akan kelihatan sama /+@+.(2,3)/i .

Kelas RegExp dalam JavaScript ialah ungkapan biasa - objek yang menerangkan corak aksara. Objek RegExp biasanya dibuat menggunakan sintaks literal khas yang dibentangkan di bawah, tetapi juga boleh dibuat menggunakan pembina RegExp().

Sintaks // menggunakan sintaks literal khas var regex = /pattern /flags ; // using the constructor var regex = new RegExp("pattern ", "flags "); var regex = new RegExp(/pattern /, "bendera");

Nilai parameter:

Bendera ungkapan biasa Penerangan Bendera

g	Membolehkan anda mencari semua perlawanan daripada berhenti selepas perlawanan pertama ( bendera perlawanan global).
i	Membenarkan padanan tidak sensitif huruf besar-besaran ( abaikan bendera kes).
m	Pemadanan dilakukan merentas berbilang baris. Watak di hadapan dan di belakang (^ dan $) diproses merentas berbilang baris, bermakna padanan berlaku pada permulaan atau penghujung setiap baris (pembatas \n atau \r), dan bukan hanya permulaan atau penghujung keseluruhan baris ( bendera berbilang talian).
u	Corak itu akan ditafsirkan sebagai urutan titik kod Unicode ( bendera unicode).
y	Pemadanan berlaku pada indeks yang ditunjuk oleh sifat lastIndex bagi ungkapan biasa ini, manakala pemadanan tidak dilakukan pada indeks kemudian atau lebih awal ( bendera melekit).

Set aksara Metacharacters Penerangan Simbol

.	Membolehkan anda mencari satu watak selain daripada watak itu baris baru, atau hujung aksara baris (\n, \r, \u2028 atau \u2029).
\d	Membolehkan anda mencari simbol nombor dalam abjad Latin asas. Setara dengan menggunakan set aksara.
\D	Membolehkan anda mencari sebarang aksara yang bukan nombor dalam abjad Latin asas. Bersamaan dengan set aksara [^0-9].
\s	Membolehkan anda mencari satu aksara ruang putih. Watak ruang putih bermaksud ruang, tab, suapan halaman, suapan baris dan lain-lain. aksara ruang putih Unicode. Bersamaan dengan set aksara [\f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​\u2005\u2006​​\u2007\u2008​ u200a​ \u2028\u2029​\u202f\u205f​\u3000].
\S	Membolehkan anda mencari satu aksara yang bukan ruang putih. Ruang putih merujuk kepada ruang, tab, suapan halaman, suapan baris dan aksara ruang putih Unikod yang lain. Bersamaan dengan set aksara [^ \f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​\u2005\u2006​\u2007\u2008 \u200a \u2028\u2029​\u202f\u205f​\u3000].
[\b]	Membolehkan anda mencari aksara ruang belakang (watak khas \b, U+0008).
\0	Membolehkan anda mencari simbol 0 (sifar).
\n	Membolehkan anda mencari watak baris baharu.
\f	Membolehkan anda mencari watak suapan halaman.
\r	Membolehkan anda mencari watak pemulangan pengangkutan.
\t	Membolehkan anda mencari watak tab mendatar.
\v	Membolehkan anda mencari watak tab menegak.
\w	Membolehkan anda mencari sebarang aksara abjad angka dalam abjad Latin asas, termasuk garis bawah. Setara dengan set watak.
\W	Membolehkan anda mencari sebarang aksara yang bukan aksara daripada abjad Latin asas. Bersamaan dengan set aksara [^a-Za-z0-9_].
\cX	Membolehkan anda mencari watak kawalan dalam rentetan. Di mana X ialah huruf dari A hingga Z. Contohnya, /\cM/ mewakili aksara Ctrl-M.
\xhh	Membolehkan anda mencari simbol menggunakan nilai heksadesimal(hh ialah nilai perenambelasan dua digit).
\uhhhh	Membolehkan anda mencari aksara menggunakan pengekodan UTF-16 (hhhh ialah nilai perenambelasan empat digit).
\u(hhhh) atau \u(hhhhh)	Membolehkan anda mencari aksara dengan nilai Unikod U+hhhh atau U+hhhhh (nilai perenambelasan). Hanya apabila bendera u diberikan.
\	Menunjukkan bahawa watak berikut adalah istimewa dan tidak boleh ditafsirkan secara literal. Untuk watak yang biasanya ditafsirkan dengan cara yang istimewa, nyatakan bahawa watak berikut tidak istimewa dan harus ditafsirkan secara literal.

Pengkuantiti Sekatan Penerangan Simbol

n*	Padanan berlaku pada mana-mana rentetan yang mengandungi sifar atau lebih kejadian aksara n.
n+	Pemadanan berlaku dengan mana-mana rentetan yang mengandungi sekurang-kurangnya satu aksara n.
n?	Padanan berlaku pada mana-mana rentetan dengan elemen sebelumnya n sifar atau satu kali.
n(x)	Memadankan mana-mana rentetan yang mengandungi jujukan aksara n beberapa kali tertentu x. X
n(x,)	x kejadian unsur sebelumnya n. X mestilah integer positif.
n(x, y)	Padan dengan mana-mana rentetan yang mengandungi sekurang-kurangnya x, tetapi tidak lebih daripada dengan y kejadian unsur sebelumnya n. X Dan y mestilah integer positif.
n*? n+? n?? n(x)? n(x,)? n(x,y)?	Perbandingan berlaku dengan analogi dengan pengkuantiti *, +, ? dan (...), namun pada masa yang sama pencarian sedang dijalankan perbandingan minimum yang mungkin. Lalai ialah mod "tamak", ? pada penghujung pengkuantiti membolehkan anda menetapkan mod "tidak tamak" di mana perbandingan diulang sebanyak mungkin kali minimum.
x(?=y)	Membolehkan anda membandingkan x, hanya jika untuk x sepatutnya y.
x(?!y)	Membolehkan anda membandingkan x, hanya jika untuk x jangan lakukannya y.
x|y	Perbandingan berlaku dengan mana-mana alternatif yang ditentukan.

Pengumpulan dan pautan balik Penerangan Simbol

(x)	Membolehkan anda mencari simbol x dan ingat hasil perbandingan ("menangkap kurungan"). Subrentetan yang dipadankan boleh dipanggil daripada unsur tatasusunan yang terhasil ..., [n], atau daripada sifat objek RegExp yang dipratentukan $1 ..., $9.
(?:x)	Membolehkan anda mencari simbol x, tetapi tidak mengingati keputusan perlawanan ("kurung tidak menangkap"). Subrentetan yang dipadankan tidak boleh dipanggil daripada unsur tatasusunan yang terhasil ..., [n], atau daripada sifat objek RegExp yang dipratakrifkan $1 ..., $9.
\n	Rujukan kembali kepada subrentetan terakhir yang sepadan dengan yang ke-n dalam kurungan dalam ungkapan biasa (penomboran kurungan pergi dari kiri ke kanan). n mestilah integer positif.