String.Compare Metode

Referensi

Definisi

Ruang nama:: System

Rakitan:: System.Runtime.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

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.

Membandingkan dua objek String yang ditentukan dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

Overload

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)	Membandingkan substring dari dua objek String yang ditentukan menggunakan opsi perbandingan yang ditentukan dan informasi khusus budaya untuk memengaruhi perbandingan, dan mengembalikan bilangan bulat yang menunjukkan hubungan dua substring satu sama lain dalam urutan pengurutan.
Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)	Membandingkan substring dari dua objek String tertentu, mengabaikan atau menghormati kasusnya dan menggunakan informasi khusus budaya untuk memengaruhi perbandingan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, Int32, String, Int32, Int32, StringComparison)	Membandingkan substring dari dua objek String yang ditentukan menggunakan aturan yang ditentukan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, Int32, String, Int32, Int32, Boolean)	Membandingkan substring dari dua objek String tertentu, mengabaikan atau menghormati kasusnya, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, Int32, String, Int32, Int32)	Membandingkan substring dari dua objek String yang ditentukan dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, String, CultureInfo, CompareOptions)	Membandingkan dua objek String yang ditentukan menggunakan opsi perbandingan yang ditentukan dan informasi khusus budaya untuk memengaruhi perbandingan, dan mengembalikan bilangan bulat yang menunjukkan hubungan kedua string satu sama lain dalam urutan pengurutan.
Compare(String, String, Boolean, CultureInfo)	Membandingkan dua objek String tertentu, mengabaikan atau menghormati kasusnya, dan menggunakan informasi khusus budaya untuk memengaruhi perbandingan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, String, StringComparison)	Membandingkan dua objek String yang ditentukan menggunakan aturan yang ditentukan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, String, Boolean)	Membandingkan dua objek String yang ditentukan, mengabaikan atau menghormati kasusnya, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, String)	Membandingkan dua objek String yang ditentukan dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

Keterangan

Semua kelebihan beban metode Compare mengembalikan bilangan bulat bertanda 32-bit yang menunjukkan hubungan leksikal antara dua comparands.

Nilai	Keadaan
Kurang dari nol	Substring pertama mendahului substring kedua dalam urutan pengurutan.
Nol	Substring terjadi dalam posisi yang sama dalam urutan pengurutan, atau `length` adalah nol.
Lebih besar dari nol	Substring pertama mengikuti substring kedua dalam urutan pengurutan.

Peringatan

Jika memungkinkan, Anda harus memanggil kelebihan beban metode Compare yang menyertakan parameter StringComparison. Untuk informasi selengkapnya, lihat Praktik Terbaik untuk Menggunakan String.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan substring dari dua objek String yang ditentukan menggunakan opsi perbandingan yang ditentukan dan informasi khusus budaya untuk memengaruhi perbandingan, dan mengembalikan bilangan bulat yang menunjukkan hubungan dua substring satu sama lain dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length, System::Globalization::CultureInfo ^ culture, System::Globalization::CompareOptions options);

public static int Compare (string? strA, int indexA, string? strB, int indexB, int length, System.Globalization.CultureInfo? culture, System.Globalization.CompareOptions options);

public static int Compare (string strA, int indexA, string strB, int indexB, int length, System.Globalization.CultureInfo culture, System.Globalization.CompareOptions options);

static member Compare : string * int * string * int * int * System.Globalization.CultureInfo * System.Globalization.CompareOptions -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer, culture As CultureInfo, options As CompareOptions) As Integer

Parameter

strA: String

String pertama yang digunakan dalam perbandingan.

indexA: Int32

Posisi awal substring dalam strA.

strB: String

String kedua yang digunakan dalam perbandingan.

indexB: Int32

Posisi awal substring dalam strB.

length: Int32

Jumlah maksimum karakter dalam substring yang akan dibandingkan.

culture: CultureInfo

Objek yang memasok informasi perbandingan khusus budaya. Jika culturenull, budaya saat ini digunakan.

options: CompareOptions

Opsi yang digunakan saat melakukan perbandingan (seperti mengabaikan huruf besar/kecil atau simbol).

Mengembalikan

Int32

Bilangan bulat yang menunjukkan hubungan leksikal antara dua substring, seperti yang ditunjukkan dalam tabel berikut.

Nilai	Keadaan
Kurang dari nol	Substring dalam `strA` mendahului substring dalam `strB` dalam urutan pengurutan.
Nol	Substring terjadi dalam posisi yang sama dalam urutan pengurutan, atau `length` adalah nol.
Lebih besar dari nol	Substring dalam `strA` mengikuti substring dalam `strB` dalam urutan pengurutan.

Pengecualian

ArgumentException

options bukan nilai CompareOptions.

ArgumentOutOfRangeException

indexA lebih besar dari strA.Length.

-atau-

indexB lebih besar dari strB.Length.

-atau-

indexA, indexB, atau length negatif.

-atau-

Baik strA atau strBnull, dan length lebih besar dari nol.

Contoh

Contoh berikut menggunakan metode Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) untuk membandingkan nama belakang dua orang. Kemudian mencantumkannya dalam urutan alfabet.

string name1 = "Jack Smith";
string name2 = "John Doe";

// Get position of character after the space character.
int index1 = name1.IndexOf(" ");
index1 = index1 < 0 ? 0 : ++index1;

int index2 = name2.IndexOf(" ");
index2 = index2 < 0 ? 0 : ++index2;

int length = Math.Max(name1.Length, name2.Length);

Console.WriteLine("Sorted alphabetically by last name:");
if (String.Compare(name1, index1, name2, index2, length,
                   new CultureInfo("en-US"), CompareOptions.IgnoreCase) < 0)
    Console.WriteLine("{0}\n{1}", name1, name2);
else
    Console.WriteLine("{0}\n{1}", name2, name1);

// The example displays the following output:
//       Sorted alphabetically by last name:
//       John Doe
//       Jack Smith

open System
open System.Globalization

let name1 = "Jack Smith"
let name2 = "John Doe"

// Get position of character after the space character.
let index1 =
    let i = name1.IndexOf " "
    if i < 0 then 0 else i + 1

let index2 = 
    let i = name2.IndexOf " "
    if i < 0 then 0 else i + 1

let length = max name1.Length name2.Length

printfn "Sorted alphabetically by last name:"
if String.Compare(name1, index1, name2, index2, length, CultureInfo "en-US", CompareOptions.IgnoreCase) < 0 then
    printfn $"{name1}\n{name2}"
else
    printfn $"{name2}\n{name1}"

// The example displays the following output:
//       Sorted alphabetically by last name:
//       John Doe
//       Jack Smith

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim name1 As String = "Jack Smith"
      Dim name2 = "John Doe"
      
      ' Get position of space character.
      Dim index1 As Integer = name1.IndexOf(" ")
      index1 = CInt(IIf(index1 < 0, 0, index1 - 1))
      
      Dim index2 As Integer = name2.IndexOf(" ")
      index1 = CInt(IIf(index1 < 0, 0, index1 - 1))
      
      Dim length As Integer = Math.Max(name1.Length, name2.Length)
      
      Console.WriteLIne("Sorted alphabetically by last name:")
      If String.Compare(name1, index1, name2, index2, length, _
                        New CultureInfo("en-US"), CompareOptions.IgnoreCase) < 0 Then
         Console.WriteLine("{0}{1}{2}", name1, vbCrLf, name2)
      Else
         Console.WriteLine("{0}{1}{2}", name2, vbCrLf, name1)
      End If
   End Sub
End Module
' The example displays the following output;
'       Sorted alphabetically by last name:
'       John Doe
'       Jack Smith

Keterangan

Substring untuk membandingkan mulai di strA pada posisi indexA dan di strB pada posisi indexB. Panjang substring pertama adalah panjang strA minus indexA. Panjang substring kedua adalah panjang strB minus indexB.

Jumlah karakter yang akan dibandingkan adalah lebih sedikit dari panjang dua substring, dan length. Parameter indexA, indexB, dan length harus nonnegatif.

Perbandingan menggunakan parameter culture untuk mendapatkan informasi khusus budaya, seperti aturan casing dan urutan alfabet karakter individu. Misalnya, budaya tertentu dapat menentukan bahwa kombinasi karakter tertentu diperlakukan sebagai karakter tunggal, karakter huruf besar dan huruf kecil tersebut dibandingkan dengan cara tertentu, atau bahwa urutan pengurutan karakter tergantung pada karakter yang mendahului atau mengikutinya.

Hati

Metode Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) dirancang terutama untuk digunakan dalam operasi pengurutan atau alfabetisasi. Ini tidak boleh digunakan ketika tujuan utama panggilan metode adalah untuk menentukan apakah dua substring setara (yaitu, ketika tujuan panggilan metode adalah untuk menguji nilai pengembalian nol). Untuk menentukan apakah dua string setara, panggil metode Equals.

Satu atau kedua strA dan strB dapat null. Menurut definisi, string apa pun, termasuk String.Empty, membandingkan lebih besar dari referensi null, dan dua referensi null dibandingkan satu sama lain.

Perbandingan dapat ditentukan lebih lanjut oleh parameter options, yang terdiri dari satu atau beberapa anggota enumerasi System.Globalization.CompareOptions. Namun, karena tujuan dari metode ini adalah untuk melakukan perbandingan string yang sensitif terhadap budaya, nilai CompareOptions.Ordinal dan CompareOptions.OrdinalIgnoreCase tidak berpengaruh.

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua substring telah dibandingkan. Namun, jika dua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) tidak mempertimbangkan karakter ini ketika melakukan perbandingan linguistik atau peka budaya. Untuk mengenali karakter yang tidak dapat diabaikan dalam perbandingan Anda, berikan nilai Ordinal atau OrdinalIgnoreCase untuk parameter options.

Lihat juga

Equals

Berlaku untuk

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan substring dari dua objek String tertentu, mengabaikan atau menghormati kasusnya dan menggunakan informasi khusus budaya untuk memengaruhi perbandingan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length, bool ignoreCase, System::Globalization::CultureInfo ^ culture);

public static int Compare (string? strA, int indexA, string? strB, int indexB, int length, bool ignoreCase, System.Globalization.CultureInfo? culture);

public static int Compare (string strA, int indexA, string strB, int indexB, int length, bool ignoreCase, System.Globalization.CultureInfo culture);

static member Compare : string * int * string * int * int * bool * System.Globalization.CultureInfo -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer, ignoreCase As Boolean, culture As CultureInfo) As Integer

Parameter

strA: String

String pertama yang digunakan dalam perbandingan.

indexA: Int32

Posisi substring dalam strA.

strB: String

String kedua yang digunakan dalam perbandingan.

indexB: Int32

Posisi substring dalam strB.

length: Int32

Jumlah maksimum karakter dalam substring yang akan dibandingkan.

ignoreCase: Boolean

true mengabaikan kasus selama perbandingan; jika tidak, false.

culture: CultureInfo

Objek yang memasok informasi perbandingan khusus budaya. Jika culturenull, budaya saat ini digunakan.

Mengembalikan

Int32

Bilangan bulat yang menunjukkan hubungan leksikal antara dua perbandingan.

Nilai	Keadaan
Kurang dari nol	Substring dalam `strA` mendahului substring dalam `strB` dalam urutan pengurutan.
Nol	Substring terjadi dalam posisi yang sama dalam urutan pengurutan, atau `length` adalah nol.
Lebih besar dari nol	Substring dalam `strA` mengikuti substring dalam `strB` dalam urutan pengurutan.

Pengecualian

ArgumentOutOfRangeException

indexA lebih besar dari strA.Length.

-atau-

indexB lebih besar dari strB.Length.

-atau-

indexA, indexB, atau length negatif.

-atau-

Baik strA atau strBnull, dan length lebih besar dari nol.

Contoh

Contoh berikut membandingkan dua substring menggunakan budaya yang berbeda dan mengabaikan kasus substring. Pilihan budaya mempengaruhi bagaimana huruf "I" dibandingkan.

// Sample for String::Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
using namespace System;
using namespace System::Globalization;
int main()
{
   
   //                0123456
   String^ str1 = "MACHINE";
   String^ str2 = "machine";
   String^ str;
   int result;
   Console::WriteLine();
   Console::WriteLine( "str1 = '{0}', str2 = '{1}'", str1, str2 );
   Console::WriteLine( "Ignore case, Turkish culture:" );
   result = String::Compare( str1, 4, str2, 4, 2, true, gcnew CultureInfo( "tr-TR" ) );
   str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"greater than" : "equal to"));
   Console::Write( "Substring '{0}' in '{1}' is ", str1->Substring( 4, 2 ), str1 );
   Console::Write( " {0} ", str );
   Console::WriteLine( "substring '{0}' in '{1}'.", str2->Substring( 4, 2 ), str2 );
   Console::WriteLine();
   Console::WriteLine( "Ignore case, invariant culture:" );
   result = String::Compare( str1, 4, str2, 4, 2, true, CultureInfo::InvariantCulture );
   str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"greater than" : "equal to"));
   Console::Write( "Substring '{0}' in '{1}' is ", str1->Substring( 4, 2 ), str1 );
   Console::Write( " {0} ", str );
   Console::WriteLine( "substring '{0}' in '{1}'.", str2->Substring( 4, 2 ), str2 );
}

/*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case, Turkish culture:
Substring 'IN' in 'MACHINE' is less than substring 'in' in 'machine'.

Ignore case, invariant culture:
Substring 'IN' in 'MACHINE' is equal to substring 'in' in 'machine'.
*/

// Sample for String.Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
using System;
using System.Globalization;

class Sample5
{
    public static void Main()
    {
        //                 0123456
        String str1 = "MACHINE";
        String str2 = "machine";
        String str;
        int result;

        Console.WriteLine();
        Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);
        Console.WriteLine("Ignore case, Turkish culture:");
        result = String.Compare(str1, 4, str2, 4, 2, true, new CultureInfo("tr-TR"));
        str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
        Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(4, 2), str1);
        Console.Write("{0} ", str);
        Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(4, 2), str2);

        Console.WriteLine();
        Console.WriteLine("Ignore case, invariant culture:");
        result = String.Compare(str1, 4, str2, 4, 2, true, CultureInfo.InvariantCulture);
        str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
        Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(4, 2), str1);
        Console.Write("{0} ", str);
        Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(4, 2), str2);
    }
}
/*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case, Turkish culture:
Substring 'IN' in 'MACHINE' is less than substring 'in' in 'machine'.

Ignore case, invariant culture:
Substring 'IN' in 'MACHINE' is equal to substring 'in' in 'machine'.
*/

// Sample for String.Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
open System
open System.Globalization

//                 0123456
let str1 = "MACHINE"
let str2 = "machine"

printfn $"\nstr1 = '{str1}', str2 = '{str2}'"
printfn "Ignore case, Turkish culture:"
let result = String.Compare(str1, 4, str2, 4, 2, true, CultureInfo "tr-TR")
let str = if result < 0 then "less than" elif result > 0 then "greater than" else "equal to"
printf $"Substring '{str1.Substring(4, 2)}' in '{str1}' is "
printf $"{str} "
printfn $"substring '{str2.Substring(4, 2)}' in '{str2}'."

printfn "\nIgnore case, invariant culture:"
let result2 = String.Compare(str1, 4, str2, 4, 2, true, CultureInfo.InvariantCulture)
let str3 = if result < 0 then "less than" elif result > 0 then "greater than" else "equal to"
printf $"Substring '{str1.Substring(4, 2)}' in '{str1}' is "
printf $"{str3} "
printfn $"substring '{str2.Substring(4, 2)}' in '{str2}'."

(*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case, Turkish culture:
Substring 'IN' in 'MACHINE' is less than substring 'in' in 'machine'.

Ignore case, invariant culture:
Substring 'IN' in 'MACHINE' is equal to substring 'in' in 'machine'.
*)

' Sample for String.Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
Imports System.Globalization

Class Sample
   
   Public Shared Sub Main()
      '                       0123456
      Dim str1 As [String] = "MACHINE"
      Dim str2 As [String] = "machine"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      Console.WriteLine("Ignore case, Turkish culture:")
      result = [String].Compare(str1, 4, str2, 4, 2, True, New CultureInfo("tr-TR"))
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(4, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(4, 2), str2)
      
      Console.WriteLine()
      Console.WriteLine("Ignore case, invariant culture:")
      result = [String].Compare(str1, 4, str2, 4, 2, True, CultureInfo.InvariantCulture)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(4, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(4, 2), str2)
   End Sub
End Class
'
'This example produces the following results:
'
'str1 = 'MACHINE', str2 = 'machine'
'Ignore case, Turkish culture:
'Substring 'IN' in 'MACHINE' is less than substring 'in' in 'machine'.
'
'Ignore case, invariant culture:
'Substring 'IN' in 'MACHINE' is equal to substring 'in' in 'machine'.
'

Keterangan

Substring untuk membandingkan mulai di strA pada indexA, dan di strB pada indexB. Baik indexA maupun indexB berbasis nol; artinya, karakter pertama dalam strA dan strB berada di posisi nol, bukan posisi satu. Panjang substring pertama sama dengan panjang strA dikurangi indexA ditambah satu. Panjang substring kedua sama dengan panjang strB dikurangi indexB ditambah satu.

Jumlah karakter yang akan dibandingkan adalah lebih sedikit dari panjang dua substring, dan length. Parameter indexA, indexB, dan length harus nonnegatif.

Perbandingan menggunakan parameter culture untuk mendapatkan informasi khusus budaya seperti aturan casing dan urutan alfabet karakter individual. Misalnya, budaya dapat menentukan bahwa kombinasi karakter tertentu diperlakukan sebagai karakter tunggal, atau karakter huruf besar dan kecil dibandingkan dengan cara tertentu, atau bahwa urutan pengurutan karakter tergantung pada karakter yang mendahului atau mengikutinya.

Perbandingan dilakukan menggunakan aturan pengurutan kata. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions.

Satu atau kedua perbandingan dapat null. Menurut definisi, string apa pun, termasuk string kosong (""), membandingkan yang lebih besar dari referensi null; dan dua referensi null dibandingkan satu sama lain.

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua substring telah dibandingkan. Namun, jika dua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, maka string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

Hasil yang tidak terduga dapat terjadi ketika perbandingan dipengaruhi oleh aturan casing khusus budaya. Misalnya, dalam bahasa Turki, contoh berikut menghasilkan hasil yang salah karena sistem file dalam bahasa Turki tidak menggunakan aturan kasing linguistik untuk huruf "i" dalam "file".

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Bandingkan nama jalur dengan "file" menggunakan perbandingan ordinal. Kode yang benar untuk melakukan ini adalah sebagai berikut:

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) tidak mempertimbangkan karakter ini ketika melakukan perbandingan linguistik atau peka budaya. Untuk mengenali karakter yang dapat diabaikan dalam perbandingan Anda, panggil metode Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) dan berikan nilai Ordinal atau OrdinalIgnoreCase untuk parameter options.

Lihat juga

Berlaku untuk

Compare(String, Int32, String, Int32, Int32, StringComparison)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan substring dari dua objek String yang ditentukan menggunakan aturan yang ditentukan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length, StringComparison comparisonType);

public static int Compare (string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType);

public static int Compare (string? strA, int indexA, string? strB, int indexB, int length, StringComparison comparisonType);

static member Compare : string * int * string * int * int * StringComparison -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer, comparisonType As StringComparison) As Integer

Parameter

strA: String

String pertama yang digunakan dalam perbandingan.

indexA: Int32

Posisi substring dalam strA.

strB: String

String kedua yang digunakan dalam perbandingan.

indexB: Int32

Posisi substring dalam strB.

length: Int32

Jumlah maksimum karakter dalam substring yang akan dibandingkan.

comparisonType: StringComparison

Salah satu nilai enumerasi yang menentukan aturan yang akan digunakan dalam perbandingan.

Mengembalikan

Int32

Bilangan bulat bertanda tangan 32-bit yang menunjukkan hubungan leksikal antara dua perbandingan.

Nilai	Keadaan
Kurang dari nol	Substring dalam `strA` mendahului substring dalam `strB` dalam urutan pengurutan.
Nol	Substring terjadi dalam posisi yang sama dalam urutan pengurutan, atau parameter `length` adalah nol.
Lebih besar dari nol	Substring dalam `strA` mengikuti substring dalam `strB` dalam urutan pengurutan.

Pengecualian

ArgumentOutOfRangeException

indexA lebih besar dari strA.Length.

-atau-

indexB lebih besar dari strB.Length.

-atau-

indexA, indexB, atau length negatif.

-atau-

Baik indexA atau indexBnull, dan length lebih besar dari nol.

ArgumentException

comparisonType bukan nilai StringComparison.

Contoh

Contoh berikut membandingkan dua substring.

// Sample for String::Compare(String, Int32, String, Int32, Int32)
using namespace System;
int main()
{
   
   //                0123456
   String^ str1 = "machine";
   String^ str2 = "device";
   String^ str;
   int result;
   Console::WriteLine();
   Console::WriteLine( "str1 = '{0}', str2 = '{1}'", str1, str2 );
   result = String::Compare( str1, 2, str2, 0, 2 );
   str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"greater than" : "equal to"));
   Console::Write( "Substring '{0}' in ' {1}' is ", str1->Substring( 2, 2 ), str1 );
   Console::Write( " {0} ", str );
   Console::WriteLine( "substring '{0}' in ' {1}'.", str2->Substring( 0, 2 ), str2 );
}

/*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*/

String str1 = "machine";
String str2 = "device";
String str;
int result;

Console.WriteLine();
Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);
result = String.Compare(str1, 2, str2, 0, 2);
str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1);
Console.Write("{0} ", str);
Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(0, 2), str2);

/*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*/

open System

let str1 = "machine"
let str2 = "device"

printfn "\nstr1 = '{str1}', str2 = '{str2}'"

let result = String.Compare(str1, 2, str2, 0, 2)
let str = 
    if result < 0 then "less than" 
    elif result > 0 then "greater than" 
    else "equal to"

printf $"Substring '{str1.Substring(2, 2)}' in '{str1}' is "
printf $"{str} "
printfn $"substring '{str2.Substring(0, 2)}' in '{str2}'."

(*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*)

' Sample for String.Compare(String, Int32, String, Int32, Int32)
Class Sample
   Public Shared Sub Main()
      '                       0123456
      Dim str1 As [String] = "machine"
      Dim str2 As [String] = "device"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      result = [String].Compare(str1, 2, str2, 0, 2)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(0, 2), str2)
   End Sub
End Class
'
'This example produces the following results:
'
'str1 = 'machine', str2 = 'device'
'Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
'

Keterangan

Substring untuk membandingkan mulai di strA pada indexA dan di strB pada indexB. Baik indexA maupun indexB berbasis nol; artinya, karakter pertama dalam strA dan strB berada di posisi nol, bukan posisi satu. Panjang substring pertama sama dengan panjang strA dikurangi indexA ditambah satu. Panjang substring kedua sama dengan panjang strB dikurangi indexB ditambah satu.

Jumlah karakter yang akan dibandingkan adalah lebih sedikit dari panjang dua substring, dan length. Parameter indexA, indexB, dan length harus nonnegatif.

Parameter comparisonType menunjukkan apakah perbandingan harus menggunakan budaya saat ini atau invarian, menghormati atau mengabaikan kasus perbandingan, atau menggunakan aturan pengurutan kata (peka budaya) atau ordinal (tidak peka budaya).

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua substring telah dibandingkan. Namun, jika kedua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Bandingkan nama jalur dengan "file" menggunakan perbandingan ordinal. Kode yang benar untuk melakukan ini adalah sebagai berikut:

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, Int32, String, Int32, Int32, StringComparison) tidak mempertimbangkan karakter ini ketika melakukan perbandingan linguistik atau peka budaya. Untuk mengenali karakter yang tidak dapat diabaikan dalam perbandingan Anda, berikan nilai Ordinal atau OrdinalIgnoreCase untuk parameter comparisonType.

Lihat juga

Berlaku untuk

Compare(String, Int32, String, Int32, Int32, Boolean)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan substring dari dua objek String tertentu, mengabaikan atau menghormati kasusnya, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length, bool ignoreCase);

public static int Compare (string? strA, int indexA, string? strB, int indexB, int length, bool ignoreCase);

public static int Compare (string strA, int indexA, string strB, int indexB, int length, bool ignoreCase);

static member Compare : string * int * string * int * int * bool -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer, ignoreCase As Boolean) As Integer

Parameter

strA: String

String pertama yang digunakan dalam perbandingan.

indexA: Int32

Posisi substring dalam strA.

strB: String

String kedua yang digunakan dalam perbandingan.

indexB: Int32

Posisi substring dalam strB.

length: Int32

Jumlah maksimum karakter dalam substring yang akan dibandingkan.

ignoreCase: Boolean

true mengabaikan kasus selama perbandingan; jika tidak, false.

Mengembalikan

Int32

Bilangan bulat bertanda tangan 32-bit yang menunjukkan hubungan leksikal antara dua perbandingan.

Nilai	Keadaan
Kurang dari nol	Substring dalam `strA` mendahului substring dalam `strB` dalam urutan pengurutan.
Nol	Substring terjadi dalam posisi yang sama dalam urutan pengurutan, atau `length` adalah nol.
Lebih besar dari nol	Substring dalam `strA` mengikuti substring dalam `strB` dalam urutan pengurutan.

Pengecualian

ArgumentOutOfRangeException

indexA lebih besar dari strA.Length.

-atau-

indexB lebih besar dari strB.Length.

-atau-

indexA, indexB, atau length negatif.

-atau-

Baik indexA atau indexBnull, dan length lebih besar dari nol.

Contoh

Contoh berikut melakukan dua perbandingan dua substring yang hanya berbeda jika. Perbandingan pertama mengabaikan kasus dan perbandingan kedua mempertimbangkan kasus.

// Sample for String::Compare(String, Int32, String, Int32, Int32, Boolean)
using namespace System;
int main()
{
   
   //                0123456
   String^ str1 = "MACHINE";
   String^ str2 = "machine";
   String^ str;
   int result;
   Console::WriteLine();
   Console::WriteLine( "str1 = '{0}', str2 = '{1}'", str1, str2 );
   Console::WriteLine( "Ignore case:" );
   result = String::Compare( str1, 2, str2, 2, 2, true );
   str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"greater than" : "equal to"));
   Console::Write( "Substring '{0}' in '{1}' is ", str1->Substring( 2, 2 ), str1 );
   Console::Write( " {0} ", str );
   Console::WriteLine( "substring '{0}' in '{1}'.", str2->Substring( 2, 2 ), str2 );
   Console::WriteLine();
   Console::WriteLine( "Honor case:" );
   result = String::Compare( str1, 2, str2, 2, 2, false );
   str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"greater than" : "equal to"));
   Console::Write( "Substring '{0}' in '{1}' is ", str1->Substring( 2, 2 ), str1 );
   Console::Write( " {0} ", str );
   Console::WriteLine( "substring '{0}' in '{1}'.", str2->Substring( 2, 2 ), str2 );
}

/*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case:
Substring 'CH' in 'MACHINE' is equal to substring 'ch' in 'machine'.

Honor case:
Substring 'CH' in 'MACHINE' is greater than substring 'ch' in 'machine'.
*/

String str1 = "MACHINE";
String str2 = "machine";
String str;
int result;

Console.WriteLine();
Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);

Console.WriteLine("Ignore case:");
result = String.Compare(str1, 2, str2, 2, 2, true);
str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1);
Console.Write("{0} ", str);
Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(2, 2), str2);
Console.WriteLine();

Console.WriteLine("Honor case:");
result = String.Compare(str1, 2, str2, 2, 2, false);
str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1);
Console.Write("{0} ", str);
Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(2, 2), str2);

/*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case:
Substring 'CH' in 'MACHINE' is equal to substring 'ch' in 'machine'.

Honor case:
Substring 'CH' in 'MACHINE' is greater than substring 'ch' in 'machine'.
*/

open System

let str1 = "MACHINE"
let str2 = "machine"

printfn $"\nstr1 = '{str1}', str2 = '{str2}'"

printfn "Ignore case:"
let result = String.Compare(str1, 2, str2, 2, 2, true)
let str = 
    if result < 0 then "less than" 
    elif result > 0 then "greater than"
    else "equal to"

printf $"Substring '{str1.Substring(2, 2)}' in '{str1}' is "
printf $"{str} "
printfn $"substring '{str2.Substring(2, 2)}' in '{str2}'.\n"

printfn "Honor case:"
let result2 = String.Compare(str1, 2, str2, 2, 2, false)
let str3 = 
    if result < 0 then "less than" 
    elif result > 0 then "greater than" 
    else "equal to"

printfn $"Substring '{str1.Substring(2, 2)}' in '{str1}' is "
printf $"{str3} "
printfn $"substring '{str2.Substring(2, 2)}' in '{str2}'."

(*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case:
Substring 'CH' in 'MACHINE' is equal to substring 'ch' in 'machine'.

Honor case:
Substring 'CH' in 'MACHINE' is greater than substring 'ch' in 'machine'.
*)

' Sample for String.Compare(String, Int32, String, Int32, Int32, Boolean)
Class Sample
   
   Public Shared Sub Main()
      '                       0123456
      Dim str1 As [String] = "MACHINE"
      Dim str2 As [String] = "machine"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      Console.WriteLine("Ignore case:")
      result = [String].Compare(str1, 2, str2, 2, 2, True)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(2, 2), str2)
      
      Console.WriteLine()
      Console.WriteLine("Honor case:")
      result = [String].Compare(str1, 2, str2, 2, 2, False)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(2, 2), str2)
   End Sub
End Class
'
'This example produces the following results:
'
'str1 = 'MACHINE', str2 = 'machine'
'Ignore case:
'Substring 'CH' in 'MACHINE' is equal to substring 'ch' in 'machine'.
'
'Honor case:
'Substring 'CH' in 'MACHINE' is greater than substring 'ch' in 'machine'.
'

Keterangan

Substring untuk membandingkan mulai di strA pada indexA, dan di strB pada indexB. Baik indexA maupun indexB berbasis nol; yaitu, karakter pertama dalam strA dan strB berada di posisi nol. Panjang substring pertama sama dengan panjang strA dikurangi indexA ditambah satu. Panjang substring kedua sama dengan panjang strB dikurangi indexB ditambah satu.

Jumlah karakter yang akan dibandingkan adalah lebih sedikit dari panjang dua substring, dan length. Parameter indexA, indexB, dan length harus nonnegatif.

Perbandingan menggunakan budaya saat ini untuk mendapatkan informasi khusus budaya seperti aturan kasing dan urutan alfabet karakter individu. Misalnya, budaya dapat menentukan bahwa kombinasi karakter tertentu diperlakukan sebagai karakter tunggal, atau karakter huruf besar dan kecil dibandingkan dengan cara tertentu, atau bahwa urutan pengurutan karakter tergantung pada karakter yang mendahului atau mengikutinya.

Perbandingan dilakukan menggunakan aturan pengurutan kata. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions.

Peringatan

Saat membandingkan string, Anda harus memanggil metode Compare(String, Int32, String, Int32, Int32, StringComparison), yang mengharuskan Anda secara eksplisit menentukan jenis perbandingan string yang digunakan metode. Untuk informasi selengkapnya, lihat Praktik Terbaik untuk Menggunakan String.

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua substring telah dibandingkan. Namun, jika dua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, maka string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Nama jalur perlu dibandingkan dengan cara yang invarian. Kode yang benar untuk melakukan ini adalah sebagai berikut.

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, Int32, String, Int32, Int32, Boolean) tidak mempertimbangkan karakter ini ketika melakukan perbandingan linguistik atau peka budaya. Untuk mengenali karakter yang dapat diabaikan dalam perbandingan Anda, panggil metode Compare(String, Int32, String, Int32, Int32, StringComparison) dan berikan nilai Ordinal atau OrdinalIgnoreCase untuk parameter comparisonType.

Lihat juga

Berlaku untuk

Compare(String, Int32, String, Int32, Int32)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan substring dari dua objek String yang ditentukan dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length);

public static int Compare (string strA, int indexA, string strB, int indexB, int length);

public static int Compare (string? strA, int indexA, string? strB, int indexB, int length);

static member Compare : string * int * string * int * int -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer) As Integer

Parameter

strA: String

String pertama yang digunakan dalam perbandingan.

indexA: Int32

Posisi substring dalam strA.

strB: String

String kedua yang digunakan dalam perbandingan.

indexB: Int32

Posisi substring dalam strB.

length: Int32

Jumlah maksimum karakter dalam substring yang akan dibandingkan.

Mengembalikan

Int32

Bilangan bulat bertanda tangan 32-bit yang menunjukkan hubungan leksikal antara kedua comparands.

Nilai	Keadaan
Kurang dari nol	Substring dalam `strA` mendahului substring dalam `strB` dalam urutan pengurutan.
Nol	Substring terjadi dalam posisi yang sama dalam urutan pengurutan, atau `length` adalah nol.
Lebih besar dari nol	Substring dalam `strA` mengikuti substring dalam `strB` dalam urutan pengurutan.

Pengecualian

ArgumentOutOfRangeException

indexA lebih besar dari strA.Length.

-atau-

indexB lebih besar dari strB.Length.

-atau-

indexA, indexB, atau length negatif.

-atau-

Baik indexA atau indexBnull, dan length lebih besar dari nol.

Contoh

Contoh berikut membandingkan dua substring.

// Sample for String::Compare(String, Int32, String, Int32, Int32)
using namespace System;
int main()
{
   
   //                0123456
   String^ str1 = "machine";
   String^ str2 = "device";
   String^ str;
   int result;
   Console::WriteLine();
   Console::WriteLine( "str1 = '{0}', str2 = '{1}'", str1, str2 );
   result = String::Compare( str1, 2, str2, 0, 2 );
   str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"greater than" : "equal to"));
   Console::Write( "Substring '{0}' in ' {1}' is ", str1->Substring( 2, 2 ), str1 );
   Console::Write( " {0} ", str );
   Console::WriteLine( "substring '{0}' in ' {1}'.", str2->Substring( 0, 2 ), str2 );
}

/*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*/

String str1 = "machine";
String str2 = "device";
String str;
int result;

Console.WriteLine();
Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);
result = String.Compare(str1, 2, str2, 0, 2);
str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1);
Console.Write("{0} ", str);
Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(0, 2), str2);

/*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*/

open System

let str1 = "machine"
let str2 = "device"

printfn "\nstr1 = '{str1}', str2 = '{str2}'"

let result = String.Compare(str1, 2, str2, 0, 2)
let str = 
    if result < 0 then "less than" 
    elif result > 0 then "greater than" 
    else "equal to"

printf $"Substring '{str1.Substring(2, 2)}' in '{str1}' is "
printf $"{str} "
printfn $"substring '{str2.Substring(0, 2)}' in '{str2}'."

(*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*)

' Sample for String.Compare(String, Int32, String, Int32, Int32)
Class Sample
   Public Shared Sub Main()
      '                       0123456
      Dim str1 As [String] = "machine"
      Dim str2 As [String] = "device"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      result = [String].Compare(str1, 2, str2, 0, 2)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(0, 2), str2)
   End Sub
End Class
'
'This example produces the following results:
'
'str1 = 'machine', str2 = 'device'
'Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
'

Keterangan

Substring untuk membandingkan mulai di strA pada indexA dan di strB pada indexB. Baik indexA maupun indexB berbasis nol; yaitu, karakter pertama dalam strA dan strB berada di posisi nol. Panjang substring pertama sama dengan panjang strA dikurangi indexA ditambah satu. Panjang substring kedua sama dengan panjang strB dikurangi indexB ditambah satu.

Jumlah karakter yang akan dibandingkan adalah lebih sedikit dari panjang dua substring, dan length. Parameter indexA, indexB, dan length harus nonnegatif.

Perbandingan dilakukan menggunakan aturan pengurutan kata. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions.

Peringatan

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua substring telah dibandingkan. Namun, jika dua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, maka string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Bandingkan nama jalur dengan "file" menggunakan perbandingan ordinal. Kode yang benar untuk melakukan ini adalah sebagai berikut:

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, Int32, String, Int32, Int32) tidak mempertimbangkan karakter ini ketika melakukan perbandingan linguistik atau peka budaya. Untuk mengenali karakter yang dapat diabaikan dalam perbandingan Anda, panggil metode Compare(String, Int32, String, Int32, Int32, StringComparison) dan berikan nilai Ordinal atau OrdinalIgnoreCase untuk parameter comparisonType.

Lihat juga

Berlaku untuk

Compare(String, String, CultureInfo, CompareOptions)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan dua objek String yang ditentukan menggunakan opsi perbandingan yang ditentukan dan informasi khusus budaya untuk memengaruhi perbandingan, dan mengembalikan bilangan bulat yang menunjukkan hubungan kedua string satu sama lain dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, System::String ^ strB, System::Globalization::CultureInfo ^ culture, System::Globalization::CompareOptions options);

public static int Compare (string? strA, string? strB, System.Globalization.CultureInfo? culture, System.Globalization.CompareOptions options);

public static int Compare (string strA, string strB, System.Globalization.CultureInfo culture, System.Globalization.CompareOptions options);

static member Compare : string * string * System.Globalization.CultureInfo * System.Globalization.CompareOptions -> int

Public Shared Function Compare (strA As String, strB As String, culture As CultureInfo, options As CompareOptions) As Integer

Parameter

strA: String

String pertama yang akan dibandingkan.

strB: String

String kedua yang akan dibandingkan.

culture: CultureInfo

Budaya yang memasok informasi perbandingan khusus budaya. Jika culturenull, budaya saat ini digunakan.

options: CompareOptions

Opsi yang digunakan saat melakukan perbandingan (seperti mengabaikan huruf besar/kecil atau simbol).

Mengembalikan

Int32

Bilangan bulat bertanda tangan 32-bit yang menunjukkan hubungan leksikal antara strA dan strB, seperti yang ditunjukkan dalam tabel berikut

Nilai	Keadaan
Kurang dari nol	`strA` mendahului `strB` dalam urutan pengurutan.
Nol	`strA` terjadi dalam posisi yang sama dengan `strB` dalam urutan pengurutan.
Lebih besar dari nol	`strA` mengikuti `strB` dalam urutan pengurutan.

Pengecualian

ArgumentException

options bukan nilai CompareOptions.

Contoh

Contoh berikut membandingkan dua string dengan tiga cara berbeda: Gunakan perbandingan linguistik untuk budaya en-US; menggunakan perbandingan peka huruf besar/kecil linguistik untuk budaya en-US; dan menggunakan perbandingan ordinal. Ini menggambarkan bagaimana tiga metode perbandingan menghasilkan tiga hasil yang berbeda.

using namespace System;
using namespace System::Globalization;

public ref class Example
{
public:
   static void Main()
   {
      String^ string1 = "brother";
      String^ string2 = "Brother";
      String^ relation;
      int result;

      // Cultural (linguistic) comparison.
      result = String::Compare(string1, string2, gcnew CultureInfo("en-US"),
                              CompareOptions::None);
      if (result > 0)
         relation = "comes after";
      else if (result == 0)
         relation = "is the same as";
      else
         relation = "comes before";

      Console::WriteLine("'{0}' {1} '{2}'.",
                        string1, relation, string2);

      // Cultural (linguistic) case-insensitive comparison.
      result = String::Compare(string1, string2, gcnew CultureInfo("en-US"),
                              CompareOptions::IgnoreCase);
      if (result > 0)
         relation = "comes after";
      else if (result == 0)
         relation = "is the same as";
      else
         relation = "comes before";

      Console::WriteLine("'{0}' {1} '{2}'.",
                        string1, relation, string2);

       // Culture-insensitive ordinal comparison.
      result = String::CompareOrdinal(string1, string2);
      if (result > 0)
         relation = "comes after";
      else if (result == 0)
         relation = "is the same as";
      else
         relation = "comes before";

      Console::WriteLine("'{0}' {1} '{2}'.",
                        string1, relation, string2);
   }
};

int main()
{
    Example::Main();
}


// The example produces the following output:
//    'brother' comes before 'Brother'.
//    'brother' is the same as 'Brother'.
//    'brother' comes after 'Brother'.

using System;
using System.Globalization;

public class Example0
{
    public static void Main()
    {
        string string1 = "brother";
        string string2 = "Brother";
        string relation;
        int result;

        // Cultural (linguistic) comparison.
        result = String.Compare(string1, string2, new CultureInfo("en-US"), 
                              CompareOptions.None);
        if (result > 0)
            relation = "comes after";
        else if (result == 0)
            relation = "is the same as";
        else
            relation = "comes before";

        Console.WriteLine("'{0}' {1} '{2}'.", 
                        string1, relation, string2);

        // Cultural (linguistic) case-insensitive comparison.
        result = String.Compare(string1, string2, new CultureInfo("en-US"), 
                              CompareOptions.IgnoreCase);
        if (result > 0)
            relation = "comes after";
        else if (result == 0)
            relation = "is the same as";
        else
            relation = "comes before";

        Console.WriteLine("'{0}' {1} '{2}'.", 
                        string1, relation, string2);
 
        // Culture-insensitive ordinal comparison.
        result = String.CompareOrdinal(string1, string2);
        if (result > 0)
            relation = "comes after";
        else if (result == 0)
            relation = "is the same as";
        else
            relation = "comes before";

        Console.WriteLine("'{0}' {1} '{2}'.", 
                        string1, relation, string2);

        // The example produces the following output:
        //    'brother' comes before 'Brother'.   
        //    'brother' is the same as 'Brother'.
        //    'brother' comes after 'Brother'.
    }
}

open System
open System.Globalization

let string1 = "brother"
let string2 = "Brother"

// Cultural (linguistic) comparison.
let result = String.Compare(string1, string2, CultureInfo "en-US", CompareOptions.None)
let relation =
    if result > 0 then "comes after"
    elif result = 0 then "is the same as"
    else "comes before"

printfn $"'{string1}' {relation} '{string2}'."

// Cultural (linguistic) case-insensitive comparison.
let result2 = String.Compare(string1, string2, CultureInfo "en-US", CompareOptions.IgnoreCase)
let relation2 =
    if result2 > 0 then "comes after"
    elif result2 = 0 then "is the same as"
    else "comes before"

printfn $"'{string1}' {relation2} '{string2}'."

// Culture-insensitive ordinal comparison.
let result3 = String.CompareOrdinal(string1, string2)
let relation3 =
    if result2 > 0 then "comes after"
    elif result2 = 0 then "is the same as"
    else "comes before"

printfn $"'{string1}' {relation} '{string2}'."

// The example produces the following output:
//    'brother' comes before 'Brother'.   
//    'brother' is the same as 'Brother'.
//    'brother' comes after 'Brother'.

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim string1 As String = "brother"
      Dim string2 As String = "Brother"
      Dim relation As String
      Dim result As Integer

      ' Cultural (linguistic) comparison.
      result = String.Compare(string1, string2, _
                              New CultureInfo("en-US"), CompareOptions.None)
      If result > 0 Then
         relation = "comes after"
      ElseIf result = 0 Then
         relation = "is the same as"
      Else
         relation = "comes before"
      End If
      Console.WriteLine("'{0}' {1} '{2}'.", string1, relation, string2)

      ' Cultural (linguistic) case-insensitive comparison.
      result = String.Compare(string1, string2, _
                              New CultureInfo("en-US"), CompareOptions.IgnoreCase)
      If result > 0 Then
         relation = "comes after"
      ElseIf result = 0 Then
         relation = "is the same as"
      Else
         relation = "comes before"
      End If
      Console.WriteLine("'{0}' {1} '{2}'.", string1, relation, string2)

      ' Culture-insensitive ordinal comparison.
      result = String.CompareOrdinal(string1, string2)
      If result > 0 Then
         relation = "comes after"
      ElseIf result = 0 Then
         relation = "is the same as"
      Else
         relation = "comes before"
      End If
      Console.WriteLine("'{0}' {1} '{2}'.", string1, relation, string2)
   End Sub
End Module
' The example produces the following output:
'    'brother' comes before 'Brother'.   
'    'brother' is the same as 'Brother'.
'    'brother' comes after 'Brother'.

Keterangan

Hati

Metode Compare(String, String, CultureInfo, CompareOptions) dirancang terutama untuk digunakan dalam operasi pengurutan atau alfabetisasi. Ini tidak boleh digunakan ketika tujuan utama panggilan metode adalah untuk menentukan apakah dua string setara (yaitu, ketika tujuan panggilan metode adalah untuk menguji nilai pengembalian nol). Untuk menentukan apakah dua string setara, panggil metode Equals.

Perbandingan dapat ditentukan lebih lanjut oleh parameter options, yang terdiri dari satu atau beberapa anggota enumerasi CompareOptions. Namun, karena tujuan dari metode ini adalah untuk melakukan perbandingan string yang sensitif terhadap budaya, nilai CompareOptions.Ordinal dan CompareOptions.OrdinalIgnoreCase tidak berpengaruh.

Baik atau kedua perbandingan dapat null. Menurut definisi, string apa pun, termasuk String.Empty, membandingkan lebih besar dari referensi null, dan dua referensi null dibandingkan satu sama lain.

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua string telah dibandingkan. Namun, jika dua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, string dengan karakter yang tersisa dianggap lebih besar.

Catatan Bagi Pemanggil

Set karakter termasuk karakter yang tidak dapat diabaikan, yang merupakan karakter yang tidak dipertimbangkan saat melakukan perbandingan linguistik atau peka budaya. Metode Compare(String, String, CultureInfo, CompareOptions) tidak mempertimbangkan karakter tersebut ketika melakukan perbandingan yang sensitif terhadap budaya. Untuk mengenali karakter yang tidak dapat diabaikan dalam perbandingan Anda, berikan nilai Ordinal atau OrdinalIgnoreCase untuk parameter options.

Lihat juga

Berlaku untuk

Compare(String, String, Boolean, CultureInfo)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan dua objek String tertentu, mengabaikan atau menghormati kasusnya, dan menggunakan informasi khusus budaya untuk memengaruhi perbandingan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, System::String ^ strB, bool ignoreCase, System::Globalization::CultureInfo ^ culture);

public static int Compare (string? strA, string? strB, bool ignoreCase, System.Globalization.CultureInfo? culture);

public static int Compare (string strA, string strB, bool ignoreCase, System.Globalization.CultureInfo culture);

static member Compare : string * string * bool * System.Globalization.CultureInfo -> int

Public Shared Function Compare (strA As String, strB As String, ignoreCase As Boolean, culture As CultureInfo) As Integer

Parameter

strA: String

String pertama yang akan dibandingkan.

strB: String

String kedua yang akan dibandingkan.

ignoreCase: Boolean

true mengabaikan kasus selama perbandingan; jika tidak, false.

culture: CultureInfo

Objek yang memasok informasi perbandingan khusus budaya. Jika culturenull, budaya saat ini digunakan.

Mengembalikan

Int32

Bilangan bulat bertanda tangan 32-bit yang menunjukkan hubungan leksikal antara dua perbandingan.

Nilai	Keadaan
Kurang dari nol	`strA` mendahului `strB` dalam urutan pengurutan.
Nol	`strA` terjadi dalam posisi yang sama dengan `strB` dalam urutan pengurutan.
Lebih besar dari nol	`strA` mengikuti `strB` dalam urutan pengurutan.

Contoh

Contoh berikut menunjukkan bagaimana budaya dapat memengaruhi perbandingan. Dalam budaya Ceko - Republik Ceko, "ch" adalah karakter tunggal yang lebih besar dari "d". Namun, dalam bahasa Inggris - budaya Amerika Serikat, "ch" terdiri dari dua karakter, dan "c" kurang dari "d".

using namespace System;
using namespace System::Globalization;
String^ symbol( int r )
{
   String^ s = "=";
   if ( r < 0 )
      s = "<";
   else
   if ( r > 0 )
      s = ">";


   return s;
}

int main()
{
   String^ str1 = "change";
   String^ str2 = "dollar";
   String^ relation = nullptr;
   relation = symbol( String::Compare( str1, str2, false, gcnew CultureInfo( "en-US" ) ) );
   Console::WriteLine( "For en-US: {0} {1} {2}", str1, relation, str2 );
   relation = symbol( String::Compare( str1, str2, false, gcnew CultureInfo( "cs-CZ" ) ) );
   Console::WriteLine( "For cs-CZ: {0} {1} {2}", str1, relation, str2 );
}

/*
This example produces the following results.
For en-US: change < dollar
For cs-CZ: change > dollar
*/

public static void Main()
{
    String str1 = "change";
    String str2 = "dollar";
    String relation;

    relation = symbol(String.Compare(str1, str2, false, new CultureInfo("en-US")));
    Console.WriteLine("For en-US: {0} {1} {2}", str1, relation, str2);

    relation = symbol(String.Compare(str1, str2, false, new CultureInfo("cs-CZ")));
    Console.WriteLine("For cs-CZ: {0} {1} {2}", str1, relation, str2);
}

private static String symbol(int r)
{
    String s = "=";
    if (r < 0) s = "<";
    else if (r > 0) s = ">";
    return s;
}

/*
This example produces the following results.
For en-US: change < dollar
For cs-CZ: change > dollar
*/

let symbol r =
    if r < 0 then "<"
    elif r > 0 then ">"
    else "="

let str1 = "change"
let str2 = "dollar"

let relation1 = 
    String.Compare(str1, str2, false, CultureInfo "en-US")
    |> symbol
printfn $"For en-US: {str1} {relation1} {str2}"

let relation2 = 
    String.Compare(str1, str2, false, CultureInfo "cs-CZ")
    |> symbol
printfn $"For cs-CZ: {str1} {relation2} {str2}"

(*
This example produces the following results.
For en-US: change < dollar
For cs-CZ: change > dollar
*)

Imports System.Globalization
 _

Class Sample
   Public Shared Sub Main()
      Dim str1 As [String] = "change"
      Dim str2 As [String] = "dollar"
      Dim relation As [String] = Nothing
      
      relation = symbol([String].Compare(str1, str2, False, New CultureInfo("en-US")))
      Console.WriteLine("For en-US: {0} {1} {2}", str1, relation, str2)
      
      relation = symbol([String].Compare(str1, str2, False, New CultureInfo("cs-CZ")))
      Console.WriteLine("For cs-CZ: {0} {1} {2}", str1, relation, str2)
   End Sub
   
   Private Shared Function symbol(r As Integer) As [String]
      Dim s As [String] = "="
      If r < 0 Then
         s = "<"
      Else
         If r > 0 Then
            s = ">"
         End If
      End If
      Return s
   End Function 'symbol
End Class
'
'This example produces the following results.
'For en-US: change < dollar
'For cs-CZ: change > dollar
'

Keterangan

Perbandingan dilakukan menggunakan aturan pengurutan kata. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions.

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua string telah dibandingkan. Namun, jika dua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, maka string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Bandingkan nama jalur dengan "file" menggunakan perbandingan ordinal. Kode yang benar untuk melakukan ini adalah sebagai berikut:

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, String, Boolean, CultureInfo) tidak mempertimbangkan karakter tersebut ketika melakukan perbandingan yang sensitif terhadap budaya. Misalnya, jika kode berikut dijalankan pada .NET Framework 4 atau yang lebih baru, perbandingan "hewan" yang tidak peka huruf besar/kecil dengan "Ani-mal" (menggunakan tanda hubung lunak, atau U+00AD) menggunakan budaya invarian menunjukkan bahwa kedua string tersebut setara.

  string s1 = "Ani\u00ADmal";
  string s2 = "animal";

  Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                  s1, s2, String.Compare(s1, s2, true,
                  CultureInfo.InvariantCulture));

  // The example displays the following output:
  //       Comparison of 'Ani-mal' and 'animal': 0

open System
open System.Globalization

let s1 = "Ani\u00ADmal"
let s2 = "animal"

printfn $"Comparison of '{s1}' and '{s2}': {String.Compare(s1, s2, true, CultureInfo.InvariantCulture)}"

// The example displays the following output:
//       Comparison of 'Ani-mal' and 'animal': 0

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim s1 As String = "Ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, s2, String.Compare(s1, s2, True,
                        CultureInfo.InvariantCulture))
  End Sub
End Module
' The example displays the following output:
'       Comparison of 'ani-mal' and 'animal': 0

Untuk mengenali karakter yang dapat diabaikan dalam perbandingan string, panggil metode Compare(String, String, CultureInfo, CompareOptions) dan berikan nilai baik Ordinal atau OrdinalIgnoreCase untuk parameter options.

Lihat juga

Berlaku untuk

Compare(String, String, StringComparison)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan dua objek String yang ditentukan menggunakan aturan yang ditentukan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, System::String ^ strB, StringComparison comparisonType);

public static int Compare (string strA, string strB, StringComparison comparisonType);

public static int Compare (string? strA, string? strB, StringComparison comparisonType);

static member Compare : string * string * StringComparison -> int

Public Shared Function Compare (strA As String, strB As String, comparisonType As StringComparison) As Integer

Parameter

strA: String

String pertama yang akan dibandingkan.

strB: String

String kedua yang akan dibandingkan.

comparisonType: StringComparison

Salah satu nilai enumerasi yang menentukan aturan yang akan digunakan dalam perbandingan.

Mengembalikan

Int32

Bilangan bulat bertanda tangan 32-bit yang menunjukkan hubungan leksikal antara dua perbandingan.

Nilai	Keadaan
Kurang dari nol	`strA` mendahului `strB` dalam urutan pengurutan.
Nol	`strA` berada dalam posisi yang sama dengan `strB` dalam urutan pengurutan.
Lebih besar dari nol	`strA` mengikuti `strB` dalam urutan pengurutan.

Pengecualian

ArgumentException

comparisonType bukan nilai StringComparison.

NotSupportedException

StringComparison tidak didukung.

Contoh

Contoh berikut membandingkan tiga versi huruf "I". Hasilnya dipengaruhi oleh pilihan budaya, apakah kasus diabaikan, dan apakah perbandingan ordinal dilakukan.

// This example demonstrates the
// System.String.Compare(String, String, StringComparison) method.

using namespace System;
using namespace System::Threading;

void Test(int testStringIndex, int searchStringIndex, 
          StringComparison comparison, array<String^>^ testI, 
          array<String^>^ testNames)
{
    String^ resultFormat = "{0} is {1} {2}";
    String^ resultString = "equal to";
    int comparisonValue = 0;

    comparisonValue = String::Compare(testI[testStringIndex],
        testI[searchStringIndex], comparison);
    if (comparisonValue < 0)
    {
        resultString = "less than";
    }
    else if (comparisonValue > 0)
    {
        resultString = "greater than";
    }
    Console::WriteLine(resultFormat, testNames[testStringIndex], resultString,
        testNames[searchStringIndex]);
}

int main()
{
    String^ introMessage =
        "Compare three versions of the letter I using different " +
        "values of StringComparison.";

    // Define an array of strings where each element contains a version of
    // the letter I. (An array of strings is used so you can easily modify
    // this code example to test additional or different combinations of
    // strings.)

    array<String^>^ letterVariation = gcnew array<String^>(3);
    // LATIN SMALL LETTER I (U+0069)
    letterVariation[0] = "i";
    // LATIN SMALL LETTER DOTLESS I (U+0131)
    letterVariation[1] = L"\u0131";
    // LATIN CAPITAL LETTER I (U+0049)
    letterVariation[2] = "I";

    array<String^>^ unicodeNames = {
        "LATIN SMALL LETTER I (U+0069)",
        "LATIN SMALL LETTER DOTLESS I (U+0131)",
        "LATIN CAPITAL LETTER I (U+0049)"};

    array<StringComparison>^ comparisonValues = {
        StringComparison::CurrentCulture,
        StringComparison::CurrentCultureIgnoreCase,
        StringComparison::InvariantCulture,
        StringComparison::InvariantCultureIgnoreCase,
        StringComparison::Ordinal,
        StringComparison::OrdinalIgnoreCase};

    Console::Clear();
    Console::WriteLine(introMessage);

    // Display the current culture because the culture-specific comparisons
    // can produce different results with different cultures.
    Console::WriteLine("The current culture is {0}.{1}",
        Thread::CurrentThread->CurrentCulture->Name, Environment::NewLine);

    // Determine the relative sort order of three versions of the letter I.
    for each (StringComparison stringCmp in comparisonValues)
    {
        Console::WriteLine("StringComparison.{0}:", stringCmp);

        // LATIN SMALL LETTER I (U+0069) : LATIN SMALL LETTER DOTLESS I
        // (U+0131)
        Test(0, 1, stringCmp, letterVariation, unicodeNames);

        // LATIN SMALL LETTER I (U+0069) : LATIN CAPITAL LETTER I (U+0049)
        Test(0, 2, stringCmp, letterVariation, unicodeNames);

        // LATIN SMALL LETTER DOTLESS I (U+0131) : LATIN CAPITAL LETTER I
        // (U+0049)
        Test(1, 2, stringCmp, letterVariation, unicodeNames);

        Console::WriteLine();
    }
}

/*
This code example produces the following results:

Compare three versions of the letter I using different values of 
StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER 
  DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN 
  CAPITAL LETTER I (U+0049)

StringComparison.CurrentCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER 
  DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN 
  CAPITAL LETTER I (U+0049)

StringComparison.InvariantCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER 
  DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN 
  CAPITAL LETTER I (U+0049)

StringComparison.InvariantCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER 
  DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN 
  CAPITAL LETTER I (U+0049)

StringComparison.Ordinal:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER 
  DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is greater than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN 
  CAPITAL LETTER I (U+0049)

StringComparison.OrdinalIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER 
  DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN 
  CAPITAL LETTER I (U+0049)

*/

// This example demonstrates the 
// System.String.Compare(String, String, StringComparison) method.

using System;
using System.Threading;

class Sample 
{
    public static void Main() 
    {
        string intro = "Compare three versions of the letter I using different " + 
                       "values of StringComparison.";

        // Define an array of strings where each element contains a version of the 
        // letter I. (An array of strings is used so you can easily modify this 
        // code example to test additional or different combinations of strings.)  

        string[] threeIs = new string[3];
        // LATIN SMALL LETTER I (U+0069)
        threeIs[0] = "\u0069";
        // LATIN SMALL LETTER DOTLESS I (U+0131)
        threeIs[1] = "\u0131";
        // LATIN CAPITAL LETTER I (U+0049)
        threeIs[2] = "\u0049";

        string[] unicodeNames = 
        {
            "LATIN SMALL LETTER I (U+0069)", 
            "LATIN SMALL LETTER DOTLESS I (U+0131)", 
            "LATIN CAPITAL LETTER I (U+0049)"
        };

        StringComparison[] scValues =
        {
            StringComparison.CurrentCulture,
            StringComparison.CurrentCultureIgnoreCase,
            StringComparison.InvariantCulture,
            StringComparison.InvariantCultureIgnoreCase,
            StringComparison.Ordinal,
            StringComparison.OrdinalIgnoreCase
        };

        Console.Clear();
        Console.WriteLine(intro);

        // Display the current culture because the culture-specific comparisons
        // can produce different results with different cultures.
        Console.WriteLine(
            "The current culture is {0}.\n", Thread.CurrentThread.CurrentCulture.Name);

        // Determine the relative sort order of three versions of the letter I. 
        foreach (StringComparison sc in scValues)
        {
            Console.WriteLine("StringComparison.{0}:", sc);

            // LATIN SMALL LETTER I (U+0069) : LATIN SMALL LETTER DOTLESS I (U+0131)
            Test(0, 1, sc, threeIs, unicodeNames);

            // LATIN SMALL LETTER I (U+0069) : LATIN CAPITAL LETTER I (U+0049)
            Test(0, 2, sc, threeIs, unicodeNames);

            // LATIN SMALL LETTER DOTLESS I (U+0131) : LATIN CAPITAL LETTER I (U+0049)
            Test(1, 2, sc, threeIs, unicodeNames);

            Console.WriteLine();
        }
    }

    protected static void Test(
        int x, int y, StringComparison comparison, string[] testI, string[] testNames)
    {
        string resultFmt = "{0} is {1} {2}";
        string result = "equal to";
        int cmpValue = 0;

        cmpValue = String.Compare(testI[x], testI[y], comparison);
        if (cmpValue < 0)
            result = "less than";
        else if (cmpValue > 0)
            result = "greater than";
        Console.WriteLine(resultFmt, testNames[x], result, testNames[y]);
    }
}

/*
This code example produces the following results:

Compare three versions of the letter I using different values of StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.CurrentCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.InvariantCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.InvariantCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.Ordinal:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is greater than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.OrdinalIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

*/

// This example demonstrates the 
// System.String.Compare(String, String, StringComparison) method.

open System
open System.Threading

let test x y (comparison: StringComparison) (testI: string[]) (testNames: string[]) =
    let cmpValue = String.Compare(testI[x], testI[y], comparison)
    let result =
        if cmpValue < 0 then
            "less than"
        elif cmpValue > 0 then
            "greater than"
        else
            "equal to"
    printfn $"{testNames[x]} is {result} {testNames[y]}"

let intro = "Compare three versions of the letter I using different values of StringComparison."

// Define an array of strings where each element contains a version of the 
// letter I. (An array of strings is used so you can easily modify this 
// code example to test additional or different combinations of strings.)  

let threeIs = 
  [|// LATIN SMALL LETTER I (U+0069)
    "\u0069"
    // LATIN SMALL LETTER DOTLESS I (U+0131)
    "\u0131"
    // LATIN CAPITAL LETTER I (U+0049)
    "\u0049" |]

let unicodeNames =
    [| "LATIN SMALL LETTER I (U+0069)"
       "LATIN SMALL LETTER DOTLESS I (U+0131)"
       "LATIN CAPITAL LETTER I (U+0049)" |]

let scValues =
    [| StringComparison.CurrentCulture
       StringComparison.CurrentCultureIgnoreCase
       StringComparison.InvariantCulture
       StringComparison.InvariantCultureIgnoreCase
       StringComparison.Ordinal
       StringComparison.OrdinalIgnoreCase |]

Console.Clear()
printfn $"{intro}"

// Display the current culture because the culture-specific comparisons
// can produce different results with different cultures.
printfn $"The current culture is {Thread.CurrentThread.CurrentCulture.Name}.\n"

// Determine the relative sort order of three versions of the letter I. 
for sc in scValues do
    printfn $"StringComparison.{sc}:"

    // LATIN SMALL LETTER I (U+0069) : LATIN SMALL LETTER DOTLESS I (U+0131)
    test 0 1 sc threeIs unicodeNames

    // LATIN SMALL LETTER I (U+0069) : LATIN CAPITAL LETTER I (U+0049)
    test 0 2 sc threeIs unicodeNames

    // LATIN SMALL LETTER DOTLESS I (U+0131) : LATIN CAPITAL LETTER I (U+0049)
    test 1 2 sc threeIs unicodeNames

    printfn ""

(*
This code example produces the following results:

Compare three versions of the letter I using different values of StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.CurrentCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.InvariantCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.InvariantCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.Ordinal:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is greater than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.OrdinalIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
*)

' This example demonstrates the 
' System.String.Compare(String, String, StringComparison) method.

Imports System.Threading

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Compare three versions of the letter I using different " & _
                              "values of StringComparison."
        
        ' Define an array of strings where each element contains a version of the 
        ' letter I. (An array of strings is used so you can easily modify this 
        ' code example to test additional or different combinations of strings.)  
        Dim threeIs(2) As String
        ' LATIN SMALL LETTER I (U+0069)
        threeIs(0) = "i"
        ' LATIN SMALL LETTER DOTLESS I (U+0131)
        threeIs(1) = "ı"
        ' LATIN CAPITAL LETTER I (U+0049)
        threeIs(2) = "I"
        
        Dim unicodeNames As String() =  { _
                            "LATIN SMALL LETTER I (U+0069)", _
                            "LATIN SMALL LETTER DOTLESS I (U+0131)", _
                            "LATIN CAPITAL LETTER I (U+0049)" }
        
        Dim scValues As StringComparison() =  { _
                            StringComparison.CurrentCulture, _
                            StringComparison.CurrentCultureIgnoreCase, _
                            StringComparison.InvariantCulture, _
                            StringComparison.InvariantCultureIgnoreCase, _
                            StringComparison.Ordinal, _
                            StringComparison.OrdinalIgnoreCase }
        '
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because the culture-specific comparisons
        ' can produce different results with different cultures.
        Console.WriteLine("The current culture is {0}." & vbCrLf, _
                           Thread.CurrentThread.CurrentCulture.Name)
        
        ' Determine the relative sort order of three versions of the letter I. 
        Dim sc As StringComparison
        For Each sc In  scValues
            Console.WriteLine("StringComparison.{0}:", sc)
            
            ' LATIN SMALL LETTER I (U+0069) : LATIN SMALL LETTER DOTLESS I (U+0131)
            Test(0, 1, sc, threeIs, unicodeNames)
            
            ' LATIN SMALL LETTER I (U+0069) : LATIN CAPITAL LETTER I (U+0049)
            Test(0, 2, sc, threeIs, unicodeNames)
            
            ' LATIN SMALL LETTER DOTLESS I (U+0131) : LATIN CAPITAL LETTER I (U+0049)
            Test(1, 2, sc, threeIs, unicodeNames)
            
            Console.WriteLine()
        Next sc
    
    End Sub
    
    Protected Shared Sub Test(ByVal x As Integer, ByVal y As Integer, _
                              ByVal comparison As StringComparison, _
                              ByVal testI() As String, ByVal testNames() As String) 
        Dim resultFmt As String = "{0} is {1} {2}"
        Dim result As String = "equal to"
        Dim cmpValue As Integer = 0
        '
        cmpValue = String.Compare(testI(x), testI(y), comparison)
        If cmpValue < 0 Then
            result = "less than"
        ElseIf cmpValue > 0 Then
            result = "greater than"
        End If
        Console.WriteLine(resultFmt, testNames(x), result, testNames(y))
    
    End Sub
End Class

'
'This code example produces the following results:
'
'Compare three versions of the letter I using different values of StringComparison.
'The current culture is en-US.
'
'StringComparison.CurrentCulture:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.CurrentCultureIgnoreCase:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.InvariantCulture:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.InvariantCultureIgnoreCase:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.Ordinal:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is greater than LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.OrdinalIgnoreCase:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'

Keterangan

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua string telah dibandingkan. Namun, jika kedua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Bandingkan nama jalur dengan "file" menggunakan perbandingan ordinal. Kode yang benar untuk melakukan ini adalah sebagai berikut:

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, String, StringComparison) tidak mempertimbangkan karakter tersebut ketika melakukan perbandingan yang sensitif terhadap budaya. Untuk mengenali karakter yang tidak dapat diabaikan dalam perbandingan Anda, berikan nilai Ordinal atau OrdinalIgnoreCase untuk parameter comparisonType.

Lihat juga

Berlaku untuk

Compare(String, String, Boolean)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan dua objek String yang ditentukan, mengabaikan atau menghormati kasusnya, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, System::String ^ strB, bool ignoreCase);

public static int Compare (string strA, string strB, bool ignoreCase);

public static int Compare (string? strA, string? strB, bool ignoreCase);

static member Compare : string * string * bool -> int

Public Shared Function Compare (strA As String, strB As String, ignoreCase As Boolean) As Integer

Parameter

strA: String

String pertama yang akan dibandingkan.

strB: String

String kedua yang akan dibandingkan.

ignoreCase: Boolean

true mengabaikan kasus selama perbandingan; jika tidak, false.

Mengembalikan

Int32

Bilangan bulat bertanda tangan 32-bit yang menunjukkan hubungan leksikal antara dua perbandingan.

Nilai	Keadaan
Kurang dari nol	`strA` mendahului `strB` dalam urutan pengurutan.
Nol	`strA` terjadi dalam posisi yang sama dengan `strB` dalam urutan pengurutan.
Lebih besar dari nol	`strA` mengikuti `strB` dalam urutan pengurutan.

Contoh

Contoh berikut menunjukkan bahwa metode Compare(String, String, Boolean) setara dengan menggunakan ToUpper atau ToLower saat membandingkan string.

using namespace System;

void main()
{
   // Create upper-case characters from their Unicode code units.
   String^ stringUpper = "\x0041\x0042\x0043";

   // Create lower-case characters from their Unicode code units.
   String^ stringLower = "\x0061\x0062\x0063";

   // Display the strings.
   Console::WriteLine("Comparing '{0}' and '{1}':", 
                      stringUpper, stringLower);

   // Compare the uppercased strings; the result is true.
   Console::WriteLine("The Strings are equal when capitalized? {0}",
                      String::Compare(stringUpper->ToUpper(), stringLower->ToUpper()) == 0 
                                      ? "true" : "false");

   // The previous method call is equivalent to this Compare method, which ignores case.
   Console::WriteLine("The Strings are equal when case is ignored? {0}",
                      String::Compare(stringUpper, stringLower, true) == 0
                                      ? "true" : "false");
}
// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

// Create upper-case characters from their Unicode code units.
String stringUpper = "\x0041\x0042\x0043";

// Create lower-case characters from their Unicode code units.
String stringLower = "\x0061\x0062\x0063";

// Display the strings.
Console.WriteLine("Comparing '{0}' and '{1}':", 
                stringUpper, stringLower);

// Compare the uppercased strings; the result is true.
Console.WriteLine("The Strings are equal when capitalized? {0}",
                String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) == 0 
                               ? "true" : "false");

// The previous method call is equivalent to this Compare method, which ignores case.
Console.WriteLine("The Strings are equal when case is ignored? {0}",
                String.Compare(stringUpper, stringLower, true) == 0
                               ? "true" : "false" );

// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

open System

// Create upper-case characters from their Unicode code units.
let stringUpper = "\x0041\x0042\x0043"

// Create lower-case characters from their Unicode code units.
let stringLower = "\x0061\x0062\x0063"

// Display the strings.
printfn $"Comparing '{stringUpper}' and '{stringLower}':"

// Compare the uppercased strings the result is true.
printfn $"The Strings are equal when capitalized? %b{String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) = 0}"

// The previous method call is equivalent to this Compare method, which ignores case.
printfn $"The Strings are equal when case is ignored? %b{String.Compare(stringUpper, stringLower, true) = 0}"

// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

Public Module Example
   Public Sub Main()
      ' Create upper-case characters from their Unicode code units.
      Dim stringUpper As String = ChrW(&H41) + ChrW(&H42) + ChrW(&H43)

      ' Create lower-case characters from their Unicode code units.
      Dim stringLower As String = ChrW(&H61) + ChrW(&H62) + ChrW(&H63)

      ' Display the strings.
      Console.WriteLine("Comparing '{0}' and '{1}':", 
                        stringUpper, stringLower)

      ' Compare the uppercased strings; the result is true.
      Console.WriteLine("The Strings are equal when capitalized? {0}",
                        If(String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) = 0, 
                                          "true", "false"))

      ' The previous method call is equivalent to this Compare method, which ignores case.
      Console.WriteLine("The Strings are equal when case is ignored? {0}",
                        If(String.Compare(stringUpper, stringLower, true) = 0,
                                          "true", "false"))
   End Sub
End Module 
' The example displays the following output:
'       Comparing 'ABC' and 'abc':
'       The Strings are equal when capitalized? true
'       The Strings are equal when case is ignored? true

Keterangan

Perbandingan dilakukan menggunakan aturan pengurutan kata. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions.

Peringatan

Saat membandingkan string, Anda harus memanggil metode Compare(String, String, StringComparison), yang mengharuskan Anda secara eksplisit menentukan jenis perbandingan string yang digunakan metode. Untuk informasi selengkapnya, lihat Praktik Terbaik untuk Menggunakan String.

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua string telah dibandingkan. Namun, jika dua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, maka string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Bandingkan nama jalur dengan "file" menggunakan perbandingan ordinal. Kode yang benar untuk melakukan ini adalah sebagai berikut:

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, String, Boolean) tidak mempertimbangkan karakter tersebut ketika melakukan perbandingan yang sensitif terhadap budaya. Misalnya, perbandingan "hewan" yang peka terhadap budaya dan tidak peka huruf besar/kecil dengan "Ani-mal" (menggunakan tanda hubung lunak, atau U+00AD) menunjukkan bahwa kedua string tersebut setara.

string s1 = "Ani\u00ADmal";
string s2 = "animal";

Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
                s1, s2, String.Compare(s1, s2, true));

// The example displays the following output:
//       Comparison of 'Ani-mal' and 'animal': 0

open System

let s1 = "Ani\u00ADmal"
let s2 = "animal"

printfn $"Comparison of '{s1}' and '{s2}': {String.Compare(s1, s2, true)}"

// The example displays the following output:
//       Comparison of 'Ani-mal' and 'animal': 0

Module Example
   Public Sub Main()
      Dim s1 As String = "Ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, s2, String.Compare(s1, s2, True))
  End Sub
End Module
' The example displays the following output:
'       Comparison of 'ani-mal' and 'animal': 0

Untuk mengenali karakter yang dapat diabaikan dalam perbandingan string, panggil metode Compare(String, String, StringComparison) dan berikan nilai baik Ordinal atau OrdinalIgnoreCase untuk parameter comparisonType.

Lihat juga

Berlaku untuk

Compare(String, String)

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Sumber:: String.Comparison.cs

Membandingkan dua objek String yang ditentukan dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.

public:
 static int Compare(System::String ^ strA, System::String ^ strB);

public static int Compare (string strA, string strB);

public static int Compare (string? strA, string? strB);

static member Compare : string * string -> int

Public Shared Function Compare (strA As String, strB As String) As Integer

Parameter

strA: String

String pertama yang akan dibandingkan.

strB: String

String kedua yang akan dibandingkan.

Mengembalikan

Int32

Bilangan bulat bertanda tangan 32-bit yang menunjukkan hubungan leksikal antara dua perbandingan.

Nilai	Keadaan
Kurang dari nol	`strA` mendahului `strB` dalam urutan pengurutan.
Nol	`strA` terjadi dalam posisi yang sama dengan `strB` dalam urutan pengurutan.
Lebih besar dari nol	`strA` mengikuti `strB` dalam urutan pengurutan.

Contoh

Contoh berikut memanggil metode Compare(String, String) untuk membandingkan tiga set string.

using namespace System;

void main()
{
   // Create upper-case characters from their Unicode code units.
   String^ stringUpper = "\x0041\x0042\x0043";

   // Create lower-case characters from their Unicode code units.
   String^ stringLower = "\x0061\x0062\x0063";

   // Display the strings.
   Console::WriteLine("Comparing '{0}' and '{1}':", 
                      stringUpper, stringLower);

   // Compare the uppercased strings; the result is true.
   Console::WriteLine("The Strings are equal when capitalized? {0}",
                      String::Compare(stringUpper->ToUpper(), stringLower->ToUpper()) == 0 
                                      ? "true" : "false");

   // The previous method call is equivalent to this Compare method, which ignores case.
   Console::WriteLine("The Strings are equal when case is ignored? {0}",
                      String::Compare(stringUpper, stringLower, true) == 0
                                      ? "true" : "false");
}
// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

// Create upper-case characters from their Unicode code units.
String stringUpper = "\x0041\x0042\x0043";

// Create lower-case characters from their Unicode code units.
String stringLower = "\x0061\x0062\x0063";

// Display the strings.
Console.WriteLine("Comparing '{0}' and '{1}':", 
                stringUpper, stringLower);

// Compare the uppercased strings; the result is true.
Console.WriteLine("The Strings are equal when capitalized? {0}",
                String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) == 0 
                               ? "true" : "false");

// The previous method call is equivalent to this Compare method, which ignores case.
Console.WriteLine("The Strings are equal when case is ignored? {0}",
                String.Compare(stringUpper, stringLower, true) == 0
                               ? "true" : "false" );

// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

open System

// Create upper-case characters from their Unicode code units.
let stringUpper = "\x0041\x0042\x0043"

// Create lower-case characters from their Unicode code units.
let stringLower = "\x0061\x0062\x0063"

// Display the strings.
printfn $"Comparing '{stringUpper}' and '{stringLower}':"

// Compare the uppercased strings the result is true.
printfn $"The Strings are equal when capitalized? %b{String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) = 0}"

// The previous method call is equivalent to this Compare method, which ignores case.
printfn $"The Strings are equal when case is ignored? %b{String.Compare(stringUpper, stringLower, true) = 0}"

// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

Public Module Example
   Public Sub Main()
      ' Create upper-case characters from their Unicode code units.
      Dim stringUpper As String = ChrW(&H41) + ChrW(&H42) + ChrW(&H43)

      ' Create lower-case characters from their Unicode code units.
      Dim stringLower As String = ChrW(&H61) + ChrW(&H62) + ChrW(&H63)

      ' Display the strings.
      Console.WriteLine("Comparing '{0}' and '{1}':", 
                        stringUpper, stringLower)

      ' Compare the uppercased strings; the result is true.
      Console.WriteLine("The Strings are equal when capitalized? {0}",
                        If(String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) = 0, 
                                          "true", "false"))

      ' The previous method call is equivalent to this Compare method, which ignores case.
      Console.WriteLine("The Strings are equal when case is ignored? {0}",
                        If(String.Compare(stringUpper, stringLower, true) = 0,
                                          "true", "false"))
   End Sub
End Module 
' The example displays the following output:
'       Comparing 'ABC' and 'abc':
'       The Strings are equal when capitalized? true
'       The Strings are equal when case is ignored? true

Dalam contoh berikut, kelas ReverseStringComparer menunjukkan bagaimana Anda dapat mengevaluasi dua string dengan metode Compare.

using namespace System;
using namespace System::Text;
using namespace System::Collections;

ref class ReverseStringComparer: public IComparer
{
public:
   virtual int Compare( Object^ x, Object^ y )
   {
      String^ s1 = dynamic_cast<String^>(x);
      String^ s2 = dynamic_cast<String^>(y);

      //negate the return value to get the reverse order
      return  -String::Compare( s1, s2 );
   }

};

void PrintValues( String^ title, IEnumerable^ myList )
{
   Console::Write( "{0,10}: ", title );
   StringBuilder^ sb = gcnew StringBuilder;
   {
      IEnumerator^ en = myList->GetEnumerator();
      String^ s;
      while ( en->MoveNext() )
      {
         s = en->Current->ToString();
         sb->AppendFormat(  "{0}, ", s );
      }
   }
   sb->Remove( sb->Length - 2, 2 );
   Console::WriteLine( sb );
}

void main()
{
   // Creates and initializes a new ArrayList.
   ArrayList^ myAL = gcnew ArrayList;
   myAL->Add( "Eric" );
   myAL->Add( "Mark" );
   myAL->Add( "Lance" );
   myAL->Add( "Rob" );
   myAL->Add( "Kris" );
   myAL->Add( "Brad" );
   myAL->Add( "Kit" );
   myAL->Add( "Bradley" );
   myAL->Add( "Keith" );
   myAL->Add( "Susan" );

   // Displays the properties and values of the ArrayList.
   Console::WriteLine( "Count: {0}", myAL->Count.ToString() );

   PrintValues( "Unsorted", myAL );

   myAL->Sort();
   PrintValues( "Sorted", myAL );

   myAL->Sort( gcnew ReverseStringComparer );
   PrintValues( "Reverse", myAL );

   array<String^>^names = dynamic_cast<array<String^>^>(myAL->ToArray( String::typeid ));
}

using System;
using System.Text;
using System.Collections;

public class SamplesArrayList
{

    public static void Main()
    {
        // Creates and initializes a new ArrayList.
        ArrayList myAL = new ArrayList();
        myAL.Add("Eric");
        myAL.Add("Mark");
        myAL.Add("Lance");
        myAL.Add("Rob");
        myAL.Add("Kris");
        myAL.Add("Brad");
        myAL.Add("Kit");
        myAL.Add("Bradley");
        myAL.Add("Keith");
        myAL.Add("Susan");

        // Displays the properties and values of	the	ArrayList.
        Console.WriteLine("Count: {0}", myAL.Count);

        PrintValues("Unsorted", myAL);
        myAL.Sort();
        PrintValues("Sorted", myAL);
        myAL.Sort(new ReverseStringComparer());
        PrintValues("Reverse", myAL);

        string[] names = (string[])myAL.ToArray(typeof(string));
    }
    public static void PrintValues(string title, IEnumerable myList)
    {
        Console.Write("{0,10}: ", title);
        StringBuilder sb = new StringBuilder();
        foreach (string s in myList)
        {
            sb.AppendFormat("{0}, ", s);
        }
        sb.Remove(sb.Length - 2, 2);
        Console.WriteLine(sb);
    }
}
public class ReverseStringComparer : IComparer
{
    public int Compare(object? x, object? y)
    {
        string? s1 = x as string;
        string? s2 = y as string;
        //negate the return value to get the reverse order
        return -String.Compare(s1, s2);
    }
}

open System
open System.Text
open System.Collections.Generic

type ReverseStringComparer() =
    interface IComparer<string> with
        member _.Compare(x, y) =
            -String.Compare(x, y)

let printValues title (myList: #seq<string>) =
    printf $"{title,10}: "
    let sb = StringBuilder()
    for s in myList do
        sb.Append $"{s}, " |> ignore
    sb.Remove(sb.Length - 2, 2) |> ignore
    printfn $"{sb}"

// Creates and initializes a new ResizeArray.
let myAL = ResizeArray()
myAL.Add "Eric"
myAL.Add "Mark"
myAL.Add "Lance"
myAL.Add "Rob"
myAL.Add "Kris"
myAL.Add "Brad"
myAL.Add "Kit"
myAL.Add "Bradley"
myAL.Add "Keith"
myAL.Add "Susan"

// Displays the properties and values of	the	ArrayList.
printfn $"Count: {myAL.Count}"

printValues "Unsorted" myAL
myAL.Sort()
printValues "Sorted" myAL
myAL.Sort(ReverseStringComparer())
printValues "Reverse" myAL

Imports System.Text
Imports System.Collections



Public Class SamplesArrayList
    
    
    Public Shared Sub Main()
        Dim myAL As New ArrayList()
        ' Creates and initializes a new ArrayList.
        myAL.Add("Eric")
        myAL.Add("Mark")
        myAL.Add("Lance")
        myAL.Add("Rob")
        myAL.Add("Kris")
        myAL.Add("Brad")
        myAL.Add("Kit")
        myAL.Add("Bradley")
        myAL.Add("Keith")
        myAL.Add("Susan")
        
        ' Displays the properties and values of	the	ArrayList.
        Console.WriteLine("Count: {0}", myAL.Count)
        PrintValues("Unsorted", myAL)
        myAL.Sort()
        PrintValues("Sorted", myAL)
        Dim comp as New ReverseStringComparer
        myAL.Sort(comp)
        PrintValues("Reverse", myAL)

        Dim names As String() = CType(myAL.ToArray(GetType(String)), String())
    End Sub
   
   
    
    Public Shared Sub PrintValues(title As String, myList As IEnumerable)
        Console.Write("{0,10}: ", title)
        Dim sb As New StringBuilder()
        Dim s As String
        For Each s In  myList
            sb.AppendFormat("{0}, ", s)
        Next s
        sb.Remove(sb.Length - 2, 2)
        Console.WriteLine(sb)
    End Sub
End Class

Public Class ReverseStringComparer 
  Implements IComparer
    
     Function Compare(x As Object, y As Object) As Integer implements IComparer.Compare
        Dim s1 As String = CStr (x)
        Dim s2 As String = CStr (y)
        
        'negate the return value to get the reverse order
        Return - [String].Compare(s1, s2)
    
    End Function 'Compare
End Class

Keterangan

Perbandingan dilakukan menggunakan aturan pengurutan kata. Untuk informasi selengkapnya tentang pengurutan kata, string, dan ordinal, lihat System.Globalization.CompareOptions.

Peringatan

Perbandingan berakhir ketika ketidaksamaan ditemukan atau kedua string telah dibandingkan. Namun, jika dua string dibandingkan dengan akhir satu string, dan string lainnya memiliki karakter yang tersisa, maka string dengan karakter yang tersisa dianggap lebih besar. Nilai yang dikembalikan adalah hasil dari perbandingan terakhir yang dilakukan.

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Bandingkan nama jalur dengan "file" menggunakan perbandingan ordinal. Kode yang benar untuk melakukan ini adalah sebagai berikut:

static bool IsFileURI(String^ path)
{
    return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Catatan Bagi Pemanggil

Set karakter mencakup karakter yang dapat diabaikan. Metode Compare(String, String) tidak mempertimbangkan karakter tersebut ketika melakukan perbandingan yang sensitif terhadap budaya. Misalnya, jika kode berikut dijalankan pada .NET Framework 4 atau yang lebih baru, perbandingan "hewan" yang sensitif terhadap budaya dengan "ani-mal" (menggunakan tanda hubung lunak, atau U+00AD) menunjukkan bahwa kedua string tersebut setara.

string s1 = "ani\u00ADmal";
string s2 = "animal";

Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
                s1, s2, String.Compare(s1, s2));

// The example displays the following output:
//       Comparison of 'ani-mal' and 'animal': 0

open System

let s1 = "ani\u00ADmal"
let s2 = "animal"

printfn $"Comparison of '{s1}' and '{s2}': {String.Compare(s1, s2)}"

// The example displays the following output:
//       Comparison of 'ani-mal' and 'animal': 0

Module Example
   Public Sub Main()
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, s2, String.Compare(s1, s2))
  End Sub
End Module
' The example displays the following output:
'       Comparison of 'ani-mal' and 'animal': 0

Lihat juga

Berlaku untuk

Bagikan melalui

String.Compare Metode

Definisi

Overload

Keterangan

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Compare(String, Int32, String, Int32, Int32, StringComparison)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Compare(String, Int32, String, Int32, Int32, Boolean)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Compare(String, Int32, String, Int32, Int32)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Compare(String, String, CultureInfo, CompareOptions)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Compare(String, String, Boolean, CultureInfo)

Parameter

Mengembalikan

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Compare(String, String, StringComparison)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Compare(String, String, Boolean)

Parameter

Mengembalikan

Contoh