Regex.Match Metodo

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input);

public System.Text.RegularExpressions.Match Match (string input);

member this.Match : string -> System.Text.RegularExpressions.Match

Public Function Match (input As String) As Match

Parametri

Restituisce

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

Esempio

Nell'esempio seguente vengono trovate corrispondenze di criteri di espressione regolare in una stringa, quindi vengono elencati i gruppi, le acquisizioni e le posizioni di acquisizione corrispondenti.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

using System;
using System.Text.RegularExpressions;

class Example
{
   static void Main()
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);

      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success)
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++)
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++)
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
              Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

Il criterio di espressione regolare (\w+)\s+(car) corrisponde alle occorrenze della parola "car" insieme alla parola che lo precede. Viene interpretato come illustrato nella tabella seguente.

Commenti

Il metodo Match(String) restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una stringa di input. Per informazioni sugli elementi del linguaggio usati per creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

È possibile determinare se il criterio di espressione regolare è stato trovato nella stringa di input controllando il valore della proprietà Success dell'oggetto restituito Match. Se viene trovata una corrispondenza, la proprietà Value dell'oggetto Match restituita contiene la sottostringa di input che corrisponde al criterio di espressione regolare. Se non viene trovata alcuna corrispondenza, il relativo valore è String.Empty.

Questo metodo restituisce la prima sottostringa in input che corrisponde al criterio di espressione regolare. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo Match.NextMatch dell'oggetto restituito Match. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo chiamando il metodo Regex.Matches(String).

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato dal costruttore Regex.Regex(String, RegexOptions, TimeSpan). Se non si imposta un intervallo di timeout quando si chiama il costruttore, l'eccezione viene generata se l'operazione supera qualsiasi valore di timeout stabilito per il dominio applicazione in cui viene creato l'oggetto Regex. Se non viene definito alcun timeout nella chiamata al costruttore Regex o nelle proprietà del dominio applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

Vedi anche

• NextMatch()
• linguaggio delle espressioni regolari - di riferimento rapido

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int startat);

public System.Text.RegularExpressions.Match Match (string input, int startat);

member this.Match : string * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, startat As Integer) As Match

Parametri

Restituisce

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

Commenti

Per altre informazioni su questa API, vedere osservazioni supplementari sull'API per Regex.Match.

Vedi anche

• NextMatch()
• linguaggio delle espressioni regolari - di riferimento rapido

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern);

public static System.Text.RegularExpressions.Match Match (string input, string pattern);

static member Match : string * string -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String) As Match

Parametri

Restituisce

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

Esempio

Nell'esempio seguente viene chiamato il metodo Match(String, String) per trovare la prima parola contenente almeno un carattere z, quindi chiama il metodo Match.NextMatch per trovare eventuali corrispondenze aggiuntive.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example
    {
        public static void Main()
        {
            string input = "ablaze beagle choral dozen elementary fanatic " +
                           "glaze hunger inept jazz kitchen lemon minus " +
                           "night optical pizza quiz restoration stamina " +
                           "train unrest vertical whiz xray yellow zealous";
            string pattern = @"\b\w*z+\w*\b";
            Match m = Regex.Match(input, pattern);
            while (m.Success)
            {
                Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index);
                m = m.NextMatch();
            }
        }
    }
}

// The example displays the following output:
//    'ablaze' found at position 0
//    'dozen' found at position 21
//    'glaze' found at position 46
//    'jazz' found at position 65
//    'pizza' found at position 104
//    'quiz' found at position 110
//    'whiz' found at position 157
//    'zealous' found at position 174

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ablaze beagle choral dozen elementary fanatic " +
                            "glaze hunger inept jazz kitchen lemon minus " +
                            "night optical pizza quiz restoration stamina " +
                            "train unrest vertical whiz xray yellow zealous"
      Dim pattern As String = "\b\w*z+\w*\b"
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success 
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index)
         m = m.NextMatch()
      Loop                      
   End Sub
End Module
' The example displays the following output:
    'ablaze' found at position 0
    'dozen' found at position 21
    'glaze' found at position 46
    'jazz' found at position 65
    'pizza' found at position 104
    'quiz' found at position 110
    'whiz' found at position 157
    'zealous' found at position 174

Il criterio di espressione regolare \b\w*z+\w*\b viene interpretato come illustrato nella tabella seguente.

Commenti

Il metodo Match(String, String) restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una stringa di input. Per informazioni sugli elementi del linguaggio usati per creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

Il metodo Match(String, String) statico equivale a costruire un oggetto Regex con il criterio di espressione regolare specificato e chiamare il metodo Match(String) dell'istanza. In questo caso, il motore delle espressioni regolari memorizza nella cache il criterio di espressione regolare.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference.

È possibile determinare se il criterio di espressione regolare è stato trovato nella stringa di input controllando il valore della proprietà Success dell'oggetto restituito Match. Se viene trovata una corrispondenza, la proprietà Value dell'oggetto Match restituita contiene la sottostringa di input che corrisponde al criterio di espressione regolare. Se non viene trovata alcuna corrispondenza, il relativo valore è String.Empty.

Questo metodo restituisce la prima sottostringa in input che corrisponde al criterio di espressione regolare. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo Match.NextMatch dell'oggetto restituito Match. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo chiamando il metodo Regex.Matches(String, String).

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato per il dominio applicazione in cui viene chiamato il metodo . Se non viene definito alcun timeout nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

Note per i chiamanti

Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato. Se non è stato definito un valore di timeout per il dominio applicazione, viene usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per il recupero di una corrispondenza dei criteri è Match(String, String), che consente di impostare l'intervallo di timeout.

Vedi anche

• NextMatch()
• linguaggio delle espressioni regolari - di riferimento rapido

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int beginning, int length);

public System.Text.RegularExpressions.Match Match (string input, int beginning, int length);

member this.Match : string * int * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, beginning As Integer, length As Integer) As Match

Parametri

Restituisce

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

Commenti

Il metodo Match(String, Int32, Int32) restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una parte di una stringa di input. Per informazioni sugli elementi del linguaggio usati per creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

Modello di espressione regolare per il quale il metodo Match(String, Int32, Int32) cerca è definito dalla chiamata a uno dei costruttori di classi Regex. Per altre informazioni sugli elementi che possono formare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

Il metodo Match(String, Int32, Int32) cerca la parte di input definita dai parametri beginning e length per il criterio di espressione regolare. beginning definisce sempre l'indice del carattere più a sinistra da includere nella ricerca e length definisce il numero massimo di caratteri da cercare. Insieme definiscono l'intervallo della ricerca. Il comportamento è esattamente come se il input fosse effettivamente input.Substring(beginning, length), ad eccezione del fatto che l'indice di qualsiasi corrispondenza viene conteggiato rispetto all'inizio di input. Ciò significa che qualsiasi ancoraggio o asserzione di larghezza zero all'inizio o alla fine del modello si comporta come se non vi sia alcun input all'esterno di questo intervallo. Ad esempio, gli ancoraggi ^, \Ge \A verranno soddisfatti in beginning e $ e \z verranno soddisfatti in beginning + length - 1.

Se la ricerca procede da sinistra a destra (impostazione predefinita), il motore delle espressioni regolari cerca dal carattere in corrispondenza dell'indice beginning al carattere in corrispondenza dell'indice beginning + length - 1. Se è stata creata un'istanza del motore delle espressioni regolari usando l'opzione RegexOptions.RightToLeft in modo che la ricerca procede da destra a sinistra, il motore delle espressioni regolari cerca dal carattere in corrispondenza dell'indice beginning + length - 1 al carattere in corrispondenza dell'indice beginning.

Questo metodo restituisce la prima corrispondenza trovata all'interno di questo intervallo. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo Match.NextMatch dell'oggetto restituito Match.

È possibile determinare se il criterio di espressione regolare è stato trovato nella stringa di input controllando il valore della proprietà Success dell'oggetto restituito Match. Se viene trovata una corrispondenza, la proprietà Value dell'oggetto Match restituita contiene la sottostringa di input che corrisponde al criterio di espressione regolare. Se non viene trovata alcuna corrispondenza, il relativo valore è String.Empty.

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato dal costruttore Regex.Regex(String, RegexOptions, TimeSpan). Se non si imposta un valore di timeout quando si chiama il costruttore, l'eccezione viene generata se l'operazione supera qualsiasi valore di timeout stabilito per il dominio applicazione in cui viene creato l'oggetto Regex. Se non viene definito alcun timeout nella chiamata al costruttore Regex o nelle proprietà del dominio applicazione oppure se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

Vedi anche

• NextMatch()
• linguaggio delle espressioni regolari - di riferimento rapido

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions) As Match

Parametri

Restituisce

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

Esempio

Nell'esempio seguente viene definita un'espressione regolare che corrisponde alle parole che iniziano con la lettera "a". Usa l'opzione RegexOptions.IgnoreCase per assicurarsi che l'espressione regolare individua le parole che iniziano con una "a" maiuscola e una minuscola "a".

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example2
    {
        public static void Main()
        {
            string pattern = @"\ba\w*\b";
            string input = "An extraordinary day dawns with each new day.";
            Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
            if (m.Success)
                Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index);
        }
    }
}

// The example displays the following output:
//        Found 'An' at position 0.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\ba\w*\b"
      Dim input As String = "An extraordinary day dawns with each new day."
      Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
      If m.Success Then
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index)
      End If
   End Sub
End Module
' The example displays the following output:
'       Found 'An' at position 0.

Il criterio di espressione regolare \ba\w*\b viene interpretato come illustrato nella tabella seguente.

Commenti

Il metodo Match(String, String, RegexOptions) restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una stringa di input. Per informazioni sugli elementi del linguaggio usati per creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

Il metodo Match(String, String, RegexOptions) statico equivale a costruire un oggetto Regex con il costruttore Regex(String, RegexOptions) e chiamando il metodo Match(String) dell'istanza.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference.

È possibile determinare se il criterio di espressione regolare è stato trovato nella stringa di input controllando il valore della proprietà Success dell'oggetto restituito Match. Se viene trovata una corrispondenza, la proprietà Value dell'oggetto Match restituita contiene la sottostringa di input che corrisponde al criterio di espressione regolare. Se non viene trovata alcuna corrispondenza, il relativo valore è String.Empty.

Questo metodo restituisce la prima sottostringa trovata in input che corrisponde al criterio di espressione regolare. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo NextMatch dell'oggetto restituito Match. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo chiamando il metodo Regex.Matches(String, String, RegexOptions).

L'eccezione RegexMatchTimeoutException viene generata se il tempo di esecuzione dell'operazione corrispondente supera l'intervallo di timeout specificato per il dominio applicazione in cui viene chiamato il metodo . Se non viene definito alcun timeout nelle proprietà del dominio applicazione o se il valore di timeout è Regex.InfiniteMatchTimeout, non viene generata alcuna eccezione.

Note per i chiamanti

Questo metodo si verifica il timeout dopo un intervallo uguale al valore di timeout predefinito del dominio applicazione in cui viene chiamato. Se non è stato definito un valore di timeout per il dominio applicazione, viene usato il valore InfiniteMatchTimeout, che impedisce il timeout del metodo. Il metodo statico consigliato per il recupero di una corrispondenza dei criteri è Match(String, String), che consente di impostare l'intervallo di timeout.

Vedi anche

• NextMatch()
• linguaggio delle espressioni regolari - di riferimento rapido

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

Origine:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Match

Parametri

Restituisce

Oggetto che contiene informazioni sulla corrispondenza.

Eccezioni

Commenti

Il metodo Match(String, String, RegexOptions, TimeSpan) restituisce la prima sottostringa che corrisponde a un criterio di espressione regolare in una stringa di input. Per informazioni sugli elementi del linguaggio usati per creare un criterio di espressione regolare, vedere Linguaggio di espressioni regolari - Riferimento rapido.

Il metodo Match(String, String, RegexOptions, TimeSpan) statico equivale a costruire un oggetto Regex con il costruttore Regex(String, RegexOptions, TimeSpan) e chiamando il metodo Match(String) dell'istanza.

Il parametro pattern è costituito da elementi del linguaggio delle espressioni regolari che descrivono simbolicamente la stringa da trovare. Per altre informazioni sulle espressioni regolari, vedere .NET Regular Expressions e Regular Expression Language - Quick Reference.

È possibile determinare se il criterio di espressione regolare è stato trovato nella stringa di input controllando il valore della proprietà Success dell'oggetto restituito Match. Se viene trovata una corrispondenza, la proprietà Value dell'oggetto Match restituita contiene la sottostringa di input che corrisponde al criterio di espressione regolare. Se non viene trovata alcuna corrispondenza, il relativo valore è String.Empty.

Questo metodo restituisce la prima sottostringa trovata in input che corrisponde al criterio di espressione regolare. È possibile recuperare le corrispondenze successive chiamando ripetutamente il metodo NextMatch dell'oggetto restituito Match. È anche possibile recuperare tutte le corrispondenze in una singola chiamata al metodo chiamando il metodo Regex.Matches(String, String, RegexOptions).

Il parametro matchTimeout consente di specificare per quanto tempo un metodo di ricerca dei criteri di ricerca deve provare a trovare una corrispondenza prima del timeout. L'impostazione di un intervallo di timeout impedisce che le espressioni regolari che si basano su un backtracking eccessivo vengano visualizzate per interrompere la risposta quando elaborano l'input che contiene corrispondenze vicine. Per altre informazioni, vedere procedure consigliate per le espressioni regolari e backtracking. Se non viene trovata alcuna corrispondenza in tale intervallo di tempo, il metodo genera un'eccezione RegexMatchTimeoutException. matchTimeout esegue l'override di qualsiasi valore di timeout predefinito definito per il dominio applicazione in cui viene eseguito il metodo.

Note per i chiamanti

È consigliabile impostare il parametro matchTimeout su un valore appropriato, ad esempio due secondi. Se si disabilitano i timeout specificando InfiniteMatchTimeout, il motore delle espressioni regolari offre prestazioni leggermente migliori. Tuttavia, è consigliabile disabilitare i timeout solo nelle condizioni seguenti:

• Quando l'input elaborato da un'espressione regolare è derivato da un'origine nota e attendibile o è costituito da testo statico. Questo esclude il testo che è stato immesso dinamicamente dagli utenti.

• Quando il criterio di espressione regolare è stato testato accuratamente per garantire che gestisca in modo efficiente corrispondenze, non corrispondenze e corrispondenze vicine.

• Quando il criterio di espressione regolare non contiene elementi del linguaggio noti per causare un backtracking eccessivo durante l'elaborazione di una corrispondenza vicina.

Vedi anche

• linguaggio delle espressioni regolari - di riferimento rapido