String.Substring String.Substring String.Substring String.Substring Method

Definition

Ruft eine Teilzeichenfolge dieser Instanz ab.Retrieves a substring from this instance.

Dieser Member wird überladen.This member is overloaded. Klicken Sie auf einen Namen in der Überladungsliste, um vollständige Informationen zu diesem Member sowie zu Syntax, Nutzung und Beispielen zu erhalten.For complete information about this member, including syntax, usage, and examples, click a name in the overload list.

Überlädt

Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

Ruft eine Teilzeichenfolge dieser Instanz ab.Retrieves a substring from this instance. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt.The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

Ruft eine Teilzeichenfolge dieser Instanz ab.Retrieves a substring from this instance. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge.The substring starts at a specified character position and has a specified length.

Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

Ruft eine Teilzeichenfolge dieser Instanz ab.Retrieves a substring from this instance. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt.The substring starts at a specified character position and continues to the end of the string.

public:
 System::String ^ Substring(int startIndex);
public string Substring (int startIndex);
member this.Substring : int -> string
Public Function Substring (startIndex As Integer) As String

Parameter

startIndex
Int32 Int32 Int32 Int32

Die nullbasierte Anfangsposition einer Teilzeichenfolge innerhalb dieser Instanz.The zero-based starting character position of a substring in this instance.

Gibt zurück

Eine Zeichenfolge, die der Teilzeichenfolge ab startIndex in dieser Instanz entspricht, oder Empty, wenn startIndex gleich der Länge dieser Instanz ist.A string that is equivalent to the substring that begins at startIndex in this instance, or Empty if startIndex is equal to the length of this instance.

Ausnahmen

startIndex ist kleiner als 0 (null) oder größer als die Länge dieser Instanz.startIndex is less than zero or greater than the length of this instance.

Beispiele

Das folgende Beispiel zeigt eine Teilzeichenfolge aus einer Zeichenfolge abrufen.The following example demonstrates obtaining a substring from a string.

using namespace System;
using namespace System::Collections;

int main()
{
   array<String^>^info = { "Name: Felica Walker", "Title: Mz.",
                           "Age: 47", "Location: Paris", "Gender: F"};
   int found = 0;
   Console::WriteLine("The initial values in the array are:");
   for each (String^ s in info) 
      Console::WriteLine(s);

   Console::WriteLine("\nWe want to retrieve only the key information. That is:");
   for each (String^ s in info) { 
      found = s->IndexOf(": ");
      Console::WriteLine("   {0}", s->Substring(found + 2));
   }
}
// The example displays the following output:
//       The initial values in the array are:
//       Name: Felica Walker
//       Title: Mz.
//       Age: 47
//       Location: Paris
//       Gender: F
//       
//       We want to retrieve only the key information. That is:
//       Felica Walker
//       Mz.
//       47
//       Paris
//       F
using System;

public class SubStringTest {
    public static void Main() {
        string [] info = { "Name: Felica Walker", "Title: Mz.", 
                           "Age: 47", "Location: Paris", "Gender: F"};
        int found = 0;

        Console.WriteLine("The initial values in the array are:");
        foreach (string s in info)
            Console.WriteLine(s);

        Console.WriteLine("\nWe want to retrieve only the key information. That is:");        
        foreach (string s in info) {
            found = s.IndexOf(": ");
            Console.WriteLine("   {0}", s.Substring(found + 2));
        }
    }
}
// The example displays the following output:
//       The initial values in the array are:
//       Name: Felica Walker
//       Title: Mz.
//       Age: 47
//       Location: Paris
//       Gender: F
//       
//       We want to retrieve only the key information. That is:
//          Felica Walker
//          Mz.
//          47
//          Paris
//          F
Public Class SubStringTest
    Public Shared Sub Main()
        Dim info As String() = { "Name: Felica Walker", "Title: Mz.", 
                                 "Age: 47", "Location: Paris", "Gender: F"}
        Dim found As Integer = 0
       
        Console.WriteLine("The initial values in the array are:")
        For Each s As String In info
            Console.WriteLine(s)
        Next s

        Console.WriteLine(vbCrLf + "We want to retrieve only the key information. That is:")
        For Each s As String In info
            found = s.IndexOf(": ")
            Console.WriteLine("   {0}", s.Substring(found + 2))
        Next s
    End Sub 
End Class 
' The example displays the following output:
'       The initial values in the array are:
'       Name: Felica Walker
'       Title: Mz.
'       Age: 47
'       Location: Paris
'       Gender: F
'       
'       We want to retrieve only the key information. That is:
'          Felica Walker
'          Mz.
'          47
'          Paris
'          F

Im folgenden Beispiel wird die Substring Methode, um Schlüssel/Wert-Paare trennen, die durch ein Gleichheitszeichen getrennt sind ("=") Zeichen.The following example uses the Substring method to separate key/value pairs that are delimited by an equals ("=") character.

using System;

public class Example
{
   public static void Main()
   {
      String[] pairs = { "Color1=red", "Color2=green", "Color3=blue",
                         "Title=Code Repository" };
      foreach (var pair in pairs) {
         int position = pair.IndexOf("=");
         if (position < 0)
            continue;
         Console.WriteLine("Key: {0}, Value: '{1}'", 
                           pair.Substring(0, position),
                           pair.Substring(position + 1));
      }                          
   }
}
// The example displays the following output:
//     Key: Color1, Value: 'red'
//     Key: Color2, Value: 'green'
//     Key: Color3, Value: 'blue'
//     Key: Title, Value: 'Code Repository'
Module Example
   Public Sub Main()
      Dim pairs() As String = { "Color1=red", "Color2=green", "Color3=blue",
                                "Title=Code Repository" }
      For Each pair In pairs
         Dim position As Integer = pair.IndexOf("=")
         If position < 0 then Continue For
         Console.WriteLine("Key: {0}, Value: '{1}'", 
                           pair.Substring(0, position),
                           pair.Substring(position + 1))
      Next                          
   End Sub
End Module
' The example displays the following output:
'     Key: Color1, Value: 'red'
'     Key: Color2, Value: 'green'
'     Key: Color3, Value: 'blue'
'     Key: Title, Value: 'Code Repository'

Die IndexOf Methode wird verwendet, um die Position des Zeichens gleich in der Zeichenfolge abzurufen.The IndexOf method is used to get the position of the equals character in the string. Der Aufruf der Substring(Int32, Int32) -Methode extrahiert den Schlüsselnamen, der vom ersten Zeichen in der Zeichenfolge beginnt, und erweitern für die Anzahl der Zeichen zurückgegeben werden, durch den Aufruf der IndexOf Methode.The call to the Substring(Int32, Int32) method extracts the key name, which starts from the first character in the string and extends for the number of characters returned by the call to the IndexOf method. Der Aufruf der Substring(Int32) Methode extrahiert dann den Wert auf den Schlüssel zugewiesen.The call to the Substring(Int32) method then extracts the value assigned to the key. Es beginnt an einer Position des Zeichens hinter dem Gleichheitszeichen und reicht bis zum Ende der Zeichenfolge.It starts at one character position beyond the equals character and extends to the end of the string.

Hinweise

Rufen Sie die Substring(Int32) Methode, um eine Unterzeichenfolge aus einer Zeichenfolge zu extrahieren, die an einer angegebenen Zeichenposition beginnt und am Ende der Zeichenfolge endet.You call the Substring(Int32) method to extract a substring from a string that begins at a specified character position and ends at the end of the string. Die Position des ersten Zeichens ist ein nullbasierter; Das heißt, ist das erste Zeichen in der Zeichenfolge am Index 0 (null) nicht Index 1 ein.The starting character position is a zero-based; in other words, the first character in the string is at index 0, not index 1. Um eine Teilzeichenfolge, die an einer angegebenen Zeichenposition beginnt und endet, die vor dem Ende der Zeichenfolge zu extrahieren, rufen Sie die Substring(Int32, Int32) Methode.To extract a substring that begins at a specified character position and ends before the end of the string, call the Substring(Int32, Int32) method.

Hinweis

Diese Methode ändert nicht den Wert der aktuellen Instanz.This method does not modify the value of the current instance. Stattdessen wird eine neue Zeichenfolge, die bei beginnt die startIndex Position in der aktuellen Zeichenfolge.Instead, it returns a new string that begins at the startIndex position in the current string.

Um eine untergeordnete Zeichenfolge zu extrahieren, die mit einem bestimmten Zeichen oder die Zeichenfolge beginnt, eine Methode aufrufen, wie z. B. IndexOf oder IndexOf den Wert der abzurufenden startIndex.To extract a substring that begins with a particular character or character sequence, call a method such as IndexOf or IndexOf to get the value of startIndex. Das zweite Beispiel veranschaulicht dies; extrahiert einen Schlüssel-Wert, der eine Zeichenposition nach dem Zeichen "=" beginnt.The second example illustrates this; it extracts a key value that begins one character position after the "=" character.

Wenn startIndex ist gleich 0 (null), die Methode gibt zurück, die die ursprüngliche Zeichenfolge unverändert.If startIndex is equal to zero, the method returns the original string unchanged.

Siehe auch

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

Ruft eine Teilzeichenfolge dieser Instanz ab.Retrieves a substring from this instance. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge.The substring starts at a specified character position and has a specified length.

public:
 System::String ^ Substring(int startIndex, int length);
public string Substring (int startIndex, int length);
member this.Substring : int * int -> string
Public Function Substring (startIndex As Integer, length As Integer) As String

Parameter

startIndex
Int32 Int32 Int32 Int32

Die nullbasierte Anfangsposition einer Teilzeichenfolge innerhalb dieser Instanz.The zero-based starting character position of a substring in this instance.

length
Int32 Int32 Int32 Int32

Die Anzahl der Zeichen in der Teilzeichenfolge.The number of characters in the substring.

Gibt zurück

Eine Zeichenfolge, die der Teilzeichenfolge mit der Länge length ab startIndex in dieser Instanz entspricht, oder Empty, wenn startIndex gleich der Länge dieser Instanz und length 0 (null) ist.A string that is equivalent to the substring of length length that begins at startIndex in this instance, or Empty if startIndex is equal to the length of this instance and length is zero.

Ausnahmen

startIndex plus length gibt eine Position außerhalb dieser Instanz an.startIndex plus length indicates a position not within this instance.

- oder - -or- startIndex oder length ist kleiner als 0.startIndex or length is less than zero.

Beispiele

Das folgende Beispiel veranschaulicht einen einfachen Aufruf der Substring(Int32, Int32) -Methode, die zwei Zeichen aus einer Zeichenfolge, die beginnend ab der sechsten Zeichenposition extrahiert (d. h. am index 5).The following example illustrates a simple call to the Substring(Int32, Int32) method that extracts two characters from a string starting at the sixth character position (that is, at index five).

using System;

public class Example
{
   public static void Main()
   {
      String value = "This is a string.";
      int startIndex = 5;
      int length = 2;
      String substring = value.Substring(startIndex, length);
      Console.WriteLine(substring);
   }
}
// The example displays the following output:
//       is
Module Example
   Public Sub Main()
      Dim value As String = "This is a string."
      Dim startIndex As Integer = 5
      Dim length As Integer = 2
      Dim substring As String = value.Substring(startIndex, length)
      Console.WriteLine(substring)
   End Sub
End Module
' The example displays the following output:
'       is

Im folgenden Beispiel wird die Substring(Int32, Int32) -Methode in der folgenden drei Fälle aus, um Teilzeichenfolgen in einer Zeichenfolge zu isolieren.The following example uses the Substring(Int32, Int32) method in the following three cases to isolate substrings within a string. In beiden Fällen werden die Teilzeichenfolgen in Vergleichen verwendet, und klicken Sie in den dritten Fall wird eine Ausnahme ausgelöst, weil ungültige Parameter angegeben werden.In two cases the substrings are used in comparisons, and in the third case an exception is thrown because invalid parameters are specified.

  • Er extrahiert das einzelne Zeichen und der dritten Position in der Zeichenfolge (am Index 2) und vergleicht sie mit der ein "c".It extracts the single character and the third position in the string (at index 2) and compares it with a "c". Dieser Vergleich gibt true.This comparison returns true.

  • Es werden keine Zeichen beginnend an der vierten Position in der Zeichenfolge (am Index 3) extrahiert und übergibt es an der IsNullOrEmpty Methode.It extracts zero characters starting at the fourth position in the string (at index 3) and passes it to the IsNullOrEmpty method. Dies gibt true zurück, da der Aufruf der Substring Methodenrückgabe String.Empty.This returns true because the call to the Substring method returns String.Empty.

  • Es wird versucht, ein Zeichen, beginnend an der vierten Position in der Zeichenfolge zu extrahieren.It attempts to extract one character starting at the fourth position in the string. Da Sie an dieser Position kein Zeichen vorhanden ist, löst der Methodenaufruf eine ArgumentOutOfRangeException Ausnahme.Because there is no character at that position, the method call throws an ArgumentOutOfRangeException exception.

using System;

public class Sample
{
   public static void Main() {
      String myString = "abc";
      bool test1 = myString.Substring(2, 1).Equals("c"); // This is true.
      Console.WriteLine(test1);
      bool test2 = String.IsNullOrEmpty(myString.Substring(3, 0)); // This is true.
      Console.WriteLine(test2);
      try {
         string str3 = myString.Substring(3, 1); // This throws ArgumentOutOfRangeException.
         Console.WriteLine(str3);
      }
      catch (ArgumentOutOfRangeException e) {
         Console.WriteLine(e.Message);
      }         
   }
}
// The example displays the following output:
//       True
//       True
//       Index and length must refer to a location within the string.
//       Parameter name: length
Public Class Sample
   Public Shared Sub Main()
      Dim myString As String = "abc"
      Dim test1 As Boolean = myString.Substring(2, 1).Equals("c") ' This is true.
      Console.WriteLine(test1)
      Dim test2 As Boolean = String.IsNullOrEmpty(myString.Substring(3, 0)) ' This is true.
      Console.WriteLine(test2)
      Try  
         Dim str3 As String = myString.Substring(3, 1) ' This throws ArgumentOutOfRangeException.
         Console.WriteLine(str3)
      Catch e As ArgumentOutOfRangeException
         Console.WriteLIne(e.Message)
      End Try   
   End Sub
End Class 
' The example displays the following output:
'       True
'       True
'       Index and length must refer to a location within the string.
'       Parameter name: length

Im folgenden Beispiel wird die Substring Methode, um Schlüssel/Wert-Paare trennen, die durch ein Gleichheitszeichen getrennt sind ("=") Zeichen.The following example uses the Substring method to separate key/value pairs that are delimited by an equals ("=") character.

using System;

public class Example
{
   public static void Main()
   {
      String[] pairs = { "Color1=red", "Color2=green", "Color3=blue",
                         "Title=Code Repository" };
      foreach (var pair in pairs) {
         int position = pair.IndexOf("=");
         if (position < 0)
            continue;
         Console.WriteLine("Key: {0}, Value: '{1}'", 
                           pair.Substring(0, position),
                           pair.Substring(position + 1));
      }                          
   }
}
// The example displays the following output:
//     Key: Color1, Value: 'red'
//     Key: Color2, Value: 'green'
//     Key: Color3, Value: 'blue'
//     Key: Title, Value: 'Code Repository'
Module Example
   Public Sub Main()
      Dim pairs() As String = { "Color1=red", "Color2=green", "Color3=blue",
                                "Title=Code Repository" }
      For Each pair In pairs
         Dim position As Integer = pair.IndexOf("=")
         If position < 0 then Continue For
         Console.WriteLine("Key: {0}, Value: '{1}'", 
                           pair.Substring(0, position),
                           pair.Substring(position + 1))
      Next                          
   End Sub
End Module
' The example displays the following output:
'     Key: Color1, Value: 'red'
'     Key: Color2, Value: 'green'
'     Key: Color3, Value: 'blue'
'     Key: Title, Value: 'Code Repository'

Die IndexOf Methode wird verwendet, um die Position des Zeichens gleich in der Zeichenfolge abzurufen.The IndexOf method is used to get the position of the equals character in the string. Der Aufruf der Substring(Int32, Int32) -Methode extrahiert den Schlüsselnamen, der vom ersten Zeichen in der Zeichenfolge beginnt, und erweitern für die Anzahl der Zeichen zurückgegeben werden, durch den Aufruf der IndexOf Methode.The call to the Substring(Int32, Int32) method extracts the key name, which starts from the first character in the string and extends for the number of characters returned by the call to the IndexOf method. Der Aufruf der Substring(Int32) Methode extrahiert dann den Wert auf den Schlüssel zugewiesen.The call to the Substring(Int32) method then extracts the value assigned to the key. Es beginnt an einer Position des Zeichens hinter dem Gleichheitszeichen und reicht bis zum Ende der Zeichenfolge.It starts at one character position beyond the equals character and extends to the end of the string.

Hinweise

Rufen Sie die Substring(Int32, Int32) Methode, um eine Unterzeichenfolge aus einer Zeichenfolge zu extrahieren, die an einer angegebenen Zeichenposition beginnt und vor dem Ende der Zeichenfolge endet.You call the Substring(Int32, Int32) method to extract a substring from a string that begins at a specified character position and ends before the end of the string. Die Position des ersten Zeichens ist ein nullbasierter; Das heißt, ist das erste Zeichen in der Zeichenfolge am Index 0 (null) nicht Index 1 ein.The starting character position is a zero-based; in other words, the first character in the string is at index 0, not index 1. Um eine Teilzeichenfolge, die an einer angegebenen Zeichenposition beginnt und bis zum Ende der Zeichenfolge zu extrahieren, rufen Sie die Substring(Int32) Methode.To extract a substring that begins at a specified character position and continues to the end of the string, call the Substring(Int32) method.

Hinweis

Diese Methode ändert nicht den Wert der aktuellen Instanz.This method does not modify the value of the current instance. Stattdessen wird eine neue Zeichenfolge mit length von Zeichen ab der der startIndex Position in der aktuellen Zeichenfolge.Instead, it returns a new string with length characters starting from the startIndex position in the current string.

Die length Parameter stellt die Gesamtzahl der Zeichen, die aus der aktuellen Zeichenfolgeninstanz zu extrahieren.The length parameter represents the total number of characters to extract from the current string instance. Dies schließt das erste Zeichen am Index gefunden startIndex.This includes the starting character found at index startIndex. Das heißt, die Substring -Methode versucht, das Extrahieren von Zeichen aus dem Index startIndex Index startIndex + length - 1.In other words, the Substring method attempts to extract characters from index startIndex to index startIndex + length - 1.

Um eine untergeordnete Zeichenfolge zu extrahieren, die mit einem bestimmten Zeichen oder die Zeichenfolge beginnt, eine Methode aufrufen, wie z. B. IndexOf oder LastIndexOf den Wert der abzurufenden startIndex.To extract a substring that begins with a particular character or character sequence, call a method such as IndexOf or LastIndexOf to get the value of startIndex.

Wenn die Teilzeichenfolge vom erstreckt startIndex auf eine angegebene Zeichenfolge angegeben wird, können Sie z. B. eine Methode aufrufen IndexOf oder LastIndexOf um den Index, der das abschließende Zeichen oder die Zeichenfolge abzurufen.If the substring extends from startIndex to a specified character sequence, you can call a method such as IndexOf or LastIndexOf to get the index of the ending character or character sequence. Sie können dann wie folgt diesen Wert an eine Indexposition in der Zeichenfolge konvertieren:You can then convert that value to an index position in the string as follows:

  • Wenn Sie ein einzelnes Zeichen gesucht haben, die zum Kennzeichnen der Teilzeichenfolge, die length entspricht endIndex - startIndex + 1, in denen endIndex ist der Rückgabewert von der IndexOf oder IndexOf -Methode.If you've searched for a single character that is to mark the end of the substring, the length parameter equals endIndex - startIndex + 1, where endIndex is the return value of the IndexOf or IndexOf method. Das folgende Beispiel extrahiert einen kontinuierlichen Speicherplatzblock "b"-Zeichen aus einer Zeichenfolge.The following example extracts a continuous block of "b" characters from a string.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          String s = "aaaaabbbcccccccdd";
          Char charRange = 'b';
          int startIndex = s.IndexOf(charRange);
          int endIndex = s.LastIndexOf(charRange);
          int length = endIndex - startIndex + 1;
          Console.WriteLine("{0}.Substring({1}, {2}) = {3}",
                            s, startIndex, length, 
                            s.Substring(startIndex, length));
       }
    }
    // The example displays the following output:
    //       aaaaabbbcccccccdd.Substring(5, 3) = bbb
    
    Module Example
       Public Sub Main()
          Dim s As String = "aaaaabbbcccccccdd"
          Dim charRange As Char = "b"c
          Dim startIndex As Integer = s.Indexof(charRange)
          Dim endIndex As Integer = s.LastIndexOf(charRange)
          Dim length = endIndex - startIndex + 1
          Console.WriteLine("{0}.Substring({1}, {2}) = {3}",
                            s, startIndex, length, 
                            s.Substring(startIndex, length))
       End Sub
    End Module
    ' The example displays the following output:
    '     aaaaabbbcccccccdd.Substring(5, 3) = bbb
    
  • Wenn Sie mehrere Zeichen gesucht haben, die zum Kennzeichnen der Teilzeichenfolge, die length entspricht endIndex + endMatchLength - startIndex, wobei endIndex ist der Rückgabewert von der IndexOf oder IndexOf -Methode und endMatchLength ist die Länge der Zeichenfolge, die das Ende der Teilzeichenfolge markiert.If you've searched for multiple characters that are to mark the end of the substring, the length parameter equals endIndex + endMatchLength - startIndex, where endIndex is the return value of the IndexOf or IndexOf method, and endMatchLength is the length of the character sequence that marks the end of the substring. Das folgende Beispiel extrahiert einen Textblock, der eine XML-Code enthält <definition> Element.The following example extracts a block of text that contains an XML <definition> element.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          String s = "<term>extant<definition>still in existence</definition></term>";
          String searchString = "<definition>";
          int startIndex = s.IndexOf(searchString);
          searchString = "</" + searchString.Substring(1);
          int endIndex = s.IndexOf(searchString);
          String substring = s.Substring(startIndex, endIndex + searchString.Length - startIndex);
          Console.WriteLine("Original string: {0}", s);
          Console.WriteLine("Substring;       {0}", substring); 
       }
    }
    // The example displays the following output:
    //     Original string: <term>extant<definition>still in existence</definition></term>
    //     Substring;       <definition>still in existence</definition>
    
    Module Example
       Public Sub Main()
          Dim s As String = "<term>extant<definition>still in existence</definition></term>"
          Dim searchString As String = "<definition>"
          Dim startindex As Integer = s.IndexOf(searchString)
          searchString = "</" + searchString.Substring(1)
          Dim endIndex As Integer = s.IndexOf(searchString)
          Dim substring As String = s.Substring(startIndex, endIndex + searchString.Length - StartIndex)
          Console.WriteLine("Original string: {0}", s)
          Console.WriteLine("Substring;       {0}", substring) 
       End Sub
    End Module
    ' The example displays the following output:
    '   Original string: <term>extant<definition>still in existence</definition></term>
    '   Substring;       <definition>still in existence</definition>
    
  • Wenn das Zeichen oder die Zeichenfolge am Ende der Teilzeichenfolge, nicht enthalten ist das length entspricht endIndex - startIndex, wobei endIndex ist der Rückgabewert von der IndexOf oder IndexOf -Methode.If the character or character sequence is not included in the end of the substring, the length parameter equals endIndex - startIndex, where endIndex is the return value of the IndexOf or IndexOf method.

Wenn startIndex gleich 0 (null) und ist gleich der Länge der aktuellen Zeichenfolge, die Methode gibt die ursprüngliche Zeichenfolge unverändert zurück.If startIndex is equal to zero and equals the length of the current string, the method returns the original string unchanged.

Siehe auch

Gilt für: