Číst v angličtině

Sdílet prostřednictvím

String.LastIndexOf Metoda

  • Reference

Definice

Obor názvů:
System
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku nebo řetězce Unicode v rámci této instance. Metoda vrátí -1, pokud se v této instanci nenajde znak nebo řetězec.

Přetížení

LastIndexOf(String, Int32, Int32, StringComparison)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného řetězce v rámci této instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků. Parametr určuje typ porovnání, který se má provést při hledání zadaného řetězce.
LastIndexOf(String, Int32, Int32)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného řetězce v rámci této instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků.
LastIndexOf(Char, Int32, Int32)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v podřetědci v rámci této instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků.
LastIndexOf(String, StringComparison)

Hlásí index založený na nule posledního výskytu zadaného řetězce v aktuálním String objektu. Parametr určuje typ hledání, který se má použít pro zadaný řetězec.
LastIndexOf(String, Int32, StringComparison)

Hlásí index založený na nule posledního výskytu zadaného řetězce v aktuálním String objektu. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce. Parametr určuje typ porovnání, který se má provést při hledání zadaného řetězce.
LastIndexOf(Char, Int32)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v této instanci. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce.
LastIndexOf(String)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného řetězce v rámci této instance.
LastIndexOf(Char)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v této instanci.
LastIndexOf(String, Int32)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného řetězce v rámci této instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce.

LastIndexOf(String, Int32, Int32, StringComparison)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí pozici indexu založeného na nule posledního výskytu zadaného řetězce v rámci této instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků. Parametr určuje typ porovnání, který se má provést při hledání zadaného řetězce.

public int LastIndexOf (string value, int startIndex, int count, StringComparison comparisonType);

Parametry

value
String

Řetězec, který chcete vyhledat.

startIndex
Int32

Počáteční pozice hledání. Hledání pokračuje od startIndex směrem k začátku této instance.

count
Int32

Počet pozic znaků, které chcete prozkoumat.

comparisonType
StringComparison

Jedna z hodnot výčtu, která určuje pravidla pro vyhledávání.

Návraty

Int32

Pozice počátečního indexu založeného na nule value parametru, pokud je tento řetězec nalezen, nebo -1 pokud není nalezena nebo pokud aktuální instance se rovná Empty.

Výjimky

ArgumentNullException

value je null.

ArgumentOutOfRangeException

count je negativní.

-nebo-

Aktuální instance se nerovná Emptya startIndex je záporná.

-nebo-

Aktuální instance se nerovná Emptya startIndex je větší než délka této instance.

-nebo-

Aktuální instance se nerovná Emptya startIndex + 1 – count určuje pozici, která není v této instanci.

-nebo-

Aktuální instance se rovná Empty a startIndex je menší než -1 nebo větší než nula.

-nebo-

Aktuální instance se rovná Empty a count je větší než 1.

ArgumentException

comparisonType není platná hodnota StringComparison.

Příklady

Následující příklad ukazuje tři přetížení LastIndexOf metoda, které najdou poslední výskyt řetězce v jiném řetězci pomocí různých hodnot StringComparison výčtu.

// This code example demonstrates the 
// System.String.LastIndexOf(String, ..., StringComparison) methods.

using System;
using System.Threading;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last 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 StringComparsion. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(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 last 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

*/

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1.

Hledání začíná na pozici startIndex znaku a pokračuje zpět, dokud se nenajde value nebo count pozice znaků. Pokud je například startIndexLength - 1, metoda vyhledá zpětně count znaky od posledního znaku v řetězci.

Parametr comparisonType určuje, že se má vyhledat parametr value pomocí:

  • Aktuální nebo invariantní jazyková verze.
  • Vyhledávání nerozlišuje velká a malá a velká písmena.
  • Pravidla porovnávání slov nebo řadových pravidel

Poznámky pro volající

Znakové sady obsahují ignorovatelné znaky, což jsou znaky, které se při provádění jazykového nebo jazykového porovnání nerozlišují. V hledání citlivém na jazykovou verzi (to znamená, že pokud comparisonType není Ordinal nebo OrdinalIgnoreCase), pokud value obsahuje ignorovatelný znak, je výsledek ekvivalentní hledání s tímto znakem odebraným.

V následujícím příkladu se metoda LastIndexOf(String, Int32, Int32, StringComparison) používá k vyhledání pozice měkkého spojovníku (U+00AD) následovaného znakem "m" ve všech kromě první pozice znaku před posledním znakem "m" ve dvou řetězcích. Požadovaný podřetězc obsahuje pouze jeden z řetězců. Pokud je příklad spuštěn v rozhraní .NET Framework 4 nebo novější, v obou případech, protože měkký spojovník je ignorovatelný znak, metoda vrátí index "m" v řetězci, když provede porovnání s jazykovou verzí. Když však provede řadové porovnání, najde podřetězce pouze v prvním řetězci. Všimněte si, že v případě prvního řetězce, který obsahuje měkké pomlčky následované "m", metoda vrátí index "m", když provede porovnání citlivé na jazykovou verzi. Metoda vrátí index měkkého spojovníku v prvním řetězci pouze při provádění pořadového porovnání.

string searchString = "\u00ADm";

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

int position;

position = s1.LastIndexOf('m');
if (position >= 1)
{
    Console.WriteLine(s1.LastIndexOf(searchString, position, position, StringComparison.CurrentCulture));
    Console.WriteLine(s1.LastIndexOf(searchString, position, position, StringComparison.Ordinal));
}

position = s2.LastIndexOf('m');
if (position >= 1)
{
    Console.WriteLine(s2.LastIndexOf(searchString, position, position, StringComparison.CurrentCulture));
    Console.WriteLine(s2.LastIndexOf(searchString, position, position, StringComparison.Ordinal));
}

// The example displays the following output:
//
// 4
// 3
// 3
// -1

Platí pro

.NET 9 a další verze
Produkt Verze
.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

LastIndexOf(String, Int32, Int32)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí pozici indexu založeného na nule posledního výskytu zadaného řetězce v rámci této instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků.

public int LastIndexOf (string value, int startIndex, int count);

Parametry

value
String

Řetězec, který chcete vyhledat.

startIndex
Int32

Počáteční pozice hledání. Hledání pokračuje od startIndex směrem k začátku této instance.

count
Int32

Počet pozic znaků, které chcete prozkoumat.

Návraty

Int32

Pozice počátečního indexu založeného na nule value, pokud se tento řetězec najde, nebo -1, pokud se nenajde nebo pokud se aktuální instance rovná Empty.

Výjimky

ArgumentNullException

value je null.

ArgumentOutOfRangeException

count je negativní.

-nebo-

Aktuální instance se nerovná Emptya startIndex je záporná.

-nebo-

Aktuální instance se nerovná Emptya startIndex je větší než délka této instance.

-nebo-

Aktuální instance se nerovná Emptya startIndex - count+ 1 určuje pozici, která není v této instanci.

-nebo-

Aktuální instance se rovná Empty a startIndex je menší než -1 nebo větší než nula.

-nebo-

Aktuální instance se rovná Empty a count je větší než 1.

Příklady

Následující příklad najde index všech výskytů řetězce v podřetězci, který pracuje od konce podřetězce až po začátek podřetězce.

// Sample for String.LastIndexOf(String, Int32, Int32)
using System;

class Sample {
    public static void 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 count;
    int end;

    start = str.Length-1;
    end = start/2 - 1;
    Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, end);
    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 > -1) && (at > -1))
        {
        count = start - end; //Count must be within the substring.
        at = str.LastIndexOf("he", start, count);
        if (at > -1)
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 'he' from position 66 to 32.
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): 56 45
*/

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1.

Hledání začíná na startIndex pozici znaku této instance a pokračuje směrem k začátku, dokud se nenajde value nebo count pozice znaků. Pokud je například startIndexLength - 1, metoda vyhledá zpětně count znaky od posledního znaku v řetězci.

Tato metoda provádí hledání slov (rozlišujících velká a malá písmena a jazykové verze) pomocí aktuální jazykové verze.

Znakové sady obsahují ignorovatelné znaky, což jsou znaky, které se při provádění jazykového nebo jazykového porovnání nerozlišují. Pokud v hledání citlivém na jazykovou verzi value obsahuje ignorovatelný znak, výsledek odpovídá hledání s odebraným znakem.

V následujícím příkladu se metoda LastIndexOf používá k vyhledání pozice měkkého spojovníku (U+00AD) následovaného znakem "m" nebo "n" ve dvou řetězcích. Pouze jeden z řetězců obsahuje měkké pomlčky. V případě řetězce, který obsahuje měkké pomlčky následované znakem "m", LastIndexOf vrátí index "m" při hledání měkkého spojovníku následovaného znakem "m".

int position = 0;
string s1 = "ani\u00ADmal";
string s2 = "animal";

// Find the index of the soft hyphen followed by "n".
position = s1.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s1.LastIndexOf("\u00ADn", position, position + 1));

position = s2.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s2.LastIndexOf("\u00ADn", position, position + 1));

// Find the index of the soft hyphen followed by "m".
position = s1.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s1.LastIndexOf("\u00ADm", position, position + 1));

position = s2.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s2.LastIndexOf("\u00ADm", position, position + 1));

// The example displays the following output:
//
// 'm' at position 4
// 1
// 'm' at position 3
// 1
// 'm' at position 4
// 4
// 'm' at position 3
// 3

Poznámky pro volající

Jak je vysvětleno v osvědčených postupů pro používání řetězců, doporučujeme vyhnout se volání metod porovnání řetězců, které nahrazují výchozí hodnoty a místo toho volají metody, které vyžadují explicitní zadání parametrů. Chcete-li provést tuto operaci pomocí srovnávacích pravidel aktuální jazykové verze, signalizovat záměr explicitně voláním přetížení metody LastIndexOf(String, Int32, Int32, StringComparison) s hodnotou CurrentCulture pro jeho comparisonType parametr. Pokud nepotřebujete porovnání s lingvistiky, zvažte použití Ordinal.

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.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

LastIndexOf(Char, Int32, Int32)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v podřetědci v rámci této instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků.

public int LastIndexOf (char value, int startIndex, int count);

Parametry

value
Char

Znak Unicode, který se má vyhledat.

startIndex
Int32

Počáteční pozice hledání. Hledání pokračuje od startIndex směrem k začátku této instance.

count
Int32

Počet pozic znaků, které chcete prozkoumat.

Návraty

Int32

Umístění indexu založeného na nule value, pokud je tento znak nalezen, nebo -1 pokud není nalezen nebo pokud aktuální instance se rovná Empty.

Výjimky

ArgumentOutOfRangeException

Aktuální instance se nerovná Emptya startIndex je menší než nula nebo větší nebo rovna délce této instance.

-nebo-

Aktuální instance se nerovná Emptya startIndex - count + 1 je menší než nula.

Příklady

Následující příklad najde index všech výskytů znaku v podřetězdci, který pracuje od konce podřetězdce až po začátek podřetězdce.

// Sample for String.LastIndexOf(Char, Int32, Int32)
using System;

class Sample {
    public static void 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 count;
    int end;

    start = str.Length-1;
    end = start/2 - 1;
    Console.WriteLine("All occurrences of 't' from position {0} to {1}.", start, end);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The letter 't' occurs at position(s): ");

    count = 0;
    at = 0;
    while((start > -1) && (at > -1))
        {
        count = start - end; //Count must be within the substring.
        at = str.LastIndexOf('t', start, count);
        if (at > -1)
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 't' from position 66 to 32.
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): 64 55 44 41 33


*/

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1.

Tato metoda začne hledat na pozici znaku startIndex a pokračuje zpět směrem k začátku této instance, dokud se nenajde value nebo count pozice znaků byly prozkoumány. Pokud je například startIndexLength - 1, metoda vyhledá zpětně count znaky od posledního znaku v řetězci. Hledání se rozlišují malá a velká písmena.

Tato metoda provádí řadové vyhledávání (bez rozlišení jazykové verze), kde je znak považován za ekvivalentní jinému znaku pouze v případě, že skalární hodnota Unicode je stejná. Chcete-li provést vyhledávání citlivé na jazykovou verzi, použijte metodu CompareInfo.LastIndexOf, kde skalární hodnota Unicode představující předkomposovaný znak, například ligaturu "Æ" (U+00C6), může být v závislosti na jazykové verzi považována za ekvivalentní jakémukoli výskytu součástí znaku ve správném pořadí, například "AE" (U+0041, U+0045).

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.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

LastIndexOf(String, StringComparison)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí index založený na nule posledního výskytu zadaného řetězce v aktuálním String objektu. Parametr určuje typ hledání, který se má použít pro zadaný řetězec.

public int LastIndexOf (string value, StringComparison comparisonType);

Parametry

value
String

Řetězec, který chcete vyhledat.

comparisonType
StringComparison

Jedna z hodnot výčtu, která určuje pravidla pro vyhledávání.

Návraty

Int32

Pozice počátečního indexu založeného na nule parametru value, pokud se tento řetězec najde, nebo -1, pokud ne.

Výjimky

ArgumentNullException

value je null.

ArgumentException

comparisonType není platná hodnota StringComparison.

Příklady

Následující příklad ukazuje tři přetížení LastIndexOf metoda, které najdou poslední výskyt řetězce v jiném řetězci pomocí různých hodnot StringComparison výčtu.

// This code example demonstrates the 
// System.String.LastIndexOf(String, ..., StringComparison) methods.

using System;
using System.Threading;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last 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 StringComparsion. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(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 last 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

*/

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1.

Parametr comparisonType určuje, že se má vyhledat parametr value pomocí:

  • Aktuální nebo invariantní jazyková verze.
  • Vyhledávání nerozlišuje velká a malá a velká písmena.
  • Pravidla porovnávání slov nebo řadových pravidel

Hledání začíná na poslední pozici znaku této instance a pokračuje zpět směrem k začátku, dokud se nenajde value nebo se prozkoumá první pozice znaku.

Poznámky pro volající

Znakové sady obsahují ignorovatelné znaky, což jsou znaky, které se při provádění jazykového nebo jazykového porovnání nerozlišují. V hledání citlivém na jazykovou verzi (to znamená, že pokud options není Ordinal nebo OrdinalIgnoreCase), pokud value obsahuje ignorovatelný znak, je výsledek ekvivalentní hledání s tímto znakem odebraným.

V následujícím příkladu se metoda LastIndexOf(String, StringComparison) používá k vyhledání dvou podřetězců (měkký spojovník následovaný "n" a měkký spojovník následovaný "m") ve dvou řetězcích. Pouze jeden z řetězců obsahuje měkké pomlčky. Pokud je příklad spuštěn v rozhraní .NET Framework 4 nebo novější, protože měkký spojovník je ignorovatelný znak, vrátí vyhledávání citlivé na jazykovou verzi stejnou hodnotu, kterou by vrátila, pokud by se do vyhledávacího řetězce nezahrnulo měkké pomlčky. Pořadové vyhledávání však úspěšně najde měkké spojovníky v jednom řetězci a hlásí, že chybí ve druhém řetězci.

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

Console.WriteLine("Culture-sensitive comparison:");

// Use culture-sensitive comparison to find the last soft hyphen followed by "n".
Console.WriteLine(s1.LastIndexOf("\u00ADn", StringComparison.CurrentCulture));
Console.WriteLine(s2.LastIndexOf("\u00ADn", StringComparison.CurrentCulture));

// Use culture-sensitive comparison to find the last soft hyphen followed by "m".
Console.WriteLine(s1.LastIndexOf("\u00ADm", StringComparison.CurrentCulture));
Console.WriteLine(s2.LastIndexOf("\u00ADm", StringComparison.CurrentCulture));

Console.WriteLine("Ordinal comparison:");

// Use ordinal comparison to find the last soft hyphen followed by "n".
Console.WriteLine(s1.LastIndexOf("\u00ADn", StringComparison.Ordinal));
Console.WriteLine(s2.LastIndexOf("\u00ADn", StringComparison.Ordinal));

// Use ordinal comparison to find the last soft hyphen followed by "m".
Console.WriteLine(s1.LastIndexOf("\u00ADm", StringComparison.Ordinal));
Console.WriteLine(s2.LastIndexOf("\u00ADm", StringComparison.Ordinal));

// The example displays the following output:
//
// Culture-sensitive comparison:
// 1
// 1
// 4
// 3
// Ordinal comparison:
// -1
// -1
// 3
// -1

Platí pro

.NET 9 a další verze
Produkt Verze
.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

LastIndexOf(String, Int32, StringComparison)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí index založený na nule posledního výskytu zadaného řetězce v aktuálním String objektu. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce. Parametr určuje typ porovnání, který se má provést při hledání zadaného řetězce.

public int LastIndexOf (string value, int startIndex, StringComparison comparisonType);

Parametry

value
String

Řetězec, který chcete vyhledat.

startIndex
Int32

Počáteční pozice hledání. Hledání pokračuje od startIndex směrem k začátku této instance.

comparisonType
StringComparison

Jedna z hodnot výčtu, která určuje pravidla pro vyhledávání.

Návraty

Int32

Pozice počátečního indexu založeného na nule value parametru, pokud je tento řetězec nalezen, nebo -1 pokud není nalezena nebo pokud aktuální instance se rovná Empty.

Výjimky

ArgumentNullException

value je null.

ArgumentOutOfRangeException

Aktuální instance se nerovná Emptya startIndex je menší než nula nebo větší než délka aktuální instance.

-nebo-

Aktuální instance se rovná Emptya startIndex je menší než -1 nebo větší než nula.

ArgumentException

comparisonType není platná hodnota StringComparison.

Příklady

Následující příklad ukazuje tři přetížení LastIndexOf metoda, které najdou poslední výskyt řetězce v jiném řetězci pomocí různých hodnot StringComparison výčtu.

// This code example demonstrates the 
// System.String.LastIndexOf(String, ..., StringComparison) methods.

using System;
using System.Threading;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last 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 StringComparsion. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(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 last 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

*/

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1.

Hledání začíná na pozici startIndex znaku a pokračuje zpět, dokud se nenajde value nebo se prozkoumá první pozice znaku. Pokud je například startIndexLength - 1, metoda vyhledá každý znak od posledního znaku v řetězci na začátek.

Parametr comparisonType určuje, že má hledat parametr value pomocí aktuální nebo invariantní jazykové verze, pomocí vyhledávání bez rozlišování velkých a malých a velkých písmen a použití pravidel porovnání slov nebo řadových porovnání.

Poznámky pro volající

Znakové sady obsahují ignorovatelné znaky, což jsou znaky, které se při provádění jazykového nebo jazykového porovnání nerozlišují. V hledání citlivém na jazykovou verzi (to znamená, že pokud comparisonType není Ordinal nebo OrdinalIgnoreCase), pokud value obsahuje ignorovatelný znak, je výsledek ekvivalentní hledání s tímto znakem odebraným.

V následujícím příkladu se metoda LastIndexOf(String, Int32, StringComparison) používá k vyhledání pozice měkkého spojovníku (U+00AD), za kterým následuje "m", počínaje posledním "m" ve dvou řetězcích. Požadovaný podřetězc obsahuje pouze jeden z řetězců. Pokud je příklad spuštěn v rozhraní .NET Framework 4 nebo novější, v obou případech, protože měkký spojovník je ignorovatelný znak, metoda vrátí index "m" v řetězci, když provede porovnání s jazykovou verzí. Všimněte si, že v případě prvního řetězce, který obsahuje měkké pomlčky následované znakem "m", metoda vrátí index "m" a ne index měkkého spojovníku. Metoda vrátí index měkkého spojovníku v prvním řetězci pouze při provádění pořadového porovnání.

string searchString = "\u00ADm";

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

int position;

position = s1.LastIndexOf('m');
if (position >= 0)
{
    Console.WriteLine(s1.LastIndexOf(searchString, position, StringComparison.CurrentCulture));
    Console.WriteLine(s1.LastIndexOf(searchString, position, StringComparison.Ordinal));
}

position = s2.LastIndexOf('m');
if (position >= 0)
{
    Console.WriteLine(s2.LastIndexOf(searchString, position, StringComparison.CurrentCulture));
    Console.WriteLine(s2.LastIndexOf(searchString, position, StringComparison.Ordinal));
}

// The example displays the following output:
//
// 4
// 3
// 3
// -1

Platí pro

.NET 9 a další verze
Produkt Verze
.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

LastIndexOf(Char, Int32)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v této instanci. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce.

public int LastIndexOf (char value, int startIndex);

Parametry

value
Char

Znak Unicode, který se má vyhledat.

startIndex
Int32

Počáteční pozice hledání. Hledání pokračuje od startIndex směrem k začátku této instance.

Návraty

Int32

Umístění indexu založeného na nule value, pokud je tento znak nalezen, nebo -1 pokud není nalezen nebo pokud aktuální instance se rovná Empty.

Výjimky

ArgumentOutOfRangeException

Aktuální instance se nerovná Emptya startIndex je menší než nula nebo větší nebo rovna délce této instance.

Příklady

Následující příklad najde index všech výskytů znaku v řetězci, který pracuje od konce řetězce po začátek řetězce.

// Sample for String.LastIndexOf(Char, Int32)
using System;

class Sample {
    public static void 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;

    start = str.Length-1;
    Console.WriteLine("All occurrences of 't' from position {0} to 0.", start);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The letter 't' occurs at position(s): ");

    at = 0;
    while((start > -1) && (at > -1))
        {
        at = str.LastIndexOf('t', start);
        if (at > -1)
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 't' from position 66 to 0.
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): 64 55 44 41 33 11 7
*/

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1. Tato metoda začne prohledávat startIndex pozici znaku této instance a pokračuje zpět k začátku aktuální instance, dokud se nenajde value nebo se prozkoumá první pozice znaku. Pokud je například startIndexLength - 1, metoda vyhledá každý znak od posledního znaku v řetězci na začátek. Hledání se rozlišují malá a velká písmena.

Tato metoda provádí řadové vyhledávání (bez rozlišení jazykové verze), kde se znak považuje za ekvivalentní jinému znaku pouze v případě, že skalární hodnoty Unicode jsou stejné. Chcete-li provést vyhledávání citlivé na jazykovou verzi, použijte metodu CompareInfo.LastIndexOf, kde skalární hodnota Unicode představující předkomposovaný znak, například ligaturu "Æ" (U+00C6), může být v závislosti na jazykové verzi považována za ekvivalentní jakémukoli výskytu součástí znaku ve správném pořadí, například "AE" (U+0041, U+0045).

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.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

LastIndexOf(String)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí pozici indexu založeného na nule posledního výskytu zadaného řetězce v rámci této instance.

public int LastIndexOf (string value);

Parametry

value
String

Řetězec, který chcete vyhledat.

Návraty

Int32

Pozice počátečního indexu založeného na nule value, pokud se tento řetězec najde, nebo -1, pokud není.

Výjimky

ArgumentNullException

value je null.

Příklady

Následující příklad odebere otevírání a zavírání značek HTML z řetězce, pokud značky začínají a ukončují řetězec. Pokud řetězec končí znakem uzavírací hranaté závorky (">"), příklad používá metodu LastIndexOf k vyhledání začátku koncové značky.

using System;

public class Example 
{
   public static void Main() 
   {
      string[] strSource = { "<b>This is bold text</b>", "<H1>This is large Text</H1>",
               "<b><i><font color=green>This has multiple tags</font></i></b>",
               "<b>This has <i>embedded</i> tags.</b>",
               "This line ends with a greater than symbol and should not be modified>" };

      // Strip HTML start and end tags from each string if they are present.
      foreach (string s in strSource)
      {
         Console.WriteLine("Before: " + s);
         string item = s;
         // Use EndsWith to find a tag at the end of the line.
         if (item.Trim().EndsWith(">")) 
         {
            // Locate the opening tag.
            int endTagStartPosition = item.LastIndexOf("</");
            // Remove the identified section, if it is valid.
            if (endTagStartPosition >= 0 )
               item = item.Substring(0, endTagStartPosition);

            // Use StartsWith to find the opening tag.
            if (item.Trim().StartsWith("<"))
            {
               // Locate the end of opening tab.
               int openTagEndPosition = item.IndexOf(">");
               // Remove the identified section, if it is valid.
               if (openTagEndPosition >= 0)
                  item = item.Substring(openTagEndPosition + 1);
            }      
         }
         // Display the trimmed string.
         Console.WriteLine("After: " + item);
         Console.WriteLine();
      }                   
   }
}
// The example displays the following output:
//    Before: <b>This is bold text</b>
//    After: This is bold text
//    
//    Before: <H1>This is large Text</H1>
//    After: This is large Text
//    
//    Before: <b><i><font color=green>This has multiple tags</font></i></b>
//    After: <i><font color=green>This has multiple tags</font></i>
//    
//    Before: <b>This has <i>embedded</i> tags.</b>
//    After: This has <i>embedded</i> tags.
//    
//    Before: This line ends with a greater than symbol and should not be modified>
//    After: This line ends with a greater than symbol and should not be modified>

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1.

Hledání začíná na poslední pozici znaku této instance a pokračuje zpět směrem k začátku, dokud se nenajde value nebo se prozkoumá první pozice znaku.

Tato metoda provádí hledání slov (rozlišujících velká a malá písmena a jazykové verze) pomocí aktuální jazykové verze.

Znakové sady obsahují ignorovatelné znaky, což jsou znaky, které se při provádění jazykového nebo jazykového porovnání nerozlišují. Pokud v hledání citlivém na jazykovou verzi value obsahuje ignorovatelný znak, výsledek odpovídá hledání s odebraným znakem.

V následujícím příkladu se metoda LastIndexOf(String) používá k vyhledání dvou podřetězců (měkký spojovník následovaný "n" a měkký spojovník následovaný "m") ve dvou řetězcích. Pouze jeden z řetězců obsahuje měkké pomlčky. Pokud je příklad spuštěn v rozhraní .NET Framework 4 nebo novější, v každém případě, protože měkký spojovník je ignorovatelný znak, výsledek je stejný jako v případě, že měkké pomlčky nebyly zahrnuty do value.

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

// Find the index of the last soft hyphen followed by "n".
Console.WriteLine(s1.LastIndexOf("\u00ADn"));
Console.WriteLine(s2.LastIndexOf("\u00ADn"));

// Find the index of the last soft hyphen followed by "m".
Console.WriteLine(s1.LastIndexOf("\u00ADm"));
Console.WriteLine(s2.LastIndexOf("\u00ADm"));

// The example displays the following output:
//
// 1
// 1
// 4
// 3

Poznámky pro volající

Jak je vysvětleno v osvědčených postupů pro používání řetězců, doporučujeme vyhnout se volání metod porovnání řetězců, které nahrazují výchozí hodnoty a místo toho volají metody, které vyžadují explicitní zadání parametrů. Pokud chcete najít poslední index podřetězce v instanci řetězce pomocí srovnávacích pravidel aktuální jazykové verze, signalizovat záměr explicitně voláním LastIndexOf(String, StringComparison) přetížení metody s hodnotou CurrentCulture pro jeho comparisonType parametr. Pokud nepotřebujete porovnání s lingvistiky, zvažte použití Ordinal.

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.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

LastIndexOf(Char)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v této instanci.

public int LastIndexOf (char value);

Parametry

value
Char

Znak Unicode, který se má vyhledat.

Návraty

Int32

Pozice indexu založeného na nule value, pokud je tento znak nalezen, nebo -1, pokud není.

Příklady

Následující příklad definuje ExtractFilename metodu, která používá metodu LastIndexOf(Char) k vyhledání posledního znaku oddělovače adresáře v řetězci a k extrahování názvu souboru řetězce. Pokud soubor existuje, vrátí metoda název souboru bez jeho cesty.

using System;
using System.IO;

public class TestLastIndexOf
{
   public static void Main()
   {
      string filename;
      
      filename = ExtractFilename(@"C:\temp\");
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
      
      filename = ExtractFilename(@"C:\temp\delegate.txt"); 
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);

      filename = ExtractFilename("delegate.txt");      
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
      
      filename = ExtractFilename(@"C:\temp\notafile.txt");
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
   }

   public static string ExtractFilename(string filepath)
   {
      // If path ends with a "\", it's a path only so return String.Empty.
      if (filepath.Trim().EndsWith(@"\"))
         return String.Empty;
      
      // Determine where last backslash is.
      int position = filepath.LastIndexOf('\\');
      // If there is no backslash, assume that this is a filename.
      if (position == -1)
      {
         // Determine whether file exists in the current directory.
         if (File.Exists(Environment.CurrentDirectory + Path.DirectorySeparatorChar + filepath)) 
            return filepath;
         else
            return String.Empty;
      }
      else
      {
         // Determine whether file exists using filepath.
         if (File.Exists(filepath))
            // Return filename without file path.
            return filepath.Substring(position + 1);
         else
            return String.Empty;
      }
   }
}

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1.

Tato metoda začne prohledávat poslední pozici znaku této instance a pokračuje směrem k začátku, dokud se nenajde value nebo se prozkoumá první pozice znaku. Hledání se rozlišují malá a velká písmena.

Tato metoda provádí řadové vyhledávání (bez rozlišení jazykové verze), kde se znak považuje za ekvivalentní jinému znaku pouze v případě, že skalární hodnoty Unicode jsou stejné. Chcete-li provést vyhledávání citlivé na jazykovou verzi, použijte metodu CompareInfo.LastIndexOf, kde skalární hodnota Unicode představující předkomposovaný znak, například ligaturu "Æ" (U+00C6), může být v závislosti na jazykové verzi považována za ekvivalentní jakémukoli výskytu součástí znaku ve správném pořadí, například "AE" (U+0041, U+0045).

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.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

LastIndexOf(String, Int32)

Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs
Zdroj:
String.Searching.cs

Hlásí pozici indexu založeného na nule posledního výskytu zadaného řetězce v rámci této instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce.

public int LastIndexOf (string value, int startIndex);

Parametry

value
String

Řetězec, který chcete vyhledat.

startIndex
Int32

Počáteční pozice hledání. Hledání pokračuje od startIndex směrem k začátku této instance.

Návraty

Int32

Pozice počátečního indexu založeného na nule value, pokud se tento řetězec najde, nebo -1, pokud se nenajde nebo pokud se aktuální instance rovná Empty.

Výjimky

ArgumentNullException

value je null.

ArgumentOutOfRangeException

Aktuální instance se nerovná Emptya startIndex je menší než nula nebo větší než délka aktuální instance.

-nebo-

Aktuální instance se rovná Emptya startIndex je menší než -1 nebo větší než nula.

Příklady

Následující příklad najde index všech výskytů řetězce v cílovém řetězci, který pracuje od konce cílového řetězce až po začátek cílového řetězce.

// Sample for String.LastIndexOf(String, Int32)
using System;

class Sample {
    public static void 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;

    start = str.Length-1;
    Console.WriteLine("All occurrences of 'he' from position {0} to 0.", start);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The string 'he' occurs at position(s): ");

    at = 0;
    while((start > -1) && (at > -1))
        {
        at = str.LastIndexOf("he", start);
        if (at > -1)
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 'he' from position 66 to 0.
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): 56 45 8


*/

Poznámky

Číslování indexů začíná od nuly. To znamená, že první znak v řetězci je na nule indexu a poslední je v Length - 1.

Hledání začíná na startIndex pozici znaku této instance a pokračuje směrem k začátku, dokud se nenajde value nebo se prozkoumá první pozice znaku. Pokud je například startIndexLength - 1, metoda vyhledá každý znak od posledního znaku v řetězci na začátek.

Tato metoda provádí hledání slov (rozlišujících velká a malá písmena a jazykové verze) pomocí aktuální jazykové verze.

Znakové sady obsahují ignorovatelné znaky, což jsou znaky, které se při provádění jazykového nebo jazykového porovnání nerozlišují. Pokud v hledání citlivém na jazykovou verzi value obsahuje ignorovatelný znak, výsledek odpovídá hledání s odebraným znakem. V následujícím příkladu se metoda LastIndexOf(String, Int32) používá k vyhledání podřetězce, který obsahuje měkký spojovník (U+00AD) a který předchází nebo obsahuje konečný řetězec "m". Pokud je příklad spuštěn v rozhraní .NET Framework 4 nebo novější, protože měkký spojovník ve vyhledávacím řetězci je ignorován, volání metody k vyhledání podřetězce, která se skládá z měkkého spojovníku a "m" vrátí pozici "m" v řetězci, zatímco volání k nalezení podřetězce, který se skládá z měkké spojovníku a "n" vrátí pozici "n".

int position = 0;
string s1 = "ani\u00ADmal";
string s2 = "animal";

// Find the index of the soft hyphen followed by "n".
position = s1.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s1.LastIndexOf("\u00ADn", position));

position = s2.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s2.LastIndexOf("\u00ADn", position));

// Find the index of the soft hyphen followed by "m".
position = s1.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s1.LastIndexOf("\u00ADm", position));

position = s2.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s2.LastIndexOf("\u00ADm", position));

// The example displays the following output:
//
// 'm' at position 4
// 1
// 'm' at position 3
// 1
// 'm' at position 4
// 4
// 'm' at position 3
// 3

Poznámky pro volající

Jak je vysvětleno v osvědčených postupů pro používání řetězců, doporučujeme vyhnout se volání metod porovnání řetězců, které nahrazují výchozí hodnoty a místo toho volají metody, které vyžadují explicitní zadání parametrů. Chcete-li najít index podřetětěce, který předchází určité pozici znaku pomocí srovnávacích pravidel aktuální jazykové verze, signalizujete záměr explicitně voláním přetížení metody LastIndexOf(String, Int32, StringComparison) s hodnotou CurrentCulture pro jeho comparisonType parametr. Pokud nepotřebujete porovnání s lingvistiky, zvažte použití Ordinal.

Viz také

Platí pro

.NET 9 a další verze
Produkt Verze
.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