String.StartsWith Metoda

Zdroj:

String.Comparison.cs

Zdroj:

String.Comparison.cs

Zdroj:

String.Comparison.cs

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

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

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

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

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

Parametry

Návraty

true pokud parametr value odpovídá začátku tohoto řetězce, falsev opačném případě .

Výjimky

Příklady

Následující příklad určuje, zda se řetězec vyskytuje na začátku jiného řetězce. Metoda StartsWith je volána několikrát s použitím rozlišování velkých a malých 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.StartsWith(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 aRingXYZ = "\u0061\u030a" + "xyz";

// Clear the screen and display an introduction.
    Console.Clear();

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

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

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

    Console.WriteLine("Case insensitive:");
    result = aRingXYZ.StartsWith(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 = aRingXYZ.StartsWith(capitalARing, false, ci);
    Console.WriteLine(msg3, result);

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

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

Search for the target string "Å" in the string "a°xyz".

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.StartsWith(String, ..., CultureInfo) method.

open System
open System.Globalization
 
[<EntryPoint>]
let main _ =
    let msg1 = "Search for the target string \"{0}\" in the string \"{1}\".\n"
    let msg2 = "Using the {0} - \"{1}\" culture:"
    let msg3 = "  The string to search ends with the target string: {0}"

    // 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 aRingXYZ = "\u0061\u030a" + "xyz"

    // Clear the screen and display an introduction.
    Console.Clear()

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

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

    printfn "Case sensitive:"
    let result = aRingXYZ.StartsWith(capitalARing, false, ci)
    Console.WriteLine(msg3, result)

    printfn "Case insensitive:"
    let result = aRingXYZ.StartsWith(capitalARing, true, ci)
    Console.WriteLine(msg3, result)
    printfn ""

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

    printfn "Case sensitive:"
    let result = aRingXYZ.StartsWith(capitalARing, false, ci)
    Console.WriteLine(msg3, result)

    printfn "Case insensitive:"
    let result = aRingXYZ.StartsWith(capitalARing, true, ci)
    Console.WriteLine(msg3, result)
    0
(*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).

Search for the target string "Å" in the string "a°xyz".

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.StartsWith(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 aRingXYZ As String = "å" & "xyz"
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        
        ' Display the string to search for and the string to search.
        Console.WriteLine(msg1, capitalARing, aRingXYZ)
        
        ' Search using English-United States culture.
        ci = New CultureInfo("en-US")
        Console.WriteLine(msg2, ci.DisplayName, ci.Name)
        
        Console.WriteLine("Case sensitive:")
        result = aRingXYZ.StartsWith(capitalARing, False, ci)
        Console.WriteLine(msg3, result)
        
        Console.WriteLine("Case insensitive:")
        result = aRingXYZ.StartsWith(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 = aRingXYZ.StartsWith(capitalARing, False, ci)
        Console.WriteLine(msg3, result)
        
        Console.WriteLine("Case insensitive:")
        result = aRingXYZ.StartsWith(capitalARing, True, ci)
        Console.WriteLine(msg3, result)
    
    End Sub
End Class

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'Search for the target string "Å" in the string "a°xyz".
'
'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ězcec na začátku tohoto řetězce, který má stejnou délku jako valuea vrátí hodnotu, která označuje, zda jsou si rovny. Chcete-li být rovni, value musí být prázdný řetězec (String.Empty), musí být odkazem na stejnou instanci nebo musí odpovídat začátku této instance.

Tato metoda provede porovnání pomocí zadaných písmen a jazykové verze.

Zdroj:

String.Comparison.cs

Zdroj:

String.Comparison.cs

Zdroj:

String.Comparison.cs

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

public bool StartsWith (string value, StringComparison comparisonType);

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

member this.StartsWith : string * StringComparison -> bool

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

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

Parametry

Návraty

truepokud tato instance začíná na value; v opačném případě . false

Atributy

ComVisibleAttribute

Výjimky

Příklady

Následující příklad vyhledá řetězec "the" na začátku delšího řetězce, který začíná slovem "The". Jak ukazuje výstup z příkladu, volání StartsWith(String, StringComparison) metody, která provádí porovnání nerozlišující jazykové verze, ale rozlišuje malá a malá písmena, neodpovídá řetězci, zatímco volání, které provádí porovnání bez rozlišování jazykových verzí a malých a malých písmen, odpovídá řetězci.

using namespace System;

void main()
{
   String^ title = "The House of the Seven Gables";
   String^ searchString = "the";
   StringComparison comparison = StringComparison::InvariantCulture;
   Console::WriteLine("'{0}':", title);
   Console::WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                      searchString, comparison,
                      title->StartsWith(searchString, comparison));

   comparison = StringComparison::InvariantCultureIgnoreCase;
   Console::WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                      searchString, comparison,
                      title->StartsWith(searchString, comparison));
   }
// The example displays the following output:
//       'The House of the Seven Gables':
//          Starts with 'the' (InvariantCulture comparison): False
//          Starts with 'the' (InvariantCultureIgnoreCase comparison): True

using System;

public class Example
{
   public static void Main()
   {
      String title = "The House of the Seven Gables";
      String searchString = "the";
      StringComparison comparison = StringComparison.InvariantCulture;
      Console.WriteLine("'{0}':", title);
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison));

      comparison = StringComparison.InvariantCultureIgnoreCase;
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison));
   }
}
// The example displays the following output:
//       'The House of the Seven Gables':
//          Starts with 'the' (InvariantCulture comparison): False
//          Starts with 'the' (InvariantCultureIgnoreCase comparison): True

open System

let title = "The House of the Seven Gables"
let searchString = "the"
let comparison = StringComparison.InvariantCulture
printfn $"'{title}':"
printfn $"   Starts with '{searchString}' ({comparison:G} comparison): {title.StartsWith(searchString, comparison)}"

let comparison2 = StringComparison.InvariantCultureIgnoreCase
printfn $"   Starts with '{searchString}' ({comparison2:G} comparison): {title.StartsWith(searchString, comparison2)}"
// The example displays the following output:
//       'The House of the Seven Gables':
//          Starts with 'the' (InvariantCulture comparison): False
//          Starts with 'the' (InvariantCultureIgnoreCase comparison): True

Module Example
   Public Sub Main()
      Dim title As String = "The House of the Seven Gables"
      Dim searchString As String = "the"
      Dim comparison As StringComparison = StringComparison.InvariantCulture
      Console.WriteLine("'{0}':", title)
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison))

      comparison = StringComparison.InvariantCultureIgnoreCase
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison))
   End Sub
End Module
' The example displays the following output:
'    'The House of the Seven Gables':
'       Starts with 'the' (InvariantCulture comparison): False
'       Starts with 'the' (InvariantCultureIgnoreCase comparison): True

Následující příklad určuje, zda řetězec začíná určitým podřetězcem. Inicializuje dvojrozměrné pole řetězců. První prvek ve druhé dimenzi obsahuje řetězec a druhý prvek obsahuje řetězec, který se má vyhledat na začátku prvního řetězce. Výsledky jsou ovlivněny volbou jazykové verze, ignorováním velkých a malých písmen a tím, jestli se provádí porovnání řad. Všimněte si, že pokud instance řetězce obsahuje ligaturu, porovnání jazykových verzí s jejími po sobě jdoucími znaky se úspěšně shodují.

using namespace System;

void main()
{
   array<String^, 2>^ strings = gcnew array<String^, 2> { {"ABCdef", "abc" },                    
                         {"ABCdef", "abc" }, {"œil","oe" }, 
                         { "læring}", "lae" } };
   for (int ctr1 = strings->GetLowerBound(0); ctr1 <= strings->GetUpperBound(0); ctr1++)
   {
         for each (String^ cmpName in Enum::GetNames(StringComparison::typeid))
         { 
            StringComparison strCmp = (StringComparison) Enum::Parse(StringComparison::typeid, 
                                                         cmpName);
            String^ instance = strings[ctr1, 0];
            String^ value = strings[ctr1, 1];
            Console::WriteLine("{0} starts with {1}: {2} ({3} comparison)", 
                               instance, value, 
                               instance->StartsWith(value, strCmp), 
                               strCmp); 
         }
         Console::WriteLine();   
   }   
}

// The example displays the following output:
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       œil starts with oe: True (CurrentCulture comparison)
//       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
//       œil starts with oe: True (InvariantCulture comparison)
//       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
//       œil starts with oe: False (Ordinal comparison)
//       œil starts with oe: False (OrdinalIgnoreCase comparison)
//       
//       læring} starts with lae: True (CurrentCulture comparison)
//       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
//       læring} starts with lae: True (InvariantCulture comparison)
//       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
//       læring} starts with lae: False (Ordinal comparison)
//       læring} starts with lae: False (OrdinalIgnoreCase comparison)

using System;

public class Example
{
   public static void Main()
   {
      string[,] strings = { {"ABCdef", "abc" },                    
                            {"ABCdef", "abc" },  
                            {"œil","oe" },
                            { "læring}", "lae" } };
      for (int ctr1 = strings.GetLowerBound(0); ctr1 <= strings.GetUpperBound(0); ctr1++)
      {
            foreach (string cmpName in Enum.GetNames(typeof(StringComparison)))
            { 
               StringComparison strCmp = (StringComparison) Enum.Parse(typeof(StringComparison), 
                                                      cmpName);
               string instance = strings[ctr1, 0];
               string value = strings[ctr1, 1];
               Console.WriteLine("{0} starts with {1}: {2} ({3} comparison)", 
                                 instance, value, 
                                 instance.StartsWith(value, strCmp), 
                                 strCmp); 
            }
            Console.WriteLine();   
      }   
   }
}
// The example displays the following output:
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       œil starts with oe: True (CurrentCulture comparison)
//       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
//       œil starts with oe: True (InvariantCulture comparison)
//       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
//       œil starts with oe: False (Ordinal comparison)
//       œil starts with oe: False (OrdinalIgnoreCase comparison)
//       
//       læring} starts with lae: True (CurrentCulture comparison)
//       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
//       læring} starts with lae: True (InvariantCulture comparison)
//       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
//       læring} starts with lae: False (Ordinal comparison)
//       læring} starts with lae: False (OrdinalIgnoreCase comparison)

open System

let strings =
    array2D 
      [ [ "ABCdef"; "abc" ]
        [ "ABCdef"; "abc" ]
        [ "œil"; "oe" ]
        [ "læring}"; "lae" ] ]

for ctr1 = strings.GetLowerBound 0 to strings.GetUpperBound 0 do
    for cmpName in Enum.GetNames typeof<StringComparison> do
        let strCmp = Enum.Parse(typeof<StringComparison>, cmpName) :?> StringComparison
        let instance = strings[ctr1, 0]
        let value = strings[ctr1, 1]
        printfn $"{instance} starts with {value}: {instance.StartsWith(value, strCmp)} ({strCmp} comparison)"
    printfn ""
// The example displays the following output:
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//
//       œil starts with oe: True (CurrentCulture comparison)
//       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
//       œil starts with oe: True (InvariantCulture comparison)
//       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
//       œil starts with oe: False (Ordinal comparison)
//       œil starts with oe: False (OrdinalIgnoreCase comparison)
//
//       læring} starts with lae: True (CurrentCulture comparison)
//       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
//       læring} starts with lae: True (InvariantCulture comparison)
//       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
//       læring} starts with lae: False (Ordinal comparison)
//       læring} starts with lae: False (OrdinalIgnoreCase comparison)

Module Example
   Public Sub Main()
      Dim strings(,) As String = { {"ABCdef", "abc" },                    
                                   {"ABCdef", "abc" },  
                                   {"œil","oe" },
                                   { "læring}", "lae" } }
      For ctr1 As Integer = strings.GetLowerBound(0) To strings.GetUpperBound(0)
            For Each cmpName As String In [Enum].GetNames(GetType(StringComparison)) 
               Dim strCmp As StringComparison = CType([Enum].Parse(GetType(StringComparison), 
                                                      cmpName), StringComparison)
               Dim instance As String = strings(ctr1, 0)
               Dim value As String = strings(ctr1, 1)
               Console.WriteLine("{0} starts with {1}: {2} ({3} comparison)", 
                                 instance, value, 
                                 instance.StartsWith(value, strCmp), 
                                 strCmp) 
            Next
            Console.WriteLine()   
      Next   
   End Sub
End Module
' The example displays the following output:
'       ABCdef starts with abc: False (CurrentCulture comparison)
'       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
'       ABCdef starts with abc: False (InvariantCulture comparison)
'       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
'       ABCdef starts with abc: False (Ordinal comparison)
'       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
'       
'       ABCdef starts with abc: False (CurrentCulture comparison)
'       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
'       ABCdef starts with abc: False (InvariantCulture comparison)
'       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
'       ABCdef starts with abc: False (Ordinal comparison)
'       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
'       
'       œil starts with oe: True (CurrentCulture comparison)
'       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
'       œil starts with oe: True (InvariantCulture comparison)
'       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
'       œil starts with oe: False (Ordinal comparison)
'       œil starts with oe: False (OrdinalIgnoreCase comparison)
'       
'       læring} starts with lae: True (CurrentCulture comparison)
'       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
'       læring} starts with lae: True (InvariantCulture comparison)
'       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
'       læring} starts with lae: False (Ordinal comparison)
'       læring} starts with lae: False (OrdinalIgnoreCase comparison)

Poznámky

Metoda StartsWith porovná value parametr s podřetězcec na začátku tohoto řetězce a vrátí hodnotu, která označuje, zda jsou si rovny. Chcete-li být rovni, value musí být odkazem na stejný řetězec, musí být prázdný řetězec (""), nebo musí odpovídat začátku tohoto řetězce. Typ porovnání provedený metodou StartsWith závisí na hodnotě parametru comparisonType . Porovnání může používat konvence aktuální jazykové verze (StringComparison.CurrentCulture a StringComparison.CurrentCultureIgnoreCase) nebo invariantní jazykové verze (StringComparison.InvariantCulture a StringComparison.InvariantCultureIgnoreCase), nebo se může skládat z porovnání jednotlivých znaků bodů kódu (StringComparison.Ordinal nebo StringComparison.OrdinalIgnoreCase). Porovnání může také rozlišovat malá a malá písmena (StringComparison.CurrentCulture, StringComparison.InvariantCulturenebo StringComparison.Ordinal) nebo může ignorovat velká a malá písmena (StringComparison.CurrentCultureIgnoreCase, StringComparison.InvariantCultureIgnoreCase, ). StringComparison.OrdinalIgnoreCase

Viz také

• StringComparison

Zdroj:

String.Comparison.cs

Zdroj:

String.Comparison.cs

Zdroj:

String.Comparison.cs

public:
 bool StartsWith(char value);

public bool StartsWith (char value);

member this.StartsWith : char -> bool

Public Function StartsWith (value As Char) As Boolean

Parametry

Návraty

truepokud value odpovídá začátku tohoto řetězce, v opačném případě . false

Poznámky

Tato metoda provádí porovnání podle pořadového čísla (se zahrnutím velkých a malých písmen a jazykové verze).

Zdroj:

String.Comparison.cs

Zdroj:

String.Comparison.cs

Zdroj:

String.Comparison.cs

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

public bool StartsWith (string value);

member this.StartsWith : string -> bool

Public Function StartsWith (value As String) As Boolean

Parametry

Návraty

truepokud value odpovídá začátku tohoto řetězce, v opačném případě . false

Výjimky

Příklady

Následující příklad definuje metodu StripStartTags , která používá metodu StartsWith(String) k odebrání počátečních značek HTML od začátku řetězce. Všimněte si StripStartTags , že metoda je volána rekurzivně, aby se zajistilo, že se na začátku řádku odebere více počátečních značek HTML. Příklad neodebere značky HTML vložené v řetězci.

using namespace System;

String^ StripStartTags( String^ item )
{
   // Determine whether a tag begins the string.
   if (item->Trim()->StartsWith("<")) {
      // Find the closing tag.
      int lastLocation = item->IndexOf(">");
      
      // Remove the tag.
      if ( lastLocation >= 0 ) {
         item = item->Substring(lastLocation+ 1);
            
         // Remove any additional starting tags.
         item = StripStartTags(item);
      }      
   }

   return item;
}

int main()
{
   array<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 begins with a lesser than symbol, it should not be modified" };
   
   // Display the initial string array.
   Console::WriteLine("The original strings:");
   Console::WriteLine("---------------------");
   for each (String^ s in strSource)    
      Console::WriteLine( s );
   Console::WriteLine();

   Console::WriteLine( "Strings after starting tags have been stripped:");
   Console::WriteLine( "-----------------------------------------------");
   
   // Display the strings with starting tags removed.
   for each (String^ s in strSource)
      Console::WriteLine(StripStartTags(s));
}
// The example displays the following output:
//    The original strings:
//    ---------------------
//    <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 begins with a lesser than symbol, it should not be modified
//    
//    Strings after starting tags have been stripped:
//    -----------------------------------------------
//    This is bold text</b>
//    This is large Text</H1>
//    This has multiple tags</font></i></b>
//    This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified

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

      // Display the initial string array.
      Console.WriteLine("The original strings:");
      Console.WriteLine("---------------------");
      foreach (var s in strSource)
         Console.WriteLine(s);
      Console.WriteLine();

      Console.WriteLine("Strings after starting tags have been stripped:");
      Console.WriteLine("-----------------------------------------------");

      // Display the strings with starting tags removed.
     foreach (var s in strSource)
        Console.WriteLine(StripStartTags(s));
   }

   private static string StripStartTags(string item)
   {
      // Determine whether a tag begins the string.
      if (item.Trim().StartsWith("<")) {
         // Find the closing tag.
         int lastLocation = item.IndexOf( ">" );
         // Remove the tag.
         if (lastLocation >= 0) {
            item =  item.Substring( lastLocation + 1 );

            // Remove any additional starting tags.
            item = StripStartTags(item);
         }
      }

      return item;
   }
}
// The example displays the following output:
//    The original strings:
//    ---------------------
//    <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 begins with a lesser than symbol, it should not be modified
//
//    Strings after starting tags have been stripped:
//    -----------------------------------------------
//    This is bold text</b>
//    This is large Text</H1>
//    This has multiple tags</font></i></b>
//    This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified

let rec stripStartTags (item: string) =
    // Determine whether a tag begins the string.
    if item.Trim().StartsWith "<" then
        // Find the closing tag.
        let lastLocation = item.IndexOf ">"
        // Remove the tag.
        let item = 
            if lastLocation >= 0 then
                item.Substring( lastLocation + 1 )
            else 
                item

        // Remove any additional starting tags.
        stripStartTags item
    else
        item

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 begins with a lesser than symbol, it should not be modified" |]

// Display the initial string array.
printfn "The original strings:"
printfn "---------------------"
for s in strSource do
    printfn $"{s}"
printfn ""

printfn "Strings after starting tags have been stripped:"
printfn "-----------------------------------------------"

// Display the strings with starting tags removed.
for s in strSource do
    printfn $"{stripStartTags s}"

// The example displays the following output:
//    The original strings:
//    ---------------------
//    <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 begins with a lesser than symbol, it should not be modified
//
//    Strings after starting tags have been stripped:
//    -----------------------------------------------
//    This is bold text</b>
//    This is large Text</H1>
//    This has multiple tags</font></i></b>
//    This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified

Public Class Example
   Public Shared 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 begins with a lesser than symbol, it should not be modified" }

      ' Display the initial string array.
      Console.WriteLine("The original strings:")
      Console.WriteLine("---------------------")
      For Each s In strSource
         Console.WriteLine(s)
      Next 
      Console.WriteLine()

      Console.WriteLine("Strings after starting tags have been stripped:")
      Console.WriteLine("-----------------------------------------------") 

      ' Display the strings with starting tags removed.
      For Each s In strSource
         Console.WriteLine(StripStartTags(s))
      Next 
   End Sub 

   Private Shared Function StripStartTags(item As String) As String
      ' Determine whether a tag begins the string.
      If item.Trim().StartsWith("<") Then
         ' Find the closing tag.
         Dim lastLocation As Integer = item.IndexOf(">")
         If lastLocation >= 0 Then
            ' Remove the tag.
            item = item.Substring((lastLocation + 1))
            
            ' Remove any additional starting tags.
            item = StripStartTags(item)
         End If
      End If
      
      Return item
   End Function 
End Class 
' The example displays the following output:
'    The original strings:
'    ---------------------
'    <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 begins with a lesser than symbol, it should not be modified
'    
'    Strings after starting tags have been stripped:
'    -----------------------------------------------
'    This is bold text</b>
'    This is large Text</H1>
'    This has multiple tags</font></i></b>
'    This has <i>embedded</i> tags.</b>
'    <This line simply begins with a lesser than symbol, it should not be modified

Poznámky

Tato metoda porovnává value s podřetěžce na začátku této instance, který je stejně dlouhý jako valuea vrátí indikaci, zda jsou si rovny. Chcete-li být rovni, value musí být prázdný řetězec (String.Empty), musí být odkazem na stejnou instanci nebo musí odpovídat začátku této instance.

Tato metoda provádí porovnání slov (velká a malá písmena a specifika jazykové verze) použitím aktuální jazykové verze.

Poznámky pro volající

Jak je vysvětleno v části Osvědčené postupy 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 volejte metody, které vyžadují explicitní zadání parametrů. Chcete-li zjistit, zda řetězec začíná určitým podřetězcem pomocí pravidel porovnání řetězců aktuální jazykové verze, signalizovat váš záměr explicitně voláním StartsWith(String, StringComparison) přetížení metody s hodnotou CurrentCulture pro její comparisonType parametr. Pokud nepotřebujete lingvistické porovnání, zvažte použití Ordinal.

Viz také

• EndsWith(String)