String.EndsWith Metoda

Definice

Obor názvů:: System

Sestavení:: mscorlib.dll, System.Runtime.dll

Sestavení:: netstandard.dll, System.Runtime.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci.

Přetížení

Name	Description
EndsWith(String, StringComparison)	Určuje, zda konec této instance řetězce odpovídá zadanému řetězci při porovnání pomocí zadané možnosti porovnání.
EndsWith(Rune, StringComparison)
EndsWith(Char, StringComparison)
EndsWith(String, Boolean, CultureInfo)	Určuje, zda konec této instance řetězce odpovídá zadanému řetězci při porovnání pomocí zadané jazykové verze.
EndsWith(String)	Určuje, zda konec této instance řetězce odpovídá zadanému řetězci.
EndsWith(Char)	Určuje, zda konec této instance řetězce odpovídá zadanému znaku.
EndsWith(Rune)

EndsWith(String, StringComparison)

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci při porovnání pomocí zadané možnosti porovnání.

public:
 bool EndsWith(System::String ^ value, StringComparison comparisonType);

public bool EndsWith(string value, StringComparison comparisonType);

[System.Runtime.InteropServices.ComVisible(false)]
public bool EndsWith(string value, StringComparison comparisonType);

member this.EndsWith : string * StringComparison -> bool

[<System.Runtime.InteropServices.ComVisible(false)>]
member this.EndsWith : string * StringComparison -> bool

Public Function EndsWith (value As String, comparisonType As StringComparison) As Boolean

Parametry

value: String

Řetězec, který se má porovnat s podřetězcem na konci této instance.

comparisonType: StringComparison

Jedna z hodnot výčtu, která určuje způsob porovnání tohoto řetězce a value porovnání.

Návraty

Boolean

true value pokud se parametr shoduje s koncem tohoto řetězce, jinak . false

Atributy: ComVisibleAttribute

Výjimky

ArgumentNullException

value je null.

ArgumentException

comparisonType není StringComparison hodnota.

Příklady

Následující příklad určuje, zda řetězec končí určitým podřetězcem. Výsledky jsou ovlivněny volbou jazykové verze, zda je případ ignorován a zda je provedeno řadové porovnání.

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

using System;
using System.Threading;

class Sample 
{
    public static void Main() 
    {
        string intro = "Determine whether a string ends with another string, " +
                   "using\n  different values of StringComparison.";

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

        Console.WriteLine(intro);

        // Display the current culture because the culture-specific comparisons
        // can produce different results with different cultures.
        Console.WriteLine("The current culture is {0}.\n", 
                       Thread.CurrentThread.CurrentCulture.Name);
        
        // Determine whether three versions of the letter I are equal to each other. 
        foreach (StringComparison sc in scValues)
        {
            Console.WriteLine("StringComparison.{0}:", sc);
            Test("abcXYZ", "XYZ", sc);
            Test("abcXYZ", "xyz", sc);
            Console.WriteLine();
        }
    }

    protected static void Test(string x, string y, StringComparison comparison)
    {
        string resultFmt = "\"{0}\" {1} with \"{2}\".";
        string result = "does not end";

        if (x.EndsWith(y, comparison))
            result = "ends";
        Console.WriteLine(resultFmt, x, result, y);
    }
}

/*
This code example produces the following results:

Determine whether a string ends with another string, using
  different values of StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.CurrentCultureIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

StringComparison.InvariantCulture:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.InvariantCultureIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

StringComparison.Ordinal:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.OrdinalIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

*/

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

open System
open System.Threading

let test (x: string) y (comparison: StringComparison) =
    let result = 
        if x.EndsWith(y, comparison) then
            "ends"
        else 
            "does not end"
    printfn $"\"{x}\" {result} with \"{y}\"."

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

printfn "Determine whether a string ends with another string, using\n  different values of StringComparison."

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

// Determine whether three versions of the letter I are equal to each other. 
for sc in scValues do
    printfn $"StringComparison.{sc}:"
    test "abcXYZ" "XYZ" sc
    test "abcXYZ" "xyz" sc
    printfn ""

(*
This code example produces the following results:

Determine whether a string ends with another string, using
  different values of StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.CurrentCultureIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

StringComparison.InvariantCulture:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.InvariantCultureIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

StringComparison.Ordinal:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.OrdinalIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

*)

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

Imports System.Threading

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Determine whether a string ends with another string, " & _
                              "using" & vbCrLf & "  different values of StringComparison."
        
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }

        Console.WriteLine(intro)
        
        ' Display the current culture because the culture-specific comparisons
        ' can produce different results with different cultures.
        Console.WriteLine("The current culture is {0}." & vbCrLf, _
                           Thread.CurrentThread.CurrentCulture.Name)

        ' Determine whether three versions of the letter I are equal to each other. 
        Dim sc As StringComparison
        For Each sc In  scValues
            Console.WriteLine("StringComparison.{0}:", sc)
            Test("abcXYZ", "XYZ", sc)
            Test("abcXYZ", "xyz", sc)
            Console.WriteLine()
        Next sc
    
    End Sub
    
    
    Protected Shared Sub Test(ByVal x As String, ByVal y As String, _
                              ByVal comparison As StringComparison) 
        Dim resultFmt As String = """{0}"" {1} with ""{2}""."
        Dim result As String = "does not end"
        '
        If x.EndsWith(y, comparison) Then
            result = "ends"
        End If
        Console.WriteLine(resultFmt, x, result, y)
    
    End Sub
End Class

'
'This code example produces the following results:
'
'Determine whether a string ends with another string, using
'  different values of StringComparison.
'The current culture is en-US.
'
'StringComparison.CurrentCulture:
'"abcXYZ" ends with "XYZ".
'"abcXYZ" does not end with "xyz".
'
'StringComparison.CurrentCultureIgnoreCase:
'"abcXYZ" ends with "XYZ".
'"abcXYZ" ends with "xyz".
'
'StringComparison.InvariantCulture:
'"abcXYZ" ends with "XYZ".
'"abcXYZ" does not end with "xyz".
'
'StringComparison.InvariantCultureIgnoreCase:
'"abcXYZ" ends with "XYZ".
'"abcXYZ" ends with "xyz".
'
'StringComparison.Ordinal:
'"abcXYZ" ends with "XYZ".
'"abcXYZ" does not end with "xyz".
'
'StringComparison.OrdinalIgnoreCase:
'"abcXYZ" ends with "XYZ".
'"abcXYZ" ends with "xyz".
'

Poznámky

Metoda EndsWith porovná value parametr s podřetězcem na konci tohoto řetězce a vrátí hodnotu, která označuje, zda jsou rovny. Aby byl stejný, value musí být odkazem na tento stejný řetězec, musí být prázdný řetězec (""), nebo musí odpovídat konci tohoto řetězce. Typ porovnání prováděné metodou EndsWith závisí na hodnotě parametru comparisonType .

Viz také

StringComparison

Platí pro

EndsWith(Rune, StringComparison)

public:
 bool EndsWith(System::Text::Rune value, StringComparison comparisonType);

public bool EndsWith(System.Text.Rune value, StringComparison comparisonType);

member this.EndsWith : System.Text.Rune * StringComparison -> bool

Public Function EndsWith (value As Rune, comparisonType As StringComparison) As Boolean

Parametry

value: Rune

comparisonType: StringComparison

Návraty

Boolean

Platí pro

EndsWith(Char, StringComparison)

public:
 bool EndsWith(char value, StringComparison comparisonType);

public bool EndsWith(char value, StringComparison comparisonType);

member this.EndsWith : char * StringComparison -> bool

Public Function EndsWith (value As Char, comparisonType As StringComparison) As Boolean

Parametry

value: Char

comparisonType: StringComparison

Návraty

Boolean

Platí pro

EndsWith(String, Boolean, CultureInfo)

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci při porovnání pomocí zadané jazykové verze.

public:
 bool EndsWith(System::String ^ value, bool ignoreCase, System::Globalization::CultureInfo ^ culture);

public bool EndsWith(string value, bool ignoreCase, System.Globalization.CultureInfo? culture);

public bool EndsWith(string value, bool ignoreCase, System.Globalization.CultureInfo culture);

member this.EndsWith : string * bool * System.Globalization.CultureInfo -> bool

Public Function EndsWith (value As String, ignoreCase As Boolean, culture As CultureInfo) As Boolean

Parametry

value: String

Řetězec, který se má porovnat s podřetězcem na konci této instance.

ignoreCase: Boolean

trueignorovat případ během porovnání; v opačném případě . false

culture: CultureInfo

Kulturní informace, které určují způsob porovnání této instance a value jsou porovnány. Pokud culture ano null, použije se aktuální jazyková verze.

Návraty

Boolean

true value pokud se parametr shoduje s koncem tohoto řetězce, jinak . false

Výjimky

ArgumentNullException

value je null.

Příklady

Následující příklad určuje, zda řetězec nastane na konci jiného řetězce. Metoda EndsWith se nazývá několikrát pomocí citlivosti písmen, rozlišování velkých a malých a malých písmen a různých jazykových verzí, které ovlivňují výsledky hledání.

// This code example demonstrates the 
// System.String.EndsWith(String, ..., CultureInfo) method.

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

class Sample 
{
    public static void Main() 
    {
        string msg1 = "Search for the target string \"{0}\" in the string \"{1}\".\n";
        string msg2 = "Using the {0} - \"{1}\" culture:";
        string msg3 = "  The string to search ends with the target string: {0}";
        bool result = false;
        CultureInfo ci;

        // Define a target string to search for.
        // U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        string capitalARing = "\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 xyzARing = "xyz" + "\u0061\u030a";

        // Display the string to search for and the string to search.
        Console.WriteLine(msg1, capitalARing, xyzARing);

        // Search using English-United States culture.
        ci = new CultureInfo("en-US");
        Console.WriteLine(msg2, ci.DisplayName, ci.Name);

        Console.WriteLine("Case sensitive:");
        result = xyzARing.EndsWith(capitalARing, false, ci);
        Console.WriteLine(msg3, result);

        Console.WriteLine("Case insensitive:");
        result = xyzARing.EndsWith(capitalARing, true, ci);
        Console.WriteLine(msg3, result);
        Console.WriteLine();

        // Search using Swedish-Sweden culture.
        ci = new CultureInfo("sv-SE");
        Console.WriteLine(msg2, ci.DisplayName, ci.Name);

        Console.WriteLine("Case sensitive:");
        result = xyzARing.EndsWith(capitalARing, false, ci);
        Console.WriteLine(msg3, result);

        Console.WriteLine("Case insensitive:");
        result = xyzARing.EndsWith(capitalARing, true, ci);
        Console.WriteLine(msg3, result);
    }
}

/*
This code example produces the following results (for en-us culture):

Search for the target string "Å" in the string "xyza°".

Using the English (United States) - "en-US" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: True

Using the Swedish (Sweden) - "sv-SE" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: False

*/

// This code example demonstrates the 
// System.String.EndsWith(String, ..., CultureInfo) method.
open System.Globalization

[<EntryPoint>]
let main _ =
    // Define a target string to search for.
    // U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    let capitalARing = "\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 xyzARing = "xyz" + "\u0061\u030a"

    // Display the string to search for and the string to search.
    printfn $"Search for the target string \"{capitalARing}\" in the string \"{xyzARing}\".\n"

    // Search using English-United States culture.
    let ci = CultureInfo "en-US"
    printfn $"Using the {ci.DisplayName} - \"{ci.Name}\" culture:"

    printfn "Case sensitive:"
    let result = xyzARing.EndsWith(capitalARing, false, ci)
    printfn $"  The string to search ends with the target string: {result}"

    printfn "Case insensitive:"
    let result = xyzARing.EndsWith(capitalARing, true, ci)
    printfn $"  The string to search ends with the target string: {result}\n"

    // Search using Swedish-Sweden culture.
    let ci = CultureInfo "sv-SE"
    printfn $"Using the {ci.DisplayName} - \"{ci.Name}\" culture:"

    printfn "Case sensitive:"
    let result = xyzARing.EndsWith(capitalARing, false, ci)
    printfn $"  The string to search ends with the target string: {result}"

    printfn "Case insensitive:"
    let result = xyzARing.EndsWith(capitalARing, true, ci)
    printfn $"  The string to search ends with the target string: {result}"
    0
(*
This code example produces the following results (for en-us culture):

Search for the target string "Å" in the string "xyza°".

Using the English (United States) - "en-US" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: True

Using the Swedish (Sweden) - "sv-SE" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: False
*)

' This code example demonstrates the 
' System.String.EndsWith(String, ..., CultureInfo) method.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim msg1 As String = "Search for the target string ""{0}"" in the string ""{1}""." & vbCrLf
        Dim msg2 As String = "Using the {0} - ""{1}"" culture:"
        Dim msg3 As String = "  The string to search ends with the target string: {0}"
        Dim result As Boolean = False
        Dim ci As CultureInfo
        
        ' Define a target string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim capitalARing 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 xyzARing As String = "xyz" & "å"
               
        ' Display the string to search for and the string to search.
        Console.WriteLine(msg1, capitalARing, xyzARing)
        
        ' Search using English-United States culture.
        ci = New CultureInfo("en-US")
        Console.WriteLine(msg2, ci.DisplayName, ci.Name)
        
        Console.WriteLine("Case sensitive:")
        result = xyzARing.EndsWith(capitalARing, False, ci)
        Console.WriteLine(msg3, result)
        
        Console.WriteLine("Case insensitive:")
        result = xyzARing.EndsWith(capitalARing, True, ci)
        Console.WriteLine(msg3, result)
        Console.WriteLine()
        
        ' Search using Swedish-Sweden culture.
        ci = New CultureInfo("sv-SE")
        Console.WriteLine(msg2, ci.DisplayName, ci.Name)
        
        Console.WriteLine("Case sensitive:")
        result = xyzARing.EndsWith(capitalARing, False, ci)
        Console.WriteLine(msg3, result)
        
        Console.WriteLine("Case insensitive:")
        result = xyzARing.EndsWith(capitalARing, True, ci)
        Console.WriteLine(msg3, result)
    
    End Sub
End Class

'This code example produces the following results (for en-us culture):
'
'Search for the target string "Å" in the string "xyza°".
'
'Using the English (United States) - "en-US" culture:
'Case sensitive:
'  The string to search ends with the target string: False
'Case insensitive:
'  The string to search ends with the target string: True
'
'Using the Swedish (Sweden) - "sv-SE" culture:
'Case sensitive:
'  The string to search ends with the target string: False
'Case insensitive:
'  The string to search ends with the target string: False
'

Poznámky

Tato metoda porovnává value parametr s podřetězcem na konci tohoto řetězce, který má stejnou délku jako value, a vrátí hodnotu, která určuje, zda jsou rovny. Aby byla stejná, value musí být odkazem na tuto stejnou instanci nebo odpovídat konci tohoto řetězce.

Tato metoda provádí porovnání slov (citlivé na jazykovou verzi) pomocí zadaného písmena a jazykové verze.

Viz také

InvariantCulture

Platí pro

EndsWith(String)

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci.

public:
 bool EndsWith(System::String ^ value);

public bool EndsWith(string value);

member this.EndsWith : string -> bool

Public Function EndsWith (value As String) As Boolean

Parametry

value: String

Řetězec, který se má porovnat s podřetězcem na konci této instance.

Návraty

Boolean

true pokud value odpovídá konci této instance; falsev opačném případě .

Výjimky

ArgumentNullException

value je null.

Příklady

Následující příklad označuje, zda každý řetězec v poli končí tečkou (".").

using System;

public class Example
{
   public static void Main()
   {
      String[] strings = { "This is a string.", "Hello!", "Nothing.", 
                           "Yes.", "randomize" };
      foreach (var value in strings) {
         bool endsInPeriod = value.EndsWith(".");
         Console.WriteLine("'{0}' ends in a period: {1}", 
                           value, endsInPeriod);
      }                            
   }
}
// The example displays the following output:
//       'This is a string.' ends in a period: True
//       'Hello!' ends in a period: False
//       'Nothing.' ends in a period: True
//       'Yes.' ends in a period: True
//       'randomize' ends in a period: False

let strings = 
    [| "This is a string."; "Hello!"; "Nothing."
       "Yes."; "randomize" |]

for value in strings do
    let endsInPeriod = value.EndsWith "."
    printfn $"'{value}' ends in a period: {endsInPeriod}"
// The example displays the following output:
//       'This is a string.' ends in a period: True
//       'Hello!' ends in a period: False
//       'Nothing.' ends in a period: True
//       'Yes.' ends in a period: True
//       'randomize' ends in a period: False

Module Example
   Public Sub Main()
      Dim strings() As String = { "This is a string.", "Hello!", 
                                  "Nothing.", "Yes.", "randomize" }
      For Each value In strings
         Dim endsInPeriod As Boolean = value.EndsWith(".")
         Console.WriteLine("'{0}' ends in a period: {1}", 
                           value, endsInPeriod)
      Next                            
   End Sub
End Module
' The example displays the following output:
'       'This is a string.' ends in a period: True
'       'Hello!' ends in a period: False
'       'Nothing.' ends in a period: True
'       'Yes.' ends in a period: True
'       'randomize' ends in a period: False

Následující příklad definuje metodu StripEndTags , která používá metodu EndsWith(String) k odebrání koncových značek HTML z konce řádku. Všimněte si, že StripEndTags metoda se nazývá rekurzivně, aby se zajistilo, že se na konci řádku odebere více koncových značek HTML.

using System;

public class EndsWithTest {
    public static void Main() {

        // process an input file that contains html tags.
        // this sample checks for multiple tags at the end of the line, rather than simply
        // removing the last one.
        // note: HTML markup tags always end in a greater than symbol (>).

        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 simply ends with a greater than symbol, it should not be modified>" };

        Console.WriteLine("The following lists the items before the ends have been stripped:");
        Console.WriteLine("-----------------------------------------------------------------");

        // print out the initial array of strings
        foreach ( string s in strSource )
            Console.WriteLine( s );

        Console.WriteLine();

        Console.WriteLine("The following lists the items after the ends have been stripped:");
        Console.WriteLine("----------------------------------------------------------------");

        // print out the array of strings
        foreach (var s in strSource)
            Console.WriteLine(StripEndTags(s));
    }

    private static string StripEndTags( string item ) {

        bool found = false;

        // try to find a tag at the end of the line using EndsWith
        if (item.Trim().EndsWith(">")) {

            // now search for the opening tag...
            int lastLocation = item.LastIndexOf( "</" );

            // remove the identified section, if it is a valid region
            if ( lastLocation >= 0 ) {
                found = true;
                item =  item.Substring( 0, lastLocation );
            }
        }

        if (found)
           item = StripEndTags(item);

        return item;
    }
}
// The example displays the following output:
//    The following lists the items before the ends have been stripped:
//    -----------------------------------------------------------------
//    <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 simply ends with a greater than symbol, it should not be modified>
//
//    The following lists the items after the ends have been stripped:
//    ----------------------------------------------------------------
//    <b>This is bold text
//    <H1>This is large Text
//    <b><i><font color=green>This has multiple tags
//    <b>This has <i>embedded</i> tags.
//    This line simply ends with a greater than symbol, it should not be modified>

let rec stripEndTags item =
    let mutable item: string = item
    let mutable found = false

    // try to find a tag at the end of the line using EndsWith
    if item.Trim().EndsWith ">" then
        // now search for the opening tag...
        let lastLocation = item.LastIndexOf "</"

        // remove the identified section, if it is a valid region
        if lastLocation >= 0 then
            found <- true
            item <- item.Substring(0, lastLocation)

    if found then
        stripEndTags item
    else 
        item

// process an input file that contains html tags.
// this sample checks for multiple tags at the end of the line, rather than simply
// removing the last one.
// note: HTML markup tags always end in a greater than symbol (>).

let 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 simply ends with a greater than symbol, it should not be modified>" |]

printfn "The following lists the items before the ends have been stripped:"
printfn "-----------------------------------------------------------------"

// print out the initial array of strings
for s in strSource do
    printfn $"{s}"

printfn "\nThe following lists the items after the ends have been stripped:"
printfn "----------------------------------------------------------------"

// print out the array of strings
for s in strSource do
    printfn $"{stripEndTags s}"

// The example displays the following output:
//    The following lists the items before the ends have been stripped:
//    -----------------------------------------------------------------
//    <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 simply ends with a greater than symbol, it should not be modified>
//
//    The following lists the items after the ends have been stripped:
//    ----------------------------------------------------------------
//    <b>This is bold text
//    <H1>This is large Text
//    <b><i><font color=green>This has multiple tags
//    <b>This has <i>embedded</i> tags.
//    This line simply ends with a greater than symbol, it should not be modified>

Public Module Example
    Public Sub Main()
        Dim strSource() As String = { "<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 simply ends with a greater than symbol, it should not be modified>" }

        Console.WriteLine("The following lists the items before the ends have been stripped:")
        Console.WriteLine("-----------------------------------------------------------------")

        ' Display the initial array of strings.
        For Each s As String In  strSource
            Console.WriteLine(s)
        Next
        Console.WriteLine()

        Console.WriteLine("The following lists the items after the ends have been stripped:")
        Console.WriteLine("----------------------------------------------------------------")

        ' Display the array of strings.
        For Each s As String In strSource
            Console.WriteLine(StripEndTags(s))
        Next 
    End Sub 

    Private Function StripEndTags(item As String) As String
        Dim found As Boolean = False
        
        ' Try to find a tag at the end of the line using EndsWith.
        If item.Trim().EndsWith(">") Then
            ' now search for the opening tag...
            Dim lastLocation As Integer = item.LastIndexOf("</")
            If lastLocation >= 0 Then
                found = True
                
                ' Remove the identified section, if it is a valid region.
                item = item.Substring(0, lastLocation)
            End If
        End If
        
        If found Then item = StripEndTags(item)
        Return item
    End Function 
End Module
' The example displays the following output:
'    The following lists the items before the ends have been stripped:
'    -----------------------------------------------------------------
'    <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 simply ends with a greater than symbol, it should not be modified>
'    
'    The following lists the items after the ends have been stripped:
'    ----------------------------------------------------------------
'    <b>This is bold text
'    <H1>This is large Text
'    <b><i><font color = green>This has multiple tags
'    <b>This has <i>embedded</i> tags.
'    This line simply ends with a greater than symbol, it should not be modified>

Poznámky

Tato metoda porovnává value podřetětěr na konci této instance, která má stejnou délku jako value, a vrátí indikaci, zda jsou rovny. Aby byla stejná, value musí být odkazem na tuto stejnou instanci nebo odpovídat konci této instance.

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

Poznámky pro volající

Jak je vysvětleno v osvědčených postupech 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 zjistit, zda řetězec končí určitým podřetězce pomocí pravidel porovnání řetězců aktuální jazykové verze, signalizovat záměr explicitně voláním EndsWith(String, StringComparison) přetížení metody s hodnotou CurrentCulture pro jeho comparisonType parametr. Pokud nepotřebujete lingvistické porovnání, zvažte použití .Ordinal

Viz také

Platí pro

EndsWith(Char)

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Zdroj:: String.Comparison.cs

Určuje, zda konec této instance řetězce odpovídá zadanému znaku.

public:
 bool EndsWith(char value);

public bool EndsWith(char value);

member this.EndsWith : char -> bool

Public Function EndsWith (value As Char) As Boolean

Parametry

value: Char

Znak, který se má porovnat s znakem na konci této instance.

Návraty

Boolean

true pokud value odpovídá konci této instance; falsev opačném případě .

Poznámky

Tato metoda provádí porovnání řadových (nerozlišující velká a malá písmena a nerozlišují se podle jazykové verze).

Platí pro

EndsWith(Rune)

public:
 bool EndsWith(System::Text::Rune value);

public bool EndsWith(System.Text.Rune value);

member this.EndsWith : System.Text.Rune -> bool

Public Function EndsWith (value As Rune) As Boolean

Parametry

value: Rune

Návraty

Boolean

Platí pro

Váš názor

Byla tato stránka užitečná?

Sdílet prostřednictvím

String.EndsWith Metoda

Definice

Přetížení

EndsWith(String, StringComparison)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

EndsWith(Rune, StringComparison)

Parametry

Návraty

Platí pro

EndsWith(Char, StringComparison)

Parametry

Návraty

Platí pro

EndsWith(String, Boolean, CultureInfo)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

EndsWith(String)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Poznámky pro volající

Viz také

Platí pro

EndsWith(Char)

Parametry

Návraty

Poznámky

Platí pro

EndsWith(Rune)

Parametry

Návraty

Platí pro

Váš názor