Ancoraggi in espressioni regolari
Ancoraggi o asserzioni atomiche a larghezza zero specificano una posizione nella stringa dove si deve verificare una corrispondenza. Quando si utilizza un ancoraggio nell'espressione di ricerca, il motore delle espressioni regolari non avanza nella la stringa né utilizza caratteri; cerca solo una corrispondenza nella posizione specificata. Ad esempio, ^ specifica che la corrispondenza deve iniziare all'inizio di una riga o stringa. Pertanto, l'espressione regolare ^http: corrisponde a "http": solo quando si verifica all'inizio di una riga. Nella tabella seguente vengono elencati gli ancoraggi supportati dalle espressioni regolari in .NET Framework.
Punto di ancoraggio |
Oggetto di descrizione |
|---|---|
^ |
La corrispondenza deve verificarsi all'inizio della stringa o della riga. Per ulteriori informazioni, vedere Inizio di stringa o riga. |
$ |
La corrispondenza deve verificarsi alla fine della stringa o della riga oppure prima di \n alla fine della stringa o della riga. Per ulteriori informazioni, vedere Fine di stringa o riga. |
\A |
La corrispondenza deve verificarsi solo all'inizio della stringa (nessun supporto multilingue). Per ulteriori informazioni, vedere Solo Inizio di stringa. |
\Z |
La corrispondenza deve verificarsi alla fine della stringa oppure prima di \n alla fine della stringa. Per ulteriori informazioni, vedere Fine di stringa o Prima di terminare una nuova riga. |
\z |
La corrispondenza deve verificarsi solo alla fine della stringa. Per ulteriori informazioni, vedere Solo fine di stringa. |
\G |
La corrispondenza deve iniziare nel punto in cui è terminata la corrispondenza precedente. Per ulteriori informazioni vedere Corrispondenze contigue. |
\b |
La corrispondenza deve verificarsi su un confine di parola. Per ulteriori informazioni, vedere Confine di parola. |
\B |
La corrispondenza non deve verificarsi su un confine di parola. Per ulteriori informazioni, vedere Carattere che non costituisce un confine di parola. |
Inizio di stringa o riga: ^
L'ancoraggio ^ specifica che il motivo seguente deve iniziare nella posizione del primo carattere della stringa. Se si utilizza ^ con l'opzione RegexOptions.Multiline (vedere Opzioni di espressioni regolari), si deve verificare la corrispondenza all'inizio di ogni riga.
Nell'esempio seguente viene utilizzato l'ancoraggio ^ in un'espressione regolare che estrae le informazioni riguardanti gli anni durante i quali sono esistiti alcuni team di baseball professionisti. Nell'esempio vengono chiamati due overload del metodo Regex.Matches():
La chiamata all'overload di Matches(String, String) trova solo la prima sottostringa nella stringa di input che corrisponde al criterio di espressione regolare.
La chiamata all'overload Matches(String, String, RegexOptions) con il parametro options impostato su RegexOptions.Multiline trova tutte le cinque sottostringhe.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim startPos As Integer = 0
Dim endPos As Integer = 70
Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf + _
"Chicago Cubs, National League, 1903-present" + vbCrLf + _
"Detroit Tigers, American League, 1901-present" + vbCrLf + _
"New York Giants, National League, 1885-1957" + vbCrLf + _
"Washington Senators, American League, 1901-1960" + vbCrLf
Dim pattern As String = "^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+"
Dim match As Match
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
match = Regex.Match(input, pattern)
Do While match.Success
Console.Write("The {0} played in the {1} in", _
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
startPos = 0
endPos = 70
If input.Substring(startPos, endPos).Contains(",") Then
match = Regex.Match(input, pattern, RegexOptions.Multiline)
Do While match.Success
Console.Write("The {0} played in the {1} in", _
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
' For Each match As Match in Regex.Matches(input, pattern, RegexOptions.Multiline)
' Console.Write("The {0} played in the {1} in", _
' match.Groups(1).Value, match.Groups(4).Value)
' For Each capture As Capture In match.Groups(5).Captures
' Console.Write(capture.Value)
' Next
' Console.WriteLine(".")
' Next
End Sub
End Module
' The example displays the following output:
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
' The Chicago Cubs played in the National League in 1903-present.
' The Detroit Tigers played in the American League in 1901-present.
' The New York Giants played in the National League in 1885-1957.
' The Washington Senators played in the American League in 1901-1960.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
int startPos = 0, endPos = 70;
string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
"Chicago Cubs, National League, 1903-present\n" +
"Detroit Tigers, American League, 1901-present\n" +
"New York Giants, National League, 1885-1957\n" +
"Washington Senators, American League, 1901-1960\n";
string pattern = @"^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+";
Match match;
if (input.Substring(startPos, endPos).Contains(",")) {
match = Regex.Match(input, pattern);
while (match.Success) {
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
if (input.Substring(startPos, endPos).Contains(",")) {
match = Regex.Match(input, pattern, RegexOptions.Multiline);
while (match.Success) {
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
// The Chicago Cubs played in the National League in 1903-present.
// The Detroit Tigers played in the American League in 1901-present.
// The New York Giants played in the National League in 1885-1957.
// The Washington Senators played in the American League in 1901-1960.
Il modello di espressione regolare ^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+ viene definito come illustrato nella tabella seguente.
Modello |
Oggetto di descrizione |
|---|---|
^ |
Iniziare la corrispondenza all'inizio della stringa di input (o all'inizio della riga se il metodo è chiamato con l'opzione RegexOptions.Multiline). |
((\w+(\s*)){2,} |
Trovare la corrispondenza di uno o più caratteri alfanumerici seguiti da zero o da uno spazio, esattamente per due volte. Equivale al primo gruppo di acquisizione. Questa espressione definisce anche un secondo e un terzo gruppo di acquisizione: il secondo è costituito dalla parola acquisita e il terzo dagli spazi acquisiti. |
,\s |
Trovare la corrispondenza di una virgola seguita da uno spazio vuoto. |
(\w+\s\w+) |
Trovare la corrispondenza di uno o più caratteri seguiti da uno spazio, seguito da uno o più spazi vuoti. Equivale al quarto gruppo di acquisizione. |
, |
Corrisponde a una virgola. |
\s\d{4} |
Trovare la corrispondenza di uno spazio seguito da quattro cifre decimali. |
(-(\d{4}|present))* |
Trovare la corrispondenza di un trattino seguito da quattro cifre decimali o dalla stringa "presente". Si tratta del sesto gruppo di acquisizione. Include anche un settimo gruppo di acquisizione. |
,* |
Trovare la corrispondenza di zero o un'occorrenza di una virgola. |
(\s\d{4}(-(\d{4}|present))*,*)+ |
Trovare la corrispondenza di una o più occorrenze degli elementi seguenti: uno spazio, quattro cifre decimali, zero o un'occorrenza di un trattino seguito da quattro cifre decimali o la stringa "presente" e zero o una virgola. Si tratta del quinto gruppo di acquisizione. |
Torna all'inizio
Fine di stringa o riga: $
L'ancoraggio $ specifica che il motivo precedente deve verificarsi alla fine della stringa di input oppure prima di \n alla fine della stringa di input.
Se si utilizza $ con l'opzione RegexOptions.Multiline, la corrispondenza si può verificare anche alla fine di una riga. Notare che $ corrisponde a \n ma non corrisponde a \r\n (la combinazione di ritorno a capo e di caratteri di nuova riga o CR/LF). Per ottenere la corrispondenza della combinazione del carattere di CR/LF, includere \r?$ nel criterio di espressione regolare.
Nell'esempio riportato di seguito viene aggiunto l'ancoraggio $ al criterio di espressione regolare utilizzato nella sezione Inizio di stringa o riga. In caso di utilizzo con la stringa dell'input originale che include cinque righe di testo, il metodo Regex.Matches(String, String) non è in grado di trovare una corrispondenza, perché la fine della prima riga non corrisponde al modello $. Quando la stringa dell'input originale viene suddivisa in una matrice di stringhe, il metodo Regex.Matches(String, String) riesce nell'abbinamento di ciascuna delle cinque righe. Quando il metodo Regex.Matches(String, String, RegexOptions) viene chiamato con il parametro options impostato su RegexOptions.Multiline, non si trova alcuna corrispondenza perché il criterio di espressione regolare non considera l'elemento del ritorno a capo (+000D \u). Tuttavia, quando il modello di espressione regolare viene modificato sostituendo $ con \r?$, chiama il metodo Regex.Matches(String, String, RegexOptions) con il parametro options impostato su RegexOptions.Multiline restituisce nuovamente cinque corrispondenze.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim startPos As Integer = 0
Dim endPos As Integer = 70
Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf + _
"Chicago Cubs, National League, 1903-present" + vbCrLf + _
"Detroit Tigers, American League, 1901-present" + vbCrLf + _
"New York Giants, National League, 1885-1957" + vbCrLf + _
"Washington Senators, American League, 1901-1960" + vbCrLf
Dim basePattern As String = "^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+"
Dim match As Match
Dim pattern As String = basePattern + "$"
Console.WriteLine("Attempting to match the entire input string:")
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
match = Regex.Match(input, pattern)
Do While match.Success
Console.Write("The {0} played in the {1} in", _
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
Dim teams() As String = input.Split(New String() { vbCrLf }, StringSplitOptions.RemoveEmptyEntries)
Console.WriteLine("Attempting to match each element in a string array:")
For Each team As String In teams
If team.Length > 70 Then Continue For
match = Regex.Match(team, pattern)
If match.Success Then
Console.Write("The {0} played in the {1} in", _
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
End If
Next
Console.WriteLine()
startPos = 0
endPos = 70
Console.WriteLine("Attempting to match each line of an input string with '$':")
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
match = Regex.Match(input, pattern, RegexOptions.Multiline)
Do While match.Success
Console.Write("The {0} played in the {1} in", _
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
startPos = 0
endPos = 70
pattern = basePattern + "\r?$"
Console.WriteLine("Attempting to match each line of an input string with '\r?$':")
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
match = Regex.Match(input, pattern, RegexOptions.Multiline)
Do While match.Success
Console.Write("The {0} played in the {1} in", _
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
End Sub
End Module
' The example displays the following output:
' Attempting to match the entire input string:
'
' Attempting to match each element in a string array:
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
' The Chicago Cubs played in the National League in 1903-present.
' The Detroit Tigers played in the American League in 1901-present.
' The New York Giants played in the National League in 1885-1957.
' The Washington Senators played in the American League in 1901-1960.
'
' Attempting to match each line of an input string with '$':
'
' Attempting to match each line of an input string with '\r+$':
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
' The Chicago Cubs played in the National League in 1903-present.
' The Detroit Tigers played in the American League in 1901-present.
' The New York Giants played in the National League in 1885-1957.
' The Washington Senators played in the American League in 1901-1960.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
int startPos = 0, endPos = 70;
string cr = Environment.NewLine;
string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + cr +
"Chicago Cubs, National League, 1903-present" + cr +
"Detroit Tigers, American League, 1901-present" + cr +
"New York Giants, National League, 1885-1957" + cr +
"Washington Senators, American League, 1901-1960" + cr;
Match match;
string basePattern = @"^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+";
string pattern = basePattern + "$";
Console.WriteLine("Attempting to match the entire input string:");
if (input.Substring(startPos, endPos).Contains(",")) {
match = Regex.Match(input, pattern);
while (match.Success) {
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
string[] teams = input.Split(new String[] { cr }, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine("Attempting to match each element in a string array:");
foreach (string team in teams)
{
if (team.Length > 70) continue;
match = Regex.Match(team, pattern);
if (match.Success)
{
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
}
}
Console.WriteLine();
startPos = 0;
endPos = 70;
Console.WriteLine("Attempting to match each line of an input string with '$':");
if (input.Substring(startPos, endPos).Contains(",")) {
match = Regex.Match(input, pattern, RegexOptions.Multiline);
while (match.Success) {
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
startPos = 0;
endPos = 70;
pattern = basePattern + "\r?$";
Console.WriteLine(@"Attempting to match each line of an input string with '\r?$':");
if (input.Substring(startPos, endPos).Contains(",")) {
match = Regex.Match(input, pattern, RegexOptions.Multiline);
while (match.Success) {
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// Attempting to match the entire input string:
//
// Attempting to match each element in a string array:
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
// The Chicago Cubs played in the National League in 1903-present.
// The Detroit Tigers played in the American League in 1901-present.
// The New York Giants played in the National League in 1885-1957.
// The Washington Senators played in the American League in 1901-1960.
//
// Attempting to match each line of an input string with '$':
//
// Attempting to match each line of an input string with '\r+$':
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
// The Chicago Cubs played in the National League in 1903-present.
// The Detroit Tigers played in the American League in 1901-present.
// The New York Giants played in the National League in 1885-1957.
// The Washington Senators played in the American League in 1901-1960.
Torna all'inizio
Solo inizio di stringa: \A
L'ancoraggio \A specifica che una corrispondenza deve verificarsi all'inizio della stringa di input. È identico all'ancoraggio ^, a meno che \A ignori l'opzione RegexOptions.Multiline. Pertanto, può corrispondere solo all'inizio della prima riga di una stringa di input con più righe.
L'esempio seguente è simile agli esempi per gli ancoraggi ^ e $. Utilizza l'ancoraggio \A in un'espressione regolare che estrae le informazioni riguardanti gli anni durante i quali sono esistiti alcuni team di baseball professionisti. La stringa di input include cinque righe. La chiamata al metodo Regex.Matches(String, String, RegexOptions) trova solo la prima sottostringa nella stringa di input che corrisponde al criterio di espressione regolare. Nell'esempio riportato l'opzione Multiline non ha alcun effetto.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim startPos As Integer = 0
Dim endPos As Integer = 70
Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf + _
"Chicago Cubs, National League, 1903-present" + vbCrLf + _
"Detroit Tigers, American League, 1901-present" + vbCrLf + _
"New York Giants, National League, 1885-1957" + vbCrLf + _
"Washington Senators, American League, 1901-1960" + vbCrLf
Dim pattern As String = "\A((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+"
Dim match As Match
' Provide minimal validation in the event the input is invalid.
If input.Substring(startPos, endPos).Contains(",") Then
match = Regex.Match(input, pattern, RegexOptions.Multiline)
Do While match.Success
Console.Write("The {0} played in the {1} in", _
match.Groups(1).Value, match.Groups(4).Value)
For Each capture As Capture In match.Groups(5).Captures
Console.Write(capture.Value)
Next
Console.WriteLine(".")
startPos = match.Index + match.Length
endPos = CInt(IIf(startPos + 70 <= input.Length, 70, input.Length - startPos))
If Not input.Substring(startPos, endPos).Contains(",") Then Exit Do
match = match.NextMatch()
Loop
Console.WriteLine()
End If
End Sub
End Module
' The example displays the following output:
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
int startPos = 0, endPos = 70;
string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
"Chicago Cubs, National League, 1903-present\n" +
"Detroit Tigers, American League, 1901-present\n" +
"New York Giants, National League, 1885-1957\n" +
"Washington Senators, American League, 1901-1960\n";
string pattern = @"\A((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+";
Match match;
if (input.Substring(startPos, endPos).Contains(",")) {
match = Regex.Match(input, pattern, RegexOptions.Multiline);
while (match.Success) {
Console.Write("The {0} played in the {1} in",
match.Groups[1].Value, match.Groups[4].Value);
foreach (Capture capture in match.Groups[5].Captures)
Console.Write(capture.Value);
Console.WriteLine(".");
startPos = match.Index + match.Length;
endPos = startPos + 70 <= input.Length ? 70 : input.Length - startPos;
if (! input.Substring(startPos, endPos).Contains(",")) break;
match = match.NextMatch();
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
Torna all'inizio
Fine di stringa o prima di terminare una nuova riga: \Z
L'ancoraggio \Z specifica che una corrispondenza deve verificarsi alla fine della stringa di input oppure prima di \n alla fine della stringa di input. È identico all'ancoraggio $, a meno che \Z ignori l'opzione RegexOptions.Multiline. Pertanto, in una stringa con più righe, può corrispondere solo alla fine dell'ultima riga o all'ultima riga prima di \n.
Notare che \Z corrisponde a \n ma non corrisponde a \r\n (combinazione di caratteri CR/LF). Per mettere in corrispondenza il ritorno a capo e l'avanzamento di riga, includere \r?\Z nel modello di espressione regolare.
Nell'esempio seguente viene utilizzato l'ancoraggio \Z in un'espressione regolare che è simile all'esempio presente nella sezione Inizio di stringa o riga che estrae informazioni riguardanti gli anni durante i quali sono esistiti alcuni team di baseball professionisti. La sottoespressione \r?\Z nell'espressione regolare ^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\Z corrisponde alla fine di una stringa e inoltre corrisponde a una stringa che termina con \n o \r\n. Di conseguenza, ogni elemento nella matrice corrisponde al criterio di espressione regolare.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957", _
"Chicago Cubs, National League, 1903-present" + vbCrLf, _
"Detroit Tigers, American League, 1901-present" + vbLf, _
"New York Giants, National League, 1885-1957", _
"Washington Senators, American League, 1901-1960" + vbCrLf }
Dim pattern As String = "^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\Z"
For Each input As String In inputs
If input.Length > 70 Or Not input.Contains(",") Then Continue For
Console.WriteLine(Regex.Escape(input))
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine(" Match succeeded.")
Else
Console.WriteLine(" Match failed.")
End If
Next
End Sub
End Module
' The example displays the following output:
' Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
' Match succeeded.
' Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
' Match succeeded.
' Detroit\ Tigers,\ American\ League,\ 1901-present\n
' Match succeeded.
' New\ York\ Giants,\ National\ League,\ 1885-1957
' Match succeeded.
' Washington\ Senators,\ American\ League,\ 1901-1960\r\n
' Match succeeded.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
"Chicago Cubs, National League, 1903-present" + Environment.NewLine,
"Detroit Tigers, American League, 1901-present" + Regex.Unescape(@"\n"),
"New York Giants, National League, 1885-1957",
"Washington Senators, American League, 1901-1960" + Environment.NewLine};
string pattern = @"^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\Z";
foreach (string input in inputs)
{
if (input.Length > 70 || ! input.Contains(",")) continue;
Console.WriteLine(Regex.Escape(input));
Match match = Regex.Match(input, pattern);
if (match.Success)
Console.WriteLine(" Match succeeded.");
else
Console.WriteLine(" Match failed.");
}
}
}
// The example displays the following output:
// Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
// Match succeeded.
// Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
// Match succeeded.
// Detroit\ Tigers,\ American\ League,\ 1901-present\n
// Match succeeded.
// New\ York\ Giants,\ National\ League,\ 1885-1957
// Match succeeded.
// Washington\ Senators,\ American\ League,\ 1901-1960\r\n
// Match succeeded.
Torna all'inizio
Solo fine di stringa: \z
L'ancoraggio \z specifica che una corrispondenza deve verificarsi alla fine della stringa di input. Come l'elemento di linguaggio $, \z ignora l'opzione RegexOptions.Multiline. A differenza dell'elemento di linguaggio \Z, \z non corrisponde a un carattere \n alla fine di una stringa. Pertanto, può corrispondere solo all'ultima riga della stringa di input.
Nell'esempio seguente viene utilizzato l'ancoraggio \z in un'espressione regolare che è per altri aspetti identico all'esempio presente nella sezione precedente che estrae informazioni riguardanti gli anni durante i quali sono esistiti alcuni team di baseball professionisti. Nell'esempio viene tentato di ottenere la corrispondenza di ciascuno dei cinque elementi di una matrice di stringhe al modello di espressione regolare ^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\z. Due delle stringhe terminano con caratteri di ritorno a capo e avanzamento riga, una termina con un carattere di avanzamento riga e la seconda non termina né con un carattere di ritorno a capo né con avanzamento riga. Come mostra l'output, solo le stringhe senza un ritorno a capo o il carattere di avanzamento riga corrisponde al modello.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957", _
"Chicago Cubs, National League, 1903-present" + vbCrLf, _
"Detroit Tigers, American League, 1901-present" + vbLf, _
"New York Giants, National League, 1885-1957", _
"Washington Senators, American League, 1901-1960" + vbCrLf }
Dim pattern As String = "^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\z"
For Each input As String In inputs
If input.Length > 70 Or Not input.Contains(",") Then Continue For
Console.WriteLine(Regex.Escape(input))
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine(" Match succeeded.")
Else
Console.WriteLine(" Match failed.")
End If
Next
End Sub
End Module
' The example displays the following output:
' Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
' Match succeeded.
' Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
' Match failed.
' Detroit\ Tigers,\ American\ League,\ 1901-present\n
' Match failed.
' New\ York\ Giants,\ National\ League,\ 1885-1957
' Match succeeded.
' Washington\ Senators,\ American\ League,\ 1901-1960\r\n
' Match failed.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
"Chicago Cubs, National League, 1903-present" + Environment.NewLine,
"Detroit Tigers, American League, 1901-present\\r",
"New York Giants, National League, 1885-1957",
"Washington Senators, American League, 1901-1960" + Environment.NewLine };
string pattern = @"^((\w+(\s*)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))*,*)+\r?\z";
foreach (string input in inputs)
{
if (input.Length > 70 || ! input.Contains(",")) continue;
Console.WriteLine(Regex.Escape(input));
Match match = Regex.Match(input, pattern);
if (match.Success)
Console.WriteLine(" Match succeeded.");
else
Console.WriteLine(" Match failed.");
}
}
}
// The example displays the following output:
// Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
// Match succeeded.
// Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
// Match failed.
// Detroit\ Tigers,\ American\ League,\ 1901-present\n
// Match failed.
// New\ York\ Giants,\ National\ League,\ 1885-1957
// Match succeeded.
// Washington\ Senators,\ American\ League,\ 1901-1960\r\n
// Match failed.
Torna all'inizio
Corrispondenze contigue: \G
L'ancoraggio \G specifica che una corrispondenza deve verificarsi nel punto in cui è terminata la corrispondenza precedente. Quando si utilizza questo ancoraggio con il metodo Regex.Matches o Match.NextMatch, è sicuro che tutte le corrispondenze sono contigue.
Nell'esempio seguente viene utilizzata un'espressione regolare per estrarre i nomi di specie di roditori da una stringa delimitata da virgole.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "capybara,squirrel,chipmunk,porcupine,gopher," + _
"beaver,groundhog,hamster,guinea pig,gerbil," + _
"chinchilla,prairie dog,mouse,rat"
Dim pattern As String = "\G(\w+\s?\w*),?"
Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
Console.WriteLine(match.Groups(1).Value)
match = match.NextMatch()
Loop
End Sub
End Module
' The example displays the following output:
' capybara
' squirrel
' chipmunk
' porcupine
' gopher
' beaver
' groundhog
' hamster
' guinea pig
' gerbil
' chinchilla
' prairie dog
' mouse
' rat
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "capybara,squirrel,chipmunk,porcupine,gopher," +
"beaver,groundhog,hamster,guinea pig,gerbil," +
"chinchilla,prairie dog,mouse,rat";
string pattern = @"\G(\w+\s?\w*),?";
Match match = Regex.Match(input, pattern);
while (match.Success)
{
Console.WriteLine(match.Groups[1].Value);
match = match.NextMatch();
}
}
}
// The example displays the following output:
// capybara
// squirrel
// chipmunk
// porcupine
// gopher
// beaver
// groundhog
// hamster
// guinea pig
// gerbil
// chinchilla
// prairie dog
// mouse
// rat
L'espressione regolare \G(\w+\s?\w*),? viene interpretata come illustrato nella tabella seguente.
Modello |
Oggetto di descrizione |
|---|---|
\G |
Iniziare dalla posizione in cui termina l'ultima corrispondenza. |
\w+ |
Trovare la corrispondenza di uno o più caratteri alfanumerici. |
\s? |
Trovare la corrispondenza di zero o di uno spazio. |
\w* |
Corrisponde a zero o più caratteri alfanumerici. |
(\w+\s? \w*) |
Trovare la corrispondenza di uno o più caratteri seguiti da zero o da uno spazio, seguito da zero o più caratteri alfanumerici. Equivale al primo gruppo di acquisizione. |
,? |
Trovare la corrispondenza di zero o di un'occorrenza di un carattere virgola letterale. |
Torna all'inizio
Confine di parola: \b
L'ancoraggio \b specifica che la corrispondenza deve verificarsi su un confine tra un carattere alfabetico (l'elemento di linguaggio \w ) e un carattere non-alfabetico (l'elemento di linguaggio \W ). I caratteri alfabetici sono costituiti da caratteri e sottolineature alfanumerici; un carattere non alfabetico è un carattere qualsiasi non alfanumerico né sottolineatura. Per ulteriori informazioni, vedere Classi di caratteri. La corrispondenza può verificarsi anche su un confine di parola all'inizio o alla fine della stringa.
L'ancoraggio \b viene frequentemente utilizzato per garantire la corrispondenza di una sottoespressione con una parola intera invece che con solo il relativo inizio o la relativa fine. L'espressione regolare \bare\w*\b nell'esempio seguente ne illustra l'utilizzo. Corrisponde a qualsiasi parola che inizia con la sottostringa "sono". L'output dell'esempio illustra anche che \b corrisponde sia all'inizio sia alla fine della stringa di input.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "area bare arena mare"
Dim pattern As String = "\bare\w*\b"
Console.WriteLine("Words that begin with 'are':")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("'{0}' found at position {1}", _
match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' Words that begin with 'are':
' 'area' found at position 0
' 'arena' found at position 10
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "area bare arena mare";
string pattern = @"\bare\w*\b";
Console.WriteLine("Words that begin with 'are':");
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("'{0}' found at position {1}",
match.Value, match.Index);
}
}
// The example displays the following output:
// Words that begin with 'are':
// 'area' found at position 0
// 'arena' found at position 10
Il modello dell'espressione regolare viene interpretato come illustrato nella tabella seguente.
Modello |
Oggetto di descrizione |
|---|---|
\b |
Inizia la corrispondenza sul confine di parola. |
are |
Trovare la corrispondenza della sottostringa "sono". |
\w* |
Corrisponde a zero o più caratteri alfanumerici. |
\b |
Termina la corrispondenza sul confine di parola. |
Torna all'inizio
Carattere che non costituisce un confine di parola: \B
L'ancoraggio \B specifica che la corrispondenza non deve verificarsi sul confine di una parola. È l'opposto del punto di ancoraggio \b.
Nell'esempio seguente viene utilizzato l'ancoraggio \B per individuare occorrenze della sottostringa "qu" in una parola. Il criterio di espressione regolare \Bqu\w+ corrisponde a una sottostringa che inizia con un "qu" che non inizia una parola e che continua alla fine della parola.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "equity queen equip acquaint quiet"
Dim pattern As String = "\Bqu\w+"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("'{0}' found at position {1}", _
match.Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' 'quity' found at position 1
' 'quip' found at position 14
' 'quaint' found at position 21
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "equity queen equip acquaint quiet";
string pattern = @"\Bqu\w+";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("'{0}' found at position {1}",
match.Value, match.Index);
}
}
// The example displays the following output:
// 'quity' found at position 1
// 'quip' found at position 14
// 'quaint' found at position 21
Il modello dell'espressione regolare viene interpretato come illustrato nella tabella seguente.
Modello |
Oggetto di descrizione |
|---|---|
\B |
Non iniziare la corrispondenza al confine di una parola. |
qu |
Trovare la corrispondenza della sottostringa "qu". |
\w+ |
Trovare la corrispondenza di uno o più caratteri alfanumerici. |
Torna all'inizio
Vedere anche
Riferimenti
Opzioni di espressioni regolari