mengganti fungsi

• regexp - reg. ekspresi;
• newSubStr - string yang mengubah ekspresi yang ditemukan dalam teks;
• fungsi - dipanggil untuk setiap kecocokan yang ditemukan dengan daftar variabel parameter (ingat bahwa pencarian global menemukan semua contoh kecocokan pola dalam sebuah string).

Nilai balik dari fungsi ini berfungsi sebagai pengganti.

Parameter fungsi:

• 1 - Substring yang cocok penuh.
• 2 - Arti kelompok braket (fiksasi).
• 3 - Indeks (posisi) kecocokan di string sumber.
• 4 - Rangkaian sumber.

Metode ini tidak mengubah string panggilan, tetapi mengembalikan yang baru setelah mengganti kecocokan. Untuk melakukan pencarian dan penggantian global, gunakan regexp dengan flag g.

"GHGHGHGTTTT".ganti(//g,"K"); //"KKKKKKKKKKK"

javascript

Ekspresi Reguler memungkinkan pencarian kata dan ekspresi yang fleksibel dalam teks untuk menghapus, mengekstrak, atau menggantinya.

Sintaksis:

//Cara pertama membuat regular expression var regexp=new RegExp( Sampel,pengubah); //Opsi kedua untuk membuat regular expression var regexp=/ Sampel/pengubah;

Sampel memungkinkan Anda menentukan pola karakter untuk pencarian.

pengubah memungkinkan Anda menyesuaikan perilaku pencarian:

• Saya- pencarian tanpa memperhatikan kasus surat;
• G- pencarian global (semua kecocokan dalam dokumen akan ditemukan, bukan hanya yang pertama);
• M- pencarian multi baris.

Cari kata dan ekspresi

Penggunaan ekspresi reguler yang paling sederhana adalah untuk mencari kata dan ekspresi dalam berbagai teks.

Berikut adalah contoh penggunaan pencarian dengan pengubah:

//Atur ekspresi reguler rv1 rv1=/Russia/; //Atur ekspresi reguler rv2 rv2=/Russia/g; //Atur ekspresi reguler rv3 rv3=/Russia/ig; //Ini disorot dengan huruf tebal di mana kecocokan akan ditemukan dalam teks saat menggunakan //ekspresi rv1: Rusia adalah negara terbesar di dunia. Rusia berbatasan dengan 18 negara. RUSIA adalah negara penerus Uni Soviet. //Ini disorot dengan huruf tebal di mana kecocokan akan ditemukan dalam teks saat menggunakan //ekspresi rv2: Rusia adalah negara terbesar di dunia. Rusia berbatasan dengan 18 negara. RUSIA adalah negara penerus Uni Soviet."; //Hal ini disorot dengan huruf tebal di mana kecocokan akan ditemukan dalam teks ketika menggunakan //ekspresi rv3: Rusia adalah negara bagian terbesar di dunia. Rusia berbatasan dengan 18 negara. RUSIA adalah negara penerus Uni Soviet.";

Simbol khusus

Selain karakter reguler, pola ekspresi reguler dapat digunakan Simbol khusus(karakter meta). Karakter khusus dengan deskripsi ditunjukkan pada tabel di bawah ini:

/* Ekspresi reg1 akan menemukan semua kata yang dimulai dengan dua huruf arbitrer dan diakhiri dengan "basah". Karena kata-kata dalam kalimat dipisahkan oleh spasi, maka di awal dan di akhir kita tambahkan karakter khusus \s) */ reg1=/\s..vet\s/g; txt="halo lemari beludru perjanjian"; document.write(txt.match(reg1) + "
"); /* Ekspresi reg2 akan menemukan semua kata yang dimulai dengan tiga huruf arbitrer dan diakhiri dengan "wt" */ reg2=/\s...wt\s/g; document.write(txt.match(reg2) + "
"); txt1=" halo halo halo "; /* Ekspresi reg3 akan menemukan semua kata yang dimulai dengan "with" diikuti dengan 1 digit dan diakhiri dengan "wt" */ var reg3=/when\dwt/g; document . tulis(txt1.cocok(reg3) + "
"); // Ekspresi reg4 akan menemukan semua angka dalam teks var reg4=/\d/g; txt2="5 tahun belajar, 3 tahun berenang, 9 tahun menembak." document.write(txt2. cocok(reg4) + "
");

Lihat sekilas

Karakter dalam tanda kurung siku

Menggunakan tanda kurung siku [keyu] Anda dapat menentukan sekelompok karakter untuk dicari.

Karakter ^ sebelum sekelompok karakter dalam tanda kurung siku [^kvg] mengatakan bahwa Anda perlu mencari semua karakter alfabet kecuali yang diberikan.

Menggunakan tanda hubung (-) di antara karakter dalam tanda kurung siku [ah] Anda dapat menentukan rentang karakter untuk dicari.

Anda juga dapat mencari angka menggunakan tanda kurung siku.

//Atur ekspresi reguler reg1 reg1=/\sko[tdm]\s/g; //Atur string teks txt1 txt1=" kode kepang kucing lemari laci com karpet "; //Mari gunakan ekspresi reguler reg1 untuk mencari string txt1 document.write(txt1.match(reg1) + "
"); reg2=/\sslo[^tg]/g; txt2="slot suku kata gajah"; document.write(txt2.match(reg2) + "
"); reg3=//g; txt3="5 tahun belajar, 3 tahun berenang, 9 tahun menembak"; document.write(txt3.match(reg3));

Lihat sekilas

Pengukur

Pembilang- ini adalah konstruksi yang memungkinkan Anda menentukan berapa kali karakter atau grup karakter sebelumnya harus muncul dalam sebuah pertandingan.

Sintaksis:

//Karakter sebelumnya harus muncul x - kali (X)//Karakter sebelumnya harus muncul dari x ke y kali, inklusif (x,y)// Karakter sebelumnya harus muncul setidaknya x kali (X,)//Menentukan bahwa karakter sebelumnya harus muncul 0 kali atau lebih * //Menentukan bahwa karakter sebelumnya harus muncul 1 kali atau lebih + //Menentukan bahwa karakter sebelumnya harus muncul 0 atau 1 kali ?

//Setel ekspresi reguler rv1 rv1=/ko(5)shka/g //Setel ekspresi reguler rv2 rv2=/ko(3,)shka/g //Setel ekspresi reguler rv3 rv3=/ko+shka/g //Setel ekspresi reguler rv4 rv4=/cat?cat/g //Setel ekspresi reguler rv5 rv5=/cat*cat/g //Bold menunjukkan di mana teks yang cocok akan ditemukan saat menggunakan //ekspresi rv1: cat cat untuk? coooooooooooooooooooooooooooooooooooooooooooooooooow//Bold menunjukkan di mana teks yang cocok akan ditemukan saat menggunakan //ekspresi rv3: kshka kucing kucing// tebal menunjukkan di mana dalam teks cocok akan ditemukan ketika // menggunakan ekspresi rv4: kshka kucing kucingoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooookucing kshka

Catatan: jika Anda ingin menggunakan karakter khusus (seperti .* + ? atau ()) sebagai karakter biasa, Anda harus mengawalinya dengan \.

Menggunakan tanda kurung

Dengan menyertakan bagian dari pola ekspresi reguler dalam tanda kurung, Anda memberi tahu ekspresi untuk mengingat kecocokan yang ditemukan oleh bagian pola tersebut. Kecocokan yang disimpan dapat digunakan nanti dalam kode Anda.

Misalnya, ekspresi reguler /(Dmitry)\sVasilyev/ akan menemukan string "Dmitry Vasilyev" dan mengingat substring "Dmitry".

Pada contoh di bawah ini, kami menggunakan metode replace() untuk mengubah urutan kata dalam teks. Kami menggunakan $1 dan $2 untuk mengakses kecocokan yang disimpan.

Var regexp = /(Dmitry)\s(Vasiliev)/; var text = "Dmitry Vasiliev"; var teksbaru = teks.ganti(regexp, "$2 $1"); dokumen.tulis(teksbaru);

Lihat sekilas

Tanda kurung dapat digunakan untuk mengelompokkan karakter sebelum pembilang.

Ekspresi Reguler

Ekspresi reguler adalah objek yang menggambarkan pola karakter. Kelas RegExp dalam JavaScript mewakili ekspresi reguler, dan objek dari kelas String dan RegExp menentukan metode yang menggunakan ekspresi reguler untuk melakukan operasi pencocokan pola dan penggantian teks. Tata bahasa ekspresi reguler dalam JavaScript berisi subset yang cukup lengkap dari sintaks ekspresi reguler yang digunakan di Perl 5, jadi jika Anda terbiasa dengan Perl, Anda seharusnya dapat menulis pola dalam program JavaScript dengan mudah.

Fitur ekspresi reguler Perl yang tidak didukung dalam ECMAScript termasuk flag s (mode baris tunggal) dan x (sintaks yang diperluas); escape sequence \a, \e, \l, \u, \L, \U, \E, \Q, \A, \Z, \z, dan \G, dan konstruksi tambahan lainnya yang dimulai dengan (?.

Mendefinisikan ekspresi reguler

Dalam JavaScript, ekspresi reguler diwakili oleh objek. RegExp. Objek RegExp dapat dibuat menggunakan konstruktor RegExp(), tetapi lebih sering dibuat menggunakan sintaks literal khusus. Sama seperti literal string yang ditentukan sebagai karakter yang diapit tanda kutip, literal ekspresi reguler ditentukan sebagai karakter yang diapit oleh sepasang garis miring (/). Jadi, kode JavaScript mungkin berisi baris yang mirip dengan ini:

Varpattern = /s$/;

Baris ini membuat objek RegExp baru dan menugaskannya ke variabel pola. Objek RegExp ini mencari string yang diakhiri dengan "s". Ekspresi reguler yang sama dapat didefinisikan menggunakan konstruktor RegExp() :

Varpattern = new RegExp("s$");

Spesifikasi pola ekspresi reguler terdiri dari urutan karakter. Sebagian besar karakter, termasuk semua karakter alfanumerik, secara harfiah mendeskripsikan karakter yang harus ada. Artinya, ekspresi reguler /java/ cocok dengan semua string yang mengandung substring "java".

Karakter lain dalam ekspresi reguler tidak dimaksudkan untuk dicari padanan persisnya, tetapi memiliki arti khusus. Misalnya, ekspresi reguler /s$/ berisi dua karakter. Karakter pertama s menunjukkan pencarian karakter literal. Yang kedua, $, adalah metakarakter khusus yang menandai akhir dari sebuah baris. Jadi ekspresi reguler ini cocok dengan string apa pun yang diakhiri dengan s.

Bagian berikut menjelaskan berbagai karakter dan karakter meta yang digunakan dalam ekspresi reguler JavaScript.

Simbol literal

Seperti disebutkan sebelumnya, semua karakter alfabet dan angka dalam ekspresi reguler cocok dengan dirinya sendiri. Sintaks ekspresi reguler JavaScript juga mendukung kemampuan untuk menentukan karakter non-alfabet tertentu menggunakan urutan escape yang dimulai dengan karakter garis miring terbalik (\). Misalnya, urutan \n cocok dengan karakter baris baru. Karakter ini tercantum dalam tabel di bawah ini:

Beberapa tanda baca memiliki arti khusus dalam ekspresi reguler:

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

Arti dari simbol-simbol ini dijelaskan pada bagian berikut. Beberapa dari mereka memiliki arti khusus hanya dalam konteks ekspresi reguler tertentu, sementara dalam konteks lain mereka dipahami secara harfiah. Namun, secara umum, untuk menyertakan karakter ini secara harfiah dalam ekspresi reguler, Anda harus mengawalinya dengan karakter garis miring terbalik. Karakter lain, seperti tanda kutip dan @, tidak memiliki arti khusus dan hanya cocok dengan dirinya sendiri dalam ekspresi reguler.

Jika Anda tidak dapat mengingat dengan tepat karakter mana yang harus didahului oleh \, Anda dapat dengan aman meletakkan garis miring terbalik di depan salah satu karakter. Namun, perlu diingat bahwa banyak huruf dan angka memiliki arti khusus bersama dengan garis miring, sehingga huruf dan angka yang Anda cari secara harfiah tidak boleh diawali dengan \. Untuk menyertakan karakter garis miring terbalik itu sendiri dalam ekspresi reguler, Anda jelas harus mendahuluinya dengan karakter garis miring terbalik lainnya. Misalnya, ekspresi reguler berikut cocok dengan string apa pun yang berisi karakter garis miring terbalik: /\\/.

Kelas karakter

Karakter literal individu dapat digabungkan ke dalam kelas karakter dengan melampirkannya dalam tanda kurung siku. Kelas karakter cocok dengan karakter apa pun yang ada di kelas itu. Oleh karena itu, ekspresi reguler // cocok dengan salah satu karakter a, b, atau c.

Kelas karakter yang dinegatifkan juga dapat didefinisikan, cocok dengan karakter apa pun selain yang diberikan dalam tanda kurung. Kelas karakter yang dinegasikan ditentukan oleh karakter ^ sebagai karakter pertama setelah tanda kurung kiri. Ekspresi reguler /[^abc]/ cocok dengan karakter apa pun selain a, b, atau c. Di kelas karakter, rentang karakter dapat ditentukan dengan tanda hubung. Semua karakter Latin huruf kecil dicari menggunakan ekspresi //, dan huruf atau angka apa pun dari rangkaian karakter Latin dapat ditemukan menggunakan ekspresi //.

Kelas karakter tertentu sering digunakan, sehingga sintaks ekspresi reguler dalam JavaScript menyertakan karakter khusus dan urutan pelolosan untuk menunjukkannya. Misalnya, \s cocok dengan spasi, tab, dan karakter spasi apa pun dari set Unicode, dan \S cocok dengan karakter non-spasi apa pun dari set Unicode.

Tabel di bawah mencantumkan karakter khusus ini dan sintaks dari kelas karakter. (Perhatikan bahwa beberapa kelas karakter escape sequence hanya cocok dengan karakter ASCII dan tidak diperluas untuk bekerja dengan karakter Unicode. Anda dapat secara eksplisit menentukan kelas karakter Unicode Anda sendiri, misalnya /[\u0400-\u04FF]/ cocok dengan karakter Cyrillic apa pun. )

Perhatikan bahwa urutan pelepasan karakter khusus kelas dapat dilampirkan dalam tanda kurung siku. \s cocok dengan karakter spasi apa pun dan \d cocok dengan digit apa pun, jadi /[\s\d]/ cocok dengan karakter atau digit spasi apa pun.

Pengulangan

Dengan pengetahuan sintaks ekspresi reguler yang diperoleh sejauh ini, kita dapat menggambarkan angka dua digit sebagai /\d\d/ atau angka empat digit sebagai /\d\d\d\d/, tetapi kita tidak bisa, misalnya , jelaskan angka yang terdiri dari sejumlah digit, atau rangkaian tiga huruf yang diikuti dengan digit opsional. Pola yang lebih kompleks ini menggunakan sintaks ekspresi reguler untuk menentukan berapa kali elemen ekspresi reguler tertentu dapat diulang.

Simbol yang menunjukkan pengulangan selalu mengikuti pola yang diterapkannya. Beberapa jenis pengulangan cukup sering digunakan, dan ada simbol khusus untuk kasus ini. Misalnya, + cocok dengan satu atau lebih contoh dari pola sebelumnya. Tabel berikut adalah ringkasan dari sintaks pengulangan:

Baris berikut menunjukkan beberapa contoh:

Varpattern = /\d(2,4)/; // Mencocokkan angka yang terdiri dari dua hingga empat digit pattern = /\w(3)\d?/; // Mencocokkan tepat tiga karakter kata dan satu pola angka opsional = /\s+java\s+/; // Mencocokkan kata "java" dengan satu spasi atau lebih // sebelum dan sesudahnya pattern = /[^(]*/; // Mencocokkan nol atau lebih karakter selain kurung buka

Berhati-hatilah saat menggunakan karakter berulang * dan ?. Mereka dapat mencocokkan ketiadaan pola yang didahului oleh mereka, dan karenanya ketiadaan karakter. Misalnya, ekspresi reguler /a*/ cocok dengan string "bbbb" karena tidak mengandung karakter a.

Karakter pengulangan yang tercantum dalam tabel sesuai dengan jumlah pengulangan maksimum yang memungkinkan, yang memastikan pencarian bagian selanjutnya dari ekspresi reguler. Kami mengatakan bahwa ini adalah pengulangan yang "rakus". Dimungkinkan juga untuk menerapkan pengulangan dengan cara yang "tidak serakah". Cukup dengan menentukan tanda tanya setelah karakter (atau karakter) pengulangan: ??, +?, *? atau bahkan (1,5)?.

Misalnya, ekspresi reguler /a+/ cocok dengan satu atau lebih contoh huruf a. Diterapkan ke string "aaa", ini cocok dengan ketiga huruf tersebut. Di sisi lain, /a+?/ cocok dengan satu atau lebih kemunculan huruf a dan memilih jumlah karakter sesedikit mungkin. Diterapkan pada string yang sama, pola ini hanya cocok dengan huruf pertama a.

Pengulangan yang "tidak serakah" tidak selalu memberikan hasil yang diharapkan. Pertimbangkan pola /a+b/ yang cocok dengan satu atau lebih a diikuti oleh a b. Untuk string "aaab", cocok dengan seluruh string.

Sekarang mari kita periksa versi "non-greedy" dari /a+?b/. Orang mungkin berpikir bahwa itu harus cocok dengan a b didahului oleh hanya satu a. Jika diterapkan pada string yang sama, "aaab" diharapkan cocok dengan satu a dan b terakhir. Namun, pada kenyataannya, seluruh string cocok dengan pola ini, seperti dalam kasus versi "rakus". Ini karena pencarian pola ekspresi reguler dilakukan dengan menemukan posisi pertama dalam string yang memungkinkan kecocokan. Karena kecocokan dimungkinkan mulai dari karakter pertama string, kecocokan yang lebih pendek yang dimulai dari karakter berikutnya bahkan tidak dipertimbangkan.

Alternatif, pengelompokan dan tautan

Tata bahasa ekspresi reguler menyertakan karakter khusus untuk menentukan alternatif, pengelompokan subekspresi, dan referensi ke subekspresi sebelumnya. Simbol batang vertikal | berfungsi untuk memisahkan alternatif. Misalnya, /ab|cd|ef/ cocok dengan string "ab" atau string "cd" atau string "ef" dan pola /\d(3)|(4)/ cocok dengan tiga digit atau empat huruf kecil huruf .

Perhatikan bahwa alternatif diproses dari kiri ke kanan hingga ditemukan kecocokan. Jika ditemukan kecocokan dengan alternatif kiri, alternatif kanan diabaikan, bahkan jika kecocokan yang "lebih baik" dapat dicapai. Jadi ketika /a|ab/ diterapkan pada string "ab", itu hanya akan cocok dengan karakter pertama.

Tanda kurung memiliki banyak arti dalam ekspresi reguler. Salah satunya adalah mengelompokkan elemen individu ke dalam satu subekspresi, sehingga elemen saat menggunakan karakter khusus |, *, +, ? dan yang lainnya diperlakukan sebagai satu. Misalnya, pola /java(script)?/ cocok dengan kata "java" diikuti dengan kata opsional "script", dan /(ab|cd)+|ef)/ cocok dengan string "ef" atau satu atau lebih pengulangan satu dari string "ab" atau "cd".

Penggunaan tanda kurung lainnya dalam ekspresi reguler adalah untuk mendefinisikan subpola dalam suatu pola. Ketika kecocokan ekspresi reguler ditemukan di string target, bagian dari string target yang cocok dengan subpola tanda kurung tertentu dapat diekstrak.

Misalkan Anda ingin mencari satu atau lebih huruf kecil diikuti dengan satu atau lebih angka. Anda dapat menggunakan pola /+\d+/ untuk ini. Tapi misalkan juga kita hanya menginginkan angka di akhir setiap pertandingan. Jika kita menempatkan bagian pola ini dalam tanda kurung (/+(\d+)/), maka kita dapat mengekstrak angka dari kecocokan apa pun yang kita temukan. Bagaimana ini dilakukan akan dijelaskan di bawah ini.

Terkait dengan ini adalah penggunaan lain dari subekspresi dalam tanda kurung untuk merujuk ke subekspresi dari bagian sebelumnya dari ekspresi reguler yang sama. Ini dicapai dengan menentukan satu atau lebih digit setelah karakter \. Angka mengacu pada posisi subekspresi dalam tanda kurung dalam ekspresi reguler. Misalnya, \1 merujuk ke subekspresi pertama, dan \3 merujuk ke subekspresi ketiga. Perhatikan bahwa subekspresi dapat disarangkan, sehingga posisi tanda kurung kiri digunakan dalam hitungan. Misalnya, dalam ekspresi reguler berikut, referensi ke subekspresi bersarang (skrip) akan terlihat seperti \2:

/(ava(skrip)?)\sis\s(menyenangkan\w*)/

Referensi ke subekspresi sebelumnya tidak menunjuk ke templat subekspresi ini, tetapi ke teks yang ditemukan yang cocok dengan templat ini. Oleh karena itu, referensi dapat digunakan untuk menerapkan batasan yang memilih bagian string yang berisi karakter yang persis sama. Misalnya, ekspresi reguler berikut cocok dengan nol atau lebih karakter di dalam tanda kutip tunggal atau ganda. Namun, ini tidak mengharuskan tanda kutip pembuka dan penutup cocok (yaitu, kedua tanda kutip tunggal atau ganda):

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

Kami dapat meminta kutipan agar sesuai dengan referensi ini:

Di sini \1 cocok dengan pencocokan subekspresi pertama. Dalam contoh ini, tautan memberlakukan batasan yang mengharuskan kutipan penutup cocok dengan kutipan pembuka. Ekspresi reguler ini tidak mengizinkan tanda kutip tunggal di dalam tanda kutip ganda, dan sebaliknya.

Dimungkinkan juga untuk mengelompokkan elemen dalam ekspresi reguler tanpa membuat referensi bernomor untuk elemen tersebut. Alih-alih hanya mengelompokkan elemen antara (dan) mulai grup dengan karakter (?: dan akhiri dengan karakter). Pertimbangkan, misalnya, templat berikut:

/(ava(?:skrip)?)\sis\s(menyenangkan\w*)/

Di sini subekspresi (?:skrip) hanya diperlukan untuk pengelompokan, sehingga pengulangan karakter ? dapat diterapkan ke grup. Tanda kurung yang dimodifikasi ini tidak membuat tautan, jadi \2 dalam ekspresi reguler ini merujuk ke teks yang cocok dengan pola (menyenangkan\w*).

Tabel berikut mencantumkan operator pilih-dari-alternatif, pengelompokan, dan referensi dalam ekspresi reguler:

Menentukan posisi pertandingan

Seperti dijelaskan sebelumnya, banyak elemen ekspresi reguler cocok dengan satu karakter dalam string. Misalnya, \s cocok dengan satu karakter spasi putih. Elemen ekspresi reguler lainnya cocok dengan posisi antar karakter, bukan karakter itu sendiri. Misalnya, \b cocok dengan batas kata - batas antara \w (karakter teks ASCII) dan \W (karakter non-teks), atau batas antara karakter teks ASCII dan awal atau akhir baris.

Elemen seperti \b tidak menentukan karakter apa pun yang harus ada dalam string yang cocok, tetapi menentukan posisi valid untuk pencocokan. Elemen-elemen ini terkadang disebut elemen jangkar ekspresi reguler karena mereka menambatkan pola ke posisi tertentu dalam string. Lebih sering daripada yang lain, elemen jangkar seperti ^ dan $ digunakan, yang masing-masing menautkan pola ke awal dan akhir baris.

Misalnya, kata "JavaScript" pada barisnya sendiri dapat dicocokkan dengan ekspresi reguler /^JavaScript$/. Untuk menemukan satu kata "Java" (bukan awalan, misalnya pada kata "JavaScript"), Anda dapat mencoba menggunakan pola /\sJava\s/, yang membutuhkan spasi sebelum dan sesudah kata.

Tapi solusi ini menimbulkan dua masalah. Pertama, ia hanya akan menemukan kata "Java" jika dikelilingi oleh spasi di kedua sisinya, dan tidak akan menemukannya di awal atau akhir string. Kedua, ketika pola ini cocok, string yang dikembalikannya akan berisi spasi awal dan akhir, yang tidak persis seperti yang kita inginkan. Jadi alih-alih pola yang cocok dengan karakter spasi \s, kami akan menggunakan pola (atau jangkar) yang cocok dengan batas kata \b. Ekspresi berikut akan diperoleh: /\bJava\b/.

Elemen jangkar \B cocok dengan posisi yang bukan batas kata. Artinya, pola /\Bcript/ akan cocok dengan kata "JavaScript" dan "postscript" dan tidak akan cocok dengan kata "script" atau "Scripting".

Ekspresi reguler sewenang-wenang juga dapat bertindak sebagai kondisi jangkar. Menempatkan ekspresi di antara karakter (?= dan) mengubahnya menjadi kecocokan lihat ke depan untuk karakter berikutnya, mengharuskan karakter tersebut untuk mencocokkan pola yang ditentukan tetapi tidak disertakan dalam string pencocokan.

Misalnya, untuk mencocokkan nama bahasa pemrograman umum yang diikuti titik dua, Anda dapat menggunakan ekspresi /ava(script)?(?=\:)/. Pola ini cocok dengan kata "JavaScript" dalam string "JavaScript: The Definitive Guide", tetapi tidak akan cocok dengan kata "Java" dalam string "Java in a Nutshell" karena tidak diikuti oleh titik dua.

Jika Anda memasukkan kondisi (?!, maka itu akan menjadi uji lihat ke depan negatif untuk karakter berikutnya, mengharuskan karakter berikut tidak cocok dengan pola yang ditentukan. Misalnya, pola /Java(?!Script)(\w *)/ cocok dengan substring "Java", diikuti dengan huruf besar dan sejumlah karakter teks ASCII, asalkan substring "Java" tidak diikuti oleh substring "Script" Ini cocok dengan string "JavaBeans" tetapi tidak cocok string "Javanese", cocok dengan string "JavaScrip ' tetapi tidak akan cocok dengan string 'JavaScript' atau 'JavaScripter'.

Tabel di bawah mencantumkan karakter jangkar dalam ekspresi reguler:

Bendera

Dan satu elemen terakhir dari tata bahasa ekspresi reguler. Bendera ekspresi reguler menentukan aturan pencocokan pola tingkat tinggi. Tidak seperti tata bahasa ekspresi reguler lainnya, flag tidak ditentukan di antara karakter garis miring, tetapi setelah yang kedua. Bahasa JavaScript mendukung tiga flag.

bendera i menentukan bahwa pencarian pola harus case-insensitive, dan g bendera- bahwa pencarian harus bersifat global, mis. semua kecocokan dalam string harus ditemukan. bendera m melakukan pencarian pola dalam mode multiline. Jika ekspresi string yang dicari berisi baris baru, maka dalam mode ini karakter jangkar ^ dan $, selain mencocokkan awal dan akhir seluruh ekspresi string, juga mencocokkan awal dan akhir setiap baris teks. Misalnya, pola /java$/im cocok dengan "java" dan "Java\nis fun".

Bendera ini dapat digabungkan dalam kombinasi apa pun. Misalnya, untuk mencari kemunculan pertama kata "java" (atau "Java", "JAVA", dll.) dengan cara yang tidak peka huruf besar/kecil, Anda dapat menggunakan ekspresi reguler tidak peka huruf besar/kecil /\bjava\b/ Saya. Dan untuk menemukan semua kemunculan kata ini dalam sebuah string, Anda dapat menambahkan flag g: /\bjava\b/gi.

Metode kelas string untuk pencocokan pola

Sampai saat ini, kita telah membahas tata bahasa ekspresi reguler yang dihasilkan, tetapi kita belum melihat bagaimana ekspresi reguler ini benar-benar dapat digunakan dalam skrip JavaScript. Pada bagian ini, kita akan membahas metode pada objek String yang menggunakan ekspresi reguler untuk pencocokan pola serta untuk mencari dan mengganti. Dan kemudian kita akan melanjutkan pembicaraan tentang pencocokan pola dengan ekspresi reguler dengan melihat objek RegExp, metodenya, dan propertinya.

String mendukung empat metode menggunakan ekspresi reguler. Yang paling sederhana adalah metodenya mencari(). Dibutuhkan ekspresi reguler sebagai argumen dan mengembalikan posisi karakter pertama dari substring yang ditemukan, atau -1 jika tidak ditemukan kecocokan. Misalnya, panggilan berikut akan mengembalikan 4:

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

Jika argumen metode search() bukan ekspresi reguler, pertama-tama dikonversi dengan meneruskannya ke konstruktor RegExp. Metode search() tidak mendukung pencarian global dan mengabaikan flag g dalam argumennya.

metode mengganti() melakukan operasi pencarian dan penggantian. Dibutuhkan ekspresi reguler sebagai argumen pertama dan string pengganti sebagai yang kedua. Metode mencari string yang dipanggil untuk mencocokkan pola yang ditentukan.

Jika regular expression berisi flag g, metode replace() menggantikan semua kecocokan yang ditemukan dengan string pengganti. Jika tidak, itu hanya menggantikan kecocokan pertama yang ditemukan. Jika argumen pertama dari metode replace() adalah string dan bukan ekspresi reguler, maka metode melakukan pencarian literal untuk string tersebut, daripada mengubahnya menjadi ekspresi reguler menggunakan konstruktor RegExp(), seperti pencarian() metode tidak.

Sebagai contoh, kita dapat menggunakan metode replace() untuk mengkapitalisasi kata "JavaScript" secara seragam untuk seluruh baris teks:

// Terlepas dari kasus karakter, kami mengganti kata dalam kasus yang diinginkan var result = "javascript".replace(/JavaScript/ig, "JavaScript");

Metode replace() lebih kuat daripada yang disarankan oleh contoh ini. Ingatlah bahwa subekspresi dalam tanda kurung dalam ekspresi reguler diberi nomor dari kiri ke kanan, dan ekspresi reguler mengingat teks yang cocok dengan setiap subekspresi. Jika string pengganti berisi tanda $ diikuti dengan angka, metode replace() mengganti kedua karakter tersebut dengan teks yang cocok dengan subekspresi yang ditentukan. Ini adalah fitur yang sangat berguna. Kita dapat menggunakannya, misalnya, untuk mengganti tanda kutip lurus dalam sebuah string dengan tanda kutip tipografi yang meniru karakter ASCII:

// Kutipan adalah kutipan yang diikuti oleh sejumlah karakter // selain tanda kutip (kami mengingatnya), karakter ini // diikuti oleh kutipan lain var kutipan = /"([^"]*)"/g; / / Ganti tanda kutip langsung dengan tanda kutip tipografi dan biarkan "$1" tidak berubah // Isi kutipan disimpan dalam $1 var text = ""JavaScript" adalah bahasa pemrograman yang ditafsirkan."; var result = text.replace(quote, ""$1"") ; // "JavaScript" adalah bahasa pemrograman yang ditafsirkan.

Hal penting yang perlu diperhatikan adalah bahwa argumen kedua untuk replace() dapat berupa fungsi yang secara dinamis menghitung string pengganti.

metode cocok() adalah metode kelas String paling umum yang menggunakan ekspresi reguler. Dibutuhkan ekspresi reguler sebagai satu-satunya argumen (atau mengonversi argumennya menjadi ekspresi reguler dengan meneruskannya ke konstruktor RegExp()) dan mengembalikan larik yang berisi hasil pencarian. Jika bendera g disetel dalam ekspresi reguler, metode mengembalikan larik dari semua kecocokan yang ada dalam string. Misalnya:

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

Jika regular expression tidak mengandung flag g, metode match() tidak melakukan pencarian global; itu hanya mencari pertandingan pertama. Namun, match() mengembalikan sebuah array bahkan ketika metode tersebut tidak melakukan pencarian global. Dalam hal ini, elemen pertama dari array adalah substring yang ditemukan, dan semua elemen yang tersisa adalah subekspresi dari ekspresi reguler. Oleh karena itu, jika match() mengembalikan array arr, maka arr akan berisi seluruh string yang ditemukan, arr substring yang sesuai dengan subekspresi pertama, dan seterusnya. Menggambar paralel dengan metode replace() , kita dapat mengatakan bahwa arr[n] diisi dengan isi $n.

Misalnya, lihat kode berikut yang mem-parsing URL:

Var url = /(\w+):\/\/([\w.]+)\/(\S*)/; var text = "Kunjungi situs kami http://www..php"; var result = text match(url); if (hasil != null) ( var fullurl = hasil; // Berisi "http://www..php" var protocol = hasil; // Berisi "http" var host = hasil; // Berisi "www..php ")

Perhatikan bahwa untuk ekspresi reguler yang tidak menyetel flag pencarian global g, metode match() mengembalikan nilai yang sama dengan metode exec() ekspresi reguler: larik yang dikembalikan memiliki properti indeks dan input, seperti yang dijelaskan dalam pembahasan eksekusi ( ) di bawah ini.

Metode terakhir dari objek String yang menggunakan ekspresi reguler adalah membelah(). Metode ini membagi string yang dipanggil menjadi array substring, menggunakan argumen sebagai pembatas. Misalnya:

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

Metode split() juga dapat menggunakan ekspresi reguler sebagai argumen. Ini membuat metode ini lebih kuat. Misalnya, Anda dapat menentukan pembatas yang memungkinkan sejumlah karakter spasi kosong di kedua sisi:

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

objek regexp

Seperti disebutkan, ekspresi reguler direpresentasikan sebagai objek RegExp. Selain konstruktor RegExp(), objek RegExp mendukung tiga metode dan beberapa properti.

Konstruktor RegExp() mengambil satu atau dua argumen string dan membuat objek RegExp baru. Argumen pertama konstruktor adalah string yang berisi badan ekspresi reguler, yaitu. teks yang harus muncul di antara garis miring dalam literal ekspresi reguler. Perhatikan bahwa literal string dan ekspresi reguler menggunakan karakter \ untuk menunjukkan urutan pelolosan, jadi saat meneruskan ekspresi reguler sebagai literal string ke konstruktor RegExp() , Anda harus mengganti setiap karakter \ dengan sepasang karakter \\.

Argumen kedua untuk RegExp() mungkin hilang. Jika ditentukan, ini menentukan bendera ekspresi reguler. Itu harus salah satu karakter g, i, m, atau kombinasi dari karakter-karakter ini. Misalnya:

// Menemukan kelima digit angka dalam sebuah string. Perhatikan // penggunaan karakter \\ dalam contoh ini var zipcode = new RegExp("\\d(5)", "g");

Konstruktor RegExp() berguna ketika ekspresi reguler dihasilkan secara dinamis dan karenanya tidak dapat direpresentasikan menggunakan sintaks literal ekspresi reguler. Misalnya, untuk menemukan string yang dimasukkan oleh pengguna, Anda harus membuat ekspresi reguler saat dijalankan menggunakan RegExp().

Properti regexp

Setiap objek RegExp memiliki lima properti. Properti sumber- string hanya-baca yang berisi teks ekspresi reguler. Properti global adalah nilai boolean hanya-baca yang menentukan keberadaan bendera g dalam ekspresi reguler. Properti abaikanCase adalah boolean hanya-baca yang menentukan apakah bendera i ada dalam ekspresi reguler. Properti multiline adalah boolean hanya-baca yang menentukan apakah flag m ada dalam ekspresi reguler. Dan properti terakhir indeks terakhir adalah bilangan bulat baca/tulis. Untuk pola dengan bendera g, properti ini berisi nomor posisi dalam string di mana pencarian selanjutnya harus dimulai. Seperti dijelaskan di bawah, ini digunakan oleh metode exec() dan test().

Metode RegExp

Objek RegExp mendefinisikan dua metode yang melakukan pencocokan pola; mereka berperilaku serupa dengan metode kelas String yang dijelaskan di atas. Metode utama kelas RegExp yang digunakan untuk pencocokan pola adalah eksekusi(). Ini mirip dengan metode match() dari kelas String yang disebutkan, kecuali bahwa ini adalah metode kelas RegExp yang menggunakan string sebagai argumen, bukan metode kelas String yang menggunakan argumen RegExp.

Metode exec() mengeksekusi ekspresi reguler untuk string yang ditentukan, mis. mencari kecocokan dalam string. Jika tidak ditemukan kecocokan, metode mengembalikan nol. Namun, jika kecocokan ditemukan, ia mengembalikan larik yang sama dengan larik yang dikembalikan oleh metode match() untuk mencari tanpa flag g. Elemen nol dari array berisi string yang cocok dengan ekspresi reguler, dan semua elemen berikutnya adalah substring yang cocok dengan semua subekspresi. Selain itu, properti indeks berisi nomor posisi karakter yang memulai fragmen yang sesuai, dan properti memasukkan mengacu pada string yang dicari.

Tidak seperti match(), metode exec() mengembalikan array yang strukturnya tidak bergantung pada keberadaan flag g dalam ekspresi reguler. Izinkan saya mengingatkan Anda bahwa saat meneruskan ekspresi reguler global, metode match() mengembalikan array kecocokan yang ditemukan. Dan exec() selalu mengembalikan satu kecocokan, tetapi memberikan informasi lengkap tentangnya. Ketika exec() dipanggil pada ekspresi reguler yang berisi flag g, metode ini menyetel properti lastIndex dari objek ekspresi reguler ke nomor posisi karakter tepat setelah substring yang cocok.

Saat metode exec() dipanggil untuk ekspresi reguler yang sama untuk kedua kalinya, metode ini mulai mencari pada posisi karakter yang ditentukan dalam properti lastIndex. Jika exec() tidak menemukan kecocokan, properti lastIndex disetel ke 0. (Anda juga dapat menyetel lastIndex ke nol kapan saja, yang harus Anda lakukan dalam semua kasus di mana pencarian berakhir sebelum kecocokan terakhir dalam satu baris ditemukan , dan pencarian dimulai pada string lain dengan objek RegExp yang sama.) Perilaku khusus ini memungkinkan Anda memanggil exec() berulang kali untuk mengulangi semua kecocokan ekspresi reguler dalam string. Misalnya:

Varpattern = /Java/g; var text = "JavaScript lebih menyenangkan daripada Java!"; hasil; while((result = pattern.exec(text)) != null) ( console.log("Found "" + result + """ + " at position " + result.index + "; pencarian selanjutnya akan dimulai pada " + pola .lastIndex); )

Metode lain dari objek RegExp - tes(), yang jauh lebih sederhana daripada metode exec(). Dibutuhkan string dan mengembalikan true jika string cocok dengan ekspresi reguler:

Varpattern = /java/i; pattern.test("JavaScript"); // Mengembalikan benar

Memanggil test() sama dengan memanggil exec() mengembalikan nilai true jika exec() mengembalikan non-null. Untuk alasan ini, metode test() berperilaku dengan cara yang sama seperti metode exec() saat dipanggil pada ekspresi reguler global: metode ini mulai mencari string yang ditentukan pada posisi yang ditentukan oleh properti lastIndex, dan jika menemukan kecocokan , ini menyetel properti lastIndex ke nomor posisi karakter secara langsung mengikuti kecocokan yang ditemukan. Oleh karena itu, dengan menggunakan metode test(), Anda juga dapat membentuk loop traversal string, seperti menggunakan metode exec().

Pembaruan terakhir: 11.11.2015

Ekspresi Reguler mewakili pola yang digunakan untuk mencari atau memodifikasi string. Untuk bekerja dengan ekspresi reguler dalam JavaScript, sebuah objek ditentukan RegExp.

Ada dua cara untuk mendefinisikan ekspresi reguler:

Var myExp = /hello/; var myExp = new RegExp("halo");

Ekspresi reguler yang digunakan di sini cukup sederhana: terdiri dari satu kata "halo". Dalam kasus pertama, ekspresi ditempatkan di antara dua garis miring, dan dalam kasus kedua, konstruktor RegExp digunakan, di mana ekspresi diteruskan sebagai string.

Metode RegExp

Untuk menentukan apakah regular expression cocok dengan string, objek RegExp mendefinisikan metode test() . Metode ini mengembalikan nilai true jika string cocok dengan regular expression dan false jika sebaliknya.

var initialText = "halo dunia!"; varexp = /halo/; var result = exp.test(initialText); dokumen.tulis(hasil + "
"); // true initialText = "cuaca indah"; result = exp.test(initialText); document.write(result); // false - tidak ada "hello" di string initialText

Metode exec bekerja dengan cara yang sama - ia juga memeriksa apakah string cocok dengan ekspresi reguler, hanya sekarang metode ini mengembalikan bagian string yang cocok dengan ekspresi. Jika tidak ada kecocokan, maka null dikembalikan.

var initialText = "halo dunia!"; varexp = /halo/; varresult = exp.exec(initialText); dokumen.tulis(hasil + "
"); // halo teks awal = "cuaca indah"; hasil = exp.exec(teks awal); dokumen.tulis(hasil); // null

Kelompok karakter

Ekspresi reguler tidak harus terdiri dari string reguler, tetapi juga dapat menyertakan elemen khusus sintaks ekspresi reguler. Salah satu elemen tersebut adalah sekelompok karakter yang diapit tanda kurung siku. Misalnya:

Var initialText = "defensif"; var exp = /[abc]/; var result = exp.test(initialText); dokumen.tulis(hasil + "
"); // trueTeks awal = "kota"; hasil = exp.tes(Teks awal); dokumen.tulis(hasil); // salah

Ekspresi [abc] menunjukkan bahwa string harus memiliki salah satu dari tiga huruf.

Jika kita perlu menentukan keberadaan karakter literal dari rentang tertentu dalam sebuah string, maka kita dapat mengatur rentang ini satu kali:

Var initialText = "defensif"; var exp = /[a-z]/; var result = exp.test(initialText); dokumen.tulis(hasil + "
"); // trueTeks awal = "3di0789"; hasil = exp.tes(teks awal); dokumen.tulis(hasil); // salah

Dalam hal ini, string harus berisi setidaknya satu karakter dari rentang a-z.

Sebaliknya, jika string tidak perlu hanya memiliki karakter tertentu, maka tanda ^ harus diletakkan di dalam tanda kurung siku sebelum mencantumkan karakter:

Var initialText = "defensif"; var exp = /[^a-z]/; var result = exp.test(initialText); dokumen.tulis(hasil + "
"); // false Teks awal = "3di0789"; exp = /[^0-9]/; hasil = exp.test(initialText); document.write(hasil); // true

Dalam kasus pertama, string seharusnya tidak hanya memiliki karakter dari rentang a-z, tetapi karena string "pertahanan" hanya terdiri dari karakter dari rentang ini, metode test () mengembalikan false, yaitu ekspresi reguler tidak cocok dengan rangkaian.

Dalam kasus kedua ("3di0789"), string tidak boleh hanya terdiri dari karakter numerik. Tetapi karena string juga berisi huruf, string tersebut cocok dengan ekspresi reguler, sehingga metode pengujian mengembalikan nilai true.

Jika perlu, kami dapat mengumpulkan kombinasi ekspresi:

Var initialText = "di rumah"; var exp = /[dt]o[nm]/; var result = exp.test(initialText); dokumen.tulis(hasil); // BENAR

Ekspresi [dt]o[nm] menunjukkan string yang mungkin berisi substring "house", "volume", "don", "tone".

Properti Ekspresi

Properti global memungkinkan Anda menemukan semua substring yang cocok dengan ekspresi reguler. Secara default, saat mencari substring, ekspresi reguler memilih substring pertama yang ditemukan dalam string yang cocok dengan ekspresi tersebut. Meskipun mungkin ada banyak substring dalam sebuah string yang juga cocok dengan ekspresi. Untuk ini, properti ini digunakan dalam bentuk simbol g dalam ekspresi

Properti ignCase memungkinkan Anda menemukan substring yang cocok dengan ekspresi reguler, terlepas dari kasus karakter dalam string. Untuk melakukan ini, karakter i digunakan dalam ekspresi reguler.

Properti multiline memungkinkan Anda menemukan substring yang cocok dengan ekspresi reguler dalam teks multiline. Untuk melakukan ini, simbol m digunakan dalam ekspresi reguler.

Misalnya:

Var initialText = "halo dunia"; var exp = /dunia/; var result = exp.test(initialText); // PALSU

Tidak ada kecocokan antara string dan ekspresi di sini, karena "Dunia" berbeda dari "dunia" dalam kasus. Dalam hal ini, Anda perlu mengubah ekspresi reguler dengan menambahkan properti ignCase ke dalamnya:

Varexp = /dunia/i;

Nah, kita juga bisa menggunakan beberapa properti sekaligus.