Bagaimana untuk mengoptimumkan penggunaan ungkapan biasa dalam pembangunan PHP

Cara mengoptimumkan penggunaan ungkapan biasa dalam pembangunan PHP

Dalam pembangunan PHP, ungkapan biasa ialah alat yang berkuasa dan biasa digunakan untuk memproses pemadanan rentetan, carian dan penggantian. Walau bagaimanapun, prestasi ungkapan biasa sering diabaikan oleh pembangun, yang mungkin membawa kepada operasi program yang tidak cekap. Artikel ini akan memperkenalkan beberapa kaedah untuk mengoptimumkan penggunaan ungkapan biasa dalam pembangunan PHP, membantu pembangun memberikan permainan sepenuhnya kepada kelebihan mereka dan meningkatkan prestasi program.

1. Gunakan mod paling ringkas

Apabila menggunakan ungkapan biasa, anda harus sentiasa mempertimbangkan untuk menggunakan mod paling mudah. Corak mudah umumnya mempunyai prestasi yang lebih tinggi kerana ia memerlukan lebih sedikit pengiraan dan langkah padanan. Elakkan daripada menggunakan corak kompleks seperti kumpulan bersarang, lihat ke belakang dan pandangan negatif.

2. Gunakan pengkuantiti tidak tamak

Pengkuantiti dalam ungkapan biasa menyatakan bilangan kali corak boleh muncul. Secara lalai, pengkuantiti adalah tamak, bermakna ia sepadan dengan seberapa banyak rentetan yang mungkin. Walau bagaimanapun, pengkuantiti yang tamak boleh membawa kepada prestasi yang lemah dalam beberapa kes. Untuk meningkatkan prestasi, anda boleh menggunakan pengkuantiti tidak tamak, yang sepadan dengan beberapa rentetan yang mungkin.

Sebagai contoh, apabila anda perlu memadankan rentetan yang bermula dengan a dan berakhir dengan mana-mana aksara, anda boleh menggunakan ungkapan biasa /a.*$/. Pengkuantiti * di sini adalah tamak dan akan memadankan seberapa banyak aksara yang mungkin. Jika rentetan panjang, ini akan menyebabkan perlawanan mengambil masa yang lebih lama. Untuk meningkatkan prestasi, anda boleh menggunakan pengkuantiti tidak tamak /a.*?$/, yang akan memadankan sesedikit aksara yang mungkin, dengan itu mengurangkan masa padanan. /a.*$/。这里的量词*是贪婪的，会尽可能多地匹配字符。如果字符串很长，这将导致匹配的时间增加。为了提高性能，可以使用非贪婪量词/a.*?$/，它会尽可能少地匹配字符，从而减少匹配的时间。

三、使用预编译的正则表达式

在PHP中，正则表达式可以通过preg_match()、preg_replace()等函数执行。每次调用这些函数时，PHP都会编译正则表达式并执行匹配。如果在代码中多次执行相同的正则表达式，会导致无谓的编译和匹配开销。为了提高性能，可以使用preg_match()函数的PREG_PATTERN_ORDER参数将正则表达式编译为预编译的格式，然后在后续调用中重复使用。

例如，假设需要在一个文本中匹配多次出现的日期。可以将日期的正则表达式编译为预编译的格式，并在后续的匹配中重复使用，如下所示：

$pattern = '/d{4}-d{2}-d{2}/';

$text = "Today is 2022-01-01. Tomorrow is 2022-01-02.";

preg_match($pattern, $text, $matches);
echo $matches[0];  // 输出：2022-01-01

preg_match($pattern, $text, $matches);
echo $matches[0];  // 输出：2022-01-02

使用预编译的正则表达式可以避免多次编译的开销，提高匹配的效率。

四、避免不必要的定位符

在正则表达式中，定位符（锚点）用于限定匹配的位置。常用的定位符有^（匹配行的开头）、$（匹配行的结尾）和（匹配单词边界）等。然而，不必要的定位符会增加正则表达式的复杂性，降低其性能。

在编写正则表达式时，应该避免不必要的定位符，并仔细评估是否需要使用它们。如果不需要限定位置，可以省略定位符，从而简化正则表达式。

五、最小化回溯的使用

回溯是正则表达式中的一种机制，用于处理不确定性的匹配。当正则表达式无法匹配一个字符串时，会尝试不同的匹配路径，直到找到最佳的匹配。然而，回溯的使用可能会导致性能低下，尤其是对于复杂的正则表达式和长字符串。

为了优化正则表达式的性能，应该尽量减少回溯的使用。可以通过使用非贪婪量词、避免嵌套的分组和限定匹配范围等方法来避免回溯的发生。此外，可以使用贪婪量词的惰性形式，如*?、+?和??，它们会尽可能少地匹配字符，从而减少回溯的发生。

六、使用分割替代匹配

在某些情况下，正则表达式的替换操作可能会导致性能低下。如果只需要分割字符串，而不需要替换其中的内容，可以考虑使用explode()函数，它比正则表达式的替换操作更高效。

七、使用原生字符串

在PHP中，正则表达式通常在双引号字符串中使用。由于双引号字符串会对转义字符进行解析，为了确保正则表达式不受解析的影响，应该使用原生字符串。

原生字符串可以通过在字符串前面加上@符号来表示，例如$pattern = '@d+@'

3 Gunakan ungkapan biasa tersusun

Dalam PHP, ungkapan biasa boleh dilaksanakan melalui fungsi seperti preg_match() dan preg_replace(). Setiap kali fungsi ini dipanggil, PHP menyusun ungkapan biasa dan melakukan pemadanan. Jika anda melaksanakan ungkapan biasa yang sama beberapa kali dalam kod anda, ia akan menyebabkan kompilasi yang tidak perlu dan overhed yang sepadan. Untuk meningkatkan prestasi, anda boleh menggunakan parameter PREG_PATTERN_ORDER bagi fungsi preg_match() untuk menyusun ungkapan biasa ke dalam format yang telah dikompilasi dan kemudian menggunakannya semula pada panggilan berikutnya.

Sebagai contoh, katakan anda perlu memadankan berbilang kejadian tarikh dalam teks. Ungkapan tetap tarikh boleh disusun ke dalam format tersusun dan digunakan semula dalam pemadanan berikutnya, seperti yang ditunjukkan di bawah: 🎜rrreee🎜Menggunakan ungkapan biasa tersusun boleh mengelakkan overhed berbilang kompilasi dan meningkatkan kecekapan pemadanan. 🎜🎜4. Elakkan pencari yang tidak diperlukan🎜🎜Dalam ungkapan biasa, pencari (sauh) digunakan untuk mengehadkan kedudukan padanan. Pencari yang biasa digunakan termasuk ^ (padan dengan permulaan baris), $ (padan dengan hujung baris) dan (padan dengan perkataan sempadan). Walau bagaimanapun, pencari yang tidak diperlukan meningkatkan kerumitan ungkapan biasa dan mengurangkan prestasinya. 🎜🎜Apabila menulis ungkapan biasa, anda harus mengelakkan pencari yang tidak diperlukan dan menilai dengan teliti sama ada anda perlu menggunakannya. Jika anda tidak perlu mengehadkan kedudukan, anda boleh meninggalkan pencari, dengan itu memudahkan ungkapan biasa. 🎜🎜5. Minimumkan penggunaan backtracking🎜🎜Backtracking ialah mekanisme dalam ungkapan biasa yang digunakan untuk mengendalikan padanan yang tidak pasti. Apabila ungkapan biasa tidak dapat memadankan rentetan, laluan padanan yang berbeza dicuba sehingga padanan terbaik ditemui. Walau bagaimanapun, penggunaan penjejakan ke belakang boleh mengakibatkan prestasi yang lemah, terutamanya dengan ungkapan biasa yang kompleks dan rentetan panjang. 🎜🎜Untuk mengoptimumkan prestasi ungkapan biasa, penggunaan menjejak ke belakang harus diminimumkan. Penjejakan ke belakang boleh dielakkan dengan menggunakan pengkuantiti tidak tamak, mengelakkan pengelompokan bersarang dan mengehadkan skop padanan. Selain itu, anda boleh menggunakan bentuk malas pengkuantiti tamak, seperti *?, +? dan ??, yang sepadan dengan beberapa aksara sebagai mungkin, Ini mengurangkan berlakunya backtracking. 🎜🎜6. Gunakan pembahagian dan bukannya padanan🎜🎜Dalam sesetengah kes, operasi penggantian ungkapan biasa boleh menyebabkan prestasi yang lemah. Jika anda hanya perlu membelah rentetan tanpa menggantikan kandungannya, anda boleh mempertimbangkan untuk menggunakan fungsi explode(), yang lebih cekap daripada penggantian ungkapan biasa. 🎜🎜7. Gunakan rentetan asli🎜🎜Dalam PHP, ungkapan biasa biasanya digunakan dalam rentetan petikan dua kali. Memandangkan rentetan petikan dua kali akan menghuraikan aksara melarikan diri, untuk memastikan bahawa ungkapan biasa tidak terjejas oleh penghuraian, rentetan asli harus digunakan. 🎜🎜Rentetan asli boleh diwakili dengan menambahkan simbol @ di hadapan rentetan, seperti $pattern = '@d+@'. Menggunakan rentetan asli mengelakkan ralat dan penalti prestasi yang disebabkan oleh menghuraikan aksara melarikan diri. 🎜🎜Kesimpulan🎜🎜Mengoptimumkan penggunaan ungkapan biasa dalam pembangunan PHP adalah penting untuk meningkatkan prestasi program. Anda boleh memanfaatkan sepenuhnya ungkapan biasa dengan menggunakan corak paling ringkas, pengkuantiti tidak tamak, ungkapan biasa yang telah disusun sebelumnya, mengelakkan pengesan yang tidak diperlukan, meminimumkan penggunaan penjejakan ke belakang, menggunakan pemisahan dan bukannya padanan dan menggunakan rentetan asli dan meningkatkan prestasi program . Pembangun harus memilih kaedah pengoptimuman yang sesuai untuk meningkatkan kecekapan ungkapan biasa berdasarkan keperluan dan senario tertentu. 🎜

Atas ialah kandungan terperinci Bagaimana untuk mengoptimumkan penggunaan ungkapan biasa dalam pembangunan PHP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!