Bagikan melalui

Regex.Split Metode

  • Referensi

Definisi

Ruang nama:
System.Text.RegularExpressions
Rakitan:
System.Text.RegularExpressions.dll
Rakitan:
System.dll
Rakitan:
netstandard.dll

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh kecocokan ekspresi reguler.

Overload

Split(String, String, RegexOptions, TimeSpan)

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh pola ekspresi reguler tertentu. Parameter tambahan menentukan opsi yang memodifikasi operasi pencocokan dan interval waktu habis jika tidak ada kecocokan yang ditemukan.
Split(String, String, RegexOptions)

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh pola ekspresi reguler tertentu. Opsi yang ditentukan mengubah operasi pencocokan.
Split(String, Int32, Int32)

Memisahkan string input jumlah maksimum yang ditentukan menjadi array substring, pada posisi yang ditentukan oleh ekspresi reguler yang ditentukan dalam konstruktor Regex. Pencarian pola ekspresi reguler dimulai pada posisi karakter tertentu dalam string input.
Split(String, String)

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh pola ekspresi reguler.
Split(String)

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh pola ekspresi reguler yang ditentukan dalam konstruktor Regex.
Split(String, Int32)

Memisahkan string input jumlah maksimum yang ditentukan menjadi array substring, pada posisi yang ditentukan oleh ekspresi reguler yang ditentukan dalam konstruktor Regex.

Split(String, String, RegexOptions, TimeSpan)

Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh pola ekspresi reguler tertentu. Parameter tambahan menentukan opsi yang memodifikasi operasi pencocokan dan interval waktu habis jika tidak ada kecocokan yang ditemukan.

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()

Parameter

input
String

String yang akan dipisahkan.

pattern
String

Pola ekspresi reguler yang cocok.

options
RegexOptions

Kombinasi bitwise dari nilai enumerasi yang menyediakan opsi untuk pencocokan.

matchTimeout
TimeSpan

Interval waktu habis, atau InfiniteMatchTimeout untuk menunjukkan bahwa metode tidak boleh kehabisan waktu.

Mengembalikan

String[]

Array string.

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input atau patternnull.

ArgumentOutOfRangeException

options bukan kombinasi bitwise yang valid dari nilai RegexOptions.

-atau-

matchTimeout negatif, nol, atau lebih besar dari sekitar 24 hari.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Keterangan

Metode Regex.Split mirip dengan metode String.Split(Char[]), kecuali bahwa Regex.Split membagi string pada pemisah yang ditentukan oleh ekspresi reguler alih-alih sekumpulan karakter. String dibagi sebanyak mungkin. Jika tidak ada pemisah yang ditemukan, nilai pengembalian berisi satu elemen yang nilainya adalah string input asli.

Parameter pattern terdiri dari elemen bahasa ekspresi reguler yang secara simbolis menggambarkan string yang cocok. Untuk informasi selengkapnya tentang ekspresi reguler, lihat Ekspresi Reguler .NET dan Bahasa Ekspresi Reguler - Referensi Cepat.

Penting

Ekspresi reguler yang dikompilasi yang digunakan dalam panggilan ke metode Split statis secara otomatis di-cache. Untuk mengelola masa pakai ekspresi reguler yang dikompilasi sendiri, gunakan instans Split metode.

Jika beberapa kecocokan berdekatan satu sama lain, string kosong dimasukkan ke dalam array. Misalnya, memisahkan string pada satu tanda hubung menyebabkan array yang dikembalikan menyertakan string kosong dalam posisi di mana dua tanda hubung yang berdekatan ditemukan.

Jika kecocokan ditemukan di awal atau akhir string input, string kosong disertakan di awal atau akhir array yang dikembalikan. Contoh berikut menggunakan pola ekspresi reguler [a-z]+ untuk membagi string input pada karakter alfabet huruf besar atau kecil apa pun. Karena string dimulai dan diakhir dengan karakter alfabet yang cocok, nilai elemen pertama dan terakhir dari array yang dikembalikan 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', ''

Jika menangkap tanda kurung digunakan dalam ekspresi Regex.Split, teks yang diambil disertakan dalam array string yang dihasilkan. Misalnya, jika Anda membagi string "plum-pear" pada tanda hubung yang ditempatkan dalam menangkap tanda kurung, array yang dikembalikan menyertakan elemen string yang berisi tanda hubung.

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'

Namun, ketika pola ekspresi reguler mencakup beberapa set pengambilan tanda kurung, perilaku metode ini tergantung pada versi .NET Framework. Dalam .NET Framework 1.0 dan 1.1, jika kecocokan tidak ditemukan dalam set pertama pengambilan tanda kurung, teks yang diambil dari tanda kurung penangkapan tambahan tidak disertakan dalam array yang dikembalikan. Dimulai dengan .NET Framework 2.0, semua teks yang diambil juga ditambahkan ke array yang dikembalikan. Misalnya, kode berikut menggunakan dua set pengambilan tanda kurung untuk mengekstrak elemen tanggal, termasuk pemisah tanggal, dari string tanggal. Set pertama dari menangkap tanda kurung menangkap tanda hubung, dan set kedua menangkap garis miring ke depan. Jika kode contoh dikompilasi dan dijalankan di bawah .NET Framework 1.0 atau 1.1, kode tersebut mengecualikan karakter garis miring; jika dikompilasi dan dijalankan di bawah .NET Framework 2.0 atau versi yang lebih baru, itu menyertakannya.

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'

Jika ekspresi reguler dapat mencocokkan string kosong, Split akan membagi string menjadi array string karakter tunggal karena pemisah string kosong dapat ditemukan di setiap lokasi.

Parameter matchTimeout menentukan berapa lama metode pencocokan pola harus mencoba menemukan kecocokan sebelum waktu habis. Mengatur interval waktu habis mencegah ekspresi reguler yang mengandalkan backtracking yang berlebihan muncul untuk berhenti merespons saat mereka memproses input yang berisi kecocokan dekat. Untuk informasi selengkapnya, lihat Praktik Terbaik untuk Ekspresi Reguler dan Backtracking. Jika tidak ada kecocokan yang ditemukan dalam interval waktu tersebut, metode akan memberikan pengecualian RegexMatchTimeoutException. matchTimeout mengambil alih nilai batas waktu default yang ditentukan untuk domain aplikasi tempat metode dijalankan.

Catatan Bagi Pemanggil

Kami menyarankan agar Anda mengatur parameter matchTimeout ke nilai yang sesuai, seperti dua detik. Jika Anda menonaktifkan waktu habis dengan menentukan InfiniteMatchTimeout, mesin ekspresi reguler menawarkan performa yang sedikit lebih baik. Namun, Anda harus menonaktifkan batas waktu hanya dalam kondisi berikut:

  • Ketika input yang diproses oleh ekspresi reguler berasal dari sumber yang diketahui dan tepercaya atau terdiri dari teks statis. Ini mengecualikan teks yang telah dimasukkan secara dinamis oleh pengguna.

  • Ketika pola ekspresi reguler telah diuji secara menyeluruh untuk memastikan bahwa pola regex secara efisien menangani kecocokan, non-kecocokan, dan mendekati kecocokan.

  • Ketika pola ekspresi reguler tidak berisi elemen bahasa yang diketahui menyebabkan backtracking yang berlebihan saat memproses kecocokan dekat.

Lihat juga

  • Elemen Bahasa Ekspresi Reguler

Berlaku untuk

Split(String, String, RegexOptions)

Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh pola ekspresi reguler tertentu. Opsi yang ditentukan mengubah operasi pencocokan.

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()

Parameter

input
String

String yang akan dipisahkan.

pattern
String

Pola ekspresi reguler yang cocok.

options
RegexOptions

Kombinasi bitwise dari nilai enumerasi yang menyediakan opsi untuk pencocokan.

Mengembalikan

String[]

Array string.

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input atau patternnull.

ArgumentOutOfRangeException

options bukan kombinasi bitwise yang valid dari nilai RegexOptions.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Keterangan

Metode Regex.Split mirip dengan metode String.Split(Char[]), kecuali bahwa Regex.Split membagi string pada pemisah yang ditentukan oleh ekspresi reguler alih-alih sekumpulan karakter. String dibagi sebanyak mungkin. Jika tidak ada pemisah yang ditemukan, nilai pengembalian berisi satu elemen yang nilainya adalah string input asli.

Parameter pattern terdiri dari elemen bahasa ekspresi reguler yang secara simbolis menggambarkan string yang cocok. Untuk informasi selengkapnya tentang ekspresi reguler, lihat Ekspresi Reguler .NET dan Bahasa Ekspresi Reguler - Referensi Cepat.

Penting

Ekspresi reguler yang dikompilasi yang digunakan dalam panggilan ke metode Split statis secara otomatis di-cache. Untuk mengelola masa pakai ekspresi reguler yang dikompilasi sendiri, gunakan instans Split metode.

Jika beberapa kecocokan berdekatan satu sama lain, string kosong dimasukkan ke dalam array. Misalnya, memisahkan string pada satu tanda hubung menyebabkan array yang dikembalikan menyertakan string kosong dalam posisi di mana dua tanda hubung yang berdekatan ditemukan.

Jika kecocokan ditemukan di awal atau akhir string input, string kosong disertakan di awal atau akhir array yang dikembalikan. Contoh berikut menggunakan pola ekspresi reguler [a-z]+ untuk membagi string input pada karakter alfabet huruf besar atau kecil apa pun. Karena string dimulai dan diakhir dengan karakter alfabet yang cocok, nilai elemen pertama dan terakhir dari array yang dikembalikan 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', ''

Jika menangkap tanda kurung digunakan dalam ekspresi Regex.Split, teks yang diambil disertakan dalam array string yang dihasilkan. Misalnya, jika Anda membagi string "plum-pear" pada tanda hubung yang ditempatkan dalam menangkap tanda kurung, array yang dikembalikan menyertakan elemen string yang berisi tanda hubung.

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'

Namun, ketika pola ekspresi reguler mencakup beberapa set pengambilan tanda kurung, perilaku metode ini tergantung pada versi .NET Framework. Dalam .NET Framework 1.0 dan 1.1, jika kecocokan tidak ditemukan dalam set pertama pengambilan tanda kurung, teks yang diambil dari tanda kurung penangkapan tambahan tidak disertakan dalam array yang dikembalikan. Dimulai dengan .NET Framework 2.0, semua teks yang diambil juga ditambahkan ke array yang dikembalikan. Misalnya, kode berikut menggunakan dua set pengambilan tanda kurung untuk mengekstrak elemen tanggal, termasuk pemisah tanggal, dari string tanggal. Set pertama dari menangkap tanda kurung menangkap tanda hubung, dan set kedua menangkap garis miring ke depan. Jika kode contoh dikompilasi dan dijalankan di bawah .NET Framework 1.0 atau 1.1, kode tersebut mengecualikan karakter garis miring; jika dikompilasi dan dijalankan di bawah .NET Framework 2.0 atau versi yang lebih baru, itu menyertakannya.

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'

Jika ekspresi reguler dapat mencocokkan string kosong, Split akan membagi string menjadi array string karakter tunggal karena pemisah string kosong dapat ditemukan di setiap lokasi.

Pengecualian RegexMatchTimeoutException dilemparkan jika waktu eksekusi operasi pemisahan melebihi interval waktu habis yang ditentukan untuk domain aplikasi tempat metode dipanggil. Jika tidak ada waktu habis yang ditentukan dalam properti domain aplikasi, atau jika nilai batas waktu Regex.InfiniteMatchTimeout, tidak ada pengecualian yang dilemparkan.

Catatan Bagi Pemanggil

Metode ini kehabisan waktu setelah interval yang sama dengan nilai batas waktu default domain aplikasi tempat metode dipanggil. Jika nilai waktu habis belum ditentukan untuk domain aplikasi, nilai InfiniteMatchTimeout, yang mencegah metode kehabisan waktu, digunakan. Metode statis yang direkomendasikan untuk memisahkan teks pada kecocokan pola adalah Split(String, String, RegexOptions, TimeSpan), yang memungkinkan Anda mengatur interval waktu habis.

Lihat juga

  • Elemen Bahasa Ekspresi Reguler

Berlaku untuk

Split(String, Int32, Int32)

Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs

Memisahkan string input jumlah maksimum yang ditentukan menjadi array substring, pada posisi yang ditentukan oleh ekspresi reguler yang ditentukan dalam konstruktor Regex. Pencarian pola ekspresi reguler dimulai pada posisi karakter tertentu dalam string input.

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()

Parameter

input
String

String yang akan dipisahkan.

count
Int32

Berapa kali pemisahan dapat terjadi.

startat
Int32

Posisi karakter dalam string input tempat pencarian akan dimulai.

Mengembalikan

String[]

Array string.

Pengecualian

ArgumentNullException

input null.

ArgumentOutOfRangeException

startat kurang dari nol atau lebih besar dari panjang input.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Keterangan

Metode Regex.Split mirip dengan metode String.Split, kecuali bahwa Regex.Split membagi string pada pemisah yang ditentukan oleh ekspresi reguler alih-alih sekumpulan karakter. Parameter count menentukan jumlah maksimum substring tempat string input dipisahkan; string terakhir berisi sisa unsplit dari string. Nilai count nol memberikan perilaku default pemisahan sebanyak mungkin. Parameter startat menentukan titik di mana pencarian pemisah pertama dimulai (ini dapat digunakan untuk melewati spasi kosong di depan).

Untuk detail selengkapnya tentang startat, lihat bagian Keterangan dari Match(String, Int32).

Jika tidak ada kecocokan yang ditemukan dari posisi count+1 dalam string, metode mengembalikan array satu elemen yang berisi string input. Jika satu atau beberapa kecocokan ditemukan, elemen pertama dari array yang dikembalikan berisi bagian pertama string dari karakter pertama hingga satu karakter sebelum kecocokan.

Jika beberapa kecocokan berdekatan satu sama lain dan jumlah kecocokan yang ditemukan setidaknya dua kurang dari count, string kosong dimasukkan ke dalam array. Demikian pula, jika kecocokan ditemukan di startat, yang merupakan karakter pertama dalam string, elemen pertama dari array yang dikembalikan adalah string kosong. Artinya, string kosong yang dihasilkan dari kecocokan yang berdekatan dihitung dalam menentukan apakah jumlah substring yang cocok sama dengan count. Dalam contoh berikut, ekspresi reguler \d+ digunakan untuk menemukan posisi awal substring pertama karakter numerik dalam string, lalu untuk memisahkan string maksimum tiga kali mulai dari posisi tersebut. Karena pola ekspresi reguler cocok dengan awal string input, array string yang dikembalikan terdiri dari string kosong, string alfabet lima karakter, dan sisa string,

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'

Jika menangkap tanda kurung digunakan dalam ekspresi reguler, teks yang diambil disertakan dalam array string terpisah. Namun, elemen array apa pun yang berisi teks yang diambil tidak dihitung dalam menentukan apakah jumlah kecocokan telah mencapai count. Misalnya, membagi string '"apple-apricot-plum-pear-pomegranate-pineapple-peach" menjadi maksimal empat substring yang dimulai pada karakter 15 dalam string menghasilkan array tujuh elemen, seperti yang ditunjukkan kode berikut.

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'

Namun, ketika pola ekspresi reguler mencakup beberapa set pengambilan tanda kurung, perilaku metode ini tergantung pada versi .NET Framework. Di .NET Framework 1.0 dan 1.1, jika kecocokan tidak ditemukan dalam kumpulan pertama menangkap tanda kurung, teks yang diambil dari tanda kurung penangkapan tambahan tidak disertakan dalam array yang dikembalikan. Dimulai dengan .NET Framework 2.0, semua teks yang diambil juga ditambahkan ke array yang dikembalikan. Misalnya, kode berikut menggunakan dua set pengambilan tanda kurung untuk mengekstrak kata individual dalam string. Set pertama dari menangkap tanda kurung menangkap tanda hubung, dan set kedua menangkap bilah vertikal. Jika kode contoh dikompilasi dan dijalankan di bawah .NET Framework 1.0 atau 1.1, kode tersebut mengecualikan karakter bilah vertikal; jika dikompilasi dan dijalankan di bawah .NET Framework 2.0 atau versi yang lebih baru, itu menyertakannya.

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'

Jika ekspresi reguler dapat mencocokkan string kosong, Split akan membagi string menjadi array string karakter tunggal karena pemisah string kosong dapat ditemukan di setiap lokasi. Contoh berikut membagi string "karakter" menjadi elemen sebanyak yang dikandung string input, dimulai dengan karakter "a". Karena string null cocok dengan akhir string input, string null dimasukkan di akhir array yang dikembalikan.

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}

Pengecualian RegexMatchTimeoutException dilemparkan jika waktu eksekusi operasi pemisahan melebihi interval waktu habis yang ditentukan oleh konstruktor Regex.Regex(String, RegexOptions, TimeSpan). Jika Anda tidak mengatur interval waktu habis saat Memanggil konstruktor, pengecualian akan dibuang jika operasi melebihi nilai batas waktu yang ditetapkan untuk domain aplikasi tempat objek Regex dibuat. Jika tidak ada waktu habis yang ditentukan dalam panggilan konstruktor Regex atau di properti domain aplikasi, atau jika nilai batas waktu Regex.InfiniteMatchTimeout, tidak ada pengecualian yang dilemparkan

Lihat juga

  • Bahasa Ekspresi Reguler - Referensi Cepat

Berlaku untuk

Split(String, String)

Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh pola ekspresi reguler.

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()

Parameter

input
String

String yang akan dipisahkan.

pattern
String

Pola ekspresi reguler yang cocok.

Mengembalikan

String[]

Array string.

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input atau patternnull.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Keterangan

Metode Regex.Split mirip dengan metode String.Split, kecuali bahwa Regex.Split membagi string pada pemisah yang ditentukan oleh ekspresi reguler alih-alih sekumpulan karakter. String input dibagi sebanyak mungkin. Jika pattern tidak ditemukan dalam string input, nilai pengembalian berisi satu elemen yang nilainya adalah string input asli.

Parameter pattern terdiri dari elemen bahasa ekspresi reguler yang secara simbolis menggambarkan string yang cocok. Untuk informasi selengkapnya tentang ekspresi reguler, lihat Ekspresi Reguler .NET dan Bahasa Ekspresi Reguler - Referensi Cepat.

Penting

Ekspresi reguler yang dikompilasi yang digunakan dalam panggilan ke metode Split statis secara otomatis di-cache. Untuk mengelola masa pakai ekspresi reguler yang dikompilasi sendiri, gunakan instans Split metode.

Jika beberapa kecocokan berdekatan satu sama lain, string kosong dimasukkan ke dalam array. Misalnya, memisahkan string pada satu tanda hubung menyebabkan array yang dikembalikan menyertakan string kosong dalam posisi di mana dua tanda hubung yang berdekatan ditemukan, seperti yang ditunjukkan kode berikut.

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'

Jika kecocokan ditemukan di awal atau akhir string input, string kosong disertakan di awal atau akhir array yang dikembalikan. Contoh berikut menggunakan pola ekspresi reguler \d+ untuk membagi string input pada karakter numerik. Karena string dimulai dan berakhir dengan karakter numerik yang cocok, nilai elemen pertama dan terakhir dari array yang dikembalikan 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', ''

Jika menangkap tanda kurung digunakan dalam ekspresi Regex.Split, teks yang diambil disertakan dalam array string yang dihasilkan. Misalnya, jika Anda membagi string "plum-pear" pada tanda hubung yang ditempatkan dalam menangkap tanda kurung, array yang dikembalikan menyertakan elemen string yang berisi tanda hubung.

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'

Namun, ketika pola ekspresi reguler mencakup beberapa set pengambilan tanda kurung, perilaku metode ini tergantung pada versi .NET Framework. Dalam .NET Framework 1.0 dan 1.1, jika kecocokan tidak ditemukan dalam set pertama pengambilan tanda kurung, teks yang diambil dari tanda kurung penangkapan tambahan tidak disertakan dalam array yang dikembalikan. Dimulai dengan .NET Framework 2.0, semua teks yang diambil juga ditambahkan ke array yang dikembalikan. Misalnya, kode berikut menggunakan dua set pengambilan tanda kurung untuk mengekstrak elemen tanggal, termasuk pemisah tanggal, dari string tanggal. Set pertama dari menangkap tanda kurung menangkap tanda hubung, dan set kedua menangkap garis miring ke depan. Jika kode contoh dikompilasi dan dijalankan di bawah .NET Framework 1.0 atau 1.1, kode tersebut mengecualikan karakter garis miring; jika dikompilasi dan dijalankan di bawah .NET Framework 2.0 atau versi yang lebih baru, itu menyertakannya.

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'

Jika ekspresi reguler dapat mencocokkan string kosong, Split akan membagi string menjadi array string karakter tunggal karena pemisah string kosong dapat ditemukan di setiap lokasi. Misalnya:

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', ''}

Perhatikan bahwa array yang dikembalikan juga menyertakan string kosong di awal dan akhir array.

Pengecualian RegexMatchTimeoutException dilemparkan jika waktu eksekusi operasi pemisahan melebihi interval waktu habis yang ditentukan untuk domain aplikasi tempat metode dipanggil. Jika tidak ada waktu habis yang ditentukan dalam properti domain aplikasi, atau jika nilai batas waktu Regex.InfiniteMatchTimeout, tidak ada pengecualian yang dilemparkan.

Catatan Bagi Pemanggil

Metode ini kehabisan waktu setelah interval yang sama dengan nilai batas waktu default domain aplikasi tempat metode dipanggil. Jika nilai waktu habis belum ditentukan untuk domain aplikasi, nilai InfiniteMatchTimeout, yang mencegah metode kehabisan waktu, digunakan. Metode statis yang direkomendasikan untuk memisahkan teks pada kecocokan pola adalah Split(String, String, RegexOptions, TimeSpan), yang memungkinkan Anda mengatur interval waktu habis.

Lihat juga

  • Elemen Bahasa Ekspresi Reguler

Berlaku untuk

Split(String)

Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs

Memisahkan string input menjadi array substring pada posisi yang ditentukan oleh pola ekspresi reguler yang ditentukan dalam konstruktor Regex.

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()

Parameter

input
String

String yang akan dipisahkan.

Mengembalikan

String[]

Array string.

Pengecualian

ArgumentNullException

input null.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Keterangan

Metode Regex.Split mirip dengan metode String.Split(Char[]), kecuali bahwa Regex.Split membagi string pada pemisah yang ditentukan oleh ekspresi reguler alih-alih sekumpulan karakter. String dibagi sebanyak mungkin. Jika tidak ada pemisah yang ditemukan, nilai pengembalian berisi satu elemen yang nilainya adalah string input asli.

Jika beberapa kecocokan berdekatan satu sama lain, string kosong dimasukkan ke dalam array. Misalnya, memisahkan string pada satu tanda hubung menyebabkan array yang dikembalikan menyertakan string kosong dalam posisi di mana dua tanda hubung yang berdekatan ditemukan, seperti yang ditunjukkan kode berikut.

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'

Jika kecocokan ditemukan di awal atau akhir string input, string kosong disertakan di awal atau akhir array yang dikembalikan. Contoh berikut menggunakan pola ekspresi reguler \d+ untuk membagi string input pada karakter numerik. Karena string dimulai dan berakhir dengan karakter numerik yang cocok, nilai elemen pertama dan terakhir dari array yang dikembalikan 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', ''

Jika menangkap tanda kurung digunakan dalam ekspresi Regex.Split, teks yang diambil disertakan dalam array string yang dihasilkan. Misalnya, jika Anda membagi string "plum-pear" pada tanda hubung yang ditempatkan dalam menangkap tanda kurung, array yang dikembalikan menyertakan elemen string yang berisi tanda hubung.

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'

Namun, ketika pola ekspresi reguler mencakup beberapa set pengambilan tanda kurung, perilaku metode ini tergantung pada versi .NET Framework. Dalam .NET Framework 1.0 dan 1.1, jika kecocokan tidak ditemukan dalam set pertama pengambilan tanda kurung, teks yang diambil dari tanda kurung penangkapan tambahan tidak disertakan dalam array yang dikembalikan. Dimulai dengan .NET Framework 2.0, semua teks yang diambil juga ditambahkan ke array yang dikembalikan. Misalnya, kode berikut menggunakan dua set pengambilan tanda kurung untuk mengekstrak elemen tanggal, termasuk pemisah tanggal, dari string tanggal. Set pertama dari menangkap tanda kurung menangkap tanda hubung, dan set kedua menangkap garis miring ke depan. Jika kode contoh dikompilasi dan dijalankan di bawah .NET Framework 1.0 atau 1.1, kode tersebut mengecualikan karakter garis miring; jika dikompilasi dan dijalankan di bawah .NET Framework 2.0 atau versi yang lebih baru, itu menyertakannya.

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'

Jika ekspresi reguler dapat mencocokkan string kosong, Split(String) akan membagi string menjadi array string karakter tunggal karena pemisah string kosong dapat ditemukan di setiap lokasi. Misalnya:

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, }

Perhatikan bahwa array yang dikembalikan juga menyertakan string kosong di awal dan akhir array.

Pengecualian RegexMatchTimeoutException dilemparkan jika waktu eksekusi operasi pemisahan melebihi interval waktu habis yang ditentukan oleh konstruktor Regex.Regex(String, RegexOptions, TimeSpan). Jika Anda tidak mengatur interval waktu habis saat Memanggil konstruktor, pengecualian akan dibuang jika operasi melebihi nilai batas waktu yang ditetapkan untuk domain aplikasi tempat objek Regex dibuat. Jika tidak ada waktu habis yang ditentukan dalam panggilan konstruktor Regex atau di properti domain aplikasi, atau jika nilai batas waktu Regex.InfiniteMatchTimeout, tidak ada pengecualian yang dilemparkan

Lihat juga

  • Bahasa Ekspresi Reguler - Referensi Cepat

Berlaku untuk

Split(String, Int32)

Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs
Sumber:
Regex.Split.cs

Memisahkan string input jumlah maksimum yang ditentukan menjadi array substring, pada posisi yang ditentukan oleh ekspresi reguler yang ditentukan dalam konstruktor Regex.

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()

Parameter

input
String

String yang akan dipisahkan.

count
Int32

Berapa kali pemisahan dapat terjadi.

Mengembalikan

String[]

Array string.

Pengecualian

ArgumentNullException

input null.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Keterangan

Metode Regex.Split mirip dengan metode String.Split, kecuali bahwa Regex.Split membagi string pada pemisah yang ditentukan oleh ekspresi reguler alih-alih sekumpulan karakter. Parameter count menentukan jumlah maksimum substring tempat string input dapat dibagi; string terakhir berisi sisa unsplit dari string. Nilai count nol memberikan perilaku default pemisahan sebanyak mungkin.

Jika beberapa kecocokan berdekatan satu sama lain atau jika kecocokan ditemukan di awal atau akhir input, dan jumlah kecocokan yang ditemukan setidaknya dua kurang dari count, string kosong dimasukkan ke dalam array. Artinya, string kosong yang dihasilkan dari kecocokan yang berdekatan atau dari kecocokan di awal atau akhir string input dihitung dalam menentukan apakah jumlah substring yang cocok sama dengan count. Dalam contoh berikut, ekspresi reguler /d+ digunakan untuk membagi string input yang menyertakan satu atau beberapa digit desimal menjadi maksimal tiga substring. Karena awal string input cocok dengan pola ekspresi reguler, elemen array pertama berisi String.Empty, yang kedua berisi kumpulan karakter alfabet pertama dalam string input, dan yang ketiga berisi sisa string yang mengikuti kecocokan ketiga.

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'

Jika menangkap tanda kurung digunakan dalam ekspresi reguler, teks yang diambil disertakan dalam array string terpisah. Namun, elemen array apa pun yang berisi teks yang diambil tidak dihitung dalam menentukan apakah jumlah kecocokan telah mencapai count. Misalnya, memisahkan string "apple-apricot-plum-pear-banana" menjadi maksimum empat substring menghasilkan array tujuh elemen, seperti yang ditunjukkan kode berikut.

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'

Namun, ketika pola ekspresi reguler mencakup beberapa set pengambilan tanda kurung, perilaku metode ini tergantung pada versi .NET Framework. Dalam .NET Framework 1.0 dan 1.1, hanya teks yang diambil dari kumpulan tanda kurung penangkapan pertama yang disertakan dalam array yang dikembalikan. Dimulai dengan .NET Framework 2.0, semua teks yang diambil ditambahkan ke array yang dikembalikan. Namun, elemen dalam array yang dikembalikan yang berisi teks yang diambil tidak dihitung dalam menentukan apakah jumlah substring yang cocok sama dengan count. Misalnya, dalam kode berikut, ekspresi reguler menggunakan dua set pengambilan tanda kurung untuk mengekstrak elemen tanggal dari string tanggal. Set pertama dari menangkap tanda kurung menangkap tanda hubung, dan set kedua menangkap garis miring ke depan. Panggilan ke metode Split(String, Int32) kemudian menentukan maksimum dua elemen dalam array yang dikembalikan. Jika kode contoh dikompilasi dan dijalankan di bawah .NET Framework 1.0 atau 1.1, metode mengembalikan array string dua elemen. Jika dikompilasi dan dijalankan di bawah .NET Framework 2.0 atau versi yang lebih baru, metode mengembalikan array string tiga elemen.

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'

Jika ekspresi reguler dapat mencocokkan string kosong, Split(String, Int32) akan membagi string menjadi array string karakter tunggal karena pemisah string kosong dapat ditemukan di setiap lokasi. Contoh berikut membagi "karakter" string menjadi elemen sebanyak yang ada di string input. Karena string null cocok dengan awal string input, string null dimasukkan di awal array yang dikembalikan. Hal ini menyebabkan elemen kesepuluh terdiri dari dua karakter di akhir string input.

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}

Pengecualian RegexMatchTimeoutException dilemparkan jika waktu eksekusi operasi pemisahan melebihi interval waktu habis yang ditentukan oleh konstruktor Regex.Regex(String, RegexOptions, TimeSpan). Jika Anda tidak mengatur interval waktu habis saat Memanggil konstruktor, pengecualian akan dibuang jika operasi melebihi nilai batas waktu yang ditetapkan untuk domain aplikasi tempat objek Regex dibuat. Jika tidak ada waktu habis yang ditentukan dalam panggilan konstruktor Regex atau di properti domain aplikasi, atau jika nilai batas waktu Regex.InfiniteMatchTimeout, tidak ada pengecualian yang dilemparkan

Lihat juga

  • Bahasa Ekspresi Reguler - Referensi Cepat

Berlaku untuk