String.IndexOf 方法
定義
重要
部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。
報告該實例中指定 Unicode 字元或字串首次出現的零為基礎索引。 如果在此實例中找不到該字元或字串，該方法會回傳 -1。
多載
IndexOf(Char, Int32, StringComparison)
public:
int IndexOf(char value, int startIndex, StringComparison comparisonType);public int IndexOf(char value, int startIndex, StringComparison comparisonType);member this.IndexOf : char * int * StringComparison -> intPublic Function IndexOf (value As Char, startIndex As Integer, comparisonType As StringComparison) As Integer參數
- value
- Char
- startIndex
- Int32
- comparisonType
- StringComparison
傳回
適用於
IndexOf(Rune, Int32, Int32, StringComparison)
public:
int IndexOf(System::Text::Rune value, int startIndex, int count, StringComparison comparisonType);public int IndexOf(System.Text.Rune value, int startIndex, int count, StringComparison comparisonType);member this.IndexOf : System.Text.Rune * int * int * StringComparison -> intPublic Function IndexOf (value As Rune, startIndex As Integer, count As Integer, comparisonType As StringComparison) As Integer參數
- value
- Rune
- startIndex
- Int32
- count
- Int32
- comparisonType
- StringComparison
傳回
適用於
IndexOf(String, Int32, Int32, StringComparison)
報告指定字串首次出現於當前 String 物件的零為基礎索引。 參數會指定當前字串的起始搜尋位置、目前字串中可搜尋的字元數，以及該字串所要使用的搜尋類型。
public:
int IndexOf(System::String ^ value, int startIndex, int count, StringComparison comparisonType);public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType);member this.IndexOf : string * int * int * StringComparison -> intPublic Function IndexOf (value As String, startIndex As Integer, count As Integer, comparisonType As StringComparison) As Integer參數
- value
- String
那條線要尋找。
- startIndex
- Int32
搜尋起始位置。
- count
- Int32
要檢視的字元位置數目。
- comparisonType
- StringComparison
這是列舉值之一，用來指定搜尋的規則。
傳回
如果找到該字串，則以參數從當前實例起點的 value 零為基礎索引位置;若找不到則為 -1。 若 value ， Empty則返回值為 startIndex。
例外狀況
value 為 null。
count 或 startIndex 是陰性。
-或-
startIndex 大於此實例的長度。
-或-
count 大於此字串長度減 startIndex去 。
comparisonType 不是一個有效的 StringComparison 值。
範例
以下範例展示了三種方法的超載 IndexOf ，分別是利用不同列舉值 StringComparison 在另一個字串中首次出現字串。
// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.
using System;
using System.Threading;
using System.Globalization;
class Sample
{
public static void Main()
{
string intro = "Find the first occurrence of a character using different " +
"values of StringComparison.";
string resultFmt = "Comparison: {0,-28} Location: {1,3}";
// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
string CapitalAWithRing = "\u00c5";
// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
string cat = "A Cheshire c" + "\u0061\u030a" + "t";
int loc = 0;
StringComparison[] scValues = {
StringComparison.CurrentCulture,
StringComparison.CurrentCultureIgnoreCase,
StringComparison.InvariantCulture,
StringComparison.InvariantCultureIgnoreCase,
StringComparison.Ordinal,
StringComparison.OrdinalIgnoreCase };
// Clear the screen and display an introduction.
Console.Clear();
Console.WriteLine(intro);
// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Console.WriteLine("The current culture is \"{0}\" - {1}.",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentCulture.DisplayName);
// Display the string to search for and the string to search.
Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"",
CapitalAWithRing, cat);
Console.WriteLine();
// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.
Console.WriteLine("Part 1: Start index and count are specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
Console.WriteLine(resultFmt, sc, loc);
}
// Search using different values of StringComparison. Specify the
// start index.
Console.WriteLine("\nPart 2: Start index is specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, 0, sc);
Console.WriteLine(resultFmt, sc, loc);
}
// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, sc);
Console.WriteLine(resultFmt, sc, loc);
}
}
}
/*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).
This code example produces the following results:
Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"
Part 1: Start index and count are specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 2: Start index is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
*/
// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.
open System
open System.Threading
open System.Globalization
let intro = "Find the first occurrence of a character using different values of StringComparison."
// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
let CapitalAWithRing = "\u00c5"
// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
let cat = "A Cheshire c" + "\u0061\u030a" + "t"
let scValues =
[| StringComparison.CurrentCulture
StringComparison.CurrentCultureIgnoreCase
StringComparison.InvariantCulture
StringComparison.InvariantCultureIgnoreCase
StringComparison.Ordinal
StringComparison.OrdinalIgnoreCase |]
// Clear the screen and display an introduction.
Console.Clear()
printfn $"{intro}"
// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"The current culture is \"{Thread.CurrentThread.CurrentCulture.Name}\" - {Thread.CurrentThread.CurrentCulture.DisplayName}."
// Display the string to search for and the string to search.
printfn $"Search for the string \"{CapitalAWithRing}\" in the string \"{cat}\"\n"
// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.
printfn "Part 1: Start index and count are specified."
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
printfn $"Comparison: {sc,-28} Location: {loc,3}"
// Search using different values of StringComparison. Specify the
// start index.
printfn "\nPart 2: Start index is specified."
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, 0, sc)
printfn $"Comparison: {sc,-28} Location: {loc,3}"
// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.")
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, sc)
Console.WriteLine("Comparison: {0,-28} Location: {1,3}", sc, loc)
(*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).
This code example produces the following results:
Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"
Part 1: Start index and count are specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 2: Start index is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
*)
' This code example demonstrates the
' System.String.IndexOf(String, ..., StringComparison) methods.
Imports System.Threading
Imports System.Globalization
Class Sample
Public Shared Sub Main()
Dim intro As String = "Find the first occurrence of a character using different " & _
"values of StringComparison."
Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
' Define a string to search for.
' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
Dim CapitalAWithRing As String = "Å"
' Define a string to search.
' The result of combining the characters LATIN SMALL LETTER A and COMBINING
' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
Dim cat As String = "A Cheshire c" & "å" & "t"
Dim loc As Integer = 0
Dim scValues As StringComparison() = { _
StringComparison.CurrentCulture, _
StringComparison.CurrentCultureIgnoreCase, _
StringComparison.InvariantCulture, _
StringComparison.InvariantCultureIgnoreCase, _
StringComparison.Ordinal, _
StringComparison.OrdinalIgnoreCase }
Dim sc As StringComparison
' Clear the screen and display an introduction.
Console.Clear()
Console.WriteLine(intro)
' Display the current culture because culture affects the result. For example,
' try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
Console.WriteLine("The current culture is ""{0}"" - {1}.", _
Thread.CurrentThread.CurrentCulture.Name, _
Thread.CurrentThread.CurrentCulture.DisplayName)
' Display the string to search for and the string to search.
Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
CapitalAWithRing, cat)
Console.WriteLine()
' Note that in each of the following searches, we look for
' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
' the string was not found.
' Search using different values of StringComparison. Specify the start
' index and count.
Console.WriteLine("Part 1: Start index and count are specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
' Search using different values of StringComparison. Specify the
' start index.
Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, 0, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
' Search using different values of StringComparison.
Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
End Sub
End Class
'
'Note: This code example was executed on a console whose user interface
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
備註
索引編號從 0（零）開始。
startIndex參數範圍可從 0 到 字串實例的長度。
搜尋從 開始 startIndex ，持續到 startIndex + count -1。 搜尋中未包含字元 at startIndex + count 。
該 comparisonType 參數指定使用當前或不變文化、大小寫區分或非區分大小寫的搜尋，以及單字或序數比較規則來搜尋該 value 參數。
給呼叫者的注意事項
字元集包含可忽略的字元，這些字元在進行語言或文化敏感比較時未被考慮。 在文化敏感搜尋中（ comparisonType 即如果不是 Ordinal 或 OrdinalIgnoreCase），如果 value 包含可忽略的字元，結果等同於移除該字元後搜尋。 若 value 僅包含一個或多個可忽略字元， IndexOf(String, Int32, Int32, StringComparison) 該方法總是回傳 startIndex，即搜尋開始的字元位置。
以下範例中，此 IndexOf(String, Int32, Int32, StringComparison) 方法用於尋找軟連字號（U+00AD）後接從兩字串第三至第六位開始的「m」的位置。 只有一個字串包含所需的子字串。 若範例在 .NET Framework 4 或更新版本上執行，兩者皆因軟連字號可忽略，方法在進行文化敏感比較時回傳字串中「m」的索引。 然而，當它執行序數比較時，只在第一串中找到該子字串。 請注意，在第一個字串中，包含軟連字號後接「m」，方法在進行文化敏感比較時，無法回傳軟連字號的索引，而是回傳「m」的索引。 該方法僅在進行序數比較時回傳第一字串軟連字號的索引。
using System;
public class Example
{
public static void Main()
{
string searchString = "\u00ADm";
string s1 = "ani\u00ADmal" ;
string s2 = "animal";
Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture));
Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.Ordinal));
Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture));
Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.Ordinal));
// The example displays the following output:
// 4
// 3
// 3
// -1
}
}
open System
let searchString = "\u00ADm"
let s1 = "ani\u00ADmal"
let s2 = "animal"
printfn $"{s1.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture)}"
printfn $"{s1.IndexOf(searchString, 2, 4, StringComparison.Ordinal)}"
printfn $"{s2.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture)}"
printfn $"{s2.IndexOf(searchString, 2, 4, StringComparison.Ordinal)}"
// The example displays the following output:
// 4
// 3
// 3
// -1
Module Example
Public Sub Main()
Dim searchString As String = Chrw(&h00AD) + "m"
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture))
Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.Ordinal))
Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture))
Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.Ordinal))
End Sub
End Module
' The example displays the following output:
' 4
' 3
' 3
' -1
適用於
IndexOf(Char, Int32, Int32, StringComparison)
public:
int IndexOf(char value, int startIndex, int count, StringComparison comparisonType);public int IndexOf(char value, int startIndex, int count, StringComparison comparisonType);member this.IndexOf : char * int * int * StringComparison -> intPublic Function IndexOf (value As Char, startIndex As Integer, count As Integer, comparisonType As StringComparison) As Integer參數
- value
- Char
- startIndex
- Int32
- count
- Int32
- comparisonType
- StringComparison
傳回
適用於
IndexOf(Rune, Int32, StringComparison)
public:
int IndexOf(System::Text::Rune value, int startIndex, StringComparison comparisonType);public int IndexOf(System.Text.Rune value, int startIndex, StringComparison comparisonType);member this.IndexOf : System.Text.Rune * int * StringComparison -> intPublic Function IndexOf (value As Rune, startIndex As Integer, comparisonType As StringComparison) As Integer參數
- value
- Rune
- startIndex
- Int32
- comparisonType
- StringComparison
傳回
適用於
IndexOf(Rune, Int32, Int32)
public:
int IndexOf(System::Text::Rune value, int startIndex, int count);public int IndexOf(System.Text.Rune value, int startIndex, int count);member this.IndexOf : System.Text.Rune * int * int -> intPublic Function IndexOf (value As Rune, startIndex As Integer, count As Integer) As Integer參數
- value
- Rune
- startIndex
- Int32
- count
- Int32
傳回
適用於
IndexOf(String, Int32, StringComparison)
報告指定字串首次出現於當前 String 物件的零為基礎索引。 參數指定當前字串的起始搜尋位置及指定字串所用的搜尋類型。
public:
int IndexOf(System::String ^ value, int startIndex, StringComparison comparisonType);public int IndexOf(string value, int startIndex, StringComparison comparisonType);member this.IndexOf : string * int * StringComparison -> intPublic Function IndexOf (value As String, startIndex As Integer, comparisonType As StringComparison) As Integer參數
- value
- String
那條線要尋找。
- startIndex
- Int32
搜尋起始位置。
- comparisonType
- StringComparison
這是列舉值之一，用來指定搜尋的規則。
傳回
如果找到該字串，則以參數從當前實例起點的 value 零為基礎索引位置;若找不到則為 -1。 若 value ， Empty則返回值為 startIndex。
例外狀況
value 為 null。
startIndex 小於0（零）或大於此字串的長度。
comparisonType 不是一個有效的 StringComparison 值。
範例
以下範例展示了三種方法的超載 IndexOf ，分別是利用不同列舉值 StringComparison 在另一個字串中首次出現字串。
// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.
using System;
using System.Threading;
using System.Globalization;
class Sample
{
public static void Main()
{
string intro = "Find the first occurrence of a character using different " +
"values of StringComparison.";
string resultFmt = "Comparison: {0,-28} Location: {1,3}";
// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
string CapitalAWithRing = "\u00c5";
// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
string cat = "A Cheshire c" + "\u0061\u030a" + "t";
int loc = 0;
StringComparison[] scValues = {
StringComparison.CurrentCulture,
StringComparison.CurrentCultureIgnoreCase,
StringComparison.InvariantCulture,
StringComparison.InvariantCultureIgnoreCase,
StringComparison.Ordinal,
StringComparison.OrdinalIgnoreCase };
// Clear the screen and display an introduction.
Console.Clear();
Console.WriteLine(intro);
// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Console.WriteLine("The current culture is \"{0}\" - {1}.",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentCulture.DisplayName);
// Display the string to search for and the string to search.
Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"",
CapitalAWithRing, cat);
Console.WriteLine();
// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.
Console.WriteLine("Part 1: Start index and count are specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
Console.WriteLine(resultFmt, sc, loc);
}
// Search using different values of StringComparison. Specify the
// start index.
Console.WriteLine("\nPart 2: Start index is specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, 0, sc);
Console.WriteLine(resultFmt, sc, loc);
}
// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, sc);
Console.WriteLine(resultFmt, sc, loc);
}
}
}
/*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).
This code example produces the following results:
Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"
Part 1: Start index and count are specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 2: Start index is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
*/
// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.
open System
open System.Threading
open System.Globalization
let intro = "Find the first occurrence of a character using different values of StringComparison."
// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
let CapitalAWithRing = "\u00c5"
// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
let cat = "A Cheshire c" + "\u0061\u030a" + "t"
let scValues =
[| StringComparison.CurrentCulture
StringComparison.CurrentCultureIgnoreCase
StringComparison.InvariantCulture
StringComparison.InvariantCultureIgnoreCase
StringComparison.Ordinal
StringComparison.OrdinalIgnoreCase |]
// Clear the screen and display an introduction.
Console.Clear()
printfn $"{intro}"
// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"The current culture is \"{Thread.CurrentThread.CurrentCulture.Name}\" - {Thread.CurrentThread.CurrentCulture.DisplayName}."
// Display the string to search for and the string to search.
printfn $"Search for the string \"{CapitalAWithRing}\" in the string \"{cat}\"\n"
// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.
printfn "Part 1: Start index and count are specified."
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
printfn $"Comparison: {sc,-28} Location: {loc,3}"
// Search using different values of StringComparison. Specify the
// start index.
printfn "\nPart 2: Start index is specified."
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, 0, sc)
printfn $"Comparison: {sc,-28} Location: {loc,3}"
// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.")
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, sc)
Console.WriteLine("Comparison: {0,-28} Location: {1,3}", sc, loc)
(*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).
This code example produces the following results:
Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"
Part 1: Start index and count are specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 2: Start index is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
*)
' This code example demonstrates the
' System.String.IndexOf(String, ..., StringComparison) methods.
Imports System.Threading
Imports System.Globalization
Class Sample
Public Shared Sub Main()
Dim intro As String = "Find the first occurrence of a character using different " & _
"values of StringComparison."
Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
' Define a string to search for.
' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
Dim CapitalAWithRing As String = "Å"
' Define a string to search.
' The result of combining the characters LATIN SMALL LETTER A and COMBINING
' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
Dim cat As String = "A Cheshire c" & "å" & "t"
Dim loc As Integer = 0
Dim scValues As StringComparison() = { _
StringComparison.CurrentCulture, _
StringComparison.CurrentCultureIgnoreCase, _
StringComparison.InvariantCulture, _
StringComparison.InvariantCultureIgnoreCase, _
StringComparison.Ordinal, _
StringComparison.OrdinalIgnoreCase }
Dim sc As StringComparison
' Clear the screen and display an introduction.
Console.Clear()
Console.WriteLine(intro)
' Display the current culture because culture affects the result. For example,
' try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
Console.WriteLine("The current culture is ""{0}"" - {1}.", _
Thread.CurrentThread.CurrentCulture.Name, _
Thread.CurrentThread.CurrentCulture.DisplayName)
' Display the string to search for and the string to search.
Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
CapitalAWithRing, cat)
Console.WriteLine()
' Note that in each of the following searches, we look for
' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
' the string was not found.
' Search using different values of StringComparison. Specify the start
' index and count.
Console.WriteLine("Part 1: Start index and count are specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
' Search using different values of StringComparison. Specify the
' start index.
Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, 0, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
' Search using different values of StringComparison.
Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
End Sub
End Class
'
'Note: This code example was executed on a console whose user interface
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
備註
索引編號從 0 開始。
startIndex參數範圍可從 0 到 字串實例的長度。 若 startIndex 等於字串實例長度，則回傳 -1。
該 comparisonType 參數指定使用當前或不變文化、大小寫區分或非區分大小寫的搜尋，以及單字或序數比較規則來搜尋該 value 參數。
給呼叫者的注意事項
字元集包含可忽略的字元，這些字元在進行語言或文化敏感比較時未被考慮。 在文化敏感搜尋中（ comparisonType 即如果不是 Ordinal 或 OrdinalIgnoreCase），如果 value 包含可忽略的字元，結果等同於移除該字元後搜尋。 若 value 僅包含一個或多個可忽略字元， IndexOf(String, Int32, StringComparison) 該方法總是回傳 startIndex，即搜尋開始的字元位置。
以下範例中，此 IndexOf(String, Int32, StringComparison) 方法用於尋找軟連字號（U+00AD）的位置，後接從兩串字串中第三個字元位置開始的「m」。 只有一個字串包含所需的子字串。 若範例在 .NET Framework 4 或更新版本上執行，兩者皆因軟連字號可忽略，方法在進行文化敏感比較時回傳字串中「m」的索引。 請注意，在第一個字串中，包含軟連字號後面跟著「m」，方法不會回傳軟連字號的索引，而是回傳「m」的索引。 該方法僅在進行序數比較時回傳第一字串軟連字號的索引。
using System;
public class Example
{
public static void Main()
{
string searchString = "\u00ADm";
string s1 = "ani\u00ADmal" ;
string s2 = "animal";
Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.CurrentCulture));
Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.Ordinal));
Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.CurrentCulture));
Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.Ordinal));
// The example displays the following output:
// 4
// 3
// 3
// -1
}
}
open System
let searchString = "\u00ADm"
let s1 = "ani\u00ADmal"
let s2 = "animal"
printfn $"{s1.IndexOf(searchString, 2, StringComparison.CurrentCulture)}"
printfn $"{s1.IndexOf(searchString, 2, StringComparison.Ordinal)}"
printfn $"{s2.IndexOf(searchString, 2, StringComparison.CurrentCulture)}"
printfn $"{s2.IndexOf(searchString, 2, StringComparison.Ordinal)}"
// The example displays the following output:
// 4
// 3
// 3
// -1
Module Example
Public Sub Main()
Dim searchString As String = Chrw(&h00AD) + "m"
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.CurrentCulture))
Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.Ordinal))
Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.CurrentCulture))
Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.Ordinal))
End Sub
End Module
' The example displays the following output:
' 4
' 3
' 3
' -1
適用於
IndexOf(String, Int32, Int32)
報告該字串在此實例中首次出現的零為基礎的索引。 搜尋從指定的字元位置開始，並檢視指定數量的字元位置。
public:
int IndexOf(System::String ^ value, int startIndex, int count);public int IndexOf(string value, int startIndex, int count);member this.IndexOf : string * int * int -> intPublic Function IndexOf (value As String, startIndex As Integer, count As Integer) As Integer參數
- value
- String
那條線要尋找。
- startIndex
- Int32
搜尋起始位置。
- count
- Int32
要檢視的字元位置數目。
傳回
若找到該字串，則為從當前實例起始點的 value 零基索引位置;若找不到則為 -1。 若 value ， Empty則返回值為 startIndex。
例外狀況
value 為 null。
count 或 startIndex 是陰性。
-或-
startIndex 大於此字串的長度。
-或-
count 大於此字串長度減 startIndex去 。
範例
以下範例尋找字串「he」在另一個字串子串中所有出現的索引。 請注意，每次搜尋迭代都必須重新計算要搜尋的字元數。
string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+---";
string br2 = "012345678901234567890123456789012345678901234567890123456789012345678";
string str = "Now is the time for all good men to come to the aid of their country.";
int start;
int at;
int end;
int count;
end = str.Length;
start = end/2;
Console.WriteLine();
Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, end-1);
Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
Console.Write("The string 'he' occurs at position(s): ");
count = 0;
at = 0;
while((start <= end) && (at > -1))
{
// start+count must be a position within -str-.
count = end - start;
at = str.IndexOf("he", start, count);
if (at == -1) break;
Console.Write("{0} ", at);
start = at+1;
}
Console.WriteLine();
/*
This example produces the following results:
All occurrences of 'he' from position 34 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.
The string 'he' occurs at position(s): 45 56
*/
let br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+---"
let br2 = "012345678901234567890123456789012345678901234567890123456789012345678"
let str = "Now is the time for all good men to come to the aid of their country."
let last = str.Length
let mutable start = last / 2
printfn $"\nAll occurrences of 'he' from position {start} to {last - 1}."
printfn $"{br1}{Environment.NewLine}{br2}{Environment.NewLine}{str}{Environment.NewLine}"
printf "The string 'he' occurs at position(s): "
let mutable broken = false
let mutable at = 0
while (start <= last) && (at > -1) do
// start+count must be a position within -str-.
let count = last - start
at <- str.IndexOf("he", start, count)
if at = -1 then
broken <- true
else
printf $"{at} "
start <- at + 1
printfn ""
(*
This example produces the following results:
All occurrences of 'he' from position 34 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.
The string 'he' occurs at position(s): 45 56
*)
' Sample for String.IndexOf(String, Int32, Int32)
Class Sample
Public Shared Sub Main()
Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
Dim str As String = "Now is the time for all good men to come to the aid of their party."
Dim start As Integer
Dim at As Integer
Dim [end] As Integer
Dim count As Integer
[end] = str.Length
start = [end] / 2
Console.WriteLine()
Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, [end] - 1)
Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
Console.Write("The string 'he' occurs at position(s): ")
count = 0
at = 0
While start <= [end] AndAlso at > - 1
' start+count must be a position within -str-.
count = [end] - start
at = str.IndexOf("he", start, count)
If at = - 1 Then
Exit While
End If
Console.Write("{0} ", at)
start = at + 1
End While
Console.WriteLine()
End Sub
End Class
'
'This example produces the following results:
'
'All occurrences of 'he' from position 33 to 66.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The string 'he' occurs at position(s): 45 56
'
'
備註
索引編號從 0（零）開始。
startIndex參數範圍可從 0 到 字串實例的長度。
此方法使用當前文化進行詞彙搜尋（大小寫區分與文化敏感）。 搜尋從 開始 startIndex ，持續到 startIndex + count -1。 搜尋中未包含字元 at startIndex + count 。
字元集包含可忽略的字元，這些字元在進行語言或文化敏感比較時未被考慮。 在文化敏感搜尋中，若 value 包含可忽略的字元，結果等同於移除該字元後搜尋。 若 value 僅包含一個或多個可忽略字元， IndexOf(String, Int32, Int32) 該方法總是回傳 startIndex，即搜尋開始的字元位置。 以下範例中，此 IndexOf(String, Int32, Int32) 方法用於尋找軟連字號（U+00AD）後接從兩字串第三至第六位開始的「m」的位置。 只有一個字串包含所需的子字串。 若範例在 .NET Framework 4 或更新版本上執行，兩者皆因軟連字號可忽略，方法在進行文化敏感比較時回傳字串中「m」的索引。 請注意，在第一個字串中，包含軟連字號後面跟著「m」，方法不會回傳軟連字號的索引，而是回傳「m」的索引。
using System;
public class Example
{
public static void Main()
{
string searchString = "\u00ADm";
string s1 = "ani\u00ADmal" ;
string s2 = "animal";
Console.WriteLine(s1.IndexOf(searchString, 2, 4));
Console.WriteLine(s2.IndexOf(searchString, 2, 4));
// The example displays the following output:
// 4
// 3
}
}
let searchString = "\u00ADm"
let s1 = "ani\u00ADmal"
let s2 = "animal"
printfn $"{s1.IndexOf(searchString, 2, 4)}"
printfn $"{s2.IndexOf(searchString, 2, 4)}"
// The example displays the following output:
// 4
// 3
Module Example
Public Sub Main()
Dim searchString As String = Chrw(&h00AD) + "m"
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine(s1.IndexOf(searchString, 2, 4))
Console.WriteLine(s2.IndexOf(searchString, 2, 4))
End Sub
End Module
' The example displays the following output:
' 4
' 3
給呼叫者的注意事項
如《 使用字串的最佳實務》所述，我們建議避免呼叫替換預設值的字串比較方法，而是呼叫需要明確指定參數的方法。 若要使用當前文化的比較規則執行此操作，請明確地以參數值呼叫IndexOf(String, Int32, Int32, StringComparison)方法過載CurrentCulturecomparisonType來明確示意。 如果你不需要語言感知比較，可以考慮使用 Ordinal。
另請參閱
適用於
IndexOf(Char, Int32, Int32)
報告此時指定字元首次出現的零為基礎索引。 搜尋從指定的字元位置開始，並檢視指定數量的字元位置。
public:
int IndexOf(char value, int startIndex, int count);public int IndexOf(char value, int startIndex, int count);member this.IndexOf : char * int * int -> intPublic Function IndexOf (value As Char, startIndex As Integer, count As Integer) As Integer參數
- value
- Char
一個值得尋找的 Unicode 字元。
- startIndex
- Int32
搜尋起始位置。
- count
- Int32
要檢視的字元位置數目。
傳回
若找到該字元，則為從字串起始的零基索引位置;若找不到則為 -1 value 。
例外狀況
count 或 startIndex 是陰性。
-或-
startIndex 大於此字串的長度。
-或-
count 大於此字串長度減 startIndex去 。
範例
以下範例示範此 IndexOf 方法。
// Example for the String.IndexOf( char, int, int ) method.
using System;
class IndexOfCII
{
public static void Main()
{
string br1 =
"0----+----1----+----2----+----3----+----" +
"4----+----5----+----6----+----7";
string br2 =
"0123456789012345678901234567890123456789" +
"0123456789012345678901234567890";
string str =
"ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " +
"ABCDEFGHI abcdefghi ABCDEFGHI";
Console.WriteLine(
"This example of String.IndexOf( char, int, int )\n" +
"generates the following output." );
Console.WriteLine(
"{0}{1}{0}{2}{0}{3}{0}",
Environment.NewLine, br1, br2, str );
FindAllChar( 'A', str );
FindAllChar( 'a', str );
FindAllChar( 'I', str );
FindAllChar( 'i', str );
FindAllChar( '@', str );
FindAllChar( ' ', str );
}
static void FindAllChar( Char target, String searched )
{
Console.Write(
"The character '{0}' occurs at position(s): ",
target );
int startIndex = -1;
int hitCount = 0;
// Search for all occurrences of the target.
while( true )
{
startIndex = searched.IndexOf(
target, startIndex + 1,
searched.Length - startIndex - 1 );
// Exit the loop if the target is not found.
if( startIndex < 0 )
break;
Console.Write( "{0}, ", startIndex );
hitCount++;
}
Console.WriteLine( "occurrences: {0}", hitCount );
}
}
/*
This example of String.IndexOf( char, int, int )
generates the following output.
0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
01234567890123456789012345678901234567890123456789012345678901234567890
ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI
The character 'A' occurs at position(s): 0, 20, 40, 60, occurrences: 4
The character 'a' occurs at position(s): 10, 30, 50, occurrences: 3
The character 'I' occurs at position(s): 8, 28, 48, 68, occurrences: 4
The character 'i' occurs at position(s): 18, 38, 58, occurrences: 3
The character '@' occurs at position(s): occurrences: 0
The character ' ' occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6
*/
// Example for the String.IndexOf( char, int, int ) method.
open System
let br1 =
"0----+----1----+----2----+----3----+----" +
"4----+----5----+----6----+----7"
let br2 =
"0123456789012345678901234567890123456789" +
"0123456789012345678901234567890"
let str =
"ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " +
"ABCDEFGHI abcdefghi ABCDEFGHI"
printfn "This example of String.IndexOf( char, int, int )\ngenerates the following output."
printfn $"{Environment.NewLine}{br1}{Environment.NewLine}{br2}{Environment.NewLine}{str}{Environment.NewLine}"
let findAllChar (target: char) (searched: string) =
printf $"The character '{target}' occurs at position(s): "
let mutable hitCount = 0
let mutable startIndex = -1
let mutable broken = false
// Search for all occurrences of the target.
while not broken do
startIndex <- searched.IndexOf(target, startIndex + 1, searched.Length - startIndex - 1)
// Exit the loop if the target is not found.
if startIndex < 0 then
broken <- true
else
printf $"{startIndex}, "
hitCount <- hitCount + 1
printfn $"occurrences: {hitCount}"
findAllChar 'A' str
findAllChar 'a' str
findAllChar 'I' str
findAllChar 'i' str
findAllChar '@' str
findAllChar ' ' str
(*
This example of String.IndexOf( char, int, int )
generates the following output.
0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
01234567890123456789012345678901234567890123456789012345678901234567890
ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI
The character 'A' occurs at position(s): 0, 20, 40, 60, occurrences: 4
The character 'a' occurs at position(s): 10, 30, 50, occurrences: 3
The character 'I' occurs at position(s): 8, 28, 48, 68, occurrences: 4
The character 'i' occurs at position(s): 18, 38, 58, occurrences: 3
The character '@' occurs at position(s): occurrences: 0
The character ' ' occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6
*)
' Example for the String.IndexOf( Char, Integer, Integer ) method.
Module IndexOfCII
Sub Main()
Dim br1 As String = _
"0----+----1----+----2----+----3----+----" & _
"4----+----5----+----6----+----7"
Dim br2 As String = _
"0123456789012345678901234567890123456789" & _
"0123456789012345678901234567890"
Dim str As String = _
"ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " & _
"ABCDEFGHI abcdefghi ABCDEFGHI"
Console.WriteLine( _
"This example of String.IndexOf( Char, Integer, Integer )" & _
vbCrLf & "generates the following output." )
Console.WriteLine( _
"{0}{1}{0}{2}{0}{3}{0}", _
Environment.NewLine, br1, br2, str)
FindAllChar("A"c, str)
FindAllChar("a"c, str)
FindAllChar("I"c, str)
FindAllChar("i"c, str)
FindAllChar("@"c, str)
FindAllChar(" "c, str)
End Sub
Sub FindAllChar(target As Char, searched As String)
Console.Write( _
"The character ""{0}"" occurs at position(s): ", target)
Dim startIndex As Integer = - 1
Dim hitCount As Integer = 0
' Search for all occurrences of the target.
While True
startIndex = searched.IndexOf( _
target, startIndex + 1, _
searched.Length - startIndex - 1)
' Exit the loop if the target is not found.
If startIndex < 0 Then
Exit While
End If
Console.Write("{0}, ", startIndex)
hitCount += 1
End While
Console.WriteLine("occurrences: {0}", hitCount)
End Sub
End Module 'IndexOfCII
' This example of String.IndexOf( Char, Integer, Integer )
' generates the following output.
'
' 0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
' 01234567890123456789012345678901234567890123456789012345678901234567890
' ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI
'
' The character "A" occurs at position(s): 0, 20, 40, 60, occurrences: 4
' The character "a" occurs at position(s): 10, 30, 50, occurrences: 3
' The character "I" occurs at position(s): 8, 28, 48, 68, occurrences: 4
' The character "i" occurs at position(s): 18, 38, 58, occurrences: 3
' The character "@" occurs at position(s): occurrences: 0
' The character " " occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6
備註
搜尋從 開始 startIndex ，持續到 startIndex + count -1。 搜尋中未包含字元 at startIndex + count 。
索引編號從 0（零）開始。
startIndex參數範圍可從 0 到 字串實例的長度。
此方法執行序數（不依賴文化）搜尋，僅當一個字元與另一個 Unicode 標量值相同時，才被視為等價。 要執行文化敏感搜尋，請使用以下 CompareInfo.IndexOf 方法，其中代表預組合字元的 Unicode 標量值（如連字「Æ」（U+00C6））可視為等同於該字元組成部分以正確順序出現的情況，如「AE」（U+0041， U+0045），視文化而定。
另請參閱
適用於
IndexOf(Char)
報告該字串中指定 Unicode 字元首次出現的以零為基礎的索引。
public:
int IndexOf(char value);public int IndexOf(char value);member this.IndexOf : char -> intPublic Function IndexOf (value As Char) As Integer參數
- value
- Char
一個值得尋找的 Unicode 字元。
傳回
若找到該字元，則為 的零基索引位置;若找不到則為 -1 value 。
範例
以下範例示範如何利用此IndexOf方法搜尋字String元。
// Create a Unicode string with 5 Greek Alpha characters.
String szGreekAlpha = new String('\u0391',5);
// Create a Unicode string with 3 Greek Omega characters.
String szGreekOmega = "\u03A9\u03A9\u03A9";
String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha,
szGreekOmega.Clone());
// Display the entire string.
Console.WriteLine("The string: {0}", szGreekLetters);
// The first index of Alpha.
int ialpha = szGreekLetters.IndexOf('\u0391');
// The first index of Omega.
int iomega = szGreekLetters.IndexOf('\u03A9');
Console.WriteLine("First occurrence of the Greek letter Alpha: Index {0}",
ialpha);
Console.WriteLine("First occurrence of the Greek letter Omega: Index {0}",
iomega);
// The example displays the following output:
// The string: ΩΩΩΑΑΑΑΑΩΩΩ
// First occurrence of the Greek letter Alpha: Index 3
// First occurrence of the Greek letter Omega: Index 0
open System
// Create a Unicode string with 5 Greek Alpha characters.
let szGreekAlpha = String('\u0391',5)
// Create a Unicode string with 3 Greek Omega characters.
let szGreekOmega = "\u03A9\u03A9\u03A9"
let szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone())
// Display the entire string.
printfn $"The string: {szGreekLetters}"
// The first index of Alpha.
let ialpha = szGreekLetters.IndexOf '\u0391'
// The first index of Omega.
let iomega = szGreekLetters.IndexOf '\u03A9'
printfn "First occurrence of the Greek letter Alpha: Index {ialpha}"
printfn "First occurrence of the Greek letter Omega: Index {iomega}"
// The example displays the following output:
// The string: ΩΩΩΑΑΑΑΑΩΩΩ
// First occurrence of the Greek letter Alpha: Index 3
// First occurrence of the Greek letter Omega: Index 0
Public Module Example
Public Sub Main()
' Create a Unicode string with 5 Greek Alpha characters.
Dim szGreekAlpha As New String(ChrW(&H0391), 5)
' Create a Unicode string with 3 Greek Omega characters.
Dim szGreekOmega As String = ChrW(&H03A9) + ChrW(&H03A9)+
ChrW(&H03A9)
Dim szGreekLetters As String = String.Concat(szGreekOmega, szGreekAlpha, _
szGreekOmega.Clone())
' Display the entire string.
Console.WriteLine(szGreekLetters)
' The first index of Alpha.
Dim iAlpha As Integer = szGreekLetters.IndexOf(ChrW(&H0391))
' The first index of Omega.
Dim iomega As Integer = szGreekLetters.IndexOf(ChrW(&H03A9))
Console.WriteLine("First occurrence of the Greek letter Alpha: Index {0}",
ialpha)
Console.WriteLine("First occurrence of the Greek letter Omega: Index {0}",
iomega)
End Sub
End Module
' The example displays the following output:
' The string: OOO?????OOO
' First occurrence of the Greek letter Alpha: Index 3
' First occurrence of the Greek letter Omega: Index 0
備註
索引編號從零開始。
此方法執行序數（不依賴文化）搜尋，僅當一個字元與另一個 Unicode 標量值相同時，才被視為等價。 要執行文化敏感搜尋，請使用以下 CompareInfo.IndexOf 方法，其中代表預組合字元的 Unicode 標量值（如連字「Æ」（U+00C6））可視為等同於該字元組成部分以正確順序出現的情況，如「AE」（U+0041， U+0045），視文化而定。
另請參閱
適用於
IndexOf(Rune, Int32)
IndexOf(String, StringComparison)
報告指定字串首次出現於當前 String 物件的零為基礎索引。 參數指定該字串的搜尋類型。
public:
int IndexOf(System::String ^ value, StringComparison comparisonType);public int IndexOf(string value, StringComparison comparisonType);member this.IndexOf : string * StringComparison -> intPublic Function IndexOf (value As String, comparisonType As StringComparison) As Integer參數
- value
- String
那條線要尋找。
- comparisonType
- StringComparison
這是列舉值之一，用來指定搜尋的規則。
傳回
如果找到該字串，則是參數的 value 索引位置;找不到則是 -1。 若 value ， Empty則返回值為 0。
例外狀況
value 為 null。
comparisonType 不是一個有效的 StringComparison 值。
範例
以下範例展示了三種方法的超載 IndexOf ，分別是利用不同列舉值 StringComparison 在另一個字串中首次出現字串。
// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.
using System;
using System.Threading;
using System.Globalization;
class Sample
{
public static void Main()
{
string intro = "Find the first occurrence of a character using different " +
"values of StringComparison.";
string resultFmt = "Comparison: {0,-28} Location: {1,3}";
// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
string CapitalAWithRing = "\u00c5";
// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
string cat = "A Cheshire c" + "\u0061\u030a" + "t";
int loc = 0;
StringComparison[] scValues = {
StringComparison.CurrentCulture,
StringComparison.CurrentCultureIgnoreCase,
StringComparison.InvariantCulture,
StringComparison.InvariantCultureIgnoreCase,
StringComparison.Ordinal,
StringComparison.OrdinalIgnoreCase };
// Clear the screen and display an introduction.
Console.Clear();
Console.WriteLine(intro);
// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Console.WriteLine("The current culture is \"{0}\" - {1}.",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentCulture.DisplayName);
// Display the string to search for and the string to search.
Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"",
CapitalAWithRing, cat);
Console.WriteLine();
// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.
Console.WriteLine("Part 1: Start index and count are specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
Console.WriteLine(resultFmt, sc, loc);
}
// Search using different values of StringComparison. Specify the
// start index.
Console.WriteLine("\nPart 2: Start index is specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, 0, sc);
Console.WriteLine(resultFmt, sc, loc);
}
// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
foreach (StringComparison sc in scValues)
{
loc = cat.IndexOf(CapitalAWithRing, sc);
Console.WriteLine(resultFmt, sc, loc);
}
}
}
/*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).
This code example produces the following results:
Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"
Part 1: Start index and count are specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 2: Start index is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
*/
// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.
open System
open System.Threading
open System.Globalization
let intro = "Find the first occurrence of a character using different values of StringComparison."
// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
let CapitalAWithRing = "\u00c5"
// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
let cat = "A Cheshire c" + "\u0061\u030a" + "t"
let scValues =
[| StringComparison.CurrentCulture
StringComparison.CurrentCultureIgnoreCase
StringComparison.InvariantCulture
StringComparison.InvariantCultureIgnoreCase
StringComparison.Ordinal
StringComparison.OrdinalIgnoreCase |]
// Clear the screen and display an introduction.
Console.Clear()
printfn $"{intro}"
// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"The current culture is \"{Thread.CurrentThread.CurrentCulture.Name}\" - {Thread.CurrentThread.CurrentCulture.DisplayName}."
// Display the string to search for and the string to search.
printfn $"Search for the string \"{CapitalAWithRing}\" in the string \"{cat}\"\n"
// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.
printfn "Part 1: Start index and count are specified."
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
printfn $"Comparison: {sc,-28} Location: {loc,3}"
// Search using different values of StringComparison. Specify the
// start index.
printfn "\nPart 2: Start index is specified."
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, 0, sc)
printfn $"Comparison: {sc,-28} Location: {loc,3}"
// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.")
for sc in scValues do
let loc = cat.IndexOf(CapitalAWithRing, sc)
Console.WriteLine("Comparison: {0,-28} Location: {1,3}", sc, loc)
(*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).
This code example produces the following results:
Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"
Part 1: Start index and count are specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 2: Start index is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture Location: -1
Comparison: CurrentCultureIgnoreCase Location: 12
Comparison: InvariantCulture Location: -1
Comparison: InvariantCultureIgnoreCase Location: 12
Comparison: Ordinal Location: -1
Comparison: OrdinalIgnoreCase Location: -1
*)
' This code example demonstrates the
' System.String.IndexOf(String, ..., StringComparison) methods.
Imports System.Threading
Imports System.Globalization
Class Sample
Public Shared Sub Main()
Dim intro As String = "Find the first occurrence of a character using different " & _
"values of StringComparison."
Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
' Define a string to search for.
' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
Dim CapitalAWithRing As String = "Å"
' Define a string to search.
' The result of combining the characters LATIN SMALL LETTER A and COMBINING
' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
Dim cat As String = "A Cheshire c" & "å" & "t"
Dim loc As Integer = 0
Dim scValues As StringComparison() = { _
StringComparison.CurrentCulture, _
StringComparison.CurrentCultureIgnoreCase, _
StringComparison.InvariantCulture, _
StringComparison.InvariantCultureIgnoreCase, _
StringComparison.Ordinal, _
StringComparison.OrdinalIgnoreCase }
Dim sc As StringComparison
' Clear the screen and display an introduction.
Console.Clear()
Console.WriteLine(intro)
' Display the current culture because culture affects the result. For example,
' try this code example with the "sv-SE" (Swedish-Sweden) culture.
Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
Console.WriteLine("The current culture is ""{0}"" - {1}.", _
Thread.CurrentThread.CurrentCulture.Name, _
Thread.CurrentThread.CurrentCulture.DisplayName)
' Display the string to search for and the string to search.
Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
CapitalAWithRing, cat)
Console.WriteLine()
' Note that in each of the following searches, we look for
' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
' the string was not found.
' Search using different values of StringComparison. Specify the start
' index and count.
Console.WriteLine("Part 1: Start index and count are specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
' Search using different values of StringComparison. Specify the
' start index.
Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, 0, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
' Search using different values of StringComparison.
Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
For Each sc In scValues
loc = cat.IndexOf(CapitalAWithRing, sc)
Console.WriteLine(resultFmt, sc, loc)
Next sc
End Sub
End Class
'
'Note: This code example was executed on a console whose user interface
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture Location: -1
'Comparison: CurrentCultureIgnoreCase Location: 12
'Comparison: InvariantCulture Location: -1
'Comparison: InvariantCultureIgnoreCase Location: 12
'Comparison: Ordinal Location: -1
'Comparison: OrdinalIgnoreCase Location: -1
'
備註
索引編號從零開始。
該 comparisonType 參數指定使用當前或不變文化、大小寫區分或非區分大小寫的搜尋，以及單字或序數比較規則來搜尋該 value 參數。
給呼叫者的注意事項
字元集包含可忽略的字元，這些字元在進行語言或文化敏感比較時未被考慮。 在文化敏感搜尋中（ comparisonType 即如果不是 Ordinal 或 OrdinalIgnoreCase），如果 value 包含可忽略的字元，結果等同於移除該字元後搜尋。 若 value 僅包含一個或多個可忽略字元， IndexOf(String, StringComparison) 方法總是回傳 0（零），表示匹配點位於當前實例的開始處。
以下範例中，此 IndexOf(String, StringComparison) 方法用於在兩串字串中尋找三個子字串（軟連字號 U+00AD）、軟連字號後接「n」，以及軟連字號後面加「m」）。 只有一條弦包含軟連字號。 若範例在 .NET Framework 4 或更新版本上執行，因為軟連字號是可忽略的字元，文化敏感搜尋會回傳與搜尋字串中未包含軟連字號時相同的值。 然而，序數搜尋能成功在一個字串中找到軟連字號，並報告該連字號在第二個字串中缺失。
using System;
public class Example
{
public static void Main()
{
string s1 = "ani\u00ADmal";
string s2 = "animal";
Console.WriteLine("Culture-sensitive comparison:");
// Use culture-sensitive comparison to find the soft hyphen.
Console.WriteLine(s1.IndexOf("\u00AD", StringComparison.CurrentCulture));
Console.WriteLine(s2.IndexOf("\u00AD", StringComparison.CurrentCulture));
// Use culture-sensitive comparison to find the soft hyphen followed by "n".
Console.WriteLine(s1.IndexOf("\u00ADn", StringComparison.CurrentCulture));
Console.WriteLine(s2.IndexOf("\u00ADn", StringComparison.CurrentCulture));
// Use culture-sensitive comparison to find the soft hyphen followed by "m".
Console.WriteLine(s1.IndexOf("\u00ADm", StringComparison.CurrentCulture));
Console.WriteLine(s2.IndexOf("\u00ADm", StringComparison.CurrentCulture));
Console.WriteLine("Ordinal comparison:");
// Use ordinal comparison to find the soft hyphen.
Console.WriteLine(s1.IndexOf("\u00AD", StringComparison.Ordinal));
Console.WriteLine(s2.IndexOf("\u00AD", StringComparison.Ordinal));
// Use ordinal comparison to find the soft hyphen followed by "n".
Console.WriteLine(s1.IndexOf("\u00ADn", StringComparison.Ordinal));
Console.WriteLine(s2.IndexOf("\u00ADn", StringComparison.Ordinal));
// Use ordinal comparison to find the soft hyphen followed by "m".
Console.WriteLine(s1.IndexOf("\u00ADm", StringComparison.Ordinal));
Console.WriteLine(s2.IndexOf("\u00ADm", StringComparison.Ordinal));
// The example displays the following output:
// Culture-sensitive comparison:
// 0
// 0
// 1
// 1
// 4
// 3
// Ordinal comparison:
// 3
// -1
// -1
// -1
// 3
// -1
}
}
open System
let s1 = "ani\u00ADmal"
let s2 = "animal"
printfn "Culture-sensitive comparison:"
// Use culture-sensitive comparison to find the soft hyphen.
printfn $"""{s1.IndexOf("\u00AD", StringComparison.CurrentCulture)}"""
printfn $"""{s2.IndexOf("\u00AD", StringComparison.CurrentCulture)}"""
// Use culture-sensitive comparison to find the soft hyphen followed by "n".
printfn $"""{s1.IndexOf("\u00ADn", StringComparison.CurrentCulture)}"""
printfn $"""{s2.IndexOf("\u00ADn", StringComparison.CurrentCulture)}"""
// Use culture-sensitive comparison to find the soft hyphen followed by "m".
printfn $"""{s1.IndexOf("\u00ADm", StringComparison.CurrentCulture)}"""
printfn $"""{s2.IndexOf("\u00ADm", StringComparison.CurrentCulture)}"""
printfn "Ordinal comparison:"
// Use ordinal comparison to find the soft hyphen.
printfn $"""{s1.IndexOf("\u00AD", StringComparison.Ordinal)}"""
printfn $"""{s2.IndexOf("\u00AD", StringComparison.Ordinal)}"""
// Use ordinal comparison to find the soft hyphen followed by "n".
printfn $"""{s1.IndexOf("\u00ADn", StringComparison.Ordinal)}"""
printfn $"""{s2.IndexOf("\u00ADn", StringComparison.Ordinal)}"""
// Use ordinal comparison to find the soft hyphen followed by "m".
printfn $"""{s1.IndexOf("\u00ADm", StringComparison.Ordinal)}"""
printfn $"""{s2.IndexOf("\u00ADm", StringComparison.Ordinal)}"""
// The example displays the following output:
// Culture-sensitive comparison:
// 0
// 0
// 1
// 1
// 4
// 3
// Ordinal comparison:
// 3
// -1
// -1
// -1
// 3
// -1
Module Example
Public Sub Main()
Dim softHyphen As String = ChrW(&h00AD)
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
Console.WriteLine("Culture-sensitive comparison:")
' Use culture-sensitive comparison to find the soft hyphen.
Console.WriteLine(s1.IndexOf(softHyphen, StringComparison.CurrentCulture))
Console.WriteLine(s2.IndexOf(softHyphen, StringComparison.CurrentCulture))
' Use culture-sensitive comparison to find the soft hyphen followed by "n".
Console.WriteLine(s1.IndexOf(softHyphen + "n", StringComparison.CurrentCulture))
Console.WriteLine(s2.IndexOf(softHyphen + "n", StringComparison.CurrentCulture))
' Use culture-sensitive comparison to find the soft hyphen followed by "m".
Console.WriteLine(s1.IndexOf(softHyphen + "m", StringComparison.CurrentCulture))
Console.WriteLine(s2.IndexOf(softHyphen + "m", StringComparison.CurrentCulture))
Console.WriteLine("Ordinal comparison:")
' Use ordinal comparison to find the soft hyphen.
Console.WriteLine(s1.IndexOf(softHyphen, StringComparison.Ordinal))
Console.WriteLine(s2.IndexOf(softHyphen, StringComparison.Ordinal))
' Use ordinal comparison to find the soft hyphen followed by "n".
Console.WriteLine(s1.IndexOf(softHyphen + "n", StringComparison.Ordinal))
Console.WriteLine(s2.IndexOf(softHyphen + "n", StringComparison.Ordinal))
' Use ordinal comparison to find the soft hyphen followed by "m".
Console.WriteLine(s1.IndexOf(softHyphen + "m", StringComparison.Ordinal))
Console.WriteLine(s2.IndexOf(softHyphen + "m", StringComparison.Ordinal))
End Sub
End Module
' The example displays the following output:
' Culture-sensitive comparison:
' 0
' 0
' 1
' 1
' 4
' 3
' Ordinal comparison:
' 3
' -1
' -1
' -1
' 3
' -1
適用於
IndexOf(String, Int32)
報告該字串在此實例中首次出現的零為基礎的索引。 搜尋從指定的字元位置開始。
public:
int IndexOf(System::String ^ value, int startIndex);public int IndexOf(string value, int startIndex);member this.IndexOf : string * int -> intPublic Function IndexOf (value As String, startIndex As Integer) As Integer參數
- value
- String
那條線要尋找。
- startIndex
- Int32
搜尋起始位置。
傳回
若找到該字串，則為從當前實例起始點的 value 零基索引位置;若找不到則為 -1。 若 value ， Empty則返回值為 startIndex。
例外狀況
value 為 null。
startIndex 小於0（零）或大於此字串的長度。
範例
以下範例搜尋目標字串中指定字串的所有出現。
using System;
public class IndexOfTest {
public static void Main() {
string strSource = "This is the string which we will perform the search on";
Console.WriteLine("The search string is:{0}\"{1}\"{0}", Environment.NewLine, strSource);
string strTarget = "";
int found = 0;
int totFinds = 0;
do {
Console.Write("Please enter a search value to look for in the above string (hit Enter to exit) ==> ");
strTarget = Console.ReadLine();
if (strTarget != "") {
for (int i = 0; i < strSource.Length; i++) {
found = strSource.IndexOf(strTarget, i);
if (found >= 0) {
totFinds++;
i = found;
}
else
{
break;
}
}
}
else
{
return;
}
Console.WriteLine("{0}The search parameter '{1}' was found {2} times.{0}",
Environment.NewLine, strTarget, totFinds);
totFinds = 0;
} while ( true );
}
}
open System
let strSource = "This is the string which we will perform the search on"
printfn $"The search string is:{Environment.NewLine}\"{strSource}\"{Environment.NewLine}"
let mutable broken = false
while not broken do
let mutable totFinds = 0
printf "Please enter a search value to look for in the above string (hit Enter to exit) => "
let strTarget = stdin.ReadLine()
if strTarget <> "" then
let mutable i = 0
let mutable broken = false
while not broken && i <= strSource.Length - 1 do
let found = strSource.IndexOf(strTarget, i)
if found >= 0 then
totFinds <- totFinds + 1
i <- found
else
broken <- true
i <- i + 1
else
broken <- true
printfn $"{Environment.NewLine}The search parameter '{strTarget}' was found {totFinds} times.{Environment.NewLine}"
Public Class IndexOfTest
Public Shared Sub Main()
Dim strSource As String = "This is the string which we will perform the search on"
Console.WriteLine("The search string is:{0}{1}{0}", Environment.NewLine, strSource)
Dim strTarget As String = ""
Dim found As Integer = 0
Dim totFinds As Integer = 0
Do
Console.Write("Please enter a search value to look for in the above string (hit Enter to exit) ==> ")
strTarget = Console.ReadLine()
If strTarget <> "" Then
Dim i As Integer
For i = 0 To strSource.Length - 1
found = strSource.IndexOf(strTarget, i)
If found >= 0 Then
totFinds += 1
i = found
Else
Exit For
End If
Next i
Else
Return
End If
Console.WriteLine("{0}The search parameter '{1}' was found {2} times.{0}", Environment.NewLine, strTarget, totFinds)
totFinds = 0
Loop While True
End Sub
End Class
備註
索引編號從 0 開始。
startIndex參數範圍可從 0 到 字串實例的長度。 若 startIndex 等於字串實例長度，則回傳 -1。
此方法使用當前文化進行詞彙搜尋（大小寫區分與文化敏感）。 搜尋從 startIndex 該實例的字元位置開始，持續到最後一個字元位置。
字元集包含可忽略的字元，這些字元在進行語言或文化敏感比較時未被考慮。 在文化敏感搜尋中，若 value 包含可忽略的字元，結果等同於移除該字元後搜尋。 若 value 僅包含一個或多個可忽略字元， IndexOf(String, Int32) 該方法總是回傳 startIndex，即搜尋開始的字元位置。 以下範例中，此 IndexOf(String, Int32) 方法用於尋找軟連字號（U+00AD）後接兩串「m」的位置。 只有一個字串包含所需的子字串。 若範例在 .NET Framework 4 或更新版本上執行，兩者皆因軟連字號可忽略，方法會回傳字串中的「m」索引。 請注意，在第一個字串中，包含軟連字號後面跟著「m」，方法不會回傳軟連字號的索引，而是回傳「m」的索引。
using System;
public class Example
{
public static void Main()
{
string searchString = "\u00ADm";
string s1 = "ani\u00ADmal" ;
string s2 = "animal";
Console.WriteLine(s1.IndexOf(searchString, 2));
Console.WriteLine(s2.IndexOf(searchString, 2));
// The example displays the following output:
// 4
// 3
}
}
let searchString = "\u00ADm"
let s1 = "ani\u00ADmal"
let s2 = "animal"
printfn $"{s1.IndexOf(searchString, 2)}"
printfn $"{s2.IndexOf(searchString, 2)}"
// The example displays the following output:
// 4
// 3
Module Example
Public Sub Main()
Dim searchString As String = Chrw(&h00AD) + "m"
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine(s1.IndexOf(searchString, 2))
Console.WriteLine(s2.IndexOf(searchString, 2))
End Sub
End Module
' The example displays the following output:
' 4
' 3
給呼叫者的注意事項
如《 使用字串的最佳實務》所述，我們建議避免呼叫替換預設值的字串比較方法，而是呼叫需要明確指定參數的方法。 要利用當前文化的比較規則找到出現在特定字元位置後的子字串的第一個索引，請明確以參數值呼叫IndexOf(String, Int32, StringComparison)方法過載CurrentCulturecomparisonType來明確示意。 如果你不需要語言感知比較，可以考慮使用 Ordinal。
另請參閱
適用於
IndexOf(Char, StringComparison)
報告該字串中指定 Unicode 字元首次出現的以零為基礎的索引。 參數指定該字元應使用的搜尋類型。
public:
int IndexOf(char value, StringComparison comparisonType);public int IndexOf(char value, StringComparison comparisonType);member this.IndexOf : char * StringComparison -> intPublic Function IndexOf (value As Char, comparisonType As StringComparison) As Integer參數
- value
- Char
值得尋找的角色。
- comparisonType
- StringComparison
一個列舉值，用來指定搜尋的規則。
傳回
若找到該字元則為零基索引 value ，若未找到則為 -1。
例外狀況
comparisonType 不是一個有效的 StringComparison 值。
備註
索引編號從零開始。
參數 comparisonType 是一個 StringComparison 列舉成員，用來指定該參數的搜尋 value 是否使用當前或不變文化、是區分大小寫還是不區分大小寫，或使用單字或序數比較規則。
適用於
IndexOf(Char, Int32)
報告該字串中指定 Unicode 字元首次出現的以零為基礎的索引。 搜尋從指定的字元位置開始。
public:
int IndexOf(char value, int startIndex);public int IndexOf(char value, int startIndex);member this.IndexOf : char * int -> intPublic Function IndexOf (value As Char, startIndex As Integer) As Integer參數
- value
- Char
一個值得尋找的 Unicode 字元。
- startIndex
- Int32
搜尋起始位置。
傳回
若找到該字元，則為從字串起始的零基索引位置;若找不到則為 -1 value 。
例外狀況
startIndex 小於0（零）或大於弦長。
範例
以下範例示範此 IndexOf 方法。
string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+---";
string br2 = "012345678901234567890123456789012345678901234567890123456789012345678";
string str = "Now is the time for all good men to come to the aid of their country.";
int start;
int at;
Console.WriteLine();
Console.WriteLine("All occurrences of 't' from position 0 to {0}.", str.Length-1);
Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
Console.Write("The letter 't' occurs at position(s): ");
at = 0;
start = 0;
while((start < str.Length) && (at > -1))
{
at = str.IndexOf('t', start);
if (at == -1) break;
Console.Write("{0} ", at);
start = at+1;
}
Console.WriteLine();
/*
This example produces the following results:
All occurrences of 't' from position 0 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.
The letter 't' occurs at position(s): 7 11 33 41 44 55 65
*/
let br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+---"
let br2 = "012345678901234567890123456789012345678901234567890123456789012345678"
let str = "Now is the time for all good men to come to the aid of their country."
printfn ""
printfn $"All occurrences of 't' from position 0 to {str.Length - 1}."
printfn $"{br1}{Environment.NewLine}{br2}{Environment.NewLine}{str}{Environment.NewLine}"
printf "The letter 't' occurs at position(s): "
let mutable at = 0
let mutable start = 0
let mutable broken = false
while not broken && (start < str.Length) && (at > -1) do
at <- str.IndexOf('t', start)
if at = -1 then broken <- true
else
printf $"{at} "
start <- at + 1
printfn ""
(*
This example produces the following results:
All occurrences of 't' from position 0 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.
The letter 't' occurs at position(s): 7 11 33 41 44 55 65
*)
' Sample for String.IndexOf(Char, Int32)
Module Sample
Sub Main()
Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
Dim str As String = "Now is the time for all good men to come to the aid of their party."
Dim start As Integer
Dim at As Integer
Console.WriteLine()
Console.WriteLine("All occurrences of 't' from position 0 to {0}.", str.Length - 1)
Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
Console.Write("The letter 't' occurs at position(s): ")
at = 0
start = 0
While start < str.Length AndAlso at > -1
at = str.IndexOf("t"c, start)
If at = -1 Then
Exit While
End If
Console.Write("{0} ", at)
start = at + 1
End While
Console.WriteLine()
End Sub
End Module
'
'This example produces the following results:
'
'All occurrences of 't' from position 0 to 66.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The letter 't' occurs at position(s): 7 11 33 41 44 55 64
'
'
備註
索引編號從 0 開始。
startIndex參數範圍可從 0 到 字串實例的長度。 若 startIndex 等於字串實例長度，則回傳 -1。
搜尋範圍從 startIndex 字串的末端。
此方法執行序數（不依賴文化）搜尋，僅當一個字元與另一個 Unicode 標量值相同時，才被視為等價。 要執行文化敏感搜尋，請使用以下 CompareInfo.IndexOf 方法，其中代表預組合字元的 Unicode 標量值（如連字「Æ」（U+00C6））可視為等同於該字元組成部分以正確順序出現的情況，如「AE」（U+0041， U+0045），視文化而定。
另請參閱
適用於
IndexOf(String)
報告該字串在此實例中首次出現的零為基礎的索引。
public:
int IndexOf(System::String ^ value);public int IndexOf(string value);member this.IndexOf : string -> intPublic Function IndexOf (value As String) As Integer參數
- value
- String
那條線要尋找。
傳回
若找到該字串，則為 的零基索引位置;若找不到則為 -1 value 。 若 value ， Empty則返回值為 0。
例外狀況
value 為 null。
範例
以下範例搜尋「animal」中的「n」。 由於字串索引從零開始而非一，因此該 IndexOf(String) 方法表示「n」位於位置 1。
String str = "animal";
String toFind = "n";
int index = str.IndexOf("n");
Console.WriteLine("Found '{0}' in '{1}' at position {2}",
toFind, str, index);
// The example displays the following output:
// Found 'n' in 'animal' at position 1
open System
let str = "animal"
let toFind = "n"
let index = str.IndexOf "n"
printfn $"Found '{toFind}' in '{str}' at position {index}"
// The example displays the following output:
// Found 'n' in 'animal' at position 1
Public Module Example
Public Sub Main()
Dim str As String = "animal"
Dim toFind As String = "n"
Dim index As Integer = str.IndexOf("n")
Console.WriteLine("Found '{0}' in '{1}' at position {2}",
toFind, str, index)
End Sub
End Module
' The example displays the following output:
' Found 'n' in 'animal' at position 1
以下範例使用此 IndexOf 方法來判斷動物名稱在句子中的起始位置。 接著它利用這個位置插入描述動物的形容詞。
using System;
public class Example {
public static void Main()
{
string animal1 = "fox";
string animal2 = "dog";
string strTarget = String.Format("The {0} jumps over the {1}.",
animal1, animal2);
Console.WriteLine("The original string is:{0}{1}{0}",
Environment.NewLine, strTarget);
Console.Write("Enter an adjective (or group of adjectives) " +
"to describe the {0}: ==> ", animal1);
string adj1 = Console.ReadLine();
Console.Write("Enter an adjective (or group of adjectives) " +
"to describe the {0}: ==> ", animal2);
string adj2 = Console.ReadLine();
adj1 = adj1.Trim() + " ";
adj2 = adj2.Trim() + " ";
strTarget = strTarget.Insert(strTarget.IndexOf(animal1), adj1);
strTarget = strTarget.Insert(strTarget.IndexOf(animal2), adj2);
Console.WriteLine("{0}The final string is:{0}{1}",
Environment.NewLine, strTarget);
}
}
// Output from the example might appear as follows:
// The original string is:
// The fox jumps over the dog.
//
// Enter an adjective (or group of adjectives) to describe the fox: ==> bold
// Enter an adjective (or group of adjectives) to describe the dog: ==> lazy
//
// The final string is:
// The bold fox jumps over the lazy dog.
open System
let animal1 = "fox"
let animal2 = "dog"
let strTarget = String.Format("The {0} jumps over the {1}.", animal1, animal2)
do
printfn $"The original string is:{Environment.NewLine}{strTarget}{Environment.NewLine}"
printf $"Enter an adjective (or group of adjectives) to describe the {animal1}: => "
let adj1 = stdin.ReadLine()
printf $"Enter an adjective (or group of adjectives) to describe the {animal2}: => "
let adj2 = stdin.ReadLine()
let adj1 = adj1.Trim() + " "
let adj2 = adj2.Trim() + " "
let strTarget = strTarget.Insert(strTarget.IndexOf animal1, adj1)
let strTarget = strTarget.Insert(strTarget.IndexOf animal2, adj2)
printfn $"{Environment.NewLine}The final string is:{strTarget}{Environment.NewLine}"
// Output from the example might appear as follows:
// The original string is:
// The fox jumps over the dog.
//
// Enter an adjective (or group of adjectives) to describe the fox: => bold
// Enter an adjective (or group of adjectives) to describe the dog: => lazy
//
// The final string is:
// The bold fox jumps over the lazy dog.
Public Class Example
Public Shared Sub Main()
Dim animal1 As String = "fox"
Dim animal2 As String = "dog"
Dim strTarget As String = String.Format("The {0} jumps over the {1}.",
animal1, animal2)
Console.WriteLine("The original string is: {0}{1}{0}",
Environment.NewLine, strTarget)
Console.Write("Enter an adjective (or group of adjectives) " +
"to describe the {0}: ==> ", animal1)
Dim adj1 As String = Console.ReadLine()
Console.Write("Enter an adjective (or group of adjectives) " +
"to describe the {0}: ==> ", animal2)
Dim adj2 As String = Console.ReadLine()
adj1 = adj1.Trim() + " "
adj2 = adj2.Trim() + " "
strTarget = strTarget.Insert(strTarget.IndexOf(animal1), adj1)
strTarget = strTarget.Insert(strTarget.IndexOf(animal2), adj2)
Console.WriteLine("{0}The final string is:{0}{1}",
Environment.NewLine, strTarget)
End Sub
End Class
' Output from the example might appear as follows:
' The original string is:
' The fox jumps over the dog.
'
' Enter an adjective (or group of adjectives) to describe the fox: ==> bold
' Enter an adjective (or group of adjectives) to describe the dog: ==> lazy
'
' The final string is:
' The bold fox jumps over the lazy dog.
備註
索引編號從零開始。
此方法使用當前文化進行詞彙搜尋（大小寫區分與文化敏感）。 搜尋從該實例的第一個字元位置開始，持續到最後一個字元位置。
字元集包含可忽略的字元，這些字元在進行語言或文化敏感比較時未被考慮。 在文化敏感搜尋中，若 value 包含可忽略的字元，結果等同於移除該字元後搜尋。 若 value 僅包含一個或多個可忽略字元， IndexOf(String) 方法總是回傳 0（零），表示匹配點位於當前實例的開始處。 以下範例中，此 IndexOf(String) 方法用於在兩串字串中尋找三個子字串（軟連字號 U+00AD）、軟連字號後接「n」，以及軟連字號後面加「m」）。 只有一條弦包含軟連字號。 若範例在 .NET Framework 4 或更新版本上執行，且軟連字號可忽略字元，結果與未包含 value軟連字號相同。 當僅搜尋軟連字號時，方法回傳 0（零），表示已在字串開頭找到匹配。
using System;
public class Example
{
public static void Main()
{
string s1 = "ani\u00ADmal";
string s2 = "animal";
// Find the index of the soft hyphen.
Console.WriteLine(s1.IndexOf("\u00AD"));
Console.WriteLine(s2.IndexOf("\u00AD"));
// Find the index of the soft hyphen followed by "n".
Console.WriteLine(s1.IndexOf("\u00ADn"));
Console.WriteLine(s2.IndexOf("\u00ADn"));
// Find the index of the soft hyphen followed by "m".
Console.WriteLine(s1.IndexOf("\u00ADm"));
Console.WriteLine(s2.IndexOf("\u00ADm"));
// The example displays the following output
// if run under the .NET Framework 4 or later:
// 0
// 0
// 1
// 1
// 4
// 3
}
}
let s1 = "ani\u00ADmal"
let s2 = "animal"
// Find the index of the soft hyphen.
printfn $"""{s1.IndexOf "\u00AD"}"""
printfn $"""{s2.IndexOf "\u00AD"}"""
// Find the index of the soft hyphen followed by "n".
printfn $"""{s1.IndexOf "\u00ADn"}"""
printfn $"""{s2.IndexOf "\u00ADn"}"""
// Find the index of the soft hyphen followed by "m".
printfn $"""{s1.IndexOf "\u00ADm"}"""
printfn $"""{s2.IndexOf "\u00ADm"}"""
// The example displays the following output
// if run under the .NET Framework 4 or later:
// 0
// 0
// 1
// 1
// 4
// 3
Module Example
Public Sub Main()
Dim softHyphen As String = ChrW(&h00AD)
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
' Find the index of the soft hyphen.
Console.WriteLine(s1.IndexOf(softHyphen))
Console.WriteLine(s2.IndexOf(softHyphen))
' Find the index of the soft hyphen followed by "n".
Console.WriteLine(s1.IndexOf(softHyphen + "n"))
Console.WriteLine(s2.IndexOf(softHyphen + "n"))
' Find the index of the soft hyphen followed by "m".
Console.WriteLine(s1.IndexOf(softHyphen + "m"))
Console.WriteLine(s2.IndexOf(softHyphen + "m"))
End Sub
End Module
' The example displays the following output
' if run under the .NET Framework 4 or later:
' 0
' 0
' 1
' 1
' 4
' 3
給呼叫者的注意事項
如《 使用字串的最佳實務》所述，我們建議避免呼叫替換預設值的字串比較方法，而是呼叫需要明確指定參數的方法。 要利用當前文化的比較規則找到字串實例中子字串的第一個索引，請明確以參數值呼叫IndexOf(String, StringComparison)方法超載CurrentCulturecomparisonType來示意。 如果你不需要語言感知比較，可以考慮使用 Ordinal。
另請參閱
適用於
IndexOf(Rune, StringComparison)
public:
int IndexOf(System::Text::Rune value, StringComparison comparisonType);public int IndexOf(System.Text.Rune value, StringComparison comparisonType);member this.IndexOf : System.Text.Rune * StringComparison -> intPublic Function IndexOf (value As Rune, comparisonType As StringComparison) As Integer參數
- value
- Rune
- comparisonType
- StringComparison
