Regex.Split Yöntem
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
Bir giriş dizesini normal ifade eşleşmesi tarafından tanımlanan konumlarda bir alt dize dizisine böler.
Aşırı Yüklemeler
Split(String) |
Bir giriş dizesini, oluşturucuda belirtilen normal ifade deseni tarafından tanımlanan konumlardaki bir alt dize dizisine Regex böler. |
Split(String, Int32) |
Bir giriş dizesini, oluşturucuda belirtilen normal bir ifade tarafından tanımlanan konumlarda bir alt dize dizisine Regex belirtilen en fazla sayıda böler. |
Split(String, String) |
Bir giriş dizesini normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. |
Split(String, Int32, Int32) |
Bir giriş dizesini, oluşturucuda belirtilen normal bir ifade tarafından tanımlanan konumlarda bir alt dize dizisine Regex belirtilen en fazla sayıda böler. Normal ifade deseni araması, giriş dizesinde belirtilen karakter konumunda başlar. |
Split(String, String, RegexOptions) |
Bir giriş dizesini, belirtilen normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. Belirtilen seçenekler eşleşen işlemi değiştirir. |
Split(String, String, RegexOptions, TimeSpan) |
Bir giriş dizesini, belirtilen normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. Ek parametreler, eşleşen işlemi değiştiren seçenekleri ve eşleşme bulunamazsa zaman aşımı aralığını belirtir. |
Split(String)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Bir giriş dizesini, oluşturucuda belirtilen normal ifade deseni tarafından tanımlanan konumlardaki bir alt dize dizisine Regex böler.
public:
cli::array <System::String ^> ^ Split(System::String ^ input);
public string[] Split (string input);
member this.Split : string -> string[]
Public Function Split (input As String) As String()
Parametreler
- input
- String
Bölünecek dize.
Döndürülenler
Dize dizisi.
Özel durumlar
input
, null
değeridir.
Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.
Açıklamalar
Regex.Split Yöntemleri yöntemine String.Split(Char[]) benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıya böler. Dize mümkün olduğunca çok kez bölünür. Sınırlayıcı bulunmazsa, dönüş değeri özgün giriş dizesi olan bir öğe içerir.
Birden çok eşleşme birbirine bitişikse, diziye boş bir dize eklenir. Örneğin, bir dizeyi tek bir kısa çizgide bölmek, döndürülen dizinin aşağıdaki kodda gösterildiği gibi iki bitişik kısa çizginin bulunduğu konuma boş bir dize eklemesine neden olur.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
Regex regex = new Regex("-"); // Split on hyphens.
string[] substrings = regex.Split("plum--pear");
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// The example displays the following output:
// 'plum'
// ''
// 'pear'
Imports System.Text.RegularExpressions
Module RegexSplit
Public Sub Main()
Dim regex As Regex = New Regex("-") ' Split on hyphens.
Dim substrings() As String = regex.Split("plum--pear")
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The example displays the following output:
' 'plum'
' ''
' 'pear'
Giriş dizesinin başında veya sonunda eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnek, bir giriş dizesini sayısal karakterlere bölmek için normal ifade desenini \d+
kullanır. Dize eşleşen sayısal karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri olur String.Empty.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\d+";
Regex rgx = new Regex(pattern);
string input = "123ABCDE456FGHIJKL789MNOPQ012";
string[] result = rgx.Split(input);
for (int ctr = 0; ctr < result.Length; ctr++) {
Console.Write("'{0}'", result[ctr]);
if (ctr < result.Length - 1)
Console.Write(", ");
}
Console.WriteLine();
}
}
// The example displays the following output:
// '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\d+"
Dim rgx As New Regex(pattern)
Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
Dim result() As String = rgx.Split(input)
For ctr As Integer = 0 To result.Length - 1
Console.Write("'{0}'", result(ctr))
If ctr < result.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Bir ifadede Regex.Split yakalama parantezleri kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine eklenir. Örneğin, "plum-pear" dizesini yakalama parantezlerine yerleştirilen bir kısa çizgiye bölerseniz, döndürülen dizi kısa çizgi içeren bir dize öğesi içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
Regex regex = new Regex("(-)"); // Split on hyphens.
string[] substrings = regex.Split("plum-pear");
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// The example displays the following output:
// 'plum'
// '-'
// 'pear'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim regex As Regex = New Regex("(-)") ' Split on hyphens.
Dim substrings() As String = regex.Split("plum-pear")
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The example displays the following output:
' 'plum'
' '-'
' 'pear'
Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, yakalama parantezlerinin ilk kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin de döndürülen diziye eklenir. Örneğin, aşağıdaki kod tarih dizesinden tarih sınırlayıcıları da dahil olmak üzere bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk parantez yakalama kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterlerini dışlar; derlenip .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, bunları içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = @"07/14/2007";
string pattern = @"(-)|(/)";
Regex regex = new Regex(pattern);
foreach (string result in regex.Split(input))
{
Console.WriteLine("'{0}'", result);
}
}
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
// '07'
// '14'
// '2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
// '07'
// '/'
// '14'
// '/'
// '2007'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "07/14/2007"
Dim pattern As String = "(-)|(/)"
Dim regex As Regex = New Regex(pattern)
For Each result As String In regex.Split(input)
Console.WriteLine("'{0}'", result)
Next
End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
' '07'
' '14'
' '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
' '07'
' '/'
' '14'
' '/'
' '2007'
Normal ifade boş dizeyle eşleşebiliyorsa, Split(String) boş dize sınırlayıcısı her konumda bulunabileceğinden dizeyi tek karakterli dize dizisine böler. Örnek:
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "characters";
Regex regex = new Regex("");
string[] substrings = regex.Split(input);
Console.Write("{");
for(int ctr = 0; ctr < substrings.Length; ctr++)
{
Console.Write(substrings[ctr]);
if (ctr < substrings.Length - 1)
Console.Write(", ");
}
Console.WriteLine("}");
}
}
// The example displays the following output:
// {, c, h, a, r, a, c, t, e, r, s, }
Imports System.Text.RegularExpressions
Module Main
Public Sub Main()
Dim input As String = "characters"
Dim regex As New Regex("")
Dim substrings() As String = regex.Split(input)
Console.Write("{")
For ctr As Integer = 0 to substrings.Length - 1
Console.Write(substrings(ctr))
If ctr < substrings.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine("}")
End Sub
End Module
' The example produces the following output:
' {, c, h, a, r, a, c, t, e, r, s, }
Döndürülen dizinin, dizinin başında ve sonunda boş bir dize de içerdiğini unutmayın.
Bölme RegexMatchTimeoutException işleminin yürütme süresi oluşturucu tarafından Regex.Regex(String, RegexOptions, TimeSpan) belirtilen zaman aşımı aralığını aşarsa özel durum oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem nesnenin oluşturulduğu uygulama etki alanı Regex için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Oluşturucu çağrısında Regex veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeout, özel durum oluşturmaz
Ayrıca bkz.
Şunlara uygulanır
Split(String, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Bir giriş dizesini, oluşturucuda belirtilen normal bir ifade tarafından tanımlanan konumlarda bir alt dize dizisine Regex belirtilen en fazla sayıda böler.
public:
cli::array <System::String ^> ^ Split(System::String ^ input, int count);
public string[] Split (string input, int count);
member this.Split : string * int -> string[]
Public Function Split (input As String, count As Integer) As String()
Parametreler
- input
- String
Bölünecek dize.
- count
- Int32
Bölmenin en fazla kaç kez gerçekleşebileceği.
Döndürülenler
Dize dizisi.
Özel durumlar
input
, null
değeridir.
Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.
Açıklamalar
Regex.Split Yöntemleri yöntemine String.Split benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıya böler. parametresi, count
dizenin bölünebileceği en fazla alt dize input
sayısını belirtir; son dize dizenin ayrılmamış kalan kısmını içerir. count
Sıfır değeri, mümkün olduğunca çok kez bölmenin varsayılan davranışını sağlar.
Birden çok eşleşme birbirine bitişikse veya başında veya sonunda input
bir eşleşme bulunursa ve bulunan eşleşme sayısı en az iki küçükse count
, diziye boş bir dize eklenir. Başka bir ifadeyle, eşleşen alt dizelerin sayısının eşit count
olup olmadığını belirlemek için bitişik eşleşmelerden veya giriş dizesinin başında veya sonundaki eşleşmelerden kaynaklanan boş dizeler sayılır. Aşağıdaki örnekte normal ifade /d+
, bir veya daha fazla ondalık basamak içeren bir giriş dizesini en fazla üç alt dizeye bölmek için kullanılır. Giriş dizesinin başlangıcı normal ifade deseni ile eşleştiğinden, ilk dizi öğesi öğesini içerir String.Empty, ikincisi giriş dizesindeki ilk alfabetik karakter kümesini, üçüncüsü ise üçüncü eşleşmeyi izleyen dizenin geri kalanını içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\d+";
Regex rgx = new Regex(pattern);
string input = "123ABCDE456FGHIJKL789MNOPQ012";
string[] result = rgx.Split(input, 3);
for (int ctr = 0; ctr < result.Length; ctr++) {
Console.Write("'{0}'", result[ctr]);
if (ctr < result.Length - 1)
Console.Write(", ");
}
Console.WriteLine();
}
}
// The example displays the following output:
// '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\d+"
Dim rgx As New Regex(pattern)
Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
Dim result() As String = rgx.Split(input, 3)
For ctr As Integer = 0 To result.Length - 1
Console.Write("'{0}'", result(ctr))
If ctr < result.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Yakalama parantezleri normal bir ifadede kullanılıyorsa, yakalanan tüm metinler bölünmüş dize dizisine dahil edilir. Ancak, yakalanan metin içeren dizi öğeleri, eşleşme sayısının ulaşıp ulaşmadığını count
belirlerken sayılmaz. Örneğin, "apple-apricot-plum-pear-banana" dizesini en fazla dört alt dizeye bölmek, aşağıdaki kodda gösterildiği gibi yedi öğeli bir diziyle sonuçlanıyor.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "(-)";
string input = "apple-apricot-plum-pear-banana";
Regex regex = new Regex(pattern); // Split on hyphens.
string[] substrings = regex.Split(input, 4);
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// The example displays the following output:
// 'apple'
// '-'
// 'apricot'
// '-'
// 'plum'
// '-'
// 'pear-banana'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(-)"
Dim input As String = "apple-apricot-plum-pear-banana"
Dim regex As Regex = New Regex(pattern) ' Split on hyphens.
Dim substrings() As String = regex.Split(input, 4)
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The example displays the following output:
' 'apple'
' '-'
' 'apricot'
' '-'
' 'plum'
' '-'
' 'pear-banana'
Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, döndürülen diziye yalnızca ilk yakalama parantezleri kümesinden yakalanan metin eklenir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin döndürülen diziye eklenir. Ancak, döndürülen dizide yakalanan metin içeren öğeler, eşleşen alt dizelerin sayısının eşit count
olup olmadığını belirlerken sayılmaz. Örneğin, aşağıdaki kodda normal ifade, bir tarih dizesindeki bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk parantez yakalama kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Yöntemine yapılan Split(String, Int32) çağrı daha sonra döndürülen dizide en fazla iki öğe belirtir. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, yöntem iki öğeli bir dize dizisi döndürür. Derlenip .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, yöntem üç öğeli bir dize dizisi döndürür.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = @"07/14/2007";
string pattern = @"(-)|(/)";
Regex regex = new Regex(pattern);
foreach (string result in regex.Split(input, 2))
{
Console.WriteLine("'{0}'", result);
}
}
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 2 elements, as follows:
// '07'
// '14/2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 3 elements, as follows:
// '07'
// '/'
// '14/2007'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "07/14/2007"
Dim pattern As String = "(-)|(/)"
Dim regex As Regex = New Regex(pattern)
For Each result As String In regex.Split(input, 2)
Console.WriteLine("'{0}'", result)
Next
End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 2 elements, as follows:
' '07'
' '14/2007'
'
' In .NET 2.0 and later, the method returns an array of
' 3 elements, as follows:
' '07'
' '/'
' '14/2007'
Normal ifade boş dizeyle eşleşebiliyorsa, Split(String, Int32) boş dize sınırlayıcısı her konumda bulunabileceğinden dizeyi tek karakterli dize dizisine böler. Aşağıdaki örnek, "characters" dizesini giriş dizesinde olduğu kadar çok öğeye böler. Null dize giriş dizesinin başlangıcıyla eşleştiğinden, döndürülen dizinin başına bir null dize eklenir. Bu, onuncu öğenin giriş dizesinin sonundaki iki karakterden oluşmasına neden olur.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "characters"
Dim regex As New Regex("")
Dim substrings() As String = regex.Split(input, input.Length)
Console.Write("{")
For ctr As Integer = 0 to substrings.Length - 1
Console.Write(substrings(ctr))
if ctr < substrings.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine("}")
End Sub
End Module
' The example displays the following output:
' {, c, h, a, r, a, c, t, e, rs}
Bölme RegexMatchTimeoutException işleminin yürütme süresi oluşturucu tarafından Regex.Regex(String, RegexOptions, TimeSpan) belirtilen zaman aşımı aralığını aşarsa özel durum oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem nesnenin oluşturulduğu uygulama etki alanı Regex için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Oluşturucu çağrısında Regex veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeout, özel durum oluşturmaz
Ayrıca bkz.
Şunlara uygulanır
Split(String, String)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Bir giriş dizesini normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler.
public:
static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern);
public static string[] Split (string input, string pattern);
static member Split : string * string -> string[]
Public Shared Function Split (input As String, pattern As String) As String()
Parametreler
- input
- String
Bölünecek dize.
- pattern
- String
Eşleştirecek normal ifade deseni.
Döndürülenler
Dize dizisi.
Özel durumlar
Normal ifade ayrıştırma hatası oluştu.
input
veya pattern
şeklindedir null
.
Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.
Açıklamalar
Regex.Split Yöntemleri yöntemine String.Split benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıya böler. Dize input
mümkün olduğunca çok kez bölünür. Dizede input
bulunmazsapattern
, dönüş değeri özgün input
dize olan bir öğe içerir.
parametresi, pattern
eşleşecek dizeyi sembolik olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz . .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.
Önemli
Statik Split yöntemlere yapılan çağrılarda kullanılan derlenmiş normal ifadeler otomatik olarak önbelleğe alınır. Derlenmiş normal ifadelerin ömrünü kendiniz yönetmek için örnek Split yöntemlerini kullanın.
Birden çok eşleşme birbirinin yanındaysa, diziye boş bir dize eklenir. Örneğin, bir dizeyi tek bir kısa çizgiye bölmek, döndürülen dizinin aşağıdaki kodda gösterildiği gibi iki bitişik kısa çizginin bulunduğu konuma boş bir dize eklemesine neden olur.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "plum--pear";
string pattern = "-"; // Split on hyphens
string[] substrings = Regex.Split(input, pattern);
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// The method displays the following output:
// 'plum'
// ''
// 'pear'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "plum--pear"
Dim pattern As String = "-" ' Split on hyphens
Dim substrings() As String = Regex.Split(input, pattern)
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The example displays the following output:
' 'plum'
' ''
' 'pear'
Giriş dizesinin başında veya sonunda bir eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnek, bir giriş dizesini sayısal karakterlere bölmek için normal ifade desenini \d+
kullanır. Dize eşleşen sayısal karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri olur String.Empty.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\d+";
string input = "123ABCDE456FGHIJKL789MNOPQ012";
string[] result = Regex.Split(input, pattern);
for (int ctr = 0; ctr < result.Length; ctr++) {
Console.Write("'{0}'", result[ctr]);
if (ctr < result.Length - 1)
Console.Write(", ");
}
Console.WriteLine();
}
}
// The example displays the following output:
// '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\d+"
Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
Dim result() As String = Regex.Split(input, pattern)
For ctr As Integer = 0 To result.Length - 1
Console.Write("'{0}'", result(ctr))
If ctr < result.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''
Bir ifadede Regex.Split yakalama parantezleri kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine dahil edilir. Örneğin, "erik-armut" dizesini yakalama parantezlerine yerleştirilen bir kısa çizgiye bölerseniz, döndürülen dizi kısa çizgi içeren bir dize öğesi içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "plum-pear";
string pattern = "(-)";
string[] substrings = Regex.Split(input, pattern); // Split on hyphens
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// The example displays the following output:
// 'plum'
// '-'
// 'pear'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "plum-pear"
Dim pattern As String = "(-)"
Dim substrings() As String = Regex.Split(input, pattern) ' Split on hyphens.
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The method writes the following to the console:
' 'plum'
' '-'
' 'pear'
Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, ilk yakalama parantezleri kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin döndürülen diziye de eklenir. Örneğin, aşağıdaki kod tarih dizesinden tarih sınırlayıcıları da dahil olmak üzere bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantez kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterlerini dışlar; derlenip .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa bunları içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = @"07/14/2007";
string pattern = @"(-)|(/)";
foreach (string result in Regex.Split(input, pattern))
{
Console.WriteLine("'{0}'", result);
}
}
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
// '07'
// '14'
// '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
// '07'
// '/'
// '14'
// '/'
// '2007'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "07/14/2007"
Dim pattern As String = "(-)|(/)"
For Each result As String In Regex.Split(input, pattern)
Console.WriteLine("'{0}'", result)
Next
End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
' '07'
' '14'
' '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
' '07'
' '/'
' '14'
' '/'
' '2007'
Normal ifade boş dizeyle eşleşebiliyorsa, Split boş dize sınırlayıcısı her konumda bulunabildiğinden dizeyi tek karakterli dize dizisine böler. Örnek:
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "characters";
string[] substrings = Regex.Split(input, "");
Console.Write("{");
for(int ctr = 0; ctr < substrings.Length; ctr++)
{
Console.Write("'{0}'", substrings[ctr]);
if (ctr < substrings.Length - 1)
Console.Write(", ");
}
Console.WriteLine("}");
}
}
// The example produces the following output:
// {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "characters"
Dim substrings() As String = Regex.Split(input, "")
Console.Write("{")
For ctr As Integer = 0 to substrings.Length - 1
Console.Write("'{0}'", substrings(ctr))
If ctr < substrings.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine("}")
End Sub
End Module
' The example produces the following output:
' {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}
Döndürülen dizinin, dizinin başında ve sonunda boş bir dize de içerdiğini unutmayın.
RegexMatchTimeoutException Bölme işleminin yürütme süresi yöntemin çağrıldığı uygulama etki alanı için belirtilen zaman aşımı aralığını aşarsa özel durum oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeoutözel durum oluşturmaz.
Arayanlara Notlar
Bu yöntem, yönteminin çağrıldığı uygulama etki alanının varsayılan zaman aşımı değerine eşit bir aralıktan sonra zaman aşımına uğradı. Uygulama etki alanı için bir zaman aşımı değeri tanımlanmamışsa, yönteminin zaman aşımına geçmesini engelleyen değeri InfiniteMatchTimeoutkullanılır. Desen eşleşmesinde metni bölmek için önerilen statik yöntem, zaman aşımı aralığını ayarlamanıza olanak tanıyan yöntemidir Split(String, String, RegexOptions, TimeSpan).
Ayrıca bkz.
Şunlara uygulanır
Split(String, Int32, Int32)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Bir giriş dizesini, oluşturucuda belirtilen normal ifade tarafından tanımlanan konumlarda, belirtilen en fazla sayıda alt dize dizisine Regex böler. Normal ifade deseni için arama, giriş dizesinde belirtilen karakter konumunda başlar.
public:
cli::array <System::String ^> ^ Split(System::String ^ input, int count, int startat);
public string[] Split (string input, int count, int startat);
member this.Split : string * int * int -> string[]
Public Function Split (input As String, count As Integer, startat As Integer) As String()
Parametreler
- input
- String
Bölünecek dize.
- count
- Int32
Bölmenin en fazla kaç kez gerçekleşebileceği.
- startat
- Int32
Giriş dizesinde aramanın başlayacağı karakter konumu.
Döndürülenler
Dize dizisi.
Özel durumlar
input
, null
değeridir.
startat
sıfırdan küçük veya uzunluğundan büyük.input
Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.
Açıklamalar
Regex.Split Yöntemleri yöntemine String.Split benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen bir sınırlayıcıya böler. parametresi, count
dizenin bölündüğü input
en fazla alt dize sayısını belirtir; son dize dizenin kesintisiz kalan kısmını içerir. count
Sıfır değeri, mümkün olduğunca çok kez bölmenin varsayılan davranışını sağlar. parametresi, startat
ilk sınırlayıcı için aramanın başladığı noktayı tanımlar (bu, baştaki boşluğu atlamak için kullanılabilir).
hakkında startat
daha fazla ayrıntı için öğesinin Açıklamalar bölümüne Match(String, Int32)bakın.
Dizedeki count
+1 konumundan eşleşme bulunmazsa, yöntem dizeyi içeren tek öğeli input
bir dizi döndürür. Bir veya daha fazla eşleşme bulunursa, döndürülen dizinin ilk öğesi ilk karakterden eşleşmeden önce bir karaktere kadar olan dizenin ilk bölümünü içerir.
Birden çok eşleşme birbirine bitişikse ve bulunan eşleşme sayısı en az iki küçükse count
, diziye boş bir dize eklenir. Benzer şekilde, dizedeki ilk karakter olan konumunda bir eşleşme bulunursa startat
, döndürülen dizinin ilk öğesi boş bir dizedir. Başka bir ifadeyle, eşleşen alt dize sayısının eşit count
olup olmadığı belirlenirken bitişik eşleşmelerden kaynaklanan boş dizeler sayılır. Aşağıdaki örnekte, normal ifade \d+
bir dizedeki sayısal karakterlerin ilk alt dizesinin başlangıç konumunu bulmak ve ardından bu konumdan başlayarak dizeyi en fazla üç kez bölmek için kullanılır. Normal ifade deseni giriş dizesinin başlangıcıyla eşleştiğinden, döndürülen dize dizisi boş bir dizeden, beş karakterli alfabetik dizeden ve dizenin geri kalanından oluşur.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\d+";
Regex rgx = new Regex(pattern);
string input = "123ABCDE456FGHIJ789KLMNO012PQRST";
Match m = rgx.Match(input);
if (m.Success) {
int startAt = m.Index;
string[] result = rgx.Split(input, 3, startAt);
for (int ctr = 0; ctr < result.Length; ctr++) {
Console.Write("'{0}'", result[ctr]);
if (ctr < result.Length - 1)
Console.Write(", ");
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\d+"
Dim rgx As New Regex(pattern)
Dim input As String = "123ABCDE456FGHIJ789KLMNO012PQRST"
Dim m As Match = rgx.Match(input)
If m.Success Then
Dim startAt As Integer = m.Index
Dim result() As String = rgx.Split(input, 3, startAt)
For ctr As Integer = 0 To result.Length - 1
Console.Write("'{0}'", result(ctr))
If ctr < result.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine()
End If
End Sub
End Module
' The example displays the following output:
' '', 'ABCDE', 'FGHIJKL789MNOPQ012'
Yakalama parantezleri normal bir ifadede kullanılıyorsa, yakalanan tüm metinler bölünmüş dize dizisine dahil edilir. Ancak, yakalanan metin içeren dizi öğeleri eşleşme sayısının ulaşıp ulaşmadığı count
belirlenirken sayılmaz. Örneğin, '"apple-apricot-plum-pear-pomegranate-pineapple-peach" dizesini dizedeki 15 karakterinden başlayarak en fazla dört alt dizeye bölmek, aşağıdaki kodda gösterildiği gibi yedi öğeli bir diziyle sonuçlanıyor.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "(-)";
string input = "apple-apricot-plum-pear-pomegranate-pineapple-peach";
// Split on hyphens from 15th character on
Regex regex = new Regex(pattern);
// Split on hyphens from 15th character on
string[] substrings = regex.Split(input, 4, 15);
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// The method writes the following to the console:
// 'apple-apricot-plum'
// '-'
// 'pear'
// '-'
// 'pomegranate'
// '-'
// 'pineapple-peach'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(-)"
Dim input As String = "apple-apricot-plum-pear-pomegranate-pineapple-peach"
Dim regex As Regex = New Regex(pattern)
' Split on hyphens from 15th character on
Dim substrings() As String = regex.Split(input, 4, 15)
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The example displays the following output:
' 'apple-apricot-plum'
' '-'
' 'pear'
' '-'
' 'pomegranate'
' '-'
' 'pineapple-peach'
Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, yakalama parantezlerinin ilk kümesinde eşleşme bulunamazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin döndürülen diziye de eklenir. Örneğin, aşağıdaki kod dizedeki tek tek sözcükleri ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantezi kümesi kısa çizgiyi, ikinci küme ise dikey çubuğu yakalar. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, dikey çubuk karakterleri hariç tutar; derlenip .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, bunları içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "(-)|([|])"; // possible delimiters found in string
string input = "apple|apricot|plum|pear|pomegranate|pineapple|peach";
Regex regex = new Regex(pattern);
// Split on delimiters from 15th character on
string[] substrings = regex.Split(input, 4, 15);
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// In .NET 2.0 and later, the method returns an array of
// 7 elements, as follows:
// apple|apricot|plum'
// '|'
// 'pear'
// '|'
// 'pomegranate'
// '|'
// 'pineapple|peach'
// In .NET 1.0 and 1.1, the method returns an array of
// 4 elements, as follows:
// 'apple|apricot|plum'
// 'pear'
// 'pomegranate'
// 'pineapple|peach'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(-)|([|])" ' possible delimiters found in string
Dim input As String = "apple|apricot|plum|pear|pomegranate|pineapple|peach"
Dim regex As Regex = New Regex(pattern)
' Split on delimiters from 15th character on
Dim substrings() As String = regex.Split(input, 4, 15)
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' In .NET 2.0, the method returns an array of
' 7 elements, as follows:
' apple|apricot|plum'
' '|'
' 'pear'
' '|'
' 'pomegranate'
' '|'
' 'pineapple|peach'
' In .NET 1.0 and 1.1, the method returns an array of
' 4 elements, as follows:
' 'apple|apricot|plum'
' 'pear'
' 'pomegranate'
' 'pineapple|peach'
Normal ifade boş dizeyle eşleşebiliyorsa, Split boş dize sınırlayıcısı her konumda bulunabildiğinden dizeyi tek karakterli dize dizisine böler. Aşağıdaki örnek, "a" karakterinden başlayarak "characters" dizesini giriş dizesinin içerdiği sayıda öğeye böler. Null dize giriş dizesinin sonuyla eşleştiğinden, döndürülen dizinin sonuna bir null dize eklenir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "characters";
Regex regex = new Regex("");
string[] substrings = regex.Split(input, input.Length, input.IndexOf("a"));
Console.Write("{");
for(int ctr = 0; ctr < substrings.Length; ctr++)
{
Console.Write(substrings[ctr]);
if (ctr < substrings.Length - 1)
Console.Write(", ");
}
Console.WriteLine("}");
}
}
// The example displays the following output:
// {, c, h, a, r, a, c, t, e, rs}
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "characters"
Dim regex As New Regex("")
Dim substrings() As String = regex.Split(input, input.Length, _
input.IndexOf("a"))
Console.Write("{")
For ctr As Integer = 0 to substrings.Length - 1
Console.Write(substrings(ctr))
If ctr < substrings.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine("}")
End Sub
End Module
' The example produces the following output:
' {, c, h, a, r, a, c, t, e, rs}
RegexMatchTimeoutException Bölme işleminin yürütme süresi oluşturucu tarafından Regex.Regex(String, RegexOptions, TimeSpan) belirtilen zaman aşımı aralığını aşarsa özel durum oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem nesnenin oluşturulduğu uygulama etki alanı Regex için oluşturulan herhangi bir zaman aşımı değerini aşarsa özel durum oluşturulur. Oluşturucu çağrısında veya uygulama etki alanının özelliklerinde Regex hiçbir zaman aşımı tanımlanmamışsa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeoutözel durum oluşturmaz
Ayrıca bkz.
Şunlara uygulanır
Split(String, String, RegexOptions)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Bir giriş dizesini, belirtilen normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. Belirtilen seçenekler eşleşen işlemi değiştirir.
public:
static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions) As String()
Parametreler
- input
- String
Bölünecek dize.
- pattern
- String
Eşleştirecek normal ifade deseni.
- options
- RegexOptions
Eşleştirme seçenekleri sağlayan numaralandırma değerlerinin bit düzeyinde birleşimi.
Döndürülenler
Dize dizisi.
Özel durumlar
Normal ifade ayrıştırma hatası oluştu.
input
veya pattern
şeklindedir null
.
options
, değerlerin RegexOptions bit düzeyinde geçerli bir bileşimi değildir.
Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.
Açıklamalar
Regex.Split Yöntemleri yöntemine String.Split(Char[]) benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen bir sınırlayıcıya böler. Dize mümkün olduğunca çok kez bölünür. Sınırlayıcı bulunmazsa, dönüş değeri özgün input
dize olan bir öğe içerir.
parametresi, pattern
eşleşecek dizeyi sembolik olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz . .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.
Önemli
Statik Split yöntemlere yapılan çağrılarda kullanılan derlenmiş normal ifadeler otomatik olarak önbelleğe alınır. Derlenmiş normal ifadelerin ömrünü kendiniz yönetmek için örnek Split yöntemlerini kullanın.
Birden çok eşleşme birbirinin yanındaysa, diziye boş bir dize eklenir. Örneğin, bir dizeyi tek bir kısa çizgiye bölmek, döndürülen dizinin iki bitişik kısa çizginin bulunduğu konuma boş bir dize eklemesine neden olur.
Giriş dizesinin başında veya sonunda bir eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnekte, herhangi bir büyük veya küçük harf karakterdeki bir giriş dizesini bölmek için normal ifade deseni [a-z]+
kullanılır. Dize, eşleşen alfabetik karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri olur String.Empty.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "[a-z]+";
string input = "Abc1234Def5678Ghi9012Jklm";
string[] result = Regex.Split(input, pattern,
RegexOptions.IgnoreCase);
for (int ctr = 0; ctr < result.Length; ctr++) {
Console.Write("'{0}'", result[ctr]);
if (ctr < result.Length - 1)
Console.Write(", ");
}
Console.WriteLine();
}
}
// The example displays the following output:
// '', '1234', '5678', '9012', ''
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "[a-z]+"
Dim input As String = "Abc1234Def5678Ghi9012Jklm"
Dim result() As String = Regex.Split(input, pattern,
RegexOptions.IgnoreCase)
For ctr As Integer = 0 To result.Length - 1
Console.Write("'{0}'", result(ctr))
If ctr < result.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' '', '1234', '5678', '9012', ''
Bir ifadede Regex.Split yakalama parantezleri kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine dahil edilir. Örneğin, "erik-armut" dizesini yakalama parantezlerine yerleştirilen bir kısa çizgiye bölerseniz, döndürülen dizi kısa çizgi içeren bir dize öğesi içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "plum-pear";
string pattern = "(-)";
string[] substrings = Regex.Split(input, pattern); // Split on hyphens
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// The example displays the following output:
// 'plum'
// '-'
// 'pear'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "plum-pear"
Dim pattern As String = "(-)"
Dim substrings() As String = Regex.Split(input, pattern) ' Split on hyphens.
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The method writes the following to the console:
' 'plum'
' '-'
' 'pear'
Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, ilk yakalama parantezleri kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin döndürülen diziye de eklenir. Örneğin, aşağıdaki kod tarih dizesinden tarih sınırlayıcıları da dahil olmak üzere bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantez kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterlerini dışlar; derlenip .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa bunları içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = @"07/14/2007";
string pattern = @"(-)|(/)";
foreach (string result in Regex.Split(input, pattern))
{
Console.WriteLine("'{0}'", result);
}
}
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
// '07'
// '14'
// '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
// '07'
// '/'
// '14'
// '/'
// '2007'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "07/14/2007"
Dim pattern As String = "(-)|(/)"
For Each result As String In Regex.Split(input, pattern)
Console.WriteLine("'{0}'", result)
Next
End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
' '07'
' '14'
' '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
' '07'
' '/'
' '14'
' '/'
' '2007'
Normal ifade boş dizeyle eşleşebiliyorsa, Split boş dize sınırlayıcısı her konumda bulunabildiğinden dizeyi tek karakterli dize dizisine böler.
RegexMatchTimeoutException Bölme işleminin yürütme süresi yöntemin çağrıldığı uygulama etki alanı için belirtilen zaman aşımı aralığını aşarsa özel durum oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeoutözel durum oluşturmaz.
Arayanlara Notlar
Bu yöntem, yönteminin çağrıldığı uygulama etki alanının varsayılan zaman aşımı değerine eşit bir aralıktan sonra zaman aşımına uğradı. Uygulama etki alanı için bir zaman aşımı değeri tanımlanmamışsa, yöntemin zaman aşımına girmesini engelleyen değeri InfiniteMatchTimeoutkullanılır. Desen eşleşmesinde metni bölmek için önerilen statik yöntem, zaman aşımı aralığını ayarlamanıza olanak tanıyan yöntemidir Split(String, String, RegexOptions, TimeSpan).
Ayrıca bkz.
Şunlara uygulanır
Split(String, String, RegexOptions, TimeSpan)
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
- Source:
- Regex.Split.cs
Bir giriş dizesini, belirtilen normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. Ek parametreler, eşleşen işlemi değiştiren seçenekleri ve eşleşme bulunamazsa zaman aşımı aralığını belirtir.
public:
static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Split : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string[]
Public Shared Function Split (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As String()
Parametreler
- input
- String
Bölünecek dize.
- pattern
- String
Eşleştirecek normal ifade deseni.
- options
- RegexOptions
Eşleştirme seçenekleri sağlayan numaralandırma değerlerinin bit düzeyinde birleşimi.
- matchTimeout
- TimeSpan
Zaman aşımı aralığı veya InfiniteMatchTimeout yöntemin zaman aşımına neden olmaması gerektiğini belirtmek için.
Döndürülenler
Bir dize dizisi.
Özel durumlar
Normal ifade ayrıştırma hatası oluştu.
input
veya pattern
şeklindedir null
.
options
değerlerin RegexOptions bit düzeyinde geçerli bir bileşimi değildir.
-veya-
matchTimeout
negatif, sıfır veya yaklaşık 24 günden büyük.
Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.
Açıklamalar
Regex.Split Yöntemleri yöntemine String.Split(Char[]) benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıya böler. Dize mümkün olduğunca çok kez bölünür. Sınırlayıcı bulunmazsa, dönüş değeri özgün input
dize olan bir öğe içerir.
parametresi, pattern
eşleşecek dizeyi sembolik olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz . .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.
Önemli
Statik Split yöntemlere yapılan çağrılarda kullanılan derlenmiş normal ifadeler otomatik olarak önbelleğe alınır. Derlenmiş normal ifadelerin ömrünü kendiniz yönetmek için örnek Split yöntemlerini kullanın.
Birden çok eşleşme birbirine bitişikse, diziye boş bir dize eklenir. Örneğin, bir dizeyi tek bir kısa çizgiye bölmek, döndürülen dizinin iki bitişik kısa çizginin bulunduğu konuma boş bir dize eklemesine neden olur.
Giriş dizesinin başında veya sonunda eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnek, herhangi bir büyük veya küçük harf alfabetik karakterde bir giriş dizesini bölmek için normal ifade desenini [a-z]+
kullanır. Dize eşleşen alfabetik karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri olur String.Empty.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "[a-z]+";
string input = "Abc1234Def5678Ghi9012Jklm";
string[] result = Regex.Split(input, pattern,
RegexOptions.IgnoreCase,
TimeSpan.FromMilliseconds(500));
for (int ctr = 0; ctr < result.Length; ctr++) {
Console.Write("'{0}'", result[ctr]);
if (ctr < result.Length - 1)
Console.Write(", ");
}
Console.WriteLine();
}
}
// The example displays the following output:
// '', '1234', '5678', '9012', ''
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "[a-z]+"
Dim input As String = "Abc1234Def5678Ghi9012Jklm"
Dim result() As String = Regex.Split(input, pattern,
RegexOptions.IgnoreCase,
TimeSpan.FromMilliseconds(500))
For ctr As Integer = 0 To result.Length - 1
Console.Write("'{0}'", result(ctr))
If ctr < result.Length - 1 Then Console.Write(", ")
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' '', '1234', '5678', '9012', ''
Bir ifadede Regex.Split yakalama parantezleri kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine eklenir. Örneğin, "plum-pear" dizesini yakalama parantezlerine yerleştirilen bir kısa çizgiye bölerseniz, döndürülen dizi kısa çizgi içeren bir dize öğesi içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "plum-pear";
string pattern = "(-)";
string[] substrings = Regex.Split(input, pattern); // Split on hyphens
foreach (string match in substrings)
{
Console.WriteLine("'{0}'", match);
}
}
}
// The example displays the following output:
// 'plum'
// '-'
// 'pear'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "plum-pear"
Dim pattern As String = "(-)"
Dim substrings() As String = Regex.Split(input, pattern) ' Split on hyphens.
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The method writes the following to the console:
' 'plum'
' '-'
' 'pear'
Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, yakalama parantezlerinin ilk kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin de döndürülen diziye eklenir. Örneğin, aşağıdaki kod tarih dizesinden tarih sınırlayıcıları da dahil olmak üzere bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk parantez yakalama kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterlerini dışlar; derlenip .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, bunları içerir.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = @"07/14/2007";
string pattern = @"(-)|(/)";
foreach (string result in Regex.Split(input, pattern))
{
Console.WriteLine("'{0}'", result);
}
}
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
// '07'
// '14'
// '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
// '07'
// '/'
// '14'
// '/'
// '2007'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "07/14/2007"
Dim pattern As String = "(-)|(/)"
For Each result As String In Regex.Split(input, pattern)
Console.WriteLine("'{0}'", result)
Next
End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
' '07'
' '14'
' '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
' '07'
' '/'
' '14'
' '/'
' '2007'
Normal ifade boş dizeyle eşleşebiliyorsa, Split boş dize sınırlayıcısı her konumda bulunabileceğinden dizeyi tek karakterli dize dizisine böler.
parametresi, matchTimeout
desen eşleştirme yönteminin zaman aşımına uğramadan önce eşleşmeyi ne kadar süreyle bulmaya çalışılması gerektiğini belirtir. Zaman aşımı aralığı ayarlamak, aşırı geri izlemeyi kullanan normal ifadelerin, yakın eşleşmeler içeren girişi işlerken yanıt vermeyi durduracak şekilde görünmesini önler. Daha fazla bilgi için bkz. Normal İfadeler ve Geri İzlemeiçin En İyi Yöntemler. Bu zaman aralığında eşleşme bulunmazsa, yöntem bir RegexMatchTimeoutException özel durum oluşturur. matchTimeout
yöntemin yürütüldiği uygulama etki alanı için tanımlanan varsayılan zaman aşımı değerlerini geçersiz kılar.
Arayanlara Notlar
parametresini matchTimeout
iki saniye gibi uygun bir değere ayarlamanızı öneririz. belirterek InfiniteMatchTimeoutzaman aşımlarını devre dışı bırakırsanız, normal ifade altyapısı biraz daha iyi performans sunar. Ancak, zaman aşımlarını yalnızca aşağıdaki koşullarda devre dışı bırakmanız gerekir:
Normal bir ifade tarafından işlenen giriş bilinen ve güvenilen bir kaynaktan türetildiğinde veya statik metinden oluştuğunda. Bu, kullanıcılar tarafından dinamik olarak giriş yapılan metinleri dışlar.
Normal ifade deseni, eşleşmeleri, eşleşmeleri ve yakın eşleşmeleri verimli bir şekilde işlediğinden emin olmak için kapsamlı bir şekilde test edildiğinde.
Normal ifade deseni, yakın bir eşleşme işlenirken aşırı geri izlenmeye neden olduğu bilinen bir dil öğesi içermediğinde.
Ayrıca bkz.
Şunlara uygulanır
Geri Bildirim
https://aka.ms/ContentUserFeedback.
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz.Gönderin ve geri bildirimi görüntüleyin