<?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 => 'it',
  ),
  'this' => 
  array (
    0 => 'regexp.reference.assertions.php',
    1 => 'Asserzioni',
    2 => 'Asserzioni',
  ),
  'up' => 
  array (
    0 => 'reference.pcre.pattern.syntax.php',
    1 => 'Sintassi delle regex PCRE',
  ),
  'prev' => 
  array (
    0 => 'regexp.reference.back-references.php',
    1 => 'Riferimenti all\'indietro',
  ),
  'next' => 
  array (
    0 => 'regexp.reference.onlyonce.php',
    1 => 'Sotto-regole a riconoscimento singolo (Once-only subpatterns)',
  ),
  'alternatives' => 
  array (
  ),
  'source' => 
  array (
    'lang' => 'it',
    '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.assertions" class="section">
  <h2 class="title">Asserzioni</h2>
  <p class="para">
   L&#039;asserzione è un test basato su un carattere, che può precedere
   o seguire l&#039;attuale punto di riconoscimento, e non consuma
   alcun carattere. Le semplici asserzioni quali \b, \B, \A, \Z,
   \z, ^ e $ sono state descritte precedentemente. Asserzioni più
   complesse possono essere strutturate come delle sotto-regole. Se ne hanno
   di due tipologie: quelle che <em>guardano avanti</em> alla posizione attuale
   nella stringa oggetto del riconoscimento, e quelle che <em>guardano dietro</em> la posizione attuale.
  </p>
  <p class="para">
   Una asserzione definita come sotto-regola esegue il riconoscimento
   nel modo usuale, ma tale riconoscimento non sposta la posizione
   attuale nella stringa. Le asserzioni che &quot;guardano avanti&quot; cominciano
   per &quot;(?=&quot;, se sono positive, per &quot;(?!&quot;, se sono asserzioni negative. Ad esempio
   
   <code class="literal">\w+(?=;)</code>
   
   riconosce una parola seguita da &quot;;&quot;, ma non include il
   punto e virgola nel riconoscimento, mentre
   
   <code class="literal">foo(?!bar)</code>
   
   identifica qualsiasi occorrenza di &quot;foo&quot; che non sia seguita da
   &quot;bar&quot;. Attenzione che il criterio, apparentemente simile,
   
   <code class="literal">(?!foo)bar</code>
   
   non riconosce alcuna occorrenza di &quot;bar&quot; se questa è preceduta
   da qualsiasi testo che non sia  &quot;foo&quot;; infatti l&#039;espressione
   riconosce qualsiasi occorrenza di &quot;bar&quot;, poiché l&#039;asserzione (?!foo)
   è sempre <strong><code><a href="reserved.constants.php#constant.true">true</a></code></strong> quando i tre caratteri successivi sono &quot;bar&quot;.
   Pertanto è necessario una asserzione che &quot;guarda&quot; all&#039;indietro per ottenere effetto desiderato.
  </p>
  <p class="para">
   Le asserzioni che &quot;guardano&quot; indietro positive iniziano con
   &quot;(?&lt;=&quot;, e con &quot;(?&lt;!&quot; le negative. Ad esempio:
   
   <code class="literal">(?&lt;!foo)bar</code>
   
   riconosce una occorrenza di &quot;bar&quot; che non sia preceduta da
   &quot;foo&quot;. Le asserzioni che &quot;guardano&quot; indietro hanno una limitazione:
   tutte le stringhe che riconoscono devono avere lunghezza fissa.
   Mentre, se si hanno casi alternativi, la limitazione della lunghezza
   fissa non sussiste. Quindi
   
   <code class="literal">(?&lt;=bullock|donkey)</code>
   
   è una asserzione permessa, ma
   
   <code class="literal">(?&lt;!dogs?|cats?)</code>
   
   genera un errore durante la fase di compilazione. Rami alternativi
   con lunghezze di stringa differenti sono permessi solo
   al primo livello dell&#039;asserzione. Questa è da considerarsi una
   estensione rispetto a Perl 5.005, che richiede a tutte le alternative
   possibili la medesima lunghezza di stringa. Quindi una asserzione tipo
   
   <code class="literal">(?&lt;=ab(c|de))</code>
   
   non è permessa, poiché il suo singolo ramo di primo livello
   può identificare testi di due lunghezze differenti, ma è accettabile
   se riscritta usando due alternative di primo livello:
   
   <code class="literal">(?&lt;=abc|abde)</code>
   
   L&#039;implementazione di questo tipo di asserzioni consiste, per ciascuna
   alternativa, di uno spostamento all&#039;indietro temporaneo per la lunghezza
   fissa necessaria, e ad un tentativo di riconoscimento del testo. Se non
   ci sono sufficienti caratteri precedenti alla posizione attuale,
   l&#039;asserzione è destinata a fallire. L&#039;uso accoppiato delle asserzioni
   che &quot;guardano&quot; indietro con sotto-regole a riconoscimento singolo può essere utile
   per identificare la fine dei testi; un esempio è illustrato al termine
   della sezione sulle sotto-regole a riconoscimento singolo.
  </p>
  <p class="para">
   Diverse asserzioni (di qualsiasi tipologia) possono essere
   utilizzate in modo consecutivo. Ad esempio:
   
   <code class="literal">(?&lt;=\d{3})(?&lt;!999)foo</code>
   
   riconosce &quot;foo&quot; preceduto da tre cifre che non siano &quot;999&quot;.
   Occorre rilevare che ciascuna asserzione viene applicata
   singolarmente sul medesimo punto nella stringa oggetto di
   riconoscimento. Nell&#039;esempio precedente per prima cosa si
   verifica che i tre caratteri precedenti siano cifre, quindi
   che non siamo &quot;999&quot;. Questo esempio non identifica il testo
   se &quot;foo&quot; è preceduto da sei caratteri di cui i primi tre siano
   cifre e i secondi tre non siano &quot;999&quot;. In pratica il testo
   &quot;123abcfoo&quot; non viene riconosciuto. Un criterio per riconoscere tale stringa può essere:
   
   <code class="literal">(?&lt;=\d{3}...)(?&lt;!999)foo</code>
  </p>
  <p class="para">
   In questo caso la prima asserzione controlla i primi sei caratteri
   verificando che i primi tre siano cifre, mentre la seconda
   asserzione verifica che i secondi tre caratteri non siano
   &quot;999&quot;.
  </p>
  <p class="para">
   Le asserzioni possono essere annidate in qualsiasi combinazione.  Il seguente esempio
   
   <code class="literal">(?&lt;=(?&lt;!foo)bar)baz</code>
   
   identifica il testo &quot;baz&quot; se è preceduto da &quot;bar&quot; il quale
   non deve essere preceduto da &quot;foo&quot;, mentre
   
   <code class="literal">(?&lt;=\d{3}...(?&lt;!999))foo</code>
   
   è un&#039;altro criterio che riconosce &quot;foo&quot; preceduto da tre cifre
   e da tre caratteri che non siano &quot;999&quot;.
  </p>
  <p class="para">
   Le asserzioni definite come sotto-regole non catturano parte
   del testo e non possono essere ripetute (non avrebbe senso
   ripetere il medesimo riconoscimento sul medesimo testo).
   Se una di queste asserzioni contiene una sotto-regola di cattura
   questa viene conteggiata ai fini della numerazione delle regole
   di cattura. Tuttavia il testo viene effettivamente catturato
   solo nelle asserzioni positive, dato che non avrebbe senso farlo
   in quelle negative.
  </p>
  <p class="para">
   Le asserzioni possono essere composte fino ad un massimo
   di 200 sotto-regole.
  </p>
 </div><?php manual_footer($setup); ?>