String.Split Metode
Definisi
Penting
Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.
Mengembalikan array string yang berisi substring dalam instans ini yang dibatasi oleh elemen string tertentu atau array karakter Unicode.
Overload
Split(String, Int32, StringSplitOptions) |
Memisahkan string menjadi jumlah maksimum substring berdasarkan string pembatas tertentu dan opsi opsional. |
Split(Char[], Int32, StringSplitOptions) |
Memisahkan string menjadi jumlah maksimum substring berdasarkan karakter pembatas yang ditentukan dan opsi opsional. |
Split(Char, Int32, StringSplitOptions) |
Memisahkan string menjadi jumlah maksimum substring berdasarkan karakter pembatas tertentu dan opsi opsional. Memisahkan string menjadi jumlah maksimum substring berdasarkan pemisah karakter yang disediakan, secara opsional menghilangkan substring kosong dari hasilnya. |
Split(String[], StringSplitOptions) |
Memisahkan string menjadi substring berdasarkan string pembatas tertentu dan opsi opsional. |
Split(String, StringSplitOptions) |
Memisahkan string menjadi substring yang didasarkan pada pemisah string yang disediakan. |
Split(Char[]) |
Memisahkan string menjadi substring berdasarkan karakter pembatas yang ditentukan. |
Split(Char[], Int32) |
Memisahkan string menjadi jumlah maksimum substring berdasarkan karakter pembatas yang ditentukan. |
Split(Char, StringSplitOptions) |
Memisahkan string menjadi substring berdasarkan karakter pembatas tertentu dan opsi opsional. |
Split(ReadOnlySpan<Char>) | |
Split(String[], Int32, StringSplitOptions) |
Memisahkan string menjadi jumlah maksimum substring berdasarkan string pembatas yang ditentukan dan opsi opsional. |
Split(Char[], StringSplitOptions) |
Memisahkan string menjadi substring berdasarkan karakter dan opsi pembatas yang ditentukan. |
Keterangan
Split digunakan untuk memecah string yang dibatasi menjadi substring. Anda dapat menggunakan array karakter atau array string untuk menentukan nol atau lebih karakter atau string pembatas. Jika tidak ada karakter pembatas yang ditentukan, string dipisahkan pada karakter spasi putih.
Kelebihan beban Split metode memungkinkan Anda membatasi jumlah substring yang dikembalikan oleh metode ( Split(Char[], Int32) metode ), untuk menentukan apakah akan menyertakan string kosong dan/atau memangkas substring dalam hasil ( Split(Char[], StringSplitOptions) metode dan Split(String[], StringSplitOptions) ), atau untuk melakukan keduanya ( Split(Char[], Int32, StringSplitOptions) metode dan Split(String[], Int32, StringSplitOptions) ).
Tip
Metode Split ini tidak selalu merupakan cara terbaik untuk memecah string yang dibatasi menjadi substring. Jika Anda tidak ingin mengekstrak semua substring string yang dibatasi, atau jika Anda ingin mengurai string berdasarkan pola alih-alih sekumpulan karakter pemisah, pertimbangkan untuk menggunakan ekspresi reguler, atau gabungkan salah satu metode pencarian yang mengembalikan indeks karakter dengan Substring metode . Untuk informasi selengkapnya, lihat Mengekstrak substring dari string.
Contoh
Contoh berikut menunjukkan tiga kelebihan beban String.Split()
yang berbeda. Contoh pertama memanggil Split(Char[]) kelebihan beban dan melewati satu pemisah.
string s = "You win some. You lose some.";
string[] subs = s.Split(' ');
foreach (var sub in subs)
{
Console.WriteLine($"Substring: {sub}");
}
// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.
let s = "You win some. You lose some."
let subs = s.Split ' '
for sub in subs do
printfn $"Substring: {sub}"
// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.
Dim s As String = "You win some. You lose some."
Dim subs As String() = s.Split()
For Each substring As String In subs
Console.WriteLine($"Substring: {substring}")
Next
' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some.
' Substring: You
' Substring: lose
' Substring: some.
Seperti yang Anda lihat, karakter titik (.
) disertakan dalam dua substring. Jika Anda ingin mengecualikan karakter titik, Anda dapat menambahkan karakter titik sebagai karakter pembatas tambahan. Contoh berikutnya menunjukkan bagaimana melakukan hal ini.
string s = "You win some. You lose some.";
string[] subs = s.Split(' ', '.');
foreach (var sub in subs)
{
Console.WriteLine($"Substring: {sub}");
}
// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:
let s = "You win some. You lose some."
let subs = s.Split(' ', '.')
for sub in subs do
printfn $"Substring: {sub}"
// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:
Dim s As String = "You win some. You lose some."
Dim subs As String() = s.Split(" "c, "."c)
For Each substring As String In subs
Console.WriteLine($"Substring: {substring}")
Next
' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some
' Substring:
' Substring: You
' Substring: lose
' Substring: some
' Substring:
Titik telah hilang dari substring, tetapi sekarang dua substring kosong tambahan telah disertakan. Substring kosong ini mewakili substring antara kata dan titik yang mengikutinya. Untuk menghilangkan substring kosong dari array yang dihasilkan, Anda dapat memanggil kelebihan beban Split(Char[], StringSplitOptions) dan menentukan StringSplitOptions.RemoveEmptyEntries untuk parameter options
.
string s = "You win some. You lose some.";
char[] separators = new char[] { ' ', '.' };
string[] subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var sub in subs)
{
Console.WriteLine($"Substring: {sub}");
}
// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some
let s = "You win some. You lose some."
let separators = [| ' '; '.' |]
let subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries)
for sub in subs do
printfn $"Substring: {sub}"
// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some
Dim s As String = "You win some. You lose some."
Dim separators As Char() = New Char() {" "c, "."c}
Dim subs As String() = s.Split(separators, StringSplitOptions.RemoveEmptyEntries)
For Each substring As String In subs
Console.WriteLine($"Substring: {substring}")
Next
' This example produces the following output:
'
' Substring: You
' Substring: win
' Substring: some
' Substring: You
' Substring: lose
' Substring: some
Bagian untuk kelebihan beban String.Split()
individu berisi contoh lebih lanjut.
Split(String, Int32, StringSplitOptions)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi jumlah maksimum substring berdasarkan string pembatas tertentu dan opsi opsional.
public string[] Split (string? separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
public string[] Split (string separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * int * StringSplitOptions -> string[]
Public Function Split (separator As String, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()
Parameter
- separator
- String
String yang memisahkan substring dalam instans ini.
- count
- Int32
Jumlah maksimum elemen yang diharapkan dalam array.
- options
- StringSplitOptions
Kombinasi bitwise dari nilai enumerasi yang menentukan apakah akan memangkas substring dan menyertakan substring kosong.
Mengembalikan
Array yang berisi sebagian besar count
substring dari instans ini yang dibatasi oleh separator
.
Keterangan
Jika string telah dibagi count
- 1 kali, tetapi akhir string belum tercapai, maka string terakhir dalam array yang dikembalikan akan berisi substring berikutnya instans yang tersisa ini, tidak tersentuh.
Berlaku untuk
Split(Char[], Int32, StringSplitOptions)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi jumlah maksimum substring berdasarkan karakter pembatas yang ditentukan dan opsi opsional.
public:
cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count, StringSplitOptions options);
public string[] Split (char[] separator, int count, StringSplitOptions options);
public string[] Split (char[]? separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, int count, StringSplitOptions options);
member this.Split : char[] * int * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : char[] * int * StringSplitOptions -> string[]
Public Function Split (separator As Char(), count As Integer, options As StringSplitOptions) As String()
Parameter
- separator
- Char[]
Array karakter yang memisahkan substring dalam string ini, array kosong yang tidak berisi pemisah, atau null
.
- count
- Int32
Jumlah maksimum substring yang akan dikembalikan.
- options
- StringSplitOptions
Kombinasi bitwise dari nilai enumerasi yang menentukan apakah akan memangkas substring dan menyertakan substring kosong.
Mengembalikan
Array yang berisi substring dalam string ini yang dibatasi oleh satu atau beberapa karakter di separator
. Untuk informasi lebih lanjut, lihat bagian Keterangan.
- Atribut
Pengecualian
count
negatif.
options
bukan salah StringSplitOptions satu nilai.
Contoh
Contoh berikut menggunakan StringSplitOptions enumerasi untuk menyertakan atau mengecualikan substring yang dihasilkan oleh Split metode .
// This example demonstrates the String.Split(Char[], Boolean) and
// String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
while ( myEnum->MoveNext() )
{
String^ entry = safe_cast<String^>(myEnum->Current);
Console::Write( "<{0}>", entry );
}
Console::Write( "{0}{0}", Environment::NewLine );
}
int main()
{
String^ s = ",one,,,two,,,,,three,,";
array<Char>^sep = gcnew array<Char>{
','
};
array<String^>^result;
//
Console::WriteLine( "The original string is \"{0}\".", s );
Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
Console::WriteLine();
//
Console::WriteLine( "Split the string and return all elements:" );
result = s->Split( sep, StringSplitOptions::None );
Show( result );
//
Console::WriteLine( "Split the string and return all non-empty elements:" );
result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
Show( result );
//
Console::WriteLine( "Split the string and return 2 elements:" );
result = s->Split( sep, 2, StringSplitOptions::None );
Show( result );
//
Console::WriteLine( "Split the string and return 2 non-empty elements:" );
result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
Show( result );
}
/*
This example produces the following results:
The original string is ",one,,,two,,,,,three,,".
The separation character is ','.
Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>
Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>
Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>
Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>
*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
// Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:\n");
string s1 = ",ONE,, TWO,, , THREE,,";
char[] charSeparators = new char[] { ',' };
string[] result;
Console.WriteLine($"The original string is: \"{s1}\".");
Console.WriteLine($"The delimiter character is: '{charSeparators[0]}'.\n");
// Split the string and return all elements
Console.WriteLine("1a) Return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);
// Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries);
Show(result);
// Split the string and return all non-empty elements
Console.WriteLine("1c) Return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Example 2: Split a string delimited by another string
Console.WriteLine("2) Split a string delimited by another string:\n");
string s2 = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] ";
string[] stringSeparators = new string[] { "[stop]" };
Console.WriteLine($"The original string is: \"{s2}\".");
Console.WriteLine($"The delimiter string is: \"{stringSeparators[0]}\".\n");
// Split the string and return all elements
Console.WriteLine("2a) Return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);
// Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries);
Show(result);
// Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Display the array of separated strings using a local function
void Show(string[] entries)
{
Console.WriteLine($"The return value contains these {entries.Length} elements:");
foreach (string entry in entries)
{
Console.Write($"<{entry}>");
}
Console.Write("\n\n");
}
/*
This example produces the following results:
1) Split a string delimited by characters:
The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.
1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>
1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>
1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>
1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>
2) Split a string delimited by another string:
The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
The delimiter string is: "[stop]".
2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO ><>< ><THREE><>< >
2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO >< ><THREE>< >
2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
// Display the array of separated strings using a local function
let show (entries: string[]) =
printfn $"The return value contains these {entries.Length} elements:"
for entry in entries do
printf $"<{entry}>"
printf "\n\n"
// Example 1: Split a string delimited by characters
printfn "1) Split a string delimited by characters:\n"
let s1 = ",ONE,, TWO,, , THREE,,"
let charSeparators = [| ',' |]
printfn $"The original string is: \"{s1}\"."
printfn $"The delimiter character is: '{charSeparators[0]}'.\n"
// Split the string and return all elements
printfn "1a) Return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result
// Split the string and return all elements with whitespace trimmed
printfn "1b) Return all elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
show result
// Split the string and return all non-empty elements
printfn "1c) Return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "1d) Return all non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Split the string into only two elements, keeping the remainder in the last match
printfn "1e) Split into only two elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.None)
show result
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "1f) Split into only two elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
show result
// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "1g) Split into only two non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "1h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Example 2: Split a string delimited by another string
printfn "2) Split a string delimited by another string:\n"
let s2 = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] "
let stringSeparators = [| "[stop]" |]
printfn $"The original string is: \"{s2}\"."
printfn $"The delimiter string is: \"{stringSeparators[0]}\".\n"
// Split the string and return all elements
printfn "2a) Return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result
// Split the string and return all elements with whitespace trimmed
printfn "2b) Return all elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
show result
// Split the string and return all non-empty elements
printfn "2c) Return all non-empty elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "2d) Return all non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Split the string into only two elements, keeping the remainder in the last match
printfn "2e) Split into only two elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
show result
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "2f) Split into only two elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
show result
// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "2g) Split into only two non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "2h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
(*
This example produces the following results:
1) Split a string delimited by characters:
The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.
1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>
1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>
1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>
1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>
2) Split a string delimited by another string:
The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
The delimiter string is: "[stop]".
2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO ><>< ><THREE><>< >
2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO >< ><THREE>< >
2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
*)
Public Shared Sub StringSplitOptionsExamples()
' This example demonstrates the String.Split() methods that use
' the StringSplitOptions enumeration.
' Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
Dim s1 As String = ",ONE,, TWO,, , THREE,,"
Dim charSeparators() As Char = {","c}
Dim result() As String
Console.WriteLine("The original string is: ""{0}"".", s1)
Console.WriteLine("The delimiter character is: '{0}'." & vbCrLf, charSeparators(0))
' Split the string and return all elements
Console.WriteLine("1a) Return all elements:")
result = s1.Split(charSeparators, StringSplitOptions.None)
Show(result)
' Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:")
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
Show(result)
' Split the string and return all non-empty elements
Console.WriteLine("1c) Return all non-empty elements:")
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:")
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:")
result = s1.Split(charSeparators, 2, StringSplitOptions.None)
Show(result)
' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:")
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:")
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:")
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Example 2: Split a string delimited by another string
Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
Dim s2 As String = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] "
Dim stringSeparators() As String = {"[stop]"}
Console.WriteLine("The original string is: ""{0}"".", s2)
Console.WriteLine("The delimiter string is: ""{0}""." & vbCrLf, stringSeparators(0))
' Split the string and return all elements
Console.WriteLine("2a) Return all elements:")
result = s2.Split(stringSeparators, StringSplitOptions.None)
Show(result)
' Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:")
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
Show(result)
' Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:")
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:")
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
Show(result)
' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
End Sub
' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
Console.WriteLine("The return value contains these {0} elements:", entries.Length)
Dim entry As String
For Each entry In entries
Console.Write("<{0}>", entry)
Next entry
Console.Write(vbCrLf & vbCrLf)
End Sub
'This example produces the following results:
'
' 1) Split a string delimited by characters:
'
' The original string is: ",ONE,, TWO,, , THREE,,".
' The delimiter character is: ','.
'
' 1a) Return all elements:
' The return value contains these 9 elements:
' <><ONE><>< TWO><>< >< THREE><><>
'
' 1b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 1c) Return all non-empty elements:
' The return value contains these 4 elements:
' <ONE>< TWO>< >< THREE>
'
' 1d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 1e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< TWO,, , THREE,,>
'
' 1h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO,, , THREE,,>
'
' 2) Split a string delimited by another string:
'
' The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
' The delimiter string is: "[stop]".
'
' 2a) Return all elements:
' The return value contains these 9 elements:
' <><ONE>< ><TWO ><>< ><THREE><>< >
'
' 2b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 2c) Return all non-empty elements:
' The return value contains these 6 elements:
' <ONE>< ><TWO >< ><THREE>< >
'
' 2d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 2e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
'
' 2f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
'
' 2g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
'
' 2h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
'
Keterangan
Karakter pemisah tidak disertakan dalam elemen array yang dikembalikan.
Jika instans ini tidak berisi karakter apa pun dalam separator
, atau count
parameternya adalah 1, array yang dikembalikan terdiri dari satu elemen yang berisi instans ini.
separator
Jika parameter adalah null
atau tidak berisi karakter, karakter spasi putih diasumsikan sebagai pemisah. Karakter spasi putih didefinisikan oleh standar Unicode dan Char.IsWhiteSpace metode mengembalikan true
jika diteruskan ke dalamnya.
Untuk meneruskan null
char[] separator
parameter, Anda harus menunjukkan jenis null
untuk membedakan panggilan dari beberapa kelebihan beban lainnya, seperti Split(String[], Int32, StringSplitOptions). Contoh berikut menunjukkan beberapa cara untuk mengidentifikasi kelebihan beban ini secara tidak ambigu.
string phrase = "The quick brown fox";
_ = phrase.Split(default(char[]), 3, StringSplitOptions.RemoveEmptyEntries);
_ = phrase.Split((char[]?)null, 3, StringSplitOptions.RemoveEmptyEntries);
_ = phrase.Split(null as char[], 3, StringSplitOptions.RemoveEmptyEntries);
let phrase = "The quick brown fox"
phrase.Split(Unchecked.defaultof<char[]>, 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
phrase.Split(null :> char[], 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
phrase.Split((null: char[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String
words = phrase.Split(TryCast(Nothing, Char()), 3,
StringSplitOptions.RemoveEmptyEntries)
words = phrase.Split(New Char() {}, 3,
StringSplitOptions.RemoveEmptyEntries)
count
Jika parameter adalah nol, atau options
parameternya adalah RemoveEmptyEntries dan panjang instans ini adalah nol, array kosong dikembalikan.
Setiap elemen separator
mendefinisikan karakter pemisah terpisah.
options
Jika parameter adalah None, dan dua pemisah berdekatan atau pemisah ditemukan di awal atau akhir instans ini, elemen array yang sesuai berisi Empty.
Jika ada lebih dari count
substring dalam instans ini, minus 1 substring pertama count
dikembalikan dalam elemen minus 1 pertama count
dari nilai yang dikembalikan, dan karakter yang tersisa dalam instans ini dikembalikan dalam elemen terakhir dari nilai yang dikembalikan.
Jika count
lebih besar dari jumlah substring, substring yang tersedia dikembalikan dan tidak terkecuali dilemparkan.
Pertimbangan performa
Metode Split mengalokasikan memori untuk objek array yang String dikembalikan dan objek untuk setiap elemen array. Jika aplikasi Anda memerlukan performa optimal atau jika mengelola alokasi memori sangat penting dalam aplikasi Anda, pertimbangkan untuk menggunakan IndexOf metode atau IndexOfAny , dan secara Compare opsional metode , untuk menemukan substring dalam string.
Jika Anda memisahkan string pada karakter pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pemisah dalam string. Jika Anda memisahkan string pada string pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pertama string pemisah. Kemudian gunakan Compare metode untuk menentukan apakah karakter setelah karakter pertama tersebut sama dengan karakter yang tersisa dari string pemisah.
Selain itu, jika sekumpulan karakter yang sama digunakan untuk memisahkan string dalam beberapa Split panggilan metode, pertimbangkan untuk membuat satu array dan mereferensikannya di setiap panggilan metode. Ini secara signifikan mengurangi overhead tambahan dari setiap panggilan metode.
Catatan Bagi Pemanggil
Dalam .NET Framework 3.5 dan versi yang lebih lama, jika Split(Char[]) metode diteruskan separator
yang atau null
tidak berisi karakter, metode ini menggunakan sekumpulan karakter spasi putih yang sedikit berbeda untuk membagi string daripada Trim(Char[]) metode yang dilakukan untuk memangkas string. Dimulai dengan .NET Framework 4, kedua metode menggunakan sekumpulan karakter spasi putih Unicode yang identik.
Berlaku untuk
Split(Char, Int32, StringSplitOptions)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi jumlah maksimum substring berdasarkan karakter pembatas tertentu dan opsi opsional. Memisahkan string menjadi jumlah maksimum substring berdasarkan pemisah karakter yang disediakan, secara opsional menghilangkan substring kosong dari hasilnya.
public string[] Split (char separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * int * StringSplitOptions -> string[]
Public Function Split (separator As Char, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()
Parameter
- separator
- Char
Karakter yang memisahkan substring dalam instans ini.
- count
- Int32
Jumlah maksimum elemen yang diharapkan dalam array.
- options
- StringSplitOptions
Kombinasi bitwise dari nilai enumerasi yang menentukan apakah akan memangkas substring dan menyertakan substring kosong.
Mengembalikan
Array yang berisi sebagian besar count
substring dari instans ini yang dibatasi oleh separator
.
Keterangan
Jika string telah dibagi count
- 1 kali, tetapi akhir string belum tercapai, maka string terakhir dalam array yang dikembalikan akan berisi substring berikutnya instans yang tersisa ini, tidak tersentuh.
Berlaku untuk
Split(String[], StringSplitOptions)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi substring berdasarkan string pembatas tertentu dan opsi opsional.
public:
cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, StringSplitOptions options);
public string[] Split (string[] separator, StringSplitOptions options);
public string[] Split (string[]? separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, StringSplitOptions options);
member this.Split : string[] * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : string[] * StringSplitOptions -> string[]
Public Function Split (separator As String(), options As StringSplitOptions) As String()
Parameter
- separator
- String[]
Array string yang memisahkan substring dalam string ini, array kosong yang tidak berisi pemisah, atau null
.
- options
- StringSplitOptions
Kombinasi bitwise dari nilai enumerasi yang menentukan apakah akan memangkas substring dan menyertakan substring kosong.
Mengembalikan
Array yang elemennya berisi substring dalam string ini yang dibatasi oleh satu atau beberapa string di separator
. Untuk informasi lebih lanjut, lihat bagian Keterangan.
- Atribut
Pengecualian
options
bukan salah StringSplitOptions satu nilai.
Contoh
Contoh berikut mengilustrasikan perbedaan dalam array yang dikembalikan dengan memanggil metode string String.Split(String[], StringSplitOptions) dengan parameternya options
sama dengan StringSplitOptions.None dan StringSplitOptions.RemoveEmptyEntries.
string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// Display the original string and delimiter string.
Console.WriteLine($"Splitting the string:\n \"{source}\".");
Console.WriteLine();
Console.WriteLine($"Using the delimiter string:\n \"{stringSeparators[0]}\"");
Console.WriteLine();
// Split a string delimited by another string and return all elements.
result = source.Split(stringSeparators, StringSplitOptions.None);
Console.WriteLine($"Result including all elements ({result.Length} elements):");
Console.Write(" ");
foreach (string s in result)
{
Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);
}
Console.WriteLine();
Console.WriteLine();
// Split delimited by another string and return all non-empty elements.
result = source.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine($"Result including non-empty elements ({result.Length} elements):");
Console.Write(" ");
foreach (string s in result)
{
Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);
}
Console.WriteLine();
// The example displays the following output:
// Splitting the string:
// "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
//
// Using the delimiter string:
// "[stop]"
//
// Result including all elements (9 elements):
// '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//
// Result including non-empty elements (3 elements):
// 'ONE' 'TWO' 'THREE'
let source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
let stringSeparators = [| "[stop]" |]
// Display the original string and delimiter string.
printfn $"Splitting the string:\n \"{source}\".\n"
printfn $"Using the delimiter string:\n \"{stringSeparators[0]}\"\n"
// Split a string delimited by another string and return all elements.
let result = source.Split(stringSeparators, StringSplitOptions.None)
printfn $"Result including all elements ({result.Length} elements):"
printf " "
for s in result do
printf $"""'{if String.IsNullOrEmpty s then "<>" else s}' """
printfn "\n"
// Split delimited by another string and return all non-empty elements.
let result = source.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
Console.WriteLine($"Result including non-empty elements ({result.Length} elements):")
printf " "
for s in result do
printf $"""'{if String.IsNullOrEmpty s then "<>" else s}' """
printfn ""
// The example displays the following output:
// Splitting the string:
// "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
//
// Using the delimiter string:
// "[stop]"
//
// let result including all elements (9 elements):
// '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//
// let result including non-empty elements (3 elements):
// 'ONE' 'TWO' 'THREE'
Dim source As String = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]"
Dim stringSeparators() As String = {"[stop]"}
Dim result() As String
' Display the original string and delimiter string.
Console.WriteLine("Splitting the string:{0} '{1}'.", vbCrLf, source)
Console.WriteLine()
Console.WriteLine("Using the delimiter string:{0} '{1}'.",
vbCrLf, stringSeparators(0))
Console.WriteLine()
' Split a string delimited by another string and return all elements.
result = source.Split(stringSeparators, StringSplitOptions.None)
Console.WriteLine("Result including all elements ({0} elements):",
result.Length)
Console.Write(" ")
For Each s As String In result
Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))
Next
Console.WriteLine()
Console.WriteLine()
' Split delimited by another string and return all non-empty elements.
result = source.Split(stringSeparators,
StringSplitOptions.RemoveEmptyEntries)
Console.WriteLine("Result including non-empty elements ({0} elements):",
result.Length)
Console.Write(" ")
For Each s As String In result
Console.Write("'{0}' ", IIf(String.IsNullOrEmpty(s), "<>", s))
Next
Console.WriteLine()
' The example displays the following output:
' Splitting the string:
' "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
'
' Using the delimiter string:
' "[stop]"
'
' Result including all elements (9 elements):
' '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
'
' Result including non-empty elements (3 elements):
' 'ONE' 'TWO' 'THREE'
Contoh berikut menentukan array pemisah yang menyertakan tanda baca dan karakter spasi putih. Meneruskan array ini bersama dengan nilai StringSplitOptions.RemoveEmptyEntries ke Split(String[], StringSplitOptions) metode mengembalikan array yang terdiri dari kata-kata individual dari string.
string[] separators = { ",", ".", "!", "?", ";", ":", " " };
string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in words)
Console.WriteLine(word);
// The example displays the following output:
// The
// handsome
// energetic
// young
// dog
// was
// playing
// with
// his
// smaller
// more
// lethargic
// litter
// mate
let separators = [| ","; "."; "!"; "?"; ""; ":"; " " |]
let value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
let words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
for word in words do
printfn $"${word}"
// The example displays the following output:
// The
// handsome
// energetic
// young
// dog
// was
// playing
// with
// his
// smaller
// more
// lethargic
// litter
// mate
Dim separators() As String = {",", ".", "!", "?", ";", ":", " "}
Dim value As String = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate."
Dim words() As String = value.Split(separators, StringSplitOptions.RemoveEmptyEntries)
For Each word In words
Console.WriteLine(word)
Next
End Sub
' The example displays the following output:
'
' The
' handsome
' energetic
' young
' dog
' was
' playing
' with
' his
' smaller
' more
' lethargic
' litter
' mate
Perhatikan bahwa metode dipanggil dengan argumen yang options
diatur ke StringSplitOptions.RemoveEmptyEntries. Ini mencegah array yang dikembalikan menyertakan String.Empty nilai yang mewakili kecocokan substring kosong antara tanda baca dan karakter spasi putih.
Keterangan
Saat string dibatasi oleh sekumpulan string yang diketahui, Anda dapat menggunakan Split metode untuk memisahkannya menjadi substring.
String pemisah tidak disertakan dalam elemen array yang dikembalikan. Misalnya, jika separator
array menyertakan string "--" dan nilai instans string saat ini adalah "aa--bb--cc", metode mengembalikan array yang berisi tiga elemen: "aa", "bb", dan "cc".
Jika instans ini tidak berisi salah satu string dalam separator
, array yang dikembalikan terdiri dari satu elemen yang berisi instans ini.
options
Jika parameter adalah RemoveEmptyEntries dan panjang instans ini adalah nol, metode mengembalikan array kosong.
Setiap elemen separator
mendefinisikan pemisah terpisah yang terdiri dari satu atau beberapa karakter.
options
Jika argumen adalah None, dan dua pemisah berdekatan atau pemisah ditemukan di awal atau akhir instans ini, elemen array yang sesuai berisi String.Empty. Misalnya, jika separator
menyertakan dua elemen, "-" dan "_", nilai instans string adalah "-_aa-_", dan nilai options
argumen adalah None, metode mengembalikan array string dengan lima elemen berikut:
String.Empty, yang mewakili string kosong yang mendahului substring "-" pada indeks 0.
String.Empty, yang mewakili string kosong antara substring "-" pada indeks 0 dan substring "_" pada indeks 1.
"aa".
String.Empty, yang mewakili string kosong yang mengikuti substring "-" pada indeks 4.
String.Empty, yang mewakili string kosong yang mengikuti substring "_" pada indeks 5.
Array pemisah
Jika salah satu elemen dalam separator
terdiri dari beberapa karakter, seluruh substring dianggap sebagai pemisah. Misalnya, jika salah satu elemen di separator
adalah "10", mencoba memisahkan string "This10is10a10string." mengembalikan array empat elemen berikut: { "This", "is", "a", "string." }.
separator
Jika parameter adalah null
atau tidak berisi string yang tidak kosong, karakter spasi putih diasumsikan sebagai pemisah. Karakter spasi putih didefinisikan oleh standar Unicode dan Char.IsWhiteSpace metode mengembalikan true
jika diteruskan ke dalamnya.
Untuk meneruskan null
string[] separator
parameter, Anda harus menunjukkan jenis null
untuk membedakan panggilan dari beberapa kelebihan beban lainnya, seperti Split(Char[], StringSplitOptions). Contoh berikut menunjukkan beberapa cara untuk mengidentifikasi kelebihan beban ini secara tidak ambigu.
string phrase = "The quick brown fox";
_ = phrase.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries);
_ = phrase.Split((string[]?)null, StringSplitOptions.RemoveEmptyEntries);
_ = phrase.Split(null as string[], StringSplitOptions.RemoveEmptyEntries);
let phrase = "The quick brown fox"
phrase.Split(Unchecked.defaultof<string[]>, StringSplitOptions.RemoveEmptyEntries) |> ignore
phrase.Split(null :> string[], StringSplitOptions.RemoveEmptyEntries) |> ignore
phrase.Split((null: string[]), StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String
words = phrase.Split(TryCast(Nothing, String()),
StringSplitOptions.RemoveEmptyEntries)
words = phrase.Split(New String() {},
StringSplitOptions.RemoveEmptyEntries)
Detail perbandingan
Metode mengekstrak Split substring dalam string ini yang dibatasi oleh satu atau beberapa string dalam separator
parameter, dan mengembalikan substring tersebut sebagai elemen array.
Metode Split ini mencari pemisah dengan melakukan perbandingan menggunakan aturan pengurutan ordinal peka huruf besar/kecil. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions enumerasi.
Metode mengabaikan Split elemen apa pun dari separator
nilainya atau null
string kosong ("").
Untuk menghindari hasil ambigu ketika string memiliki separator
karakter yang sama, Split operasi berlangsung dari awal hingga akhir nilai instans, dan cocok dengan elemen pertama dalam separator
yang sama dengan pemisah dalam instans. Urutan di mana substring ditemui dalam instans lebih diutamakan daripada urutan elemen di separator
.
Misalnya, pertimbangkan instans yang nilainya adalah "abcdef". Jika elemen pertama adalah separator
"ef" dan elemen kedua adalah "bcde", hasil dari operasi pemisahan akan menjadi array string yang berisi dua elemen, "a" dan "f". Ini karena substring dalam instans, "bcde", ditemui dan cocok dengan elemen di separator
sebelum substring "f" ditemui.
Namun, jika elemen pertama adalah separator
"bcd" dan elemen kedua adalah "bc", hasil dari operasi pemisahan akan menjadi array string yang berisi dua elemen, "a" dan "ef". Ini karena "bcd" adalah pemisah pertama dalam separator
yang cocok dengan pemisah dalam instans. Jika urutan pemisah dibalik sehingga elemen pertama adalah "bc" dan elemen kedua adalah "bcd", hasilnya adalah array string yang berisi dua elemen, "a" dan "def".
Pertimbangan performa
Metode Split mengalokasikan memori untuk objek array yang String dikembalikan dan objek untuk setiap elemen array. Jika aplikasi Anda memerlukan performa optimal atau jika mengelola alokasi memori sangat penting dalam aplikasi Anda, pertimbangkan untuk menggunakan IndexOf metode atau IndexOfAny , dan secara Compare opsional metode , untuk menemukan substring dalam string.
Jika Anda memisahkan string pada karakter pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pemisah dalam string. Jika Anda memisahkan string pada string pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pertama string pemisah. Kemudian gunakan Compare metode untuk menentukan apakah karakter setelah karakter pertama tersebut sama dengan karakter yang tersisa dari string pemisah.
Selain itu, jika sekumpulan karakter yang sama digunakan untuk memisahkan string dalam beberapa Split panggilan metode, pertimbangkan untuk membuat satu array dan mereferensikannya di setiap panggilan metode. Ini secara signifikan mengurangi overhead tambahan dari setiap panggilan metode.
Catatan Bagi Pemanggil
Dalam .NET Framework 3.5 dan versi yang lebih lama, jika Split(Char[]) metode diteruskan separator
yang atau null
tidak berisi karakter, metode ini menggunakan sekumpulan karakter spasi putih yang sedikit berbeda untuk membagi string daripada Trim(Char[]) metode yang dilakukan untuk memangkas string. Dimulai dengan .NET Framework 4, kedua metode menggunakan sekumpulan karakter spasi putih Unicode yang identik.
Berlaku untuk
Split(String, StringSplitOptions)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi substring yang didasarkan pada pemisah string yang disediakan.
public string[] Split (string? separator, StringSplitOptions options = System.StringSplitOptions.None);
public string[] Split (string separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * StringSplitOptions -> string[]
Public Function Split (separator As String, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()
Parameter
- separator
- String
String yang memisahkan substring dalam string ini.
- options
- StringSplitOptions
Kombinasi bitwise dari nilai enumerasi yang menentukan apakah akan memangkas substring dan menyertakan substring kosong.
Mengembalikan
Array yang elemennya berisi substring dari instans ini yang dibatasi oleh separator
.
Berlaku untuk
Split(Char[])
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi substring berdasarkan karakter pembatas yang ditentukan.
public:
cli::array <System::String ^> ^ Split(... cli::array <char> ^ separator);
public string[] Split (params char[] separator);
public string[] Split (params char[]? separator);
member this.Split : char[] -> string[]
Public Function Split (ParamArray separator As Char()) As String()
Parameter
- separator
- Char[]
Array karakter pembatas, array kosong yang tidak berisi pemisah, atau null
.
Mengembalikan
Array yang elemennya berisi substring dari instans ini yang dibatasi oleh satu atau beberapa karakter di separator
. Untuk informasi lebih lanjut, lihat bagian Keterangan.
Contoh
Contoh berikut menunjukkan cara mengekstrak kata individual dari blok teks dengan memperlakukan karakter spasi (
) dan karakter tab (\t
) sebagai pembatas. String yang dipisahkan mencakup kedua karakter ini.
string s = "Today\tI'm going to school";
string[] subs = s.Split(' ', '\t');
foreach (var sub in subs)
{
Console.WriteLine($"Substring: {sub}");
}
// This example produces the following output:
//
// Substring: Today
// Substring: I'm
// Substring: going
// Substring: to
// Substring: school
let s = "Today\tI'm going to school"
let subs = s.Split(' ', '\t')
for sub in subs do
printfn $"Substring: {sub}"
// This example produces the following output:
//
// Substring: Today
// Substring: I'm
// Substring: going
// Substring: to
// Substring: school
Dim s As String = "Today" & vbTab & "I'm going to school"
Dim subs As String() = s.Split(" "c, Char.Parse(vbTab))
For Each substring In subs
Console.WriteLine("Substring: " & substring)
Next
' This example produces the following output:
'
' Substring: Today
' Substring: I 'm
' Substring: going
' Substring: to
' Substring: school
Keterangan
Saat string dibatasi oleh sekumpulan karakter yang diketahui, Anda dapat menggunakan Split(Char[]) metode untuk memisahkannya menjadi substring.
Karakter pemisah tidak disertakan dalam elemen array yang dikembalikan. Misalnya, jika array pemisah menyertakan karakter "-" dan nilai instans string saat ini adalah "aa-bb-cc", metode mengembalikan array yang berisi tiga elemen: "aa", "bb", dan "cc".
Jika instans ini tidak berisi karakter apa pun dalam separator
, array yang dikembalikan terdiri dari satu elemen yang berisi instans ini.
Setiap elemen separator
mendefinisikan karakter pemisah terpisah. Jika dua pemisah berdekatan, atau pemisah ditemukan di awal atau akhir instans ini, elemen yang sesuai dalam array yang dikembalikan berisi Empty.
Tabel berikut ini memperlihatkan beberapa contoh.
Bahasa | Nilai untai (karakter) | Pemisah | Array yang dikembalikan |
---|---|---|---|
C# | "42, 12, 19" | Char baru[] {',', ' '} | {"42", "", "12", "", "19"} |
Visual Basic | "42, 12, 19" | Char() = {","c, " "c}) | {"42", "", "12", "", "19"} |
C# | "42..12..19." | Char[] {'.'} baru | {"42", "", "12", "", "19", ""} |
Visual Basic | "42..12..19." | Char() = {"." c} | {"42", "", "12", "", "19", ""} |
C# | "Pisang" | Char[] {'.'} baru | {"Pisang"} |
Visual Basic | "Pisang" | Char() = {"." c} | {"Pisang"} |
C# | "Darb\nSmarba" | Char baru[] {} | {"Darb", "Smarba"} |
Visual Basic | "Darb" & vbLf & "Smarba" | Char() = {} | {"Darb", "Smarba"} |
C# | "Darb\nSmarba" | null | {"Darb", "Smarba"} |
Visual Basic | "Darb" & vbLf & "Smarba" | Tidak ada | {"Darb", "Smarba"} |
Array pemisah
Setiap elemen pemisah mendefinisikan pemisah terpisah yang terdiri dari satu karakter.
separator
Jika argumen adalah null
atau tidak berisi karakter, metode memperlakukan karakter spasi putih sebagai pemisah. Karakter spasi putih didefinisikan oleh standar Unicode, dan Char.IsWhiteSpace metode mengembalikan true
jika karakter spasi putih diteruskan ke dalamnya.
String.Split(Char[]) dan resolusi kelebihan beban pengkompilasi
Meskipun parameter tunggal untuk kelebihan beban String.Split ini adalah array karakter, Anda dapat memanggilnya dengan satu karakter, seperti yang ditunjukkan contoh berikut.
string value = "This is a short string.";
char delimiter = 's';
string[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
Console.WriteLine(substring);
// The example displays the following output:
// Thi
// i
// a
// hort
// tring.
let value = "This is a short string."
let delimiter = 's'
let substrings = value.Split delimiter
for substring in substrings do
printfn $"{substring}"
// The example displays the following output:
// Thi
// i
// a
// hort
// tring.
Dim value As String = "This is a short string."
Dim delimiter As Char = "s"c
Dim substrings() As String = value.Split(delimiter)
For Each substring In substrings
Console.WriteLine(substring)
Next
End Sub
' The example displays the following output:
'
' Thi
' i
' a
' hort
' tring.
separator
Karena parameter dihiasi dengan ParamArrayAttribute atribut , pengkompilasi akan menginterpretasikan satu karakter sebagai array karakter elemen tunggal. Ini bukan kasus untuk kelebihan beban lain String.Split yang menyertakan separator
parameter; Anda harus secara eksplisit melewati kelebihan beban array karakter sebagai separator
argumen.
Detail perbandingan
Metode mengekstrak Split(Char[]) substring dalam string ini yang dibatasi oleh satu atau beberapa karakter dalam separator
array, dan mengembalikan substring tersebut sebagai elemen array.
Metode Split(Char[]) ini mencari pemisah dengan melakukan perbandingan menggunakan aturan pengurutan ordinal peka huruf besar/kecil. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions enumerasi.
Pertimbangan performa
Metode Split mengalokasikan memori untuk objek array yang String dikembalikan dan objek untuk setiap elemen array. Jika aplikasi Anda memerlukan performa optimal atau jika mengelola alokasi memori sangat penting dalam aplikasi Anda, pertimbangkan untuk IndexOf menggunakan metode atau IndexOfAny . Anda juga memiliki opsi untuk menggunakan Compare metode untuk menemukan substring dalam string.
Untuk membagi string pada karakter pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pemisah dalam string. Untuk membagi string pada string pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pertama string pemisah. Kemudian gunakan Compare metode untuk menentukan apakah karakter setelah karakter pertama tersebut sama dengan karakter yang tersisa dari string pemisah.
Selain itu, jika sekumpulan karakter yang sama digunakan untuk memisahkan string dalam beberapa Split panggilan metode, pertimbangkan untuk membuat satu array dan mereferensikannya di setiap panggilan metode. Ini secara signifikan mengurangi overhead tambahan dari setiap panggilan metode.
Catatan Bagi Pemanggil
Dalam .NET Framework 3.5 dan versi yang lebih lama, jika Split(Char[]) metode diteruskan separator
yang atau null
tidak berisi karakter, metode ini menggunakan sekumpulan karakter spasi putih yang sedikit berbeda untuk membagi string daripada Trim(Char[]) metode yang dilakukan untuk memangkas string. Dimulai dengan .NET Framework 4, kedua metode menggunakan sekumpulan karakter spasi putih Unicode yang identik.
Lihat juga
- Char
- Concat(Object)
- Insert(Int32, String)
- Join(String, String[])
- Remove(Int32, Int32)
- Replace(Char, Char)
- Substring(Int32)
- Trim(Char[])
Berlaku untuk
Split(Char[], Int32)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi jumlah maksimum substring berdasarkan karakter pembatas yang ditentukan.
public:
cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count);
public string[] Split (char[] separator, int count);
public string[] Split (char[]? separator, int count);
member this.Split : char[] * int -> string[]
Public Function Split (separator As Char(), count As Integer) As String()
Parameter
- separator
- Char[]
Array karakter yang memisahkan substring dalam string ini, array kosong yang tidak berisi pemisah, atau null
.
- count
- Int32
Jumlah maksimum substring yang akan dikembalikan.
Mengembalikan
Array yang elemennya berisi substring dalam instans ini yang dibatasi oleh satu atau beberapa karakter di separator
. Untuk informasi lebih lanjut, lihat bagian Keterangan.
Pengecualian
count
negatif.
Contoh
Contoh berikut menunjukkan bagaimana count
dapat digunakan untuk membatasi jumlah string yang dikembalikan oleh Split.
string name = "Alex Johnson III";
string[] subs = name.Split(null, 2);
string firstName = subs[0];
string lastName;
if (subs.Length > 1)
{
lastName = subs[1];
}
// firstName = "Alex"
// lastName = "Johnson III"
let name = "Alex Johnson III"
let subs = name.Split(null, 2)
let firstName = subs[0]
let lastName =
if subs.Length > 1 then
subs[1]
else
""
// firstName = "Alex"
// lastName = "Johnson III"
Console.WriteLine("What is your name?")
Dim name As String = Console.ReadLine()
Dim substrings = name.Split(" "c, count:=2)
Dim firstName As String = substrings(0)
Dim lastName As String
If substrings.Length > 1 Then
lastName = substrings(1)
End If
Console.WriteLine("firstName = ""{0}""", firstName)
Console.WriteLine("lastName = ""{0}""", lastName)
' If the user enters "Alex Johnson III":
' firstName = "Alex"
' lastName = "Johnson III"
Keterangan
Karakter pemisah tidak disertakan dalam elemen array yang dikembalikan.
Jika instans ini tidak berisi karakter apa pun dalam separator
, array yang dikembalikan terdiri dari satu elemen yang berisi instans ini. Jika count
adalah nol, array kosong dikembalikan.
separator
Jika parameter adalah null
atau tidak berisi karakter, karakter spasi putih diasumsikan sebagai pemisah. Karakter spasi putih didefinisikan oleh standar Unicode dan Char.IsWhiteSpace metode mengembalikan true
jika diteruskan ke dalamnya.
Setiap elemen separator
mendefinisikan karakter pemisah terpisah. Jika dua pemisah berdekatan, atau pemisah ditemukan di awal atau akhir instans ini, elemen array yang sesuai berisi Empty.
Jika ada lebih dari count
substring dalam instans ini, substring pertama count - 1
dikembalikan dalam elemen pertama count - 1
dari nilai yang dikembalikan, dan karakter yang tersisa dalam instans ini dikembalikan dalam elemen terakhir dari nilai yang dikembalikan.
Jika count
lebih besar dari jumlah substring, substring yang tersedia dikembalikan dan tidak terkecuali dilemparkan.
Tabel berikut ini memperlihatkan beberapa contoh.
Bahasa | Nilai untai (karakter) | Pemisah | Array yang dikembalikan |
---|---|---|---|
C# | "42, 12, 19" | Char baru[] {',', ' '} | {"42", "", "12", "", "19"} |
Visual Basic | "42, 12, 19" | Char() = {","c, " "c}) | {"42", "", "12", "", "19"} |
C# | "42..12..19." | Char[] {'.'} baru | {"42", "", "12", "", "19", ""} |
Visual Basic | "42..12..19." | Char() = {"." c} | {"42", "", "12", "", "19", ""} |
C# | "Pisang" | Char[] {'.'} baru | {"Pisang"} |
Visual Basic | "Pisang" | Char() = {"." c} | {"Pisang"} |
C# | "Darb\nSmarba" | Char baru[] {} | {"Darb", "Smarba"} |
Visual Basic | "Darb" & vbLf & "Smarba" | Char() = {} | {"Darb", "Smarba"} |
C# | "Darb\nSmarba" | null | {"Darb", "Smarba"} |
Visual Basic | "Darb" & vbLf & "Smarba" | Tidak ada | {"Darb", "Smarba"} |
Pertimbangan performa
Metode Split mengalokasikan memori untuk objek array yang String dikembalikan dan objek untuk setiap elemen array. Jika aplikasi Anda memerlukan performa optimal atau jika mengelola alokasi memori sangat penting dalam aplikasi Anda, pertimbangkan untuk menggunakan IndexOf metode atau IndexOfAny , dan secara Compare opsional metode , untuk menemukan substring dalam string.
Jika Anda memisahkan string pada karakter pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pemisah dalam string. Jika Anda memisahkan string pada string pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pertama string pemisah. Kemudian gunakan Compare metode untuk menentukan apakah karakter setelah karakter pertama tersebut sama dengan karakter yang tersisa dari string pemisah.
Selain itu, jika sekumpulan karakter yang sama digunakan untuk memisahkan string dalam beberapa Split panggilan metode, pertimbangkan untuk membuat satu array dan mereferensikannya di setiap panggilan metode. Ini secara signifikan mengurangi overhead tambahan dari setiap panggilan metode.
Catatan Bagi Pemanggil
Dalam .NET Framework 3.5 dan versi yang lebih lama, jika Split(Char[]) metode diteruskan separator
yang atau null
tidak berisi karakter, metode ini menggunakan sekumpulan karakter spasi putih yang sedikit berbeda untuk membagi string daripada Trim(Char[]) metode yang dilakukan untuk memangkas string. Dimulai dengan .NET Framework 4, kedua metode menggunakan sekumpulan karakter spasi putih Unicode yang identik.
Lihat juga
- Char
- Array
- Int32
- Concat(Object)
- Insert(Int32, String)
- Join(String, String[])
- Remove(Int32, Int32)
- Replace(Char, Char)
- Substring(Int32)
- Trim(Char[])
Berlaku untuk
Split(Char, StringSplitOptions)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi substring berdasarkan karakter pembatas tertentu dan opsi opsional.
public string[] Split (char separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * StringSplitOptions -> string[]
Public Function Split (separator As Char, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()
Parameter
- separator
- Char
Karakter yang memisahkan substring dalam string ini.
- options
- StringSplitOptions
Kombinasi bitwise dari nilai enumerasi yang menentukan apakah akan memangkas substring dan menyertakan substring kosong.
Mengembalikan
Array yang elemennya berisi substring dari instans ini yang dibatasi oleh separator
.
Berlaku untuk
Split(ReadOnlySpan<Char>)
public:
cli::array <System::String ^> ^ Split(ReadOnlySpan<char> separator);
public string[] Split (scoped ReadOnlySpan<char> separator);
member this.Split : ReadOnlySpan<char> -> string[]
Public Function Split (separator As ReadOnlySpan(Of Char)) As String()
Parameter
- separator
- ReadOnlySpan<Char>
Mengembalikan
Berlaku untuk
Split(String[], Int32, StringSplitOptions)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi jumlah maksimum substring berdasarkan string pembatas yang ditentukan dan opsi opsional.
public:
cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, int count, StringSplitOptions options);
public string[] Split (string[] separator, int count, StringSplitOptions options);
public string[] Split (string[]? separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, int count, StringSplitOptions options);
member this.Split : string[] * int * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : string[] * int * StringSplitOptions -> string[]
Public Function Split (separator As String(), count As Integer, options As StringSplitOptions) As String()
Parameter
- separator
- String[]
String yang memisahkan substring dalam string ini, array kosong yang tidak berisi pemisah, atau null
.
- count
- Int32
Jumlah maksimum substring yang akan dikembalikan.
- options
- StringSplitOptions
Kombinasi bitwise dari nilai enumerasi yang menentukan apakah akan memangkas substring dan menyertakan substring kosong.
Mengembalikan
Array yang elemennya berisi substring dalam string ini yang dibatasi oleh satu atau beberapa string di separator
. Untuk informasi lebih lanjut, lihat bagian Keterangan.
- Atribut
Pengecualian
count
negatif.
options
bukan salah StringSplitOptions satu nilai.
Contoh
Contoh berikut menggunakan StringSplitOptions enumerasi untuk menyertakan atau mengecualikan substring yang dihasilkan oleh Split metode .
// This example demonstrates the String.Split(Char[], Boolean) and
// String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
while ( myEnum->MoveNext() )
{
String^ entry = safe_cast<String^>(myEnum->Current);
Console::Write( "<{0}>", entry );
}
Console::Write( "{0}{0}", Environment::NewLine );
}
int main()
{
String^ s = ",one,,,two,,,,,three,,";
array<Char>^sep = gcnew array<Char>{
','
};
array<String^>^result;
//
Console::WriteLine( "The original string is \"{0}\".", s );
Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
Console::WriteLine();
//
Console::WriteLine( "Split the string and return all elements:" );
result = s->Split( sep, StringSplitOptions::None );
Show( result );
//
Console::WriteLine( "Split the string and return all non-empty elements:" );
result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
Show( result );
//
Console::WriteLine( "Split the string and return 2 elements:" );
result = s->Split( sep, 2, StringSplitOptions::None );
Show( result );
//
Console::WriteLine( "Split the string and return 2 non-empty elements:" );
result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
Show( result );
}
/*
This example produces the following results:
The original string is ",one,,,two,,,,,three,,".
The separation character is ','.
Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>
Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>
Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>
Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>
*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
// Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:\n");
string s1 = ",ONE,, TWO,, , THREE,,";
char[] charSeparators = new char[] { ',' };
string[] result;
Console.WriteLine($"The original string is: \"{s1}\".");
Console.WriteLine($"The delimiter character is: '{charSeparators[0]}'.\n");
// Split the string and return all elements
Console.WriteLine("1a) Return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);
// Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries);
Show(result);
// Split the string and return all non-empty elements
Console.WriteLine("1c) Return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Example 2: Split a string delimited by another string
Console.WriteLine("2) Split a string delimited by another string:\n");
string s2 = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] ";
string[] stringSeparators = new string[] { "[stop]" };
Console.WriteLine($"The original string is: \"{s2}\".");
Console.WriteLine($"The delimiter string is: \"{stringSeparators[0]}\".\n");
// Split the string and return all elements
Console.WriteLine("2a) Return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);
// Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries);
Show(result);
// Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Display the array of separated strings using a local function
void Show(string[] entries)
{
Console.WriteLine($"The return value contains these {entries.Length} elements:");
foreach (string entry in entries)
{
Console.Write($"<{entry}>");
}
Console.Write("\n\n");
}
/*
This example produces the following results:
1) Split a string delimited by characters:
The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.
1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>
1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>
1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>
1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>
2) Split a string delimited by another string:
The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
The delimiter string is: "[stop]".
2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO ><>< ><THREE><>< >
2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO >< ><THREE>< >
2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
// Display the array of separated strings using a local function
let show (entries: string[]) =
printfn $"The return value contains these {entries.Length} elements:"
for entry in entries do
printf $"<{entry}>"
printf "\n\n"
// Example 1: Split a string delimited by characters
printfn "1) Split a string delimited by characters:\n"
let s1 = ",ONE,, TWO,, , THREE,,"
let charSeparators = [| ',' |]
printfn $"The original string is: \"{s1}\"."
printfn $"The delimiter character is: '{charSeparators[0]}'.\n"
// Split the string and return all elements
printfn "1a) Return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result
// Split the string and return all elements with whitespace trimmed
printfn "1b) Return all elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
show result
// Split the string and return all non-empty elements
printfn "1c) Return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "1d) Return all non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Split the string into only two elements, keeping the remainder in the last match
printfn "1e) Split into only two elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.None)
show result
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "1f) Split into only two elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
show result
// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "1g) Split into only two non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "1h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Example 2: Split a string delimited by another string
printfn "2) Split a string delimited by another string:\n"
let s2 = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] "
let stringSeparators = [| "[stop]" |]
printfn $"The original string is: \"{s2}\"."
printfn $"The delimiter string is: \"{stringSeparators[0]}\".\n"
// Split the string and return all elements
printfn "2a) Return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result
// Split the string and return all elements with whitespace trimmed
printfn "2b) Return all elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
show result
// Split the string and return all non-empty elements
printfn "2c) Return all non-empty elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "2d) Return all non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Split the string into only two elements, keeping the remainder in the last match
printfn "2e) Split into only two elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
show result
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "2f) Split into only two elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
show result
// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "2g) Split into only two non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "2h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
(*
This example produces the following results:
1) Split a string delimited by characters:
The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.
1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>
1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>
1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>
1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>
2) Split a string delimited by another string:
The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
The delimiter string is: "[stop]".
2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO ><>< ><THREE><>< >
2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO >< ><THREE>< >
2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
*)
Public Shared Sub StringSplitOptionsExamples()
' This example demonstrates the String.Split() methods that use
' the StringSplitOptions enumeration.
' Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
Dim s1 As String = ",ONE,, TWO,, , THREE,,"
Dim charSeparators() As Char = {","c}
Dim result() As String
Console.WriteLine("The original string is: ""{0}"".", s1)
Console.WriteLine("The delimiter character is: '{0}'." & vbCrLf, charSeparators(0))
' Split the string and return all elements
Console.WriteLine("1a) Return all elements:")
result = s1.Split(charSeparators, StringSplitOptions.None)
Show(result)
' Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:")
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
Show(result)
' Split the string and return all non-empty elements
Console.WriteLine("1c) Return all non-empty elements:")
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:")
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:")
result = s1.Split(charSeparators, 2, StringSplitOptions.None)
Show(result)
' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:")
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:")
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:")
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Example 2: Split a string delimited by another string
Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
Dim s2 As String = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] "
Dim stringSeparators() As String = {"[stop]"}
Console.WriteLine("The original string is: ""{0}"".", s2)
Console.WriteLine("The delimiter string is: ""{0}""." & vbCrLf, stringSeparators(0))
' Split the string and return all elements
Console.WriteLine("2a) Return all elements:")
result = s2.Split(stringSeparators, StringSplitOptions.None)
Show(result)
' Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:")
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
Show(result)
' Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:")
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:")
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
Show(result)
' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
End Sub
' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
Console.WriteLine("The return value contains these {0} elements:", entries.Length)
Dim entry As String
For Each entry In entries
Console.Write("<{0}>", entry)
Next entry
Console.Write(vbCrLf & vbCrLf)
End Sub
'This example produces the following results:
'
' 1) Split a string delimited by characters:
'
' The original string is: ",ONE,, TWO,, , THREE,,".
' The delimiter character is: ','.
'
' 1a) Return all elements:
' The return value contains these 9 elements:
' <><ONE><>< TWO><>< >< THREE><><>
'
' 1b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 1c) Return all non-empty elements:
' The return value contains these 4 elements:
' <ONE>< TWO>< >< THREE>
'
' 1d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 1e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< TWO,, , THREE,,>
'
' 1h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO,, , THREE,,>
'
' 2) Split a string delimited by another string:
'
' The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
' The delimiter string is: "[stop]".
'
' 2a) Return all elements:
' The return value contains these 9 elements:
' <><ONE>< ><TWO ><>< ><THREE><>< >
'
' 2b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 2c) Return all non-empty elements:
' The return value contains these 6 elements:
' <ONE>< ><TWO >< ><THREE>< >
'
' 2d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 2e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
'
' 2f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
'
' 2g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
'
' 2h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
'
Keterangan
String pemisah tidak disertakan dalam elemen array yang dikembalikan.
Jika instans ini tidak berisi string apa pun di separator
, atau count
parameternya adalah 1, array yang dikembalikan terdiri dari satu elemen yang berisi instans ini.
separator
Jika parameter adalah null
atau tidak berisi karakter, karakter spasi putih diasumsikan sebagai pemisah. Karakter spasi putih didefinisikan oleh standar Unicode dan Char.IsWhiteSpace metode mengembalikan true
jika diteruskan ke dalamnya.
Untuk meneruskan null
string[] separator
parameter, Anda harus menunjukkan jenis null
untuk membedakan panggilan dari beberapa kelebihan beban lainnya, seperti Split(Char[], Int32, StringSplitOptions). Contoh berikut menunjukkan beberapa cara untuk mengidentifikasi kelebihan beban ini secara tidak ambigu.
string phrase = "The quick brown fox";
_ = phrase.Split(default(string[]), 3, StringSplitOptions.RemoveEmptyEntries);
_ = phrase.Split((string[]?)null, 3, StringSplitOptions.RemoveEmptyEntries);
_ = phrase.Split(null as string[], 3, StringSplitOptions.RemoveEmptyEntries);
let phrase = "The quick brown fox"
phrase.Split(Unchecked.defaultof<string[]>, 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
phrase.Split(null :> string[], 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
phrase.Split((null: string[]), 3, StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String
words = phrase.Split(TryCast(Nothing, String()), 3,
StringSplitOptions.RemoveEmptyEntries)
words = phrase.Split(New String() {}, 3,
StringSplitOptions.RemoveEmptyEntries)
count
Jika parameter adalah nol, atau options
parameternya adalah RemoveEmptyEntries dan panjang instans ini adalah nol, array kosong dikembalikan.
Setiap elemen separator
mendefinisikan pemisah terpisah yang terdiri dari satu atau beberapa karakter.
options
Jika parameter adalah None, dan dua pemisah berdekatan atau pemisah ditemukan di awal atau akhir instans ini, elemen array yang sesuai berisi Empty.
Jika ada lebih dari count
substring dalam instans ini, minus 1 substring pertama count
dikembalikan dalam elemen minus 1 pertama count
dari nilai yang dikembalikan, dan karakter yang tersisa dalam instans ini dikembalikan dalam elemen terakhir dari nilai yang dikembalikan.
Jika count
lebih besar dari jumlah substring, substring yang tersedia dikembalikan dan tidak ada pengecualian yang dilemparkan.
Array pemisah
Jika salah satu elemen dalam separator
terdiri dari beberapa karakter, seluruh substring dianggap sebagai pemisah. Misalnya, jika salah satu elemen di separator
adalah "10", mencoba memisahkan string "This10is10a10string." mengembalikan array empat elemen ini: { "This", "is", "a", "string." }.
Detail perbandingan
Metode Split mengekstrak substring dalam string ini yang dibatasi oleh satu atau beberapa string dalam separator
parameter, dan mengembalikan substring tersebut sebagai elemen array.
Metode Split mencari pemisah dengan melakukan perbandingan menggunakan aturan pengurutan ordinal peka huruf besar/kecil. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions enumerasi.
Metode ini Split mengabaikan elemen apa pun yang separator
nilainya adalah null
atau string kosong ("").
Untuk menghindari hasil ambigu ketika string memiliki separator
kesamaan karakter, Split metode berlanjut dari awal hingga akhir nilai instans, dan cocok dengan elemen pertama dalam separator
yang sama dengan pemisah dalam instans. Urutan di mana substring ditemui dalam instans lebih diutamakan daripada urutan elemen di separator
.
Misalnya, pertimbangkan instans yang nilainya adalah "abcdef". Jika elemen pertama dalam separator
adalah "ef" dan elemen kedua adalah "bcde", hasil dari operasi pemisahan akan menjadi "a" dan "f". Ini karena substring dalam instans, "bcde", ditemui dan cocok dengan elemen di separator
sebelum substring "f" ditemui.
Namun, jika elemen pertama adalah separator
"bcd" dan elemen kedua adalah "bc", hasil dari operasi pemisahan akan menjadi "a" dan "ef". Ini karena "bcd" adalah pemisah pertama dalam separator
yang cocok dengan pemisah dalam instans. Jika urutan pemisah dibalik sehingga elemen pertama adalah "bc" dan elemen kedua adalah "bcd", hasilnya adalah "a" dan "def".
Pertimbangan performa
Metode Split mengalokasikan memori untuk objek array yang String dikembalikan dan objek untuk setiap elemen array. Jika aplikasi Anda memerlukan performa optimal atau jika mengelola alokasi memori sangat penting dalam aplikasi Anda, pertimbangkan untuk menggunakan IndexOf metode atau IndexOfAny , dan secara Compare opsional metode , untuk menemukan substring dalam string.
Jika Anda memisahkan string pada karakter pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pemisah dalam string. Jika Anda memisahkan string pada string pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pertama string pemisah. Kemudian gunakan Compare metode untuk menentukan apakah karakter setelah karakter pertama tersebut sama dengan karakter yang tersisa dari string pemisah.
Selain itu, jika sekumpulan karakter yang sama digunakan untuk memisahkan string dalam beberapa Split panggilan metode, pertimbangkan untuk membuat satu array dan mereferensikannya di setiap panggilan metode. Ini secara signifikan mengurangi overhead tambahan dari setiap panggilan metode.
Catatan Bagi Pemanggil
Dalam .NET Framework 3.5 dan versi yang lebih lama, jika Split(Char[]) metode diteruskan separator
yang atau null
tidak berisi karakter, metode ini menggunakan sekumpulan karakter spasi putih yang sedikit berbeda untuk membagi string daripada Trim(Char[]) metode yang dilakukan untuk memangkas string. Dimulai dengan .NET Framework 4, kedua metode menggunakan sekumpulan karakter spasi putih Unicode yang identik.
Berlaku untuk
Split(Char[], StringSplitOptions)
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
- Sumber:
- String.Manipulation.cs
Memisahkan string menjadi substring berdasarkan karakter dan opsi pembatas yang ditentukan.
public:
cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, StringSplitOptions options);
public string[] Split (char[] separator, StringSplitOptions options);
public string[] Split (char[]? separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, StringSplitOptions options);
member this.Split : char[] * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : char[] * StringSplitOptions -> string[]
Public Function Split (separator As Char(), options As StringSplitOptions) As String()
Parameter
- separator
- Char[]
Array karakter yang memisahkan substring dalam string ini, array kosong yang tidak berisi pemisah, atau null
.
- options
- StringSplitOptions
Kombinasi bitwise dari nilai enumerasi yang menentukan apakah akan memangkas substring dan menyertakan substring kosong.
Mengembalikan
Array yang elemennya berisi substring dalam string ini yang dibatasi oleh satu atau beberapa karakter di separator
. Untuk informasi lebih lanjut, lihat bagian Keterangan.
- Atribut
Pengecualian
options
bukan salah StringSplitOptions satu nilai.
Contoh
Contoh berikut menggunakan StringSplitOptions enumerasi untuk menyertakan atau mengecualikan substring yang dihasilkan oleh Split metode .
// This example demonstrates the String.Split(Char[], Boolean) and
// String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
while ( myEnum->MoveNext() )
{
String^ entry = safe_cast<String^>(myEnum->Current);
Console::Write( "<{0}>", entry );
}
Console::Write( "{0}{0}", Environment::NewLine );
}
int main()
{
String^ s = ",one,,,two,,,,,three,,";
array<Char>^sep = gcnew array<Char>{
','
};
array<String^>^result;
//
Console::WriteLine( "The original string is \"{0}\".", s );
Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
Console::WriteLine();
//
Console::WriteLine( "Split the string and return all elements:" );
result = s->Split( sep, StringSplitOptions::None );
Show( result );
//
Console::WriteLine( "Split the string and return all non-empty elements:" );
result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
Show( result );
//
Console::WriteLine( "Split the string and return 2 elements:" );
result = s->Split( sep, 2, StringSplitOptions::None );
Show( result );
//
Console::WriteLine( "Split the string and return 2 non-empty elements:" );
result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
Show( result );
}
/*
This example produces the following results:
The original string is ",one,,,two,,,,,three,,".
The separation character is ','.
Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>
Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>
Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>
Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>
*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
// Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:\n");
string s1 = ",ONE,, TWO,, , THREE,,";
char[] charSeparators = new char[] { ',' };
string[] result;
Console.WriteLine($"The original string is: \"{s1}\".");
Console.WriteLine($"The delimiter character is: '{charSeparators[0]}'.\n");
// Split the string and return all elements
Console.WriteLine("1a) Return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);
// Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries);
Show(result);
// Split the string and return all non-empty elements
Console.WriteLine("1c) Return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Example 2: Split a string delimited by another string
Console.WriteLine("2) Split a string delimited by another string:\n");
string s2 = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] ";
string[] stringSeparators = new string[] { "[stop]" };
Console.WriteLine($"The original string is: \"{s2}\".");
Console.WriteLine($"The delimiter string is: \"{stringSeparators[0]}\".\n");
// Split the string and return all elements
Console.WriteLine("2a) Return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);
// Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries);
Show(result);
// Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries);
Show(result);
// Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
Show(result);
// Display the array of separated strings using a local function
void Show(string[] entries)
{
Console.WriteLine($"The return value contains these {entries.Length} elements:");
foreach (string entry in entries)
{
Console.Write($"<{entry}>");
}
Console.Write("\n\n");
}
/*
This example produces the following results:
1) Split a string delimited by characters:
The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.
1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>
1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>
1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>
1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>
2) Split a string delimited by another string:
The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
The delimiter string is: "[stop]".
2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO ><>< ><THREE><>< >
2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO >< ><THREE>< >
2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
// Display the array of separated strings using a local function
let show (entries: string[]) =
printfn $"The return value contains these {entries.Length} elements:"
for entry in entries do
printf $"<{entry}>"
printf "\n\n"
// Example 1: Split a string delimited by characters
printfn "1) Split a string delimited by characters:\n"
let s1 = ",ONE,, TWO,, , THREE,,"
let charSeparators = [| ',' |]
printfn $"The original string is: \"{s1}\"."
printfn $"The delimiter character is: '{charSeparators[0]}'.\n"
// Split the string and return all elements
printfn "1a) Return all elements:"
let result = s1.Split(charSeparators, StringSplitOptions.None)
show result
// Split the string and return all elements with whitespace trimmed
printfn "1b) Return all elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
show result
// Split the string and return all non-empty elements
printfn "1c) Return all non-empty elements:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "1d) Return all non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Split the string into only two elements, keeping the remainder in the last match
printfn "1e) Split into only two elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.None)
show result
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "1f) Split into only two elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
show result
// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "1g) Split into only two non-empty elements:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "1h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Example 2: Split a string delimited by another string
printfn "2) Split a string delimited by another string:\n"
let s2 = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] "
let stringSeparators = [| "[stop]" |]
printfn $"The original string is: \"{s2}\"."
printfn $"The delimiter string is: \"{stringSeparators[0]}\".\n"
// Split the string and return all elements
printfn "2a) Return all elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.None)
show result
// Split the string and return all elements with whitespace trimmed
printfn "2b) Return all elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
show result
// Split the string and return all non-empty elements
printfn "2c) Return all non-empty elements:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string and return all non-whitespace elements with whitespace trimmed
printfn "2d) Return all non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
// Split the string into only two elements, keeping the remainder in the last match
printfn "2e) Split into only two elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
show result
// Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
printfn "2f) Split into only two elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
show result
// Split the string into only two non-empty elements, keeping the remainder in the last match
printfn "2g) Split into only two non-empty elements:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
show result
// Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
printfn "2h) Split into only two non-whitespace elements with whitespace trimmed:"
let result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries ||| StringSplitOptions.TrimEntries)
show result
(*
This example produces the following results:
1) Split a string delimited by characters:
The original string is: ",ONE,, TWO,, , THREE,,".
The delimiter character is: ','.
1a) Return all elements:
The return value contains these 9 elements:
<><ONE><>< TWO><>< >< THREE><><>
1b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
1c) Return all non-empty elements:
The return value contains these 4 elements:
<ONE>< TWO>< >< THREE>
1d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
1e) Split into only two elements:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE,, TWO,, , THREE,,>
1g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< TWO,, , THREE,,>
1h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO,, , THREE,,>
2) Split a string delimited by another string:
The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
The delimiter string is: "[stop]".
2a) Return all elements:
The return value contains these 9 elements:
<><ONE>< ><TWO ><>< ><THREE><>< >
2b) Return all elements with whitespace trimmed:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>
2c) Return all non-empty elements:
The return value contains these 6 elements:
<ONE>< ><TWO >< ><THREE>< >
2d) Return all non-whitespace elements with whitespace trimmed:
The return value contains these 3 elements:
<ONE><TWO><THREE>
2e) Split into only two elements:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2f) Split into only two elements with whitespace trimmed:
The return value contains these 2 elements:
<><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
2g) Split into only two non-empty elements:
The return value contains these 2 elements:
<ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
2h) Split into only two non-whitespace elements with whitespace trimmed:
The return value contains these 2 elements:
<ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
*)
Public Shared Sub StringSplitOptionsExamples()
' This example demonstrates the String.Split() methods that use
' the StringSplitOptions enumeration.
' Example 1: Split a string delimited by characters
Console.WriteLine("1) Split a string delimited by characters:" & vbCrLf)
Dim s1 As String = ",ONE,, TWO,, , THREE,,"
Dim charSeparators() As Char = {","c}
Dim result() As String
Console.WriteLine("The original string is: ""{0}"".", s1)
Console.WriteLine("The delimiter character is: '{0}'." & vbCrLf, charSeparators(0))
' Split the string and return all elements
Console.WriteLine("1a) Return all elements:")
result = s1.Split(charSeparators, StringSplitOptions.None)
Show(result)
' Split the string and return all elements with whitespace trimmed
Console.WriteLine("1b) Return all elements with whitespace trimmed:")
result = s1.Split(charSeparators, StringSplitOptions.TrimEntries)
Show(result)
' Split the string and return all non-empty elements
Console.WriteLine("1c) Return all non-empty elements:")
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("1d) Return all non-whitespace elements with whitespace trimmed:")
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("1e) Split into only two elements:")
result = s1.Split(charSeparators, 2, StringSplitOptions.None)
Show(result)
' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1f) Split into only two elements with whitespace trimmed:")
result = s1.Split(charSeparators, 2, StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("1g) Split into only two non-empty elements:")
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("1h) Split into only two non-whitespace elements with whitespace trimmed:")
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Example 2: Split a string delimited by another string
Console.WriteLine("2) Split a string delimited by another string:" & vbCrLf)
Dim s2 As String = "[stop]" +
"ONE[stop] [stop]" +
"TWO [stop][stop] [stop]" +
"THREE[stop][stop] "
Dim stringSeparators() As String = {"[stop]"}
Console.WriteLine("The original string is: ""{0}"".", s2)
Console.WriteLine("The delimiter string is: ""{0}""." & vbCrLf, stringSeparators(0))
' Split the string and return all elements
Console.WriteLine("2a) Return all elements:")
result = s2.Split(stringSeparators, StringSplitOptions.None)
Show(result)
' Split the string and return all elements with whitespace trimmed
Console.WriteLine("2b) Return all elements with whitespace trimmed:")
result = s2.Split(stringSeparators, StringSplitOptions.TrimEntries)
Show(result)
' Split the string and return all non-empty elements
Console.WriteLine("2c) Return all non-empty elements:")
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string and return all non-whitespace elements with whitespace trimmed
Console.WriteLine("2d) Return all non-whitespace elements with whitespace trimmed:")
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two elements, keeping the remainder in the last match
Console.WriteLine("2e) Split into only two elements:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.None)
Show(result)
' Split the string into only two elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2f) Split into only two elements with whitespace trimmed:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.TrimEntries)
Show(result)
' Split the string into only two non-empty elements, keeping the remainder in the last match
Console.WriteLine("2g) Split into only two non-empty elements:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries)
Show(result)
' Split the string into only two non-whitespace elements with whitespace trimmed, keeping the remainder in the last match
Console.WriteLine("2h) Split into only two non-whitespace elements with whitespace trimmed:")
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries Or StringSplitOptions.TrimEntries)
Show(result)
End Sub
' Display the array of separated strings.
Public Shared Sub Show(ByVal entries() As String)
Console.WriteLine("The return value contains these {0} elements:", entries.Length)
Dim entry As String
For Each entry In entries
Console.Write("<{0}>", entry)
Next entry
Console.Write(vbCrLf & vbCrLf)
End Sub
'This example produces the following results:
'
' 1) Split a string delimited by characters:
'
' The original string is: ",ONE,, TWO,, , THREE,,".
' The delimiter character is: ','.
'
' 1a) Return all elements:
' The return value contains these 9 elements:
' <><ONE><>< TWO><>< >< THREE><><>
'
' 1b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 1c) Return all non-empty elements:
' The return value contains these 4 elements:
' <ONE>< TWO>< >< THREE>
'
' 1d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 1e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE,, TWO,, , THREE,,>
'
' 1g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< TWO,, , THREE,,>
'
' 1h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO,, , THREE,,>
'
' 2) Split a string delimited by another string:
'
' The original string is: "[stop]ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] ".
' The delimiter string is: "[stop]".
'
' 2a) Return all elements:
' The return value contains these 9 elements:
' <><ONE>< ><TWO ><>< ><THREE><>< >
'
' 2b) Return all elements with whitespace trimmed:
' The return value contains these 9 elements:
' <><ONE><><TWO><><><THREE><><>
'
' 2c) Return all non-empty elements:
' The return value contains these 6 elements:
' <ONE>< ><TWO >< ><THREE>< >
'
' 2d) Return all non-whitespace elements with whitespace trimmed:
' The return value contains these 3 elements:
' <ONE><TWO><THREE>
'
' 2e) Split into only two elements:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
'
' 2f) Split into only two elements with whitespace trimmed:
' The return value contains these 2 elements:
' <><ONE[stop] [stop]TWO [stop][stop] [stop]THREE[stop][stop]>
'
' 2g) Split into only two non-empty elements:
' The return value contains these 2 elements:
' <ONE>< [stop]TWO [stop][stop] [stop]THREE[stop][stop] >
'
' 2h) Split into only two non-whitespace elements with whitespace trimmed:
' The return value contains these 2 elements:
' <ONE><TWO [stop][stop] [stop]THREE[stop][stop]>
'
Keterangan
Karakter pemisah (karakter dalam separator
array) tidak disertakan dalam elemen array yang dikembalikan. Misalnya, jika separator
array menyertakan karakter "-" dan nilai instans string saat ini adalah "aa-bb-cc", metode mengembalikan array yang berisi tiga elemen: "aa", "bb", dan "cc".
Jika instans ini tidak berisi karakter apa pun dalam separator
, array yang dikembalikan terdiri dari satu elemen yang berisi instans ini.
options
Jika parameter adalah RemoveEmptyEntries dan panjang instans ini adalah nol, metode mengembalikan array kosong.
Setiap elemen separator
mendefinisikan pemisah terpisah yang terdiri dari satu karakter.
options
Jika argumen adalah None, dan dua pemisah berdekatan atau pemisah ditemukan di awal atau akhir instans ini, elemen array yang sesuai berisi String.Empty. Misalnya, jika separator
menyertakan dua elemen, '-'
dan '_'
, nilai instans string adalah "-_aa-_", dan nilai options
argumen adalah None, metode mengembalikan array string dengan lima elemen berikut:
String.Empty, yang mewakili string kosong yang mendahului karakter "-" pada indeks 0.
String.Empty, yang mewakili string kosong antara karakter "-" pada indeks 0 dan karakter "_" pada indeks 1.
"aa".
String.Empty, yang mewakili string kosong yang mengikuti karakter "-" pada indeks 4.
String.Empty, yang mewakili string kosong yang mengikuti karakter "_" pada indeks 5.
Array pemisah
separator
Jika parameter adalah null
atau tidak berisi karakter, karakter spasi putih diasumsikan sebagai pemisah. Karakter spasi putih didefinisikan oleh standar Unicode dan Char.IsWhiteSpace metode mengembalikan true
jika diteruskan ke dalamnya.
Untuk meneruskan null
char[] separator
parameter, Anda harus menunjukkan jenis null
untuk membedakan panggilan dari beberapa kelebihan beban lainnya, seperti Split(String[], StringSplitOptions). Contoh berikut menunjukkan beberapa cara untuk mengidentifikasi kelebihan beban ini secara tidak ambigu.
string phrase = "The quick brown fox";
_ = phrase.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries);
_ = phrase.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries);
_ = phrase.Split(null as char[], StringSplitOptions.RemoveEmptyEntries);
let phrase = "The quick brown fox"
phrase.Split(Unchecked.defaultof<char[]>, StringSplitOptions.RemoveEmptyEntries) |> ignore
phrase.Split(null :> char[], StringSplitOptions.RemoveEmptyEntries) |> ignore
phrase.Split((null: char[]), StringSplitOptions.RemoveEmptyEntries) |> ignore
Dim phrase As String = "The quick brown fox"
Dim words() As String
words = phrase.Split(TryCast(Nothing, Char()),
StringSplitOptions.RemoveEmptyEntries)
words = phrase.Split(New Char() {},
StringSplitOptions.RemoveEmptyEntries)
Detail perbandingan
Metode Split mengekstrak substring dalam string ini yang dibatasi oleh satu atau beberapa karakter dalam separator
parameter, dan mengembalikan substring tersebut sebagai elemen array.
Metode Split mencari pemisah dengan melakukan perbandingan menggunakan aturan pengurutan ordinal peka huruf besar/kecil. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions enumerasi.
Pertimbangan performa
Metode Split mengalokasikan memori untuk objek array yang String dikembalikan dan objek untuk setiap elemen array. Jika aplikasi Anda memerlukan performa optimal atau jika mengelola alokasi memori sangat penting dalam aplikasi Anda, pertimbangkan untuk menggunakan IndexOf metode atau IndexOfAny , dan secara Compare opsional metode , untuk menemukan substring dalam string.
Jika Anda memisahkan string pada karakter pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pemisah dalam string. Jika Anda memisahkan string pada string pemisah, gunakan IndexOf metode atau IndexOfAny untuk menemukan karakter pertama string pemisah. Kemudian gunakan Compare metode untuk menentukan apakah karakter setelah karakter pertama tersebut sama dengan karakter yang tersisa dari string pemisah.
Selain itu, jika sekumpulan karakter yang sama digunakan untuk memisahkan string dalam beberapa Split panggilan metode, pertimbangkan untuk membuat satu array dan mereferensikannya di setiap panggilan metode. Ini secara signifikan mengurangi overhead tambahan dari setiap panggilan metode.
Catatan Bagi Pemanggil
Dalam .NET Framework 3.5 dan versi yang lebih lama, jika Split(Char[]) metode diteruskan separator
yang atau null
tidak berisi karakter, metode ini menggunakan sekumpulan karakter spasi putih yang sedikit berbeda untuk membagi string daripada Trim(Char[]) yang dilakukan metode untuk memangkas string. Dimulai dengan .NET Framework 4, kedua metode menggunakan sekumpulan karakter spasi putih Unicode yang identik.
Berlaku untuk
Saran dan Komentar
https://aka.ms/ContentUserFeedback.
Segera hadir: Sepanjang tahun 2024 kami akan menghentikan penggunaan GitHub Issues sebagai mekanisme umpan balik untuk konten dan menggantinya dengan sistem umpan balik baru. Untuk mengetahui informasi selengkapnya, lihat:Kirim dan lihat umpan balik untuk