PHP ereg vs preg

Visite php.net/ereg affiche les éléments suivants:

Avertissement

Cette fonction est OBSOLÈTE depuis PHP 5.3.0, et SUPPRIMÉ en PHP 6.0.0. S'appuyant sur cette fonctionnalité est très déconseillé.

Bas de la page, juste un peu plus loin, nous lisons ceci:

Remarque: preg_match(), qui utilise un Perl-compatible regular expression de la syntaxe, est souvent une alternative plus rapide à ereg().

Remarque de mon accent.

Il y a beaucoup de discussion sur qui est plus rapide et de meilleure qualité.

Si vous prévoyez un jour de l'avancement de PHP6 de votre prise de décision. Sinon:

Le consensus général est que PCRE est la meilleure solution, mais si vous avez une page avec beaucoup de trafic, et vous n'avez pas besoin de PHP6 il peut être intéressant de certains tests.
Par exemple, dans le manuel PHP commentaires:

Autodérision POSIX regex en PHP pour
Perl recherche, c'est comme la substitution d'
des planches de bois et de briques pour une maison
avec pré-fabriqués les chambres et les murs.
Bien sûr, vous pourriez être en mesure de mélanger et assortir
certains de pièces, mais c'est beaucoup
plus facile à modifier, avec toutes les pièces
mis en face de vous.

PCRE plus vite que POSIX RE? Pas toujours.
Dans un récent moteur de recherche du projet ici
au Cynergi, j'ai eu une simple boucle avec un
quelques mignons ereg_replace() fonctions
pris 3min pour traiter les données. J'ai changé
que 10 de ligne de boucle dans un 100-ligne
code pour le remplacement et la
la boucle est maintenant pris 10s pour traiter la
mêmes données! Ce qui ma ouvert les yeux à ce
peut , DANS CERTAINS CAS, être très lent
les expressions régulières. Dernièrement, j'ai décidé
regarder en Perl-compatible regular
les expressions (PCRE). La plupart des pages de réclamation
PCRE sont plus rapides que la norme POSIX, mais un peu de
prétendre le contraire. J'ai décidé sur
bechmarks de mon propre. Mes premiers
les tests ont confirmé PCRE pour être plus rapide,
mais... les résultats ont été légèrement
différents que d'autres ont été d'obtenir, de sorte
J'ai décidé de comparer tous les cas de
RE utilisation, j'ai eu sur un 8000 ligne sécurisé
(et rapide) de Webmail projet à la
Cynergi de le vérifier. Les résultats?
Non concluants! Parfois PCRE sont
plus rapide (parfois par un facteur de plus
de 100x plus rapide!), mais certains autres
fois POSIX RE sont plus rapides (par un facteur
(2x). J'ai encore de trouver une règle sur
quand l'un ou l'autre plus rapidement. C'est
pas seulement à propos de la recherche de la taille des données,
quantité de données appariées, ou "RE
le temps de compilation" qui permettrait de voir
lorsque vous l'avez répété la fonction souvent:
on aurait toujours être plus rapide que la
d'autres. Mais je n'ai pas trouver un modèle
ici. Mais à vrai dire, je n'ai pas
prenez le temps de regarder dans le code source
code et analyser le problème. Je peux
vous donner quelques exemples, cependant. L'
POSIX RE
([0-9]{4})/([0-9]{2})/([0-9]{2})[^0-9]+
([0-9]{2}):([0-9]{2}):([0-9]{2}) est
30% plus rapide dans POSIX que lorsque
converti à PCRE (même si vous utilisez \d
et \D et non-greedy correspondant). Sur
l'autre main, de la même PCRE
schéma complexe /[0-9]{1,2}[
\t]+[a-zA-Z]{3}[ \t]+[0-9]{4}[
\t]+[0-9]{1,2}:[0-9]{1,2}(:[0-9]{1,2})?[
\t]+[+-][0-9]{4}/est 2,5 x plus rapide dans
PCRE que dans POSIX RE. Simple
remplacement des modèles comme
ereg_replace( "[^a-zA-Z0-9-]+", "", $m
); sont 2x plus vite dans POSIX RE que
PCRE. Et ensuite, on se confondre à nouveau
car une POSIX RE modèle comme l'
(^|\n|\r)commencent-base64[ \t]+[0-7]{3,4}[
\t]+...... est 2x plus rapide que la norme POSIX RE,
mais le casse PCRE
/^Reçues[ \t]*:[ \t]par[ \t]+([^
\t]+)[ \t]/i est 30x plus rapide que son
POSIX RE version! Quand il s'agit de
sensibilité à la casse, PCRE a jusqu'à présent
semblait être la meilleure option. Mais Je
trouvé certains vraiment étrange comportement
de ereg/eregi. Sur un très simple
POSIX RE (^|\r|\n)mime-version[ \t]:
J'ai trouvé eregi() prenant en 3.60 s (juste un
nombre dans un test de référence), tandis que le
correspondant PCRE a pris 0.16 s! Mais si
J'ai utilisé ereg() (sensible à la casse) la
POSIX RE fois descendit à 0,08 s! J'Ai Donc
une enquête plus approfondie. J'ai essayé de faire
POSIX RE casse lui-même.
Je suis comme cela:
(^|\r|\n)[mM][iI][mM][eE]-vers[iI][oO][nN][
\t]*: Cette version a également pris 0.08 s.
Mais si j'essaie d'appliquer la même règle à
tout de le 'v', 'e', 'r' ou 's'
les lettres qui ne sont pas changés, le temps
est de retour à la 3.60 marque, et pas
petit à petit, mais voit tout de suite alors! L'
des données de test n'ont pas de "vers" dans
c', d'autres "mime" mots en tout ou en
"ion" qui pourrait être source de confusion l'
POSIX analyseur, donc je suis à une perte. Bas
ligne: toujours tester les performances de votre PCRE /
POSIX RE de trouver le plus rapide! Tests
ont été réalisées avec PHP 5.1.2 sous
Windows, à partir de la ligne de commande. Pedro
Freire cynergi.com

Bien, ereg et de ses dérivées des fonctions (ereg_match, etc) sont déconseillés en php5 et d'être supprimé dans php6, alors vous êtes probablement mieux d'aller avec la preg de la famille à la place.

preg est pour Perl-style expressions régulières, tandis que ereg est la norme POSIX regex.