<?php
include_once $_SERVER['DOCUMENT_ROOT'] . '/include/shared-manual.inc';
$TOC = array();
$TOC_DEPRECATED = array();
$PARENTS = array();
include_once dirname(__FILE__) ."/toc/reference.pcre.pattern.syntax.inc";
$setup = array (
  'home' => 
  array (
    0 => 'index.php',
    1 => 'PHP Manual',
  ),
  'head' => 
  array (
    0 => 'UTF-8',
    1 => 'pt_BR',
  ),
  'this' => 
  array (
    0 => 'regexp.reference.performance.php',
    1 => 'Desempenho',
    2 => 'Desempenho',
  ),
  'up' => 
  array (
    0 => 'reference.pcre.pattern.syntax.php',
    1 => 'Sintaxe das express&otilde;es regulares PCRE',
  ),
  'prev' => 
  array (
    0 => 'regexp.reference.recursive.php',
    1 => 'Express&otilde;es recursivas',
  ),
  'next' => 
  array (
    0 => 'reference.pcre.pattern.modifiers.php',
    1 => 'Poss&iacute;veis modificadores em express&otilde;es regulares',
  ),
  'alternatives' => 
  array (
  ),
  'source' => 
  array (
    'lang' => 'pt_BR',
    'path' => 'reference/pcre/pattern.syntax.xml',
  ),
  'history' => 
  array (
  ),
);
$setup["toc"] = $TOC;
$setup["toc_deprecated"] = $TOC_DEPRECATED;
$setup["parents"] = $PARENTS;
manual_setup($setup);

contributors($setup);

?>
<div id="regexp.reference.performance" class="section">
  <h2 class="title">Desempenho</h2>
  <p class="para">
   Certos itens que podem aparecer nas expressões são mais eficientes
   que outros. É mais eficiente usar uma classe de caracteres
   como [aeiou] do que um conjunto de alternativas como (a|e|i|o|u).
   Em geral, a construção mais simples que proporciona o
   comportamento requerido é normalmente a mais eficiente. O livro
   de Jeffrey Friedl contém muita discussão sobre como otimizar
   expressões regulares para um desempenho eficiente.
  </p>
  <p class="para">
   Quando uma expressão começa com .* e a opção <a href="reference.pcre.pattern.modifiers.php" class="link">PCRE_DOTALL</a> está
   definida, a expressão é implicitamente ancorada pelo PCRE, pois ela
   pode corresponder apenas ao início de um string de entrada. Porém, se
   <a href="reference.pcre.pattern.modifiers.php" class="link">PCRE_DOTALL</a>
   não estiver definida, o PCRE não poderá fazer esta otimização,
   pois o metacaractere . não corresponderá a uma nova linha
   e, se a string de entrada contiver novas linhas, a expressão poderá
   corresponder a partir do caractere imediatamente após um deles,
   em vez de desde o início. Por exemplo, a expressão

   <code class="literal">(.*) second</code>

   corresponde à string &quot;first\nand second&quot; (onde \n representa
   um caractere de nova linha) com a primeira substring capturada igual a
   &quot;and&quot;. Para fazer isso, o PCRE precisa tentar a correspondência novamente
   iniciando após cada caractere de nova linha na string.
  </p>
  <p class="para">
   Se uma expressão como essa estiver sendo usada com uma string de entrada que
   não contêm novas linhas, o melhor desempenho será obtido
   definindo <a href="reference.pcre.pattern.modifiers.php" class="link">PCRE_DOTALL</a>
   ou iniciando a expressão com ^.* para
   indicar ancoragem explícita. Isso evita que o PCRE tenha que
   varrer a string em busca de uma nova linha para reiniciar.
  </p>
  <p class="para">
   Cuidado com expressões que contêm repetições indefinidas aninhadas.
   Elas podem levar muito tempo para serem executadas quando aplicados a uma string
   que não corresponde. Considere o fragmento de expressão

   <code class="literal">(a+)*</code>
  </p>
  <p class="para">
   Isso pode corresponder a &quot;aaaa&quot; de 33 maneiras diferentes, e esse número
   aumenta muito rapidamente à medida que a string fica mais longa. (A repetição
   * pode corresponder a 0, 1, 2, 3 ou 4 vezes e, para cada um
   desses casos diferentes de 0, as repetições + podem corresponder a diferentes
   números de vezes.) Quando o restante da expressão é tal
   que toda a correspondência irá falhar, o PCRE tem que, em princípio,
   tentar todas as variações possíveis, e isso pode levar
   muito tempo.
  </p>
  <p class="para">
   Uma otimização captura alguns dos casos mais simples
   como

   <code class="literal">(a+)*b</code>,

   onde um carectere literal aparece na sequência. Antes de embarcar no
   procedimento padrão de correspondência, o PCRE verifica se existe um &quot;b&quot;
   mais à frente na string de entrada, e se não houver, ele falha
   a correspondência imediatamente. Porém, quando não há um caractere literal
   na sequência, esta otimização não pode ser usada. Pode-se ver a
   deferença comparando o comportamento de

   <code class="literal">(a+)*\d</code>

   com a expressão mais acima. A anterior falha quase
   instantaneamente quando aplicada a uma linha inteira de caracteres &quot;a&quot;,
   enquanto que a última leva um tempo apreciável com strings
   mais longas que aproximadamente 20 caracteres.
  </p>
 </div><?php manual_footer($setup); ?>