Fästpunkter i reguljära uttryck
Fästpunkter, eller atomiska nollbreddskontroller, anger en position i strängen där en matchning måste ske. När du använder en fästpunkt i sökuttrycket går motorn för reguljära uttryck inte vidare genom strängen eller använder tecken. den söker efter en matchning endast i den angivna positionen. Anger till exempel ^ att matchningen måste starta i början av en rad eller sträng. Därför matchar det reguljära uttrycket ^http: endast "http:" när det inträffar i början av en rad. I följande tabell visas de fästpunkter som stöds av reguljära uttryck i .NET.
| Fästpunkt | beskrivning |
|---|---|
^ |
Som standard måste matchningen ske i början av strängen. i flerradsläge måste det ske i början av raden. Mer information finns i Början av sträng eller rad. |
$ |
Som standard måste matchningen ske i slutet av strängen eller före \n i slutet av strängen. I flerradsläge måste den ske i slutet av raden eller före \n i slutet av raden. Mer information finns i Slutet av strängen eller raden. |
\A |
Matchningen måste endast ske i början av strängen (inget stöd för flera ledningar). Mer information finns i Endast början av sträng. |
\Z |
Matchningen måste ske i slutet av strängen eller före \n i slutet av strängen. Mer information finns i Slutet av strängen eller Innan ny rad slutar. |
\z |
Matchningen måste endast ske i slutet av strängen. Mer information finns i Endast slutet av strängen. |
\G |
Matchningen måste starta på den position där den föregående matchen slutade, eller om det inte fanns någon tidigare matchning, vid positionen i strängen där matchningen startade. Mer information finns i Sammanhängande matchningar. |
\b |
Matchningen måste ske på en ordgräns. Mer information finns i Word Boundary. |
\B |
Matchningen får inte ske på en ordgräns. Mer information finns i Icke-Word-gräns. |
Början av strängen eller raden: ^
Som standard anger fästpunkten ^ att följande mönster måste börja vid strängens första teckenposition. Om du använder ^ med RegexOptions.Multiline alternativet (se Alternativ för reguljära uttryck) måste matchningen ske i början av varje rad.
I följande exempel används fästpunkten ^ i ett reguljärt uttryck som extraherar information om de år under vilka vissa professionella basebolllag fanns. Exemplet anropar två överlagringar av Regex.Matches metoden:
Anropet till överlagringen Matches(String, String) hittar bara den första delsträngen i indatasträngen som matchar mönster för reguljära uttryck.
Anropet till överlagringen Matches(String, String, RegexOptions) med parametern
optionsinställd på RegexOptions.Multiline hittar alla fem delsträngar.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
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;
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(".");
match = match.NextMatch();
}
Console.WriteLine();
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(".");
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.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
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
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(".")
match = match.NextMatch()
Loop
Console.WriteLine()
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(".")
match = match.NextMatch()
Loop
Console.WriteLine()
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.
Mönster för ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ reguljära uttryck definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
^ |
Börja matchningen i början av indatasträngen (eller början av raden om metoden anropas med RegexOptions.Multiline alternativet ). |
((\w+(\s?)){2,} |
Matcha ett eller flera ordtecken följt av noll eller med ett blanksteg minst två gånger. Det här är den första insamlingsgruppen. Det här uttrycket definierar också en andra och tredje insamlingsgrupp: Den andra består av det insamlade ordet och det tredje består av det insamlade blanksteget. |
,\s |
Matcha ett kommatecken följt av ett blankstegstecken. |
(\w+\s\w+) |
Matcha ett eller flera ordtecken följt av ett blanksteg följt av ett eller flera ordtecken. Det här är den fjärde insamlingsgruppen. |
, |
Matcha ett kommatecken. |
\s\d{4} |
Matcha ett blanksteg följt av fyra decimalsiffror. |
(-(\d{4}|present))? |
Matcha noll eller en förekomst av ett bindestreck följt av fyra decimaltal eller strängen "present". Det här är den sjätte insamlingsgruppen. Den innehåller också en sjunde insamlingsgrupp. |
,? |
Matcha noll eller en förekomst av ett kommatecken. |
(\s\d{4}(-(\d{4}|present))?,?)+ |
Matcha en eller flera förekomster av följande: ett blanksteg, fyra decimaler, noll eller en förekomst av ett bindestreck följt av fyra decimaltal eller strängen "present" och noll eller ett kommatecken. Det här är den femte insamlingsgruppen. |
Slutet av strängen eller raden: $
Fästpunkten $ anger att föregående mönster måste ske i slutet av indatasträngen eller före \n i slutet av indatasträngen.
Om du använder $ med RegexOptions.Multiline alternativet kan matchningen också ske i slutet av en rad. Observera att $ är uppfyllt vid \n men inte vid \r\n (kombinationen av vagnretur och nya radtecken, eller CR/LF). Om du vill hantera cr/LF-teckenkombinationen tar du med \r?$ i mönster för reguljära uttryck. Observera att kommer att \r?$ inkludera alla \r i matchningen.
I följande exempel läggs fästpunkten $ till det reguljära uttrycksmönster som används i exemplet i avsnittet Början av sträng eller rad . När den används med den ursprungliga indatasträngen, som innehåller fem textrader, Regex.Matches(String, String) kan metoden inte hitta en matchning eftersom slutet på den första raden inte matchar $ mönstret. När den ursprungliga indatasträngen delas upp i en strängmatris Regex.Matches(String, String) lyckas metoden matcha var och en av de fem raderna. Regex.Matches(String, String, RegexOptions) När metoden anropas med parametern options inställd på , hittas inga matchningar eftersom mönstret för reguljära uttryck inte tar hänsyn till RegexOptions.Multilinevagnreturtecknet \r. Men när mönster för reguljära uttryck ändras genom att $ ersätta med \r?$, anropar Regex.Matches(String, String, RegexOptions) metoden med parametern options inställd på RegexOptions.Multiline igen hittar fem matchningar.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
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:");
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(".");
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)
{
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();
Console.WriteLine("Attempting to match each line of an input string with '$':");
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(".");
match = match.NextMatch();
}
Console.WriteLine();
pattern = basePattern + "\r?$";
Console.WriteLine(@"Attempting to match each line of an input string with '\r?$':");
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(".");
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.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
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:")
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(".")
match = match.NextMatch()
Loop
Console.WriteLine()
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
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()
Console.WriteLine("Attempting to match each line of an input string with '$':")
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(".")
match = match.NextMatch()
Loop
Console.WriteLine()
pattern = basePattern + "\r?$"
Console.WriteLine("Attempting to match each line of an input string with '\r?$':")
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(".")
match = match.NextMatch()
Loop
Console.WriteLine()
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.
Endast början av sträng: \A
Fästpunkten \A anger att en matchning måste ske i början av indatasträngen. Den är identisk med ^ fästpunkten, förutom att \A alternativet ignoreras RegexOptions.Multiline . Därför kan den bara matcha början av den första raden i en indatasträng med flera rader.
Följande exempel liknar exemplen för fästpunkterna ^ och $ . Den använder \A fästpunkten i ett reguljärt uttryck som extraherar information om de år under vilka vissa professionella basebolllag fanns. Indatasträngen innehåller fem rader. Anropet Regex.Matches(String, String, RegexOptions) till metoden hittar bara den första delsträngen i indatasträngen som matchar mönstret för reguljära uttryck. Som exemplet visar har alternativet Multiline ingen effekt.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
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 = 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(".");
match = match.NextMatch();
}
Console.WriteLine();
}
}
// The example displays the following output:
// The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
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 = 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(".")
match = match.NextMatch()
Loop
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
Slutet av strängen eller innan newline avslutas: \Z
Fästpunkten \Z anger att en matchning måste ske i slutet av indatasträngen eller tidigare \n i slutet av indatasträngen. Den är identisk med $ fästpunkten, förutom att \Z alternativet ignoreras RegexOptions.Multiline . I en sträng med flera rader kan den därför bara uppfyllas i slutet av den sista raden eller den sista raden före \n.
Observera att \Z är uppfyllt på \n men inte är uppfyllt på \r\n (CR/LF-teckenkombinationen). För att behandla CR/LF som om det vore \n, inkludera \r?\Z i mönstret för reguljära uttryck. Observera att detta kommer att göra den \r del av matchningen.
I följande exempel används fästpunkten \Z i ett reguljärt uttryck som liknar exemplet i avsnittet Början av sträng eller linje , som extraherar information om de år under vilka vissa professionella basebolllag fanns. Underuttrycket \r?\Z i det reguljära uttrycket ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z uppfylls i slutet av en sträng, och även i slutet av en sträng som slutar med \n eller \r\n. Därför matchar varje element i matrisen mönster för reguljära uttryck.
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)
{
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.
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
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.
Endast slutet av strängen: \z
Fästpunkten \z anger att en matchning måste ske i slutet av indatasträngen. Precis som $ språkelementet \z ignorerar alternativet RegexOptions.Multiline . \Z Till skillnad från språkelementet \z uppfylls inte av ett \n tecken i slutet av en sträng. Därför kan den bara matcha slutet av indatasträngen.
I följande exempel används fästpunkten \z i ett reguljärt uttryck som annars är identiskt med exemplet i föregående avsnitt, som extraherar information om de år under vilka vissa professionella basebolllag fanns. Exemplet försöker matcha vart och ett av fem element i en strängmatris med det reguljära uttrycksmönstret ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z. Två av strängarna slutar med vagnretur och radmatningstecken, en slutar med ett linjematningstecken och två slutar med varken vagnretur eller radmatningstecken. Som utdata visar matchar endast strängarna utan vagnretur eller radmatning mönstret.
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\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)
{
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.
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
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.
Sammanhängande matchningar: \G
Fästpunkten \G anger att en matchning måste ske vid den punkt där den föregående matchen slutade, eller om det inte fanns någon tidigare matchning, vid positionen i strängen där matchningen startade. När du använder den här fästpunkten med Regex.Matches metoden eller Match.NextMatch ser den till att alla matchningar är sammanhängande.
Dricks
Vanligtvis placerar du ett \G fästpunkt i den vänstra änden av mönstret. I det ovanliga fallet du utför en sökning från höger till vänster placerar \G du fästpunkten i den högra änden av mönstret.
I följande exempel används ett reguljärt uttryck för att extrahera namnen på gnagare från en kommaavgränsad sträng.
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
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
Det reguljära uttrycket \G(\w+\s?\w*),? tolkas som det visas i följande tabell.
| Mönster | beskrivning |
|---|---|
\G |
Börja där den senaste matchen slutade. |
\w+ |
Matcha ett eller flera ordtecken. |
\s? |
Matcha noll eller ett blanksteg. |
\w* |
Matcha noll eller fler ordtecken. |
(\w+\s?\w*) |
Matcha ett eller flera ordtecken följt av noll eller ett blanksteg följt av noll eller fler ordtecken. Det här är den första insamlingsgruppen. |
,? |
Matcha noll eller en förekomst av ett literal kommatecken. |
Word-gräns: \b
Fästpunkten \b anger att matchningen måste ske på en gräns mellan ett ordtecken ( \w språkelementet) och ett icke-ordtecken ( \W språkelementet). Word-tecken består av alfanumeriska tecken och understreck. ett icke-ordtecken är ett tecken som inte är alfanumeriskt eller understreck. (Mer information finns i Teckenklasser.) Matchningen kan också inträffa på en ordgräns i början eller slutet av strängen.
Fästpunkten \b används ofta för att säkerställa att ett underuttryck matchar ett helt ord i stället för bara början eller slutet av ett ord. Det reguljära uttrycket \bare\w*\b i följande exempel illustrerar den här användningen. Den matchar alla ord som börjar med delsträngen "are". Utdata från exemplet visar också att \b matchar både början och slutet av indatasträngen.
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
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
Mönster för reguljära uttryck tolkas enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
are |
Matcha delsträngen "are". |
\w* |
Matcha noll eller fler ordtecken. |
\b |
Avsluta matchningen vid en ordgräns. |
Gräns som inte är ord: \B
Fästpunkten \B anger att matchningen inte får ske på en ordgräns. Det är motsatsen till fästpunkten \b .
I följande exempel används fästpunkten \B för att hitta förekomster av understrängen "qu" i ett ord. Mönstret \Bqu\w+ för reguljära uttryck matchar en delsträng som börjar med en "qu" som inte startar ett ord och som fortsätter till slutet av ordet.
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
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
Mönster för reguljära uttryck tolkas enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\B |
Starta inte matchningen vid en ordgräns. |
qu |
Matcha delsträngen "qu". |
\w+ |
Matcha ett eller flera ordtecken. |
Se även
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för