Pembuatan Objek RegExp:
Penciptaan ekspresi reguler reguler dapat dilakukan secara langsung, yaitu karakter yang terlampir oleh Slash "/". Namun, di lingkungan di mana perubahan parameter diperlukan, konstruktor regexp () adalah pilihan yang lebih baik:
var reg1 =/'/w+'/g;
var reg2 = regexp baru ('/' // w+/'', 'g');
Membandingkan dua metode pembuatan, parameter pertama di RegExp adalah string reguler yang akan dibuat. Di satu sisi, itu bukan representasi langsung dari kuantitas, sehingga tidak tertutup dengan tebasan "/"; Sebaliknya, tanda kutipan "'" dan melarikan diri simbol "/" harus berupa kuadratik melarikan diri dalam string.
Selain itu, apakah itu adalah kuantitas langsung atau konstruktor regexp (), objek RegExp baru dihasilkan dan ditugaskan ke variabel.
Persamaan dan perbedaan antara match () dan exec ():
Pencocokan dan eksekutif adalah cara umum untuk mencocokkan string untuk ekspresi reguler. Fungsi yang diimplementasikan oleh keduanya serupa, dengan beberapa perbedaan halus:
1. Cara menggunakan
Match adalah metode pembungkus objek dengan string, penggunaan: string.match (regexp);
EXEC adalah metode objek ekspresi reguler, penggunaan: regexp.exec (string);
2. Hasil yang dikembalikan
Ketika RegExp tidak mengatur bendera global "G":
Hasil pengembalian keduanya sama. Yaitu, ketika tidak ada nilai yang cocok, ia mengembalikan nol, dan ketika ada nilai yang cocok, ia mengembalikan array (mari array). Array [0] adalah string yang cocok, array [1], array [2] ... sesuai dengan substring tanda kurung dalam ekspresi reguler. Pada saat yang sama, array memiliki dua properti. array.index mewakili posisi awal dari string yang cocok, dan array.input mewakili string yang diambil.
Saat RegExp memiliki bendera global "G" Set:
Pertandingan mengembalikan array array ketika ada nilai. Setiap item dalam array mewakili semua string yang cocok, jadi tidak ada lagi substring yang cocok dengan tanda kurung. Pada saat ini, array tidak memiliki atribut indeks dan atribut input.
EXEC tidak berbeda dari kinerja tanpa label global "G". Array array yang dikembalikan, array [0] adalah string pencocokan saat ini, array [1], array [2] ... adalah string pencocokan saat ini. Pada saat ini, perhatikan properti LastIndex dari objek RegExp, yang mewakili posisi terakhir di akhir string pencocokan dalam string asli. Ketika tidak ada hasil pencocokan lebih lanjut, properti LastIndex diatur ke 0. Oleh karena itu, Anda dapat menggunakan LastIndex Loop untuk menemukan semua string yang cocok.
Mendukung beberapa metode pencocokan:
Kode JS
var teststr = "Sekarang test001 test002"; var re =/test (/d+)/ig; var r = ""; while (r = re.exec (testStr)) {alert (r [0] + "" + r [1]); }Selain itu, Anda juga dapat menggunakan teststr.match (RE), tetapi dengan cara ini, tidak ada opsi untuk G, dan Anda hanya bisa mendapatkan pertandingan pertama.
1. Aturan ekspresi reguler
1.1 Karakter Normal
Surat, angka, karakter Cina, garis bawah, dan tanda baca yang tidak secara khusus didefinisikan dalam bab -bab berikut adalah semua "karakter biasa". Ketika karakter normal dalam ekspresi cocok dengan string, itu cocok dengan karakter yang sama seperti itu.
Contoh 1: Ketika ekspresi "C", saat mencocokkan string "ABCDE", hasil yang cocok adalah: Sukses; Konten yang cocok adalah: "C"; Posisi pencocokan adalah: mulai dari 2 dan berakhir pada 3. (Catatan: Subskrip dimulai dari 0 atau 1, yang dapat bervariasi tergantung pada bahasa pemrograman saat ini)
Contoh 2: Ketika ekspresi "BCD", saat mencocokkan string "ABCDE", hasil yang cocok adalah: berhasil; Konten yang cocok adalah: "BCD"; Posisi pencocokan adalah: Mulai dari 1 dan berakhir pada 4.
1.2 Karakter Escape Sederhana
Untuk beberapa karakter yang tidak nyaman untuk ditulis, gunakan metode penambahan "/" di depan. Kami sudah terbiasa dengan karakter ini.
ekspresi | Cocok |
/r, /n | Mewakili carriage return dan line break |
/T | Simbol tab |
// | Mewakili "/" itu sendiri |
Ada tanda baca lain yang khusus untuk digunakan dalam bab -bab berikut. Setelah menambahkan "/" ke depan, mereka mewakili simbol itu sendiri. Misalnya: ^ dan $ memiliki makna khusus. Jika Anda ingin mencocokkan karakter "^" dan "$" dalam sebuah string, ekspresi perlu ditulis sebagai "/^" dan "/$".
ekspresi | Cocok |
/^ | Cocokkan ^ simbol itu sendiri |
/$ | Cocokkan simbol $ itu sendiri |
/. | Cocokkan titik desimal (.) Sendiri |
Metode pencocokan karakter yang dilarikan ini mirip dengan "karakter normal". Ini juga cocok dengan karakter yang sama.
Contoh 1: Ketika ekspresi "/$ d", saat mencocokkan string "ABC $ DE", hasil yang cocok adalah: Sukses; Konten yang cocok adalah: "$ D"; Posisi pencocokan adalah: Mulai dari 3 dan berakhir pada 5.
1.3 Ekspresi yang bisa cocok dengan 'banyak karakter'
Beberapa metode representasi dalam ekspresi reguler dapat cocok dengan 'beberapa karakter'. Misalnya, ekspresi "/d" dapat cocok dengan angka apa pun. Meskipun dapat cocok dengan karakter apa pun di dalamnya, itu hanya bisa menjadi satu, bukan banyak. Ini seperti saat bermain kartu poker, raja -raja besar dan kecil dapat menggantikan kartu apa pun, tetapi mereka hanya dapat menggantikan satu kartu.
ekspresi | Cocok |
/D | Angka apa pun, salah satu dari 0 ~ 9 |
/w | Surat, nomor atau garis bawah apa pun, yaitu, salah satu dari A ~ z, a ~ z, 0 ~ 9, _ |
/S | Salah satu karakter whitespace termasuk spasi, tab, istirahat halaman, dll. |
. | Titik desimal dapat cocok dengan karakter apa pun kecuali karakter baru (/n). |
Contoh 1: Ketika ekspresi "/d/d", saat mencocokkan "ABC123", hasil pertandingan adalah: Sukses; Konten yang cocok adalah: "12"; Posisi yang cocok adalah: mulai dari 3 dan berakhir pada 5.
Contoh 2: Ketika ekspresi "A./d", saat mencocokkan "AAA100", hasil pertandingan adalah: Sukses; Konten yang cocok adalah: "AA1"; Posisi yang cocok adalah: Mulai dari 1 dan berakhir pada 4.
1.4 Kustomisasi ekspresi yang dapat cocok dengan 'banyak karakter'
Gunakan braket persegi [] untuk berisi serangkaian karakter yang dapat cocok dengan mereka. Jika Anda menggunakan [^] untuk berisi serangkaian karakter, Anda dapat mencocokkan karakter apa pun selain karakter. Dengan cara yang sama, meskipun dapat cocok dengan salah satu dari mereka, itu hanya bisa menjadi satu, bukan banyak.
ekspresi | Cocok |
[AB5@] | Cocokkan "A" atau "B" atau "5" atau "@" |
[^ABC] | Cocokkan karakter apa pun selain "A", "B", "C" |
[FK] | Cocok dengan huruf apa pun antara "f" ~ "k" |
[^A-F0-3] | Cocokkan karakter apa pun selain "A" ~ "f", "0" ~ "3" |
Contoh 1: Ketika ekspresi "[BCD] [BCD]" cocok dengan "ABC123", hasil pertandingan adalah: Sukses; Konten yang cocok adalah: "BC"; Posisi yang cocok adalah: Mulai dari 1 dan berakhir pada 3.
Contoh 2: Ketika ekspresi "[^abc]" cocok dengan "abc123", hasil pertandingan adalah: sukses; Konten yang cocok adalah: "1"; Posisi yang cocok adalah: mulai dari 3 dan berakhir pada 4.
1.5 Simbol khusus yang memodifikasi jumlah kecocokan
Ekspresi yang disebutkan dalam bab sebelumnya hanya dapat mencocokkan satu karakter atau salah satu dari banyak karakter. Jika Anda menggunakan ekspresi plus simbol khusus yang memodifikasi jumlah kecocokan, Anda dapat mengulangi kecocokan tanpa berulang kali menulis ekspresi.
Metode menggunakannya adalah: "Jumlah modifikasi" ditempatkan setelah "ekspresi yang dimodifikasi". Misalnya: "[bcd] [bcd]" dapat ditulis sebagai "[bcd] {2}".
ekspresi | memengaruhi |
{N} | Ekspresi diulangi n kali, misalnya: "/w {2}" setara dengan "/w/w"; "A {5}" setara dengan "aaaaa" |
{M N} | Ekspresi diulang setidaknya m kali, dan paling banyak N kali. Misalnya: "Ba {1,3}" dapat cocok dengan "ba" atau "baa" atau "baaa" |
{M,} | Ekspresi diulang setidaknya m kali, misalnya: "/w/d {2,}" dapat cocok dengan "a12", "_ 456", "m12344" ... |
? | Cocokkan ekspresi 0 atau 1, yang setara dengan {0,1}, misalnya: "A [CD]?" dapat mencocokkan "a", "ac", "iklan" |
+ | Ekspresi muncul setidaknya sekali, yang setara dengan {1,}. Misalnya: "A+B" dapat cocok dengan "AB", "AAB", "AAAB" ... |
* | Ekspresi tidak muncul atau terjadi kapan saja, yang setara dengan {0,}. Misalnya: "/^*b" dapat cocok dengan "b", "^^^ b" ... |
Contoh 1: Ketika ekspresi "/d+/.?/d*" dicocokkan dengan "harganya $ 12,5", hasil pertandingan adalah: berhasil; Konten yang cocok adalah: "12.5"; Posisi yang cocok adalah: mulai dari 10 dan berakhir pada 14.
Contoh 2: Ketika ekspresi "go {2,8} gle" dicocokkan dengan "iklan oleh gooooogle", hasil pertandingan adalah: sukses; Konten yang cocok adalah: "gooooogle"; Posisi yang cocok adalah: mulai dari 7 dan berakhir pada 17.
1.6 Beberapa simbol khusus lainnya yang mewakili makna abstrak
Beberapa simbol mewakili makna khusus abstraksi dalam ekspresi:
ekspresi | memengaruhi |
^ | Cocok dengan tempat di mana string dimulai, bukan karakter apa pun |
$ | Cocok dengan ujung string, tidak cocok dengan karakter apa pun |
/B | Cocokkan batas kata, yaitu posisi antara kata dan ruang, dan tidak cocok dengan karakter apa pun |
Deskripsi teks lebih lanjut masih relatif abstrak, jadi berikan contoh untuk membantu semua orang memahami.
Contoh 1: Ketika ekspresi "^AAA" cocok dengan "xxx aaa xxx", hasil yang cocok adalah: gagal. Karena "^" membutuhkan pencocokan di mana string dimulai, "^aaa" hanya dapat cocok ketika "AAA" berada di awal string, misalnya: "AAA XXX XXX".
Contoh 2: Ketika ungkapan "AAA $" dicocokkan dengan "XXX AAA XXX", hasil yang cocok adalah: Gagal. Karena "$" membutuhkan pencocokan akhir dari string, "AAA $" hanya dapat cocok ketika "AAA" berada di akhir string, misalnya: "xxx xxx aaa".
Contoh 3: Saat ekspresi "./b." dicocokkan dengan "@@@ ABC", hasil yang cocok adalah: berhasil; Konten yang cocok adalah: "@A"; Posisi pencocokan adalah: Mulai dari 2 dan berakhir pada 4.
Penjelasan lebih lanjut: "/b" mirip dengan "^" dan "$", yang tidak cocok dengan karakter apa pun sendiri, tetapi mengharuskannya berada di sisi kiri dan kanan posisi dalam hasil pencocokan, satu sisi adalah kisaran "/w" dan sisi lainnya adalah kisaran non-"/w".
Contoh 4: Ketika ekspresi "/bend/b" cocok "akhir pekan, endfor, end", hasil yang cocok adalah: berhasil; Konten yang cocok adalah: "Akhir"; Posisi pencocokan adalah: mulai dari 15 dan berakhir pada 18.
Beberapa simbol dapat mempengaruhi hubungan antara subkekspresi di dalam ekspresi:
ekspresi | memengaruhi |
| | Hubungan "atau" antara ekspresi di sisi kiri dan kanan, mencocokkan sisi kiri atau kanan |
() | (1). Ketika jumlah kecocokan dimodifikasi, ekspresi dalam kurung dapat dimodifikasi secara keseluruhan. (2). Saat mengambil hasil pencocokan, konten yang cocok dengan ekspresi dalam tanda kurung dapat diperoleh secara terpisah |
Contoh 5: Ketika ungkapan "Tom | Jack" cocok dengan string "I'm Tom, dia jack", hasil yang cocok adalah: berhasil; Konten yang cocok adalah: "Tom"; Posisi pencocokan adalah: Mulai dari 4 dan berakhir pada 7. Saat mencocokkan yang berikutnya, hasil yang cocok adalah: berhasil; Konten yang cocok adalah: "jack"; Saat Posisi Pencocokan: Dimulai pada 15 dan berakhir pada 19.
Contoh 6: Ekspresi "(go/s*)+" saat mencocokkan "Ayo pergi pergi!", Hasil yang cocok adalah: berhasil; Konten yang cocok adalah: "Go Go Go"; Posisi pencocokan adalah: Mulai dari 6 dan berakhir pada 14.
Contoh 7: Ketika ekspresi "￥ (/d+/.?/D*)" dicocokkan dengan "￥ 10.9, ￥ 20.5", hasil pertandingan adalah: berhasil; Konten yang cocok adalah: "￥ 20.5"; Posisi yang cocok adalah: Mulai dari 6 dan berakhir pada 10. Konten yang membuat rentang braket cocok secara terpisah adalah: "20,5".
2. Beberapa aturan lanjutan dalam ekspresi reguler
2.1 Keserakahan dan non-greedy dalam waktu pertandingan
Saat menggunakan simbol khusus yang memodifikasi jumlah kecocokan, ada beberapa metode representasi yang memungkinkan ekspresi yang sama cocok dengan waktu yang berbeda, seperti: "{m, n}", "{m,}", "?", "?", "*", "+". Jumlah kecocokan spesifik tergantung pada string yang cocok. Ekspresi ini dengan jumlah kecocokan berulang yang tidak pasti selalu cocok sebanyak mungkin selama proses pencocokan. Misalnya, untuk teks "dxxxdxxxd", berikut ini adalah:
ekspresi | Cocokkan hasil |
(d) (/w+) | "/W+" akan cocok dengan semua karakter setelah "D" pertama "xxxdxxxd" |
(d) (/w+) (d) | "/W+" akan cocok dengan semua karakter "xxxdxxx" antara "D" pertama dan "D" terakhir. Meskipun "/w+" juga dapat cocok dengan "D" terakhir, untuk membuat seluruh ekspresi cocok dengan sukses, "/w+" dapat "keluar" The Last "D" itu bisa cocok. |
Dapat dilihat bahwa ketika "/w+" cocok, itu selalu cocok dengan sebanyak mungkin karakter yang memenuhi aturannya. Meskipun dalam contoh kedua, itu tidak cocok dengan "D" terakhir, itu juga untuk membuat seluruh ekspresi cocok dengan sukses. Demikian pula, ekspresi dengan "*" dan "{m, n}" cocok dengan sebanyak mungkin, dan ekspresi dengan "?" juga "cocok" sebanyak mungkin ketika mereka bisa mencocokkan atau tidak cocok. Prinsip pencocokan ini disebut pola "keserakahan".
Mode non-greedy:
Menambahkan "?" Tandatangani setelah memodifikasi simbol khusus dari jumlah kecocokan dapat membuat ekspresi dengan berbagai jumlah kecocokan kecocokan sesedikit mungkin, sehingga ekspresi yang dapat cocok atau ketidakcocokan dapat "dicocokkan" sebanyak mungkin. Prinsip pencocokan ini disebut pola "non-greedy", juga disebut pola "barb". Jika ada beberapa kecocokan, itu akan menyebabkan seluruh ekspresi gagal. Mirip dengan mode serakah, mode non-greedy akan cocok dengan tingkat minimum untuk membuat seluruh ekspresi cocok dengan sukses. Misalnya, untuk teks "dxxxdxxxd":
ekspresi | Cocokkan hasil |
(d) (/w+?) | "/W+?" akan cocok dengan sedikit karakter setelah "D" pertama mungkin, dan hasilnya adalah: "/w+?" hanya cocok satu "x" |
(d) (/w+?) (D) | Agar seluruh ekspresi berhasil mencocokkan, "/w+?" Harus cocok dengan "xxx" untuk membuat kecocokan "D" berikutnya, sehingga seluruh ekspresi untuk cocok dengan sukses. Jadi hasilnya adalah: "/w+?" cocok dengan "xxx" |
Untuk kasus lainnya, silakan merujuk ke yang berikut:
Contoh 1: Ketika ekspresi "<td> (.*) </td>" cocok dengan string "<td> <p> aa </p> </td> <td> <p> bb </p> </td>", hasil yang cocok adalah: sukses; Pertandingannya adalah "<td> <p> aa </p> </td>" seluruh string, dan "</td>" dalam ekspresi akan cocok dengan yang terakhir "</td>" di string.
Contoh 2: Sebaliknya, ketika ekspresi "<td> (.*?) </td>" cocok dengan string yang sama dalam Contoh 1, Anda hanya akan mendapatkan "<td> <p> aa </p> </td>". Saat Anda mencocokkan yang berikutnya lagi, Anda akan mendapatkan yang kedua "<td> <p> bb </p> </td>".
2.2 Backreferences /1, /2 ...
Ketika ekspresi cocok, mesin ekspresi merekam string yang cocok dengan ekspresi yang terkandung dalam braket "()". Saat mendapatkan hasil yang cocok, string yang cocok dengan ekspresi yang terkandung dalam tanda kurung dapat diperoleh secara terpisah. Ini telah ditunjukkan berkali -kali dalam contoh sebelumnya. Dalam aplikasi praktis, ketika batas tertentu digunakan untuk mencari, dan konten yang akan diambil tidak mengandung batas, tanda kurung harus digunakan untuk menentukan rentang yang diinginkan. Misalnya, sebelumnya "<td> (.*?) </td>".
Faktanya, "string yang cocok dengan ekspresi yang terkandung dalam tanda kurung" tidak hanya dapat digunakan setelah pertandingan selesai, tetapi juga selama proses pencocokan. Bagian setelah ekspresi dapat merujuk ke "string sub-pertandingan sebelumnya yang telah dicocokkan" dalam tanda kurung. Metode referensi adalah menambahkan angka "/". "/1" mengacu pada string yang cocok dengan sepasang kurung pertama, "/2" mengacu pada string yang cocok dengan sepasang kurung kedua ... dan seterusnya, jika sepasang kurung berisi sepasang kurung lain, kurung luar diurutkan terlebih dahulu. Dengan kata lain, jika pasangan memiliki braket kiri "(" sebelumnya, maka pasangan akan diurutkan terlebih dahulu.
Sebagai contoh:
Contoh 1: Ekspresi "('|") (.*?) (/1) "Saat mencocokkan"' halo ', "dunia" ", hasil pertandingan adalah: berhasil; konten yang cocok adalah:"' Halo '". Saat mencocokkan yang berikutnya lagi, Anda dapat mencocokkan" "dunia" ".
Contoh 2: Ketika ekspresi "(/w)/1 {4,}" dicocokkan dengan "AA BBBB ABCDEFG CCCCC 111121111 99999999999", hasil pertandingan adalah: berhasil; Konten yang cocok adalah "CCCCCC". Ketika Anda mencocokkan yang berikutnya lagi, Anda akan mendapatkan 999999999. Ekspresi ini membutuhkan karakter dalam kisaran "/W" untuk diulang setidaknya 5 kali, memperhatikan perbedaan dari "/w {5,}".
Contoh 3: Ekspresi "<(/w+)/s*(/w+(= ('|").*?/4)?/S*)*>.*? <// 1> "cocok" <td id =' td1 'style = "bgcolor: white"> </td> "if" <td1' tidak berpasangan dengan "</white", itu akan gagal; if bgcolor ", itu tidak ada; sukses.
2.3 Pra-Pencarian, Ketidakcocokan; membalikkan pra-pencarian, ketidakcocokan
Dalam bab sebelumnya, saya berbicara tentang beberapa simbol khusus yang mewakili makna abstrak: "^", "$", "/b". Mereka semua memiliki satu kesamaan: mereka sendiri tidak cocok dengan karakter apa pun, tetapi hanya melampirkan kondisi ke "dua ujung string" atau "celah di antara karakter". Setelah memahami konsep ini, bagian ini akan terus memperkenalkan metode representasi lain yang lebih fleksibel yang menambahkan kondisi ke "dua ujung" atau "celah".
Maju Pra-Pencarian: "(? = Xxxxx)", "(?! Xxxxx)"
Format: "(? = Xxxxx)", dalam string pencocokan, kondisi yang terpasang pada "celah" atau "dua ujung" adalah bahwa sisi kanan celah harus dapat mencocokkan ekspresi bagian xxxxx. Karena itu hanya kondisi tambahan pada celah ini, itu tidak mempengaruhi ekspresi berikutnya untuk benar -benar mencocokkan karakter setelah celah ini. Ini mirip dengan "/b", yang tidak cocok dengan karakter apa pun sendiri. "/B" hanya mengambil karakter sebelum dan sesudah celah dan membuat penilaian, dan tidak akan mempengaruhi ekspresi di belakang untuk benar -benar cocok.
Contoh 1: Ketika ekspresi "windows (? = Nt | xp)" cocok dengan "Windows 98, Windows NT, Windows 2000", itu hanya akan cocok dengan "Windows" di "Windows NT", dan kata -kata lain "Windows" tidak akan cocok.
Contoh 2: Ekspresi "(/w) ((? =/1/1/1) (/1))+" Saat mencocokkan string "AAA FFFFFF 999999999", ia akan cocok dengan 4 dari 6 "F" pertama dan 7 dari 9 "9" ". Ekspresi ini dapat dibaca dan ditafsirkan sebagai: mengulangi nomor alfanumerik lebih dari 4 kali akan cocok dengan bagian sebelum 2 digit terakhir. Tentu saja, ungkapan ini tidak dapat ditulis seperti ini, dan tujuannya di sini adalah untuk tujuan demonstrasi.
Format: "(?! Xxxxx)", sisi kanan celah tidak boleh cocok dengan ekspresi xxxxx.
Contoh 3: Ekspresi "((?!/BStop/B).)+" Saat mencocokkan "fdjka ljfdl berhenti fjdsla fdj", itu akan dicocokkan dari awal ke posisi sebelum "berhenti". Jika tidak ada "berhenti" di string, seluruh string akan dicocokkan.
Contoh 4: Ekspresi "do (?!/W)" hanya bisa cocok "lakukan" saat mencocokkan string "dilakukan, lakukan, anjing". Dalam artikel ini, efek menggunakan "do" after "(?!/W)" dan menggunakan "/b" adalah sama.
Reverse Pra-Search: "(? <= Xxxxx)", "(? <! Xxxxx)"
Konsep kedua format ini mirip dengan pra-pencarian ke depan. Persyaratan untuk pra-pencarian terbalik adalah: "sisi kiri" dari celah. Kedua format mengharuskan mereka harus dapat mencocokkan dan tidak boleh cocok dengan ekspresi yang ditentukan, daripada menilai sisi kanan. Seperti "Maju Pra-Pencarian": keduanya merupakan kondisi tambahan untuk celah di mana mereka berada dan tidak cocok dengan karakter apa pun sendiri.
Contoh 5: Ekspresi "(? <=/D {4})/d+(? =/D {4})" Saat mencocokkan "1234567890123456", angka 8 tengah kecuali 4 angka pertama dan 4 angka terakhir akan dicocokkan. Karena jscript.regexp tidak mendukung pra-pencarian terbalik, artikel ini tidak dapat ditunjukkan. Banyak mesin lain dapat mendukung pra-pencarian terbalik, seperti: java.util.regex paket di atas java 1.4, sistem.text.regularexpressions namespace di .net, dan mesin reguler deelx paling sederhana dan termudah yang direkomendasikan oleh situs ini.
3. Aturan Umum Lainnya
Ada juga beberapa aturan yang lebih umum di antara berbagai mesin ekspresi reguler, yang tidak disebutkan dalam penjelasan sebelumnya.
3.1 Dalam ekspresi, "/xxx" dan "/uxxxx" dapat digunakan untuk mewakili karakter ("x" berarti angka heksadesimal)
membentuk | Rentang karakter |
/xxx | Karakter dengan angka dalam kisaran 0 hingga 255, seperti: spasi dapat diwakili oleh "/x20" |
/uxxxxx | Karakter apa pun dapat diwakili oleh "/u" ditambah jumlah angka heksadesimal 4 digitnya, seperti "/medium" |
3.2 Sementara ekspresi "/s", "/d", "/w", "/b" mewakili makna khusus, huruf kapital yang sesuai mewakili makna yang berlawanan
ekspresi | Cocok |
/S | Cocokkan semua karakter non-whitespace ("/s" dapat mencocokkan karakter whitespace individu) |
/D | Cocokkan semua karakter non-numerik |
/W | Cocokkan semua karakter selain huruf, angka, dan garis bawah |
/B | Cocokkan batas-batas non-kata, yaitu celah karakter ketika kedua sisi "/w" di sisi kiri dan kanan tidak "/w" di sisi kiri dan kanan tidak "/w" di sisi kiri dan kanan tidak |
3.3 Ada makna khusus dalam ekspresi, dan perlu ditambahkan "/" untuk mencocokkan ringkasan karakter dari karakter itu sendiri.
karakter | menjelaskan |
^ | Cocok dengan posisi mulai dari string input. Untuk mencocokkan karakter "^" itu sendiri, gunakan "/^" |
$ | Cocok dengan posisi akhir dari string input. Untuk mencocokkan karakter "$" itu sendiri, gunakan "/$" |
() | Menandai posisi awal dan akhir dari sub -ekspresi. Untuk mencocokkan tanda kurung, gunakan "/(" dan "/)" |
[] | Gunakan ekspresi khusus yang dapat cocok dengan 'beberapa karakter'. Untuk mencocokkan tanda kurung, gunakan "/[" dan "/]" |
{} | Simbol yang memodifikasi jumlah kecocokan. Untuk mencocokkan kawat gigi, gunakan "/{" dan "/}" |
. | Cocokkan karakter apa pun kecuali newline (/n). Untuk mencocokkan titik desimal itu sendiri, gunakan "/." |
? | Jumlah kecocokan modifikasi adalah 0 atau 1. Untuk mencocokkan "?" karakter itu sendiri, gunakan "/?" |
+ | Jumlah kecocokan modifikasi setidaknya 1 kali. Untuk mencocokkan karakter "+" itu sendiri, gunakan "/+" |
* | Jumlah kecocokan modifikasi adalah 0 atau apa pun. Untuk mencocokkan karakter "*" itu sendiri, gunakan "/*" |
| | Hubungan "atau" antara ekspresi di sisi kiri dan kanan. Cocokkan "|" sendiri, silakan gunakan "/|" |
3.4 Subekspresi dalam tanda kurung "()". Jika Anda ingin hasil pencocokan tidak direkam untuk penggunaan di masa mendatang, Anda dapat menggunakan format "(?: xxxxx)"
Contoh 1: Ketika ekspresi "(?: (/w)/1)+" cocok dengan "A BBCCDD EFG", hasilnya adalah "BBCCDD". Hasil pencocokan dari braket "(? :)" Rentang tidak direkam, jadi "(/w)" digunakan untuk merujuknya.
3.5 Pengantar Pengaturan Atribut Ekspresi yang umum digunakan: Ignorecase, Singleline, Multiline, Global
Properti Ekspresi | menjelaskan |
Ignorecase | Secara default, huruf dalam ekspresi peka case. Konfigurasikan sebagai Ignorecase membuat case-tidak sensitif saat mencocokkan. Beberapa mesin ekspresi memperluas konsep "kasus" ke kasus rentang unicode. |
Singleline | Secara default, titik desimal "." cocok dengan karakter selain garis istirahat (/n). Konfigurasikan sebagai singleline untuk membuat titik desimal cocok dengan semua karakter termasuk jeda garis. |
Multiline | Secara default, ekspresi "^" dan "$" hanya cocok dengan awal ① dan akhir ④ posisi string. menyukai: ①xxxxxxxx2/n ③XXXXXXXXX④ Konfigurasikan multiline untuk membuat "^" cocok ①, dan juga dapat mencocokkan posisi ③ sebelum baris berikutnya dimulai, sehingga "$" cocok ④, dan juga dapat mencocokkan posisi ② sebelum garis baru dan berakhir dengan satu baris. |
Global | Ini terutama berfungsi saat menggunakan ekspresi untuk diganti, dan dikonfigurasi sebagai global untuk menggantikan semua kecocokan. |
4. Kiat lain
4.1 Jika Anda ingin memahami bahwa mesin reguler canggih juga mendukung sintaks reguler yang kompleks, silakan merujuk ke dokumentasi mesin reguler Deelx di situs ini.
4.2 Jika Anda ingin meminta ekspresi untuk mencocokkan seluruh string, alih -alih menemukan bagian dari string, Anda dapat menggunakan "^" dan "$" di awal dan akhir ekspresi, misalnya: "^/d+$" mengharuskan seluruh string hanya memiliki angka.
4.3 Jika konten yang diperlukan untuk mencocokkan adalah kata yang lengkap dan bukan bagian dari kata, maka gunakan "/b" di awal dan akhir ekspresi, misalnya: gunakan "/b(if| staf.
4.4 Ekspresi tidak cocok dengan string kosong. Kalau tidak, pertandingan akan berhasil sepanjang waktu, dan tidak ada yang cocok. Misalnya: ketika Anda bersiap untuk menulis ekspresi yang cocok dengan "123", "123.", "123.5", ".5", dll., Bilangan bulat, titik desimal, dan bilangan desimal dapat dihilangkan, tetapi jangan menulis ekspresi sebagai: "/d*/.?/d*", karena jika tidak ada apa pun, ekspresi ini juga dapat cocok dengan sukses. Cara yang lebih baik untuk menulisnya adalah: "/d+/.?/d*|/./d+".
4.5 Jangan loop tanpa batas untuk sub-kecocokan yang dapat cocok dengan string kosong. Jika setiap bagian dari sub -ekspresi dalam tanda kurung dapat cocok 0 kali, dan tanda kurung secara keseluruhan dapat menyamai waktu yang tak terbatas, maka situasinya mungkin lebih serius daripada apa yang dikatakan artikel sebelumnya, dan proses pencocokan mungkin merupakan loop mati. Meskipun beberapa mesin ekspresi reguler sekarang telah menghindari loop dead dalam situasi ini, seperti .NET ekspresi reguler, kita masih harus berusaha menghindari situasi ini. Jika kita menemukan loop dead saat menulis ekspresi, kita juga dapat mulai dari sudut pandang ini dan mencari tahu apakah ini alasan yang disebutkan dalam artikel ini.
4.6 Pilih mode serakah dan mode non-greedy, lihat diskusi topik.
4.7 atau "|" Di sisi kiri dan kanan, yang terbaik adalah mencocokkan hanya satu sisi karakter tertentu, sehingga ekspresi di kedua sisi "|" tidak akan berbeda karena posisi pertukaran.
Artikel berikutnya ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1. Tentukan ekspresi reguler
1) Ada dua bentuk mendefinisikan ekspresi reguler, satu adalah metode biasa dan yang lainnya adalah metode konstruktor.
2) Metode normal: var reg =/ekspresi/parameter tambahan
Ekspresi: String yang mewakili aturan tertentu, di mana karakter khusus tertentu dapat digunakan untuk mewakili aturan khusus, yang akan dijelaskan secara rinci nanti.
Parameter Tambahan: Digunakan untuk memperluas arti ekspresi, saat ini ada tiga parameter utama:
G: Berarti pencocokan global dapat dilakukan.
I: Itu berarti pencocokan case tidak sensitif.
G: Berarti pencocokan beberapa baris dapat dilakukan.
Tiga parameter di atas dapat digabungkan secara sewenang -wenang untuk mewakili makna senyawa, dan tentu saja, tidak ada parameter yang ditambahkan.
contoh:
var reg =/a*b/;
var reg =/abc+f/g;
3) Metode Konstruktor: var reg = regexp baru ("ekspresi", "tambahkan parameter");
Arti "ekspresi" dan "parameter tambahan" sama dengan metode definisi di atas.
contoh:
var reg = regexp baru ("a*b");
var reg = regexp baru ("abc+f", "g");
4) Perbedaan antara metode biasa dan metode konstruktor
Ekspresi dengan cara normal harus berupa string konstan, sedangkan ekspresi dalam konstruktor dapat berupa string konstan atau variabel JS, seperti parameter ekspresi berdasarkan input pengguna, dll.:
var reg = regexp baru (document.forms [0] .exprfiled.value, "g");
2. Pola ekspresi
1) Pola ekspresi mengacu pada metode ekspresi dan gaya ekspresi, yaitu bagaimana menggambarkan "ekspresi" dalam var reg =/ekspresi/parameter tambahan?
2) Dari perspektif standar, pola ekspresi dibagi menjadi pola sederhana dan pola komposit.
3) Pola Sederhana: Mengacu pada pola yang diekspresikan melalui kombinasi karakter biasa, misalnya
var reg =/abc0d/;
Dapat dilihat bahwa pola sederhana hanya dapat mewakili kecocokan spesifik.
4) Pola majemuk: mengacu pada pola yang diekspresikan dengan karakter wildcard, misalnya:
var reg =/a+b?/w/;
The +,? dan /w semuanya adalah karakter wildcard dan mewakili makna khusus. Oleh karena itu, pola komposit dapat mengekspresikan lebih banyak logika abstrak.
Mari kita fokus pada makna dan penggunaan setiap wildcard dalam mode komposit.
5) Penjelasan Karakter Khusus dalam Mode Senyawa:
1>/: Ini digunakan sebagai karakter pelarian dalam banyak bahasa pemrograman. Secara umum
Jika / simbol diikuti oleh karakter biasa C, maka / c mewakili makna khusus. Sebagai contoh, N awalnya mewakili karakter n, tetapi /n mewakili baris baru.
Jika / simbol diikuti oleh karakter khusus C, maka / c mewakili karakter biasa c. Misalnya, / umumnya digunakan sebagai karakter pelarian, tetapi // digunakan untuk menyesuaikan karakter biasa /.
Penggunaan / dalam ekspresi reguler JavaScript sama seperti di atas, tetapi dalam bahasa pemrograman yang berbeda, tabel karakter khusus mungkin berbeda.
2>^: Cocokkan awal string input. Jika itu adalah pertandingan multi-line, yaitu parameter tambahan dari ekspresi berisi M, itu juga akan dicocokkan setelah garis baru.
contoh:
/^B/cocok dengan b pertama di "Bab bc"
Contoh 2:
/^B/gm pencocokan
“Badd b
CDAF
B dsfb ”
Baris pertama di B pertama, B pertama di baris ketiga
3> $: Cocokkan akhir dari pembuatan karakter input. Jika itu adalah pertandingan multi-line, yaitu parameter tambahan dari ekspresi berisi M, itu juga akan dicocokkan sebelum garis baru.
Bertentangan dengan penggunaan ^.
Contoh: / t $ / cocok dengan "kelelawar", tetapi tidak cocok dengan "kebencian"
Contoh 2: /t $ /cocok
“Tag at
kelelawar"
T terakhir dari baris pertama dan T dari baris kedua.
4>*: Cocokkan karakter sebelumnya 0 atau lebih kali.
Contoh: /ab* /cocok dengan "abbbb" di "dddabbbbc", dan juga cocok dengan "a" dalam "ddda"
5>+: Cocokkan karakter 1 atau lebih sebelumnya atau lebih.
Contoh: / ab+ / cocok dengan "abbbb" di "dddabbbbc", tetapi tidak cocok dengan "ddda"
Mirip dengan penggunaan {1,} berikut (prototipe: {n,})
6>?: Penggunaan? cukup istimewa. Secara umum, ini digunakan untuk mencocokkan karakter sebelumnya 0 kali atau 1 kali, tetapi memiliki dua kegunaan khusus lainnya:
Jika segera mengikuti *, +,? dan {}, itu berarti jumlah minimum kecocokan dari pertandingan asli, misalnya:
/ Ba*/ Awalnya cocok dengan "baaaa" di "bbbaaaa", tetapi/ ba*?/ cocok dengan "b" dalam "bbbaaaa" (karena*berarti 0 atau lebih pertandingan, sementara plus? Harus berarti jumlah minimum pertandingan, yaitu, 0 pertandingan).
Demikian pula: / ba+? / Cocok dengan "ba" di "baaaa".
Sebagai simbol struktur sintaks, ini digunakan dalam pra-assert, yaitu, x (? = Y) dan x (?! = Y) untuk disebutkan nanti.
7>.: "." Masuk ke titik desimal cocok dengan karakter tunggal, kecuali untuk karakter baru.
Apa karakter dalam total standar? Silakan merujuk ke: set karakter
Misalnya: / AB / cocok "ACB" di "ACBAA", tetapi tidak cocok dengan "ABBB".
8> (x): berarti pencocokan X (tidak secara khusus mengacu pada karakter X atau secara khusus mengacu pada karakter, x mewakili string), dan kecocokan akan diingat. Dalam sintaks, semacam ini () disebut "orang tua yang menangkap", yaitu, tanda kurung yang digunakan untuk menangkap.
Pencocokan diingat karena dalam fungsi yang disediakan oleh ekspresi, beberapa fungsi mengembalikan array yang memegang semua string yang cocok, seperti fungsi exec ().
Perhatikan juga bahwa premis bahwa x in () diingat adalah untuk mencocokkan x.
Contoh 1:
var regx =/a (b) c/;
var rs = regx.exec ("abcddd");
Seperti yang dapat dilihat dari hal di atas, / a (b) C / cocok "ABC" di "ABCDDD". Karena (), B juga akan merekamnya, sehingga konten angka yang dikembalikan oleh RS adalah:
{ABC, b}
Contoh 2:
var regx =/a (b) c/;
var rs = regx.exec ("acbcddd");
RS mengembalikan nol, karena / a (b) C / tidak cocok dengan "acbcddd", jadi b in () tidak akan direkam (meskipun string berisi b)
9> (?: X): Cocokkan x, tetapi tidak ingat x. () Dalam format ini disebut "orang tua yang tidak menangkap", yaitu tanda kurung untuk tidak menangkap.
contoh:
var regx =/a (?: b) c/;
var rs = regx.exec ("abcddd");
Seperti yang dapat dilihat dari hal di atas, / a (?: b) c / cocok "ABC" di "ABCDDD", karena (? :), B tidak akan direkam, jadi konten angka yang dikembalikan oleh RS adalah:
{ABC}
10> x (? = Y): Cocokkan x, hanya jika Y diikuti segera. Jika pertandingan cocok, hanya X yang akan diingat dan Anda tidak akan diingat.
contoh:
var regx =/user (? = name)/;
var rs = regx.exec ("Nama pengguna adalah Mary");
Hasil: kecocokan berhasil, dan nilai RS adalah {user}
11> x (?! Y): Cocokkan x, hanya jika Y tidak segera diikuti. Jika pertandingan cocok, hanya X yang akan diingat dan Anda tidak akan diingat.
contoh:
var regx =/user (?! name)/;
var rs = regx.exec ("Nama pengguna adalah Mary");
Hasil: kecocokan berhasil, dan nilai RS adalah {user}
Contoh 2:
var regx = // d+(?!/.)/;
var rs = regx.exec ("54.235");
Result: The matching result, the value of rs is {5}, and the mismatch is because 54 is followed by the "." tanda. Of course, 235 also matches, but due to the behavior of the exec method, 235 will not be returned.
12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。
contoh:
var regx=/beijing|shanghai/;
var rs=regx.exec(“I love beijing and shanghai”);
结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。
13>{n}：匹配前一个字符的n次出现。
n必须是一个非负数，当然如果是一个负数或小数也不会报语法错误。
contoh:
var regx=/ab{2}c/;
var rs=regx.exec(“abbcd”);
结果：匹配成功，rs的值为：{abbc}。
14>{n,}：匹配前一个字符的至少n次出现。
contoh:
var regx=/ab{2,}c/;
var rs=regx.exec(“abbcdabbbc”);
结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。
15>{n,m}：匹配前一个字符的至少n次最多m次的出现。
只要n与m为数字，而且m>=n就不会报语法错误。
contoh:
var regx=/ab{2,5}c/;
var rs=regx.exec(“abbbcd”);
结果：匹配成功，rs的值为：{abbbc}。
Contoh 2:
var regx=/ab{2,2}c/;
var rs=regx.exec(“abbcd”);
结果：匹配成功，rs的值为：{abbc}。
例子3：
var regx=/ab(2,5)/;
var rs=regx.exec(“abbbbbbbbbb”);
Result: The match is successful, and the value of rs is: {abbbbb}, which means that if the previous character appears more than m times, it will only match m times. Selain itu:
var regx=/ab(2,5)c/;
var rs=regx.exec(“abbbbbbbbbbc”);
结果：匹配失败，rs的值为：null，为什么匹配失败，因为b多于5个则b(2,5)会匹配前5个b，，而表达式/ab(2,5)c/中b后面是c，但字符串中5个b之后还是b所以会报错。
16>[xyz]：xyz表示一个字符串，该模式表示匹配[]中的一个字符，形式上[xyz]等同于[xz]。
contoh:
var regx=/a[bc]d/;
var rs=regx.exec(“abddgg”);
结果：匹配成功，rs的值为：{abd}
Contoh 2:
var regx=/a[bc]d/;
var rs=regx.exec(“abcd”);
结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。
17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^xz]。
contoh:
var regx=/a[^bc]d/;
var rs=regx.exec(“afddgg”);
结果：匹配成功，rs的值为：{afd}
Contoh 2:
var regx=/a[^bc]d/;
var rs=regx.exec(“abd”);
结果：匹配失败，rs的值为：。
18>[/b]：匹配退格键。
19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。
contoh:
var regx=//bc./;
var rs=regx.exec(“Beijing is a beautiful city”);
结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。
20>/B：代表一个非单词边界。
contoh:
var regx=//Bi./;
var rs=regx.exec(“Beijing is a beautiful city”);
结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。
21>/cX，匹配一个控制字符。例如， /cM 匹配一个Control-M 或
回车符。 x 的值必须为AZ 或az 之一。否则，将c 视为一
个原义的'c' 字符。（实际的例子还需补充）
21>/d：匹配一个数字字符，等同于[0-9]。
contoh:
var regx=/user/d/;
var rs=regx.exec(“user1”);
结果：匹配成功，rs的值为：{user1}
22>/D：匹配一个非数字字符，等同于[^0-9]。
contoh:
var regx=/user/D/;
var rs=regx.exec(“userA”);
结果：匹配成功，rs的值为：{userA}
23>/f：匹配一个换页符。
24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。
contoh:
var regx=/a/nbc/m;
var str=“a
bc”;
var rs=regx.exec(str);
结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。
25>/r：匹配一个回车符
26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029].
contoh:
var regx=//si/;
var rs=regx.exec(“Beijing is a city”);
结果：匹配成功，rs的值为：{ i}
27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].
contoh:
var regx=//Si/;
var rs=regx.exec(“Beijing is a city”);
结果：匹配成功，rs的值为：{ei}
28>/t：匹配一个tab
contoh:
var regx=/a/tb/;
var rs=regx.exec(“a bc”);
结果：匹配成功，rs的值为： {a bc}
29>/v：匹配一个竖向的tab
30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。
contoh:
var regx=//w/;
var rs=regx.exec(“$25.23”);
结果：匹配成功，rs的值为：{2}
31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。
contoh:
var regx=//w/;
var rs=regx.exec(“$25.23”);
结果：匹配成功，rs的值为：{$}
32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。
contoh:
var regx=/user([,-])group/1role/;
var rs=regx.exec(“user-group-role”);
结果：匹配成功，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是成功的，但像user-group,role等就不对了。
33>/0：匹配一个NUL字符。
34>/xhh：匹配一个由两位16进制数字所表达的字符。
35>/uhhhh：匹配一个由四位16进制数字所表达的字符。
3，表达式操作
1）表达式操作，在这里是指和表达式相关的方法，我们将介绍六个方法。
2）表达式对象（RegExp）方法：
1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的形式表现，当然如果表达式中含有捕捉用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如：
var regx=//d+/;
var rs=regx.exec(“3432ddf53”);
返回的rs值为：{3432}
var regx2=new RegExp(“ab(/d+)c”);
var rs2=regx2.exec(“ab234c44”);
返回的rs值为：{ab234c,234}
In addition, if there are multiple suitable matches, exec is executed for the first time and exec is continued, the second and third matches are returned in turn. Misalnya:
var regx=/user/d/g;
var rs=regx.exec(“ddduser1dsfuser2dd”);
var rs1=regx.exec(“ddduser1dsfuser2dd”);
则rs的值为{user1}，rs的值为{rs2}，当然注意regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。
2>test(str), determines whether the string str matches the expression, and returns a boolean value. Misalnya:
var regx=/user/d+/g;
var flag=regx.test(“user12dd”);
flag的值为true。
3）String对象方法
1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配
contoh:
var regx=/user/d/g;
var str=“user13userddduser345”;
var rs=str.match(regx);
rs的值为：{user1,user3}
2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。
contoh:
var regx=/user/d/g;
var str=“user13userddduser345”;
var rs=str.search(regx);
rs的值为：0
3>replace(expr,str)，将字符串中匹配expr的部分替换为str。另外在replace方法中，str中可以含有一种变量符号$，格式为$n，代表匹配中被记住的第n的匹配字符串（注意小括号可以记忆匹配）。
contoh:
var regx=/user/d/g;
var str=“user13userddduser345”;
var rs=str.replace(regx,”00”);
rs的值为：003userddd0045
Contoh 2:
var regx=/u(se)r/d/g;
var str=“user13userddduser345”;
var rs=str.replace(regx,”$1”);
rs的值为：se3userdddse45
对于replace(expr,str)方法还要特别注意一点，如果expr是一个表达式对象则会进行全局替换（此时表达式必须附加参数g，否则也只是替换第一个匹配），如果expr是一个字符串对象，则只会替换第一个匹配的部分，例如：
var regx=“user”
var str=“user13userddduser345”;
var rs=str.replace(regx,”00”);
rs的值为： 0013userddduser345
4>split(expr)，将字符串以匹配expr的部分做分割，返回一个数组，而且表达式是否附加参数g都没有关系，结果是一样的。
contoh:
var regx=/user/d/g;
var str=“user13userddduser345”;
var rs=str.split(regx);
rs的值为：{3userddd,45}
4，表达式相关属性
1）表达式相关属性，是指和表达式相关的属性，如下面的形式：
var regx=/myexpr/;
var rs=regx.exec(str);
其中，和表达式自身regx相关的属性有两个，和表达式匹配结果rs相关的属性有三个，下面将逐一介绍。
2）和表达式自身相关的两个属性：
1>lastIndex，返回开始下一个匹配的位置，注意必须是全局匹配（表达式中带有g参数）时，lastIndex才会有不断返回下一个匹配值，否则该值为总是返回第一个下一个匹配位置，例如：
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex1=regx.lastIndex;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex2=regx.lastIndex;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex3=regx.lastIndex;
上面lastIndex1为9，第二个lastIndex2也为9，第三个也是9；如果regx=/user/d/g，则第一个为9，第二个为18，第三个为0。
2>source, return the expression string itself. Misalnya:
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var source=regx.source;
source的值为user/d
3）和匹配结果相关的三个属性：
1>index, return the current matching position. Misalnya:
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var index1=rs.index;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var index2=rs.index;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var index3=rs.index;
index1为4，index2为4，index3为4，如果表达式加入参数g，则index1为4，index2为13，index3会报错（index为空或不是对象）。
2>input, used for matching strings. Misalnya:
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var input=rs.input;
input的值为sdsfuser1dfsfuser2。
3>[0]，返回匹配结果中的第一个匹配值，对于match而言可能返回一个多值的数字，则除了[0]外，还可以取[1]、[2]等等。例如：
var regx=/user/d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var value1=rs[0];
rs=regx.exec(“sdsfuser1dfsfuser2”);
var value2=rs[0];
value1的值为user1,value2的值为user2
5，实际应用
1）实际应用一
描述：有一表单，其中有一个“用户名”input域
要求：汉字，而且不能少于2个汉字，不能多于4个汉字。
menyelesaikan:
<script>function checkForm(obj){ var username=obj.username.value; var regx=/^[/u4e00-/u9fa5]{2,4}$/g if(!regx.test(username)){ alert("Invalid username!"); mengembalikan false; } return true;}</script><form name="myForm" onSubmit="return checkForm(this)"> <input type="text" name="username"/> <input type="submit" vlaue="submit"/>2）实际应用二
描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。
menyelesaikan:
<script>function toPlainText(htmlStr){ var regx=/<[^>]*>|<//[^>]*>/gm; var str=htmlStr.replace(regx,""); return str;}</script><form name=“myForm”> <textarea id=“htmlInput”></textarea> <input type=“button” value=“submit” onclick=“toPlainText(document.getElementById('htmlInput').value”/></form>三，小结
1，Javascript正则表达式，我想在一般的程序员之中，使用者应该不是很多，因为我们处理的页面一般都不是很复杂，而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转，富客户端已经被越来越多的人接受，而Javascript就是其中的关键技术，对于复杂的客户端逻辑而言，正则表达式的作用也是很关键的，同时它也是Javascript高手必须要掌握的重要技术之一。
2，为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识，我将前面的一些关键点和容易犯糊涂的地方再系统总结一下，这部分很关键！
总结1：附件参数g的用法
表达式加上参数g之后，表明可以进行全局匹配，注意这里“可以”的含义。我们详细叙述：
1) For the exec method of the expression object, if g is not added, it will only return the first match, no matter how many times it is executed, if g is added, the first execution will also return the first match, and then the execution will return the second match, and so on. Misalnya
var regx=/user/d/;
var str=“user18dsdfuser2dsfsd”;
var rs=regx.exec(str);//此时rs的值为{user1}
var rs2=regx.exec(str);//此时rs的值依然为{user1}
如果regx=/user/d/g；则rs的值为{user1}，rs2的值为{user2}
通过这个例子说明：对于exec方法，表达式加入了g，并不是说执行exec方法就可以返回所有的匹配，而是说加入了g之后，我可以通过某种方式得到所有的匹配，这里的“方式”对于exec而言，就是依次执行这个方法即可。
2）对于表达式对象的test方法，加入g于不加上g没有什么区别。
3) For the match method of the String object, g is not added, and it only returns the first match. If the match method is executed all the time, it always returns the first match. If g is added, then all matches will be returned at once (note that this is different from the exec method of the expression object. For exec, even if g is added, all matches will not be returned at once). Misalnya:
var regx=/user/d/;
var str=“user1sdfsffuser2dfsdf”;
var rs=str.match(regx);//此时rs的值为{user1}
var rs2=str.match(regx);//此时rs的值依然为{user1}
如果regx=/user/d/g，则rs的值为{user1,user2}，rs2的值也为{user1,user2}
4）对于String对象的replace方法，表达式不加入g，则只替换第一个匹配，如果加入g，则替换所有匹配。（开头的三道测试题能很好的说明这一点）
5）对于String对象的split方法，加上g与不加g是一样的，即：
var sep=/user/d/;
var array=“user1dfsfuser2dfsf”.split(sep);
则array的值为{dfsf, dfsf}
此时sep=/user/d/g，返回值是一样的。
6）对于String对象的search方法，加不加g也是一样的。
总结2：附加参数m的用法
附加参数m，表明可以进行多行匹配，但是这个只有当使用^和$模式时才会起作用，在其他的模式中，加不加入m都可以进行多行匹配（其实说多行的字符串也是一个普通字符串），我们举例说明这一点
1）使用^的例子
var regx=/^b./g;var str=“bd76 dfsdf sdfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);
此时加入g和不加入g，都只返回第一个匹配{bd}，如果regx=/^b./gm，则返回所有的匹配{bd,b7}，注意如果regx=/^b./m，则也只返回第一个匹配。所以，加入m表明可以进行多行匹配，加入g表明可以进行全局匹配，综合到一起就是可以进行多行全局匹配
2）使用其他模式的例子，例如
var regx=/user/d/;var str=“sdfsfsdfsdf sdfsuser3 dffs b76dsf user6”;var rs=str.match(regx);
此时不加参数g，则返回{user3}，加入参数g返回{user3,user6}，加不加入m对此没有影响。
3）因此对于m我们要清楚它的使用，记住它只对^和$模式起作用，在这两种模式中，m的作用为：如果不加入m，则只能在第一行进行匹配，如果加入m则可以在所有的行进行匹配。我们再看一个^的例子
var regx=/^b./;var str=“ret76 dfsdf bjfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);
此时rs的值为null，如果加入g，rs的值仍然为null，如果加入m，则rs的值为{bj}（也就是说，在第一行没有找到匹配，因为有参数m，所以可以继续去下面的行去找是否有匹配），如果m和g都加上，则返回{bj,b7}（只加m不加g说明，可以去多行进行匹配，但是找到一个匹配后就返回，加入g表明将多行中所有的匹配返回，当然对于match方法是如此，对于exec呢，则需要执行多次才能依次返回）
总结3：
在HTML的textarea输入域中，按一个Enter键，对应的控制字符为“/r/n”，即“回车换行”，而不是“/n/r”，即“换行回车”，我们看一个前面我们举过的例子：
var regx=/a/r/nbc/;var str=“a bc”;var rs=regx.exec(str);
结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。
The above article briefly discusses the use of RegExp objects and brackets for JS regular expressions is all the content I share with you. Saya harap ini dapat memberi Anda referensi dan saya harap Anda dapat mendukung wulin.com lebih lanjut.