String.IndexOf Méthode
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Signale l'index de base zéro de la première occurrence d'un caractère ou d'une chaîne Unicode spécifiés dans cette instance. La méthode retourne -1 si le caractère ou la chaîne est introuvable dans cette instance.
IndexOf(String, Int32, Int32, StringComparison) |
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel. Les paramètres spécifient le point de départ de la recherche dans la chaîne actuelle, le nombre de caractères de la chaîne dans laquelle effectuer la recherche et le type de recherche à utiliser pour la chaîne spécifiée. |
IndexOf(String, Int32, Int32) |
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance. La recherche commence à une position de caractère spécifiée et examine un nombre spécifié de positions de caractère. |
IndexOf(Char, Int32, Int32) |
Signale l'index de base zéro de la première occurrence du caractère spécifié dans cette instance. La recherche commence à une position de caractère spécifiée et examine un nombre spécifié de positions de caractère. |
IndexOf(String, StringComparison) |
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée. |
IndexOf(String, Int32, StringComparison) |
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel. Les paramètres spécifient la position de départ de la recherche dans la chaîne actuelle et le type de recherche à utiliser pour la chaîne spécifiée. |
IndexOf(Char, StringComparison) |
Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne. Un paramètre spécifie le type de recherche à utiliser pour le caractère spécifié. |
IndexOf(Char, Int32) |
Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne. La recherche commence à une position de caractère spécifiée. |
IndexOf(String) |
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance. |
IndexOf(Char) |
Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne. |
IndexOf(String, Int32) |
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance. La recherche commence à une position de caractère spécifiée. |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel. Les paramètres spécifient le point de départ de la recherche dans la chaîne actuelle, le nombre de caractères de la chaîne dans laquelle effectuer la recherche et le type de recherche à utiliser pour la chaîne spécifiée.
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 -> int
Public Function IndexOf (value As String, startIndex As Integer, count As Integer, comparisonType As StringComparison) As Integer
Paramètres
- value
- String
Chaîne à rechercher.
- startIndex
- Int32
Position de départ de la recherche.
- count
- Int32
Nombre de positions de caractère à examiner.
- comparisonType
- StringComparison
L'une des valeurs d'énumération qui spécifie les règles de la recherche.
Retours
Position d’index de base zéro du paramètre value
à partir du début de l’instance active si cette chaîne est trouvée, ou -1 si elle est introuvable. Si value
est Empty, la valeur de retour est startIndex
.
Exceptions
value
a la valeur null
.
count
ou startIndex
est un nombre négatif.
- ou -
startIndex
est supérieur à la longueur de cette instance.
- ou -
count
est supérieur à la longueur de cette chaîne moins startIndex
.
comparisonType
n’est pas une valeur de StringComparison valide.
Exemples
L’exemple suivant illustre trois surcharges de la IndexOf méthode qui recherchent la première occurrence d’une chaîne dans une autre chaîne à l’aide de valeurs différentes de l’énumération 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
'
Remarques
La numérotation des index commence à partir de 0 (zéro). Le paramètre startIndex
peut varier entre 0 et la longueur de l'instance de chaîne.
La recherche commence à startIndex
et se poursuit à startIndex
+ count
-1. Le caractère à startIndex
+ count
n’est pas inclus dans la recherche.
Le comparisonType
paramètre spécifie de rechercher le paramètre à l’aide value
de la culture actuelle ou invariante, à l’aide d’une recherche respectant la casse ou qui ne respecte pas la casse et à l’aide de règles de comparaison de mots ou ordinaux.
Notes pour les appelants
Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture. Dans une recherche dépendante de la culture (autrement dit, si comparisonType
n'est pas Ordinal ou OrdinalIgnoreCase), si value
contient un caractère ignorable, le résultat est équivalent à une recherche avec ce caractère supprimé. Si value
se compose uniquement d’un ou plusieurs caractères ignorés, la IndexOf(String, Int32, Int32, StringComparison) méthode retourne startIndex
toujours , qui est la position du caractère à laquelle la recherche commence.
Dans l’exemple suivant, la IndexOf(String, Int32, Int32, StringComparison) méthode est utilisée pour rechercher la position d’un trait d’union mou (U+00AD) suivi d’un « m » commençant du troisième au sixième caractère dans deux chaînes. Une seule des chaînes contient la sous-chaîne requise. Si l’exemple est exécuté sur .NET Framework 4 ou version ultérieure, dans les deux cas, comme le trait d’union mou est un caractère ignorable, la méthode retourne l’index « m » dans la chaîne lorsqu’elle effectue une comparaison sensible à la culture. Toutefois, lorsqu’il effectue une comparaison ordinale, il trouve la sous-chaîne uniquement dans la première chaîne. Notez que dans le cas de la première chaîne, qui inclut le trait d’union doux suivi d’un « m », la méthode ne parvient pas à renvoyer l’index du trait d’union souple, mais retourne à la place l’index du « m » lorsqu’elle effectue une comparaison sensible à la culture. La méthode retourne l'index du trait d'union conditionnel dans la première chaîne uniquement lorsqu'elle effectue une comparaison ordinale.
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
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance. La recherche commence à une position de caractère spécifiée et examine un nombre spécifié de positions de caractère.
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 -> int
Public Function IndexOf (value As String, startIndex As Integer, count As Integer) As Integer
Paramètres
- value
- String
Chaîne à rechercher.
- startIndex
- Int32
Position de départ de la recherche.
- count
- Int32
Nombre de positions de caractère à examiner.
Retours
Position d’index de base zéro de value
à partir du début de la instance actuelle si cette chaîne est trouvée, ou -1 si elle est introuvable. Si value
est Empty, la valeur de retour est startIndex
.
Exceptions
value
a la valeur null
.
count
ou startIndex
est un nombre négatif.
- ou -
startIndex
est supérieur à la longueur de cette chaîne.
- ou -
count
est supérieur à la longueur de cette chaîne moins startIndex
.
Exemples
L’exemple suivant recherche l’index de toutes les occurrences de la chaîne « he » dans une sous-chaîne d’une autre chaîne. Notez que le nombre de caractères à rechercher doit être recalculé pour chaque itération de recherche.
// Sample for String::IndexOf(String, Int32, Int32)
using namespace System;
int main()
{
String^ br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
String^ br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
String^ str = "Now is the time for all good men to come to the aid of their party.";
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 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
*/
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
'
'
Remarques
La numérotation des index commence à partir de 0 (zéro). Le paramètre startIndex
peut varier entre 0 et la longueur de l'instance de chaîne.
Cette méthode effectue une recherche de mots (respectant la casse et la culture) à l’aide de la culture actuelle. La recherche commence à startIndex
et se poursuit à startIndex
+ count
-1. Le caractère à startIndex
+ count
n’est pas inclus dans la recherche.
Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture. Dans une recherche dépendante de la culture, si value
contient un caractère ignorable, le résultat est équivalent à la recherche avec ce caractère supprimé. Si value
se compose uniquement d’un ou plusieurs caractères ignorés, la IndexOf(String, Int32, Int32) méthode retourne startIndex
toujours , qui est la position du caractère à laquelle la recherche commence. Dans l’exemple suivant, la IndexOf(String, Int32, Int32) méthode est utilisée pour rechercher la position d’un trait d’union mou (U+00AD) suivi d’un « m » commençant du troisième au sixième caractère dans deux chaînes. Une seule des chaînes contient la sous-chaîne requise. Si l’exemple est exécuté sur .NET Framework 4 ou version ultérieure, dans les deux cas, comme le trait d’union mou est un caractère ignorable, la méthode retourne l’index « m » dans la chaîne lorsqu’elle effectue une comparaison sensible à la culture. Notez que, dans le cas de la première chaîne, qui inclut le trait d'union conditionnel suivi d'un « m », la méthode ne parvient pas à retourner l'index du trait d'union, mais retourne à la place celui de la lettre « 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
Notes pour les appelants
Comme expliqué dans Meilleures pratiques pour l’utilisation de chaînes, nous vous recommandons d’éviter d’appeler des méthodes de comparaison de chaînes qui remplacent des valeurs par défaut et d’appeler à la place des méthodes qui nécessitent que des paramètres soient spécifiés explicitement. Pour utiliser les règles de comparaison de la culture actuelle pour effectuer cette opération, signalez explicitement votre intention en appelant la surcharge de méthode IndexOf(String, Int32, Int32, StringComparison) avec la valeur pour CurrentCulture son comparisonType
paramètre. Si vous n’avez pas besoin d’une comparaison linguistique, envisagez d’utiliser Ordinal.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence du caractère spécifié dans cette instance. La recherche commence à une position de caractère spécifiée et examine un nombre spécifié de positions de caractère.
public:
int IndexOf(char value, int startIndex, int count);
public int IndexOf (char value, int startIndex, int count);
member this.IndexOf : char * int * int -> int
Public Function IndexOf (value As Char, startIndex As Integer, count As Integer) As Integer
Paramètres
- value
- Char
Caractère Unicode à rechercher.
- startIndex
- Int32
Position de départ de la recherche.
- count
- Int32
Nombre de positions de caractère à examiner.
Retours
Position d’index de base zéro de value
à partir du début de la chaîne si ce caractère est trouvé, ou -1 s’il est introuvable.
Exceptions
count
ou startIndex
est un nombre négatif.
- ou -
startIndex
est supérieur à la longueur de cette chaîne.
- ou -
count
est supérieur à la longueur de cette chaîne moins startIndex
.
Exemples
L’exemple suivant illustre la IndexOf méthode.
// Example for the String::IndexOf( Char, int, int ) method.
using namespace System;
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 );
}
int 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 );
}
/*
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.
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
Remarques
La recherche commence à startIndex
et continue à startIndex
+ count
-1. Le caractère à startIndex
+ count
n’est pas inclus dans la recherche.
La numérotation d’index commence par 0 (zéro). Le paramètre startIndex
peut varier entre 0 et la longueur de l'instance de chaîne.
Cette méthode effectue une recherche ordinale (insensible à la culture), où un caractère est considéré comme équivalent à un autre caractère uniquement si ses valeurs scalaires Unicode sont identiques. Pour effectuer une recherche sensible à la culture, utilisez la CompareInfo.IndexOf méthode, où une valeur scalaire Unicode représentant un caractère précomposé, comme la ligature « Æ » (U+00C6), peut être considérée comme équivalente à toute occurrence des composants du caractère dans la séquence appropriée, telle que « AE » (U+0041, U+0045), selon la culture.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.
public:
int IndexOf(System::String ^ value, StringComparison comparisonType);
public int IndexOf (string value, StringComparison comparisonType);
member this.IndexOf : string * StringComparison -> int
Public Function IndexOf (value As String, comparisonType As StringComparison) As Integer
Paramètres
- value
- String
Chaîne à rechercher.
- comparisonType
- StringComparison
L'une des valeurs d'énumération qui spécifie les règles de la recherche.
Retours
Position d'index du paramètre value
si cette chaîne est trouvée, sinon, -1. Si value
est Empty, la valeur de retour est 0.
Exceptions
value
a la valeur null
.
comparisonType
n’est pas une valeur de StringComparison valide.
Exemples
L’exemple suivant illustre trois surcharges de la IndexOf méthode qui recherchent la première occurrence d’une chaîne dans une autre chaîne à l’aide de différentes valeurs de l’énumération 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
'
Remarques
La numérotation d’index commence à partir de zéro.
Le comparisonType
paramètre spécifie de rechercher le paramètre à l’aide de value
la culture actuelle ou invariante, à l’aide d’une recherche respectant la casse ou respectant la casse, et à l’aide de règles de comparaison de mots ou ordinaux.
Notes pour les appelants
Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture. Dans une recherche dépendante de la culture (autrement dit, si comparisonType
n'est pas Ordinal ou OrdinalIgnoreCase), si value
contient un caractère ignorable, le résultat est équivalent à une recherche avec ce caractère supprimé. Si value
se compose uniquement d’un ou plusieurs caractères ignorés, la IndexOf(String, StringComparison) méthode retourne toujours 0 (zéro) pour indiquer que la correspondance est trouvée au début de la instance actuelle.
Dans l’exemple suivant, la IndexOf(String, StringComparison) méthode est utilisée pour rechercher trois sous-chaînes (un trait d’union mou (U+00AD), un trait d’union doux suivi de « n » et un trait d’union doux suivi de « m ») dans deux chaînes. Une seule des chaînes contient un trait d'union conditionnel. Si l’exemple est exécuté sur .NET Framework 4 ou version ultérieure, parce que le trait d’union mou est un caractère ignoré, une recherche sensible à la culture retourne la même valeur qu’elle retournerait si le trait d’union souple n’était pas inclus dans la chaîne de recherche. Une recherche ordinale, cependant, trouve le trait d’union mou dans une chaîne et signale qu’il est absent de la deuxième chaîne.
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
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String actuel. Les paramètres spécifient la position de départ de la recherche dans la chaîne actuelle et le type de recherche à utiliser pour la chaîne spécifiée.
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 -> int
Public Function IndexOf (value As String, startIndex As Integer, comparisonType As StringComparison) As Integer
Paramètres
- value
- String
Chaîne à rechercher.
- startIndex
- Int32
Position de départ de la recherche.
- comparisonType
- StringComparison
L'une des valeurs d'énumération qui spécifie les règles de la recherche.
Retours
Position d’index de base zéro du paramètre value
à partir du début de l’instance active si cette chaîne est trouvée, ou -1 si elle est introuvable. Si value
est Empty, la valeur de retour est startIndex
.
Exceptions
value
a la valeur null
.
startIndex
est inférieur à 0 (zéro) ou supérieur à la longueur de cette chaîne.
comparisonType
n’est pas une valeur de StringComparison valide.
Exemples
L’exemple suivant illustre trois surcharges de la IndexOf méthode qui recherchent la première occurrence d’une chaîne dans une autre chaîne à l’aide de différentes valeurs de l’énumération 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
'
Remarques
La numérotation d’index commence par 0. Le paramètre startIndex
peut varier entre 0 et la longueur de l'instance de chaîne. Si startIndex
est égal à la longueur de la chaîne instance, la méthode retourne -1.
Le comparisonType
paramètre spécifie de rechercher le paramètre à l’aide de value
la culture actuelle ou invariante, à l’aide d’une recherche respectant la casse ou respectant la casse, et à l’aide de règles de comparaison de mots ou ordinaux.
Notes pour les appelants
Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture. Dans une recherche dépendante de la culture (autrement dit, si comparisonType
n'est pas Ordinal ou OrdinalIgnoreCase), si value
contient un caractère ignorable, le résultat est équivalent à une recherche avec ce caractère supprimé. Si value
se compose uniquement d’un ou plusieurs caractères ignorés, la IndexOf(String, Int32, StringComparison) méthode retourne startIndex
toujours , qui est la position de caractère à laquelle la recherche commence.
Dans l’exemple suivant, la IndexOf(String, Int32, StringComparison) méthode est utilisée pour rechercher la position d’un trait d’union doux (U+00AD) suivi d’un « m » commençant par la position du troisième caractère dans deux chaînes. Une seule des chaînes contient la sous-chaîne requise. Si l’exemple est exécuté sur .NET Framework 4 ou version ultérieure, dans les deux cas, parce que le trait d’union mou est un caractère ignoré, la méthode retourne l’index « m » dans la chaîne lorsqu’elle effectue une comparaison sensible à la culture. Notez que, dans le cas de la première chaîne, qui inclut le trait d'union conditionnel suivi d'un « m », la méthode ne parvient pas à retourner l'index du trait d'union, mais retourne à la place celui de la lettre « m ». La méthode retourne l'index du trait d'union conditionnel dans la première chaîne uniquement lorsqu'elle effectue une comparaison ordinale.
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
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne. Un paramètre spécifie le type de recherche à utiliser pour le caractère spécifié.
public:
int IndexOf(char value, StringComparison comparisonType);
public int IndexOf (char value, StringComparison comparisonType);
member this.IndexOf : char * StringComparison -> int
Public Function IndexOf (value As Char, comparisonType As StringComparison) As Integer
Paramètres
- value
- Char
Caractère à rechercher.
- comparisonType
- StringComparison
Une valeur d’énumération qui spécifie les règles de la recherche.
Retours
Index de base zéro de value
si ce caractère est trouvé, ou -1 s’il est introuvable.
Exceptions
comparisonType
n’est pas une valeur de StringComparison valide.
Remarques
La numérotation d’index commence à partir de zéro.
Le comparisonType
paramètre est un membre d’énumération StringComparison qui spécifie si la recherche de l’argument value
utilise la culture actuelle ou invariante, respecte la casse ou ne respecte pas la casse, ou utilise des règles de comparaison de mots ou ordinaux.
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Standard | 2.1 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne. La recherche commence à une position de caractère spécifiée.
public:
int IndexOf(char value, int startIndex);
public int IndexOf (char value, int startIndex);
member this.IndexOf : char * int -> int
Public Function IndexOf (value As Char, startIndex As Integer) As Integer
Paramètres
- value
- Char
Caractère Unicode à rechercher.
- startIndex
- Int32
Position de départ de la recherche.
Retours
Position d’index de base zéro de value
à partir du début de la chaîne si ce caractère est trouvé, ou -1 s’il est introuvable.
Exceptions
startIndex
est inférieur à 0 (zéro) ou supérieur à la longueur de la chaîne.
Exemples
L’exemple suivant illustre la IndexOf méthode.
// Sample for String::IndexOf(Char, Int32)
using namespace System;
int main()
{
String^ br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
String^ br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
String^ str = "Now is the time for all good men to come to the aid of their party.";
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 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
*/
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
'
'
Remarques
La numérotation d’index commence par 0. Le paramètre startIndex
peut varier entre 0 et la longueur de l'instance de chaîne. Si startIndex
est égal à la longueur de la chaîne instance, la méthode retourne -1.
Plages de recherche de startIndex
à la fin de la chaîne.
Cette méthode effectue une recherche ordinale (insensible à la culture), où un caractère est considéré comme équivalent à un autre caractère uniquement si ses valeurs scalaires Unicode sont identiques. Pour effectuer une recherche sensible à la culture, utilisez la CompareInfo.IndexOf méthode, où une valeur scalaire Unicode représentant un caractère précomposé, comme la ligature « Æ » (U+00C6), peut être considérée comme équivalente à toute occurrence des composants du caractère dans la séquence appropriée, telle que « AE » (U+0041, U+0045), selon la culture.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance.
public:
int IndexOf(System::String ^ value);
public int IndexOf (string value);
member this.IndexOf : string -> int
Public Function IndexOf (value As String) As Integer
Paramètres
- value
- String
Chaîne à rechercher.
Retours
Position d'index de base zéro de value
si cette chaîne est disponible ou -1 si elle est introuvable. Si value
est Empty, la valeur de retour est 0.
Exceptions
value
a la valeur null
.
Exemples
L’exemple suivant recherche le « n » dans « animal ». Étant donné que les index de chaîne commencent à zéro plutôt qu’à un, la IndexOf(String) méthode indique que le « n » se trouve à la position 1.
using namespace System;
void main()
{
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
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
L’exemple suivant utilise la IndexOf méthode pour déterminer la position de départ d’un nom d’animal dans une phrase. Il utilise ensuite cette position pour insérer un adjectif qui décrit l’animal dans la phrase.
using namespace System;
int 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 = String::Concat( adj1->Trim(), " " );
adj2 = String::Concat( 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.
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.
Remarques
La numérotation d’index commence à partir de zéro.
Cette méthode effectue une recherche de mots (respectant la casse et la culture) à l’aide de la culture actuelle. La recherche commence à la première position de caractère de cette instance et se poursuit jusqu’à la dernière position de caractère.
Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture. Dans une recherche dépendante de la culture, si value
contient un caractère ignorable, le résultat est équivalent à la recherche avec ce caractère supprimé. Si value
se compose uniquement d’un ou plusieurs caractères ignorés, la IndexOf(String) méthode retourne toujours 0 (zéro) pour indiquer que la correspondance est trouvée au début de la instance actuelle. Dans l’exemple suivant, la IndexOf(String) méthode est utilisée pour rechercher trois sous-chaînes (un trait d’union mou (U+00AD), un trait d’union doux suivi de « n » et un trait d’union doux suivi de « m ») dans deux chaînes. Une seule des chaînes contient un trait d'union conditionnel. Si l’exemple est exécuté sur .NET Framework 4 ou version ultérieure, dans chaque cas, car le trait d’union doux est un caractère ignorant, le résultat est identique à celui que le trait d’union doux n’avait pas été inclus dans value
. Lors de la recherche d’un trait d’union doux uniquement, la méthode retourne 0 (zéro) pour indiquer qu’elle a trouvé une correspondance au début de la chaîne.
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
Notes pour les appelants
Comme expliqué dans Meilleures pratiques pour l’utilisation de chaînes, nous vous recommandons d’éviter d’appeler des méthodes de comparaison de chaînes qui remplacent des valeurs par défaut et d’appeler plutôt des méthodes qui nécessitent des paramètres à spécifier explicitement. Pour rechercher le premier index d’une sous-chaîne au sein d’une chaîne instance à l’aide des règles de comparaison de la culture actuelle, signalez explicitement votre intention en appelant la IndexOf(String, StringComparison) surcharge de méthode avec une valeur de CurrentCulture pour son comparisonType
paramètre. Si vous n’avez pas besoin d’une comparaison linguistique, envisagez d’utiliser Ordinal.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne.
public:
int IndexOf(char value);
public int IndexOf (char value);
member this.IndexOf : char -> int
Public Function IndexOf (value As Char) As Integer
Paramètres
- value
- Char
Caractère Unicode à rechercher.
Retours
Position d'index de base zéro de value
si ce caractère est disponible ou -1 s'il est introuvable.
Exemples
L’exemple suivant montre comment rechercher un String caractère à l’aide de la IndexOf méthode .
using namespace System;
void main()
{
// Create a Unicode String with 5 Greek Alpha characters.
String^ szGreekAlpha = gcnew String(L'\x0391',5);
// Create a Unicode String with a 3 Greek Omega characters.
String^ szGreekOmega = L"\x03A9\x03A9\x03A9";
String^ szGreekLetters = String::Concat(szGreekOmega, szGreekAlpha,
szGreekOmega->Clone());
// Display the entire string.
Console::WriteLine(szGreekLetters);
// The first index of Alpha.
int ialpha = szGreekLetters->IndexOf( L'\x0391');
// The first index of Omega.
int iomega = szGreekLetters->IndexOf(L'\x03A9');
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: OOO?????OOO
// First occurrence of the Greek letter Alpha: Index 3
// First occurrence of the Greek letter Omega: Index 0
// 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
Remarques
La numérotation des index commence à partir de zéro.
Cette méthode effectue une recherche ordinale (non sensible à la culture), où un caractère est considéré comme équivalent à un autre caractère uniquement si ses valeurs scalaires Unicode sont identiques. Pour effectuer une recherche sensible à la culture, utilisez la CompareInfo.IndexOf méthode , où une valeur scalaire Unicode représentant un caractère précomposé, telle que la ligature « Æ » (U+00C6), peut être considérée comme équivalente à toute occurrence des composants du caractère dans la séquence correcte, telle que « AE » (U+0041, U+0045), selon la culture.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
- Source:
- String.Searching.cs
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance. La recherche commence à une position de caractère spécifiée.
public:
int IndexOf(System::String ^ value, int startIndex);
public int IndexOf (string value, int startIndex);
member this.IndexOf : string * int -> int
Public Function IndexOf (value As String, startIndex As Integer) As Integer
Paramètres
- value
- String
Chaîne à rechercher.
- startIndex
- Int32
Position de départ de la recherche.
Retours
Position d’index de base zéro de value
à partir du début de la instance actuelle si cette chaîne est trouvée, ou -1 si elle est introuvable. Si value
est Empty, la valeur de retour est startIndex
.
Exceptions
value
a la valeur null
.
startIndex
est inférieur à 0 (zéro) ou supérieur à la longueur de cette chaîne.
Exemples
L’exemple suivant recherche toutes les occurrences d’une chaîne spécifiée dans une chaîne cible.
using namespace System;
int 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->Equals( "" ) )
{
for ( int i = 0; i < strSource->Length; i++ )
{
found = strSource->IndexOf( strTarget, i );
if (found >= 0)
{
totFinds++;
i = found;
}
else
break;
}
}
else
return 0;
Console::WriteLine( "{0}The search parameter '{1}' was found {2} times. {0}", Environment::NewLine, strTarget, totFinds );
totFinds = 0;
}
while ( true );
}
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
Remarques
La numérotation de l’index commence à partir de 0. Le paramètre startIndex
peut varier entre 0 et la longueur de l'instance de chaîne. Si startIndex
est égal à la longueur de la chaîne instance, la méthode retourne -1.
Cette méthode effectue une recherche de mots (respectant la casse et la culture) à l’aide de la culture actuelle. La recherche commence à la startIndex
position du caractère de ce instance et se poursuit jusqu’à la dernière position du caractère.
Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture. Dans une recherche dépendante de la culture, si value
contient un caractère ignorable, le résultat est équivalent à la recherche avec ce caractère supprimé. Si value
se compose uniquement d’un ou plusieurs caractères ignorés, la IndexOf(String, Int32) méthode retourne startIndex
toujours , qui est la position du caractère à laquelle la recherche commence. Dans l’exemple suivant, la IndexOf(String, Int32) méthode est utilisée pour rechercher la position d’un trait d’union mou (U+00AD) suivi d’un « m » dans deux chaînes. Une seule des chaînes contient la sous-chaîne requise. Si l’exemple est exécuté sur .NET Framework 4 ou version ultérieure, dans les deux cas, étant donné que le trait d’union mou est un caractère ignorable, la méthode retourne l’index « m » dans la chaîne. Notez que, dans le cas de la première chaîne, qui inclut le trait d'union conditionnel suivi d'un « m », la méthode ne parvient pas à retourner l'index du trait d'union, mais retourne à la place celui de la lettre « 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
Notes pour les appelants
Comme expliqué dans Meilleures pratiques pour l’utilisation de chaînes, nous vous recommandons d’éviter d’appeler des méthodes de comparaison de chaînes qui remplacent des valeurs par défaut et d’appeler à la place des méthodes qui nécessitent que des paramètres soient spécifiés explicitement. Pour rechercher le premier index d’une sous-chaîne qui se produit après une position de caractère particulière à l’aide des règles de comparaison de la culture actuelle, signalez explicitement votre intention en appelant la surcharge de CurrentCulture méthode IndexOf(String, Int32, StringComparison) avec la valeur pour son comparisonType
paramètre. Si vous n’avez pas besoin d’une comparaison linguistique, envisagez d’utiliser Ordinal.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
Commentaires sur .NET
.NET est un projet open source. Sélectionnez un lien pour fournir des commentaires :