String.Substring Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Ruft eine Teilzeichenfolge dieser Instanz ab.

Dieser Member wird überladen. Klicken Sie auf einen Namen in der Überladungsliste, um vollständige Informationen zu diesem Member sowie zu Syntax, Nutzung und Beispielen zu erhalten.

Überlädt

Substring(Int32)	Ruft eine Teilzeichenfolge dieser Instanz ab. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt.
Substring(Int32, Int32)	Ruft eine Teilzeichenfolge dieser Instanz ab. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge.

Substring(Int32)

Quelle:

String.Manipulation.cs

Ruft eine Teilzeichenfolge dieser Instanz ab. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt.

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

Die nullbasierte Anfangsposition einer Teilzeichenfolge innerhalb dieser Instanz.

Gibt zurück

String

Eine Zeichenfolge, die der Teilzeichenfolge ab startIndex in dieser Instanz entspricht, oder Empty, wenn startIndex gleich der Länge dieser Instanz ist.

Ausnahmen

ArgumentOutOfRangeException

startIndex ist kleiner als 0 (null) oder größer als die Länge dieser Instanz.

Beispiele

Das folgende Beispiel veranschaulicht das Abrufen einer Teilzeichenfolge aus einer Zeichenfolge.

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

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

let info = 
    [| "Name: Felica Walker"; "Title: Mz."
       "Age: 47"; "Location: Paris"; "Gender: F" |]

printfn "The initial values in the array are:"
for s in info do
    printfn $"{s}"

printfn "\nWe want to retrieve only the key information. That is:"
for s in info do
    let found = s.IndexOf ": "
    printfn $"   {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 verwendet, um Schlüssel-Wert-Paare zu trennen, die durch ein Zeichen gleich (=) getrennt sind.

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'

let pairs = 
    [| "Color1=red"; "Color2=green"; "Color3=blue"
       "Title=Code Repository" |]
for pair in pairs do
    let position = pair.IndexOf "="
    if position >= 0 then
        printfn $"Key: {pair.Substring(0, position)}, Value: '{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 Gleichzeichens in der Zeichenfolge abzurufen. Der Aufruf der Substring(Int32, Int32) -Methode extrahiert den Schlüsselnamen, der mit dem ersten Zeichen in der Zeichenfolge beginnt und sich auf die Anzahl der Zeichen erweitert, die vom Aufruf der IndexOf -Methode zurückgegeben werden. Durch den Aufruf der Substring(Int32) -Methode wird dann der dem Schlüssel zugewiesene Wert extrahiert. Sie beginnt an einer Zeichenposition jenseits des zeichengleichen Zeichens und erstreckt sich bis zum Ende der Zeichenfolge.

Hinweise

Sie rufen die Substring(Int32) -Methode auf, um eine Teilzeichenfolge aus einer Zeichenfolge zu extrahieren, die an einer angegebenen Zeichenposition beginnt und am Ende der Zeichenfolge endet. Die Anfangszeichenposition ist nullbasiert; Mit anderen Worten, das erste Zeichen in der Zeichenfolge befindet sich bei Index 0, nicht bei Index 1. Um eine Teilzeichenfolge zu extrahieren, die an einer angegebenen Zeichenposition beginnt und vor dem Ende der Zeichenfolge endet, rufen Sie die -Methode auf Substring(Int32, Int32) .

Hinweis

Diese Methode ändert den Wert des aktuellen instance nicht. Stattdessen wird eine neue Zeichenfolge zurückgegeben, die an der startIndex Position in der aktuellen Zeichenfolge beginnt.

Um eine Teilzeichenfolge zu extrahieren, die mit einem bestimmten Zeichen oder einer bestimmten Zeichenfolge beginnt, rufen Sie eine Methode wie IndexOf oder IndexOf auf, um den Wert von startIndexabzurufen. Das zweite Beispiel veranschaulicht dies. Es extrahiert einen Schlüsselwert, der eine Zeichenposition nach dem = Zeichen beginnt.

Wenn startIndex gleich 0 ist, gibt die Methode die ursprüngliche Zeichenfolge unverändert zurück.

Weitere Informationen

• Int32
• Concat(Object)
• Insert(Int32, String)
• Join(String, String[])
• Remove(Int32, Int32)
• Replace(Char, Char)
• Split(Char[])
• Trim(Char[])

Substring(Int32, Int32)

Quelle:

String.Manipulation.cs

Ruft eine Teilzeichenfolge dieser Instanz ab. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge.

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

Die nullbasierte Anfangsposition einer Teilzeichenfolge innerhalb dieser Instanz.

length

Int32

Die Anzahl der Zeichen in der Teilzeichenfolge.

Gibt zurück

String

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.

Ausnahmen

ArgumentOutOfRangeException

startIndex plus length gibt eine Position außerhalb dieser Instanz an.

- oder -

startIndex oder length ist kleiner als 0.

Beispiele

Das folgende Beispiel veranschaulicht einen einfachen Aufruf der -Methode, die Substring(Int32, Int32) zwei Zeichen aus einer Zeichenfolge extrahiert, die an der position des sechsten Zeichens (d. a. bei Index fünf) beginnt.

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

let value = "This is a string."
let startIndex = 5
let length = 2
let substring = value.Substring(startIndex, length)
printfn $"{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 den folgenden drei Fällen verwendet, um Teilzeichenfolgen innerhalb einer Zeichenfolge zu isolieren. In zwei Fällen werden die Teilzeichenfolgen in Vergleichen verwendet, und im dritten Fall wird eine Ausnahme ausgelöst, da ungültige Parameter angegeben werden.

• Es extrahiert das einzelne Zeichen an der dritten Position in der Zeichenfolge (bei Index 2) und vergleicht es mit einem "c". Dieser Vergleich gibt zurück true.

• Es extrahiert null Zeichen ab der vierten Position in der Zeichenfolge (bei Index 3) und übergibt sie an die IsNullOrEmpty -Methode. Dadurch wird true zurückgegeben, da der Aufruf der Substring -Methode zurückgibt String.Empty.

• Es wird versucht, ein Zeichen ab der vierten Position in der Zeichenfolge zu extrahieren. Da an dieser Position kein Zeichen vorhanden ist, löst der Methodenaufruf eine Ausnahme aus ArgumentOutOfRangeException .

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

let myString = "abc"
let test1 = myString.Substring(2, 1).Equals "c" // This is true.
printfn $"{test1}"
let test2 = String.IsNullOrEmpty(myString.Substring(3, 0)) // This is true.
printfn $"{test2}"
try
    let str3 = myString.Substring(3, 1) // This throws ArgumentOutOfRangeException.
    printfn $"{str3}"
with :? ArgumentOutOfRangeException as e ->
    printfn $"{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 verwendet, um Schlüssel-Wert-Paare zu trennen, die durch ein Zeichen gleich (=) getrennt sind.

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'

let pairs = 
    [| "Color1=red"; "Color2=green"; "Color3=blue"
       "Title=Code Repository" |]
for pair in pairs do
    let position = pair.IndexOf "="
    if position >= 0 then
        printfn $"Key: {pair.Substring(0, position)}, Value: '{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 Gleichzeichens in der Zeichenfolge abzurufen. Der Aufruf der Substring(Int32, Int32) -Methode extrahiert den Schlüsselnamen, der mit dem ersten Zeichen in der Zeichenfolge beginnt und sich auf die Anzahl der Zeichen erweitert, die vom Aufruf der IndexOf -Methode zurückgegeben werden. Durch den Aufruf der Substring(Int32) -Methode wird dann der dem Schlüssel zugewiesene Wert extrahiert. Sie beginnt an einer Zeichenposition jenseits des zeichengleichen Zeichens und erstreckt sich bis zum Ende der Zeichenfolge.

Hinweise

Sie rufen die Substring(Int32, Int32) -Methode auf, um eine Teilzeichenfolge aus einer Zeichenfolge zu extrahieren, die an einer angegebenen Zeichenposition beginnt und vor dem Ende der Zeichenfolge endet. Die Anfangszeichenposition ist nullbasiert; Mit anderen Worten, das erste Zeichen in der Zeichenfolge befindet sich bei Index 0, nicht bei Index 1. Um eine Teilzeichenfolge zu extrahieren, die an einer angegebenen Zeichenposition beginnt und bis zum Ende der Zeichenfolge fortfährt, rufen Sie die -Methode auf Substring(Int32) .

Hinweis

Diese Methode ändert den Wert des aktuellen instance nicht. Stattdessen wird eine neue Zeichenfolge mit length Zeichen zurückgegeben, die von der startIndex Position in der aktuellen Zeichenfolge beginnen.

Der length Parameter stellt die Gesamtzahl der Zeichen dar, die aus der aktuellen Zeichenfolge instance extrahiert werden sollen. Dies schließt das Startzeichen ein, das unter index startIndexgefunden wird. Mit anderen Worten, die Substring Methode versucht, Zeichen aus dem Index startIndex in den Index startIndex + length zu extrahieren – 1.

Um eine Teilzeichenfolge zu extrahieren, die mit einem bestimmten Zeichen oder einer bestimmten Zeichenfolge beginnt, rufen Sie eine Methode wie IndexOf oder LastIndexOf auf, um den Wert von startIndexabzurufen.

Wenn die Teilzeichenfolge von startIndex zu einer angegebenen Zeichenfolge erweitert werden soll, können Sie eine Methode aufrufen, z IndexOf . B. oder LastIndexOf , um den Index des Endzeichens oder der Zeichenfolge abzurufen. Sie können diesen Wert dann wie folgt in eine Indexposition in der Zeichenfolge konvertieren:

• Wenn Sie nach einem einzelnen Zeichen gesucht haben, das das Ende der Teilzeichenfolge markieren soll, entspricht - startIndexendIndexder length Parameter + 1, wobei endIndex der Rückgabewert der IndexOf -Methode oder LastIndexOf ist. Im folgenden Beispiel wird ein fortlaufender Block mit "b"-Zeichen aus einer Zeichenfolge extrahiert.

  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
  

  let s = "aaaaabbbcccccccdd"
  let charRange = 'b'
  let startIndex = s.IndexOf charRange
  let endIndex = s.LastIndexOf charRange
  let length = endIndex - startIndex + 1
  printfn $"{s}.Substring({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 nach mehreren Zeichen gesucht haben, die das Ende der Teilzeichenfolge markieren sollen, entspricht der length Parameter - endMatchLength + endIndexstartIndex dem endIndex Rückgabewert der IndexOf -Methode oder LastIndexOf und endMatchLength der Länge der Zeichenfolge, die das Ende der Teilzeichenfolge markiert. Im folgenden Beispiel wird ein Textblock extrahiert, der ein XML-Element <definition> enthält.

  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>
  

  let s = "<term>extant<definition>still in existence</definition></term>"
  let searchString = "<definition>"
  let startIndex = s.IndexOf(searchString)
  let searchString = "</" + searchString.Substring 1
  let endIndex = s.IndexOf searchString
  let substring = s.Substring(startIndex, endIndex + searchString.Length - startIndex)
  printfn $"Original string: {s}"
  printfn $"Substring;       {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 nicht am Ende der Teilzeichenfolge enthalten ist, entspricht der length Parameter endIndexstartIndex - , wobei endIndex der Rückgabewert der IndexOf -Methode oder LastIndexOf ist.

Wenn startIndex gleich 0 und length der Länge der aktuellen Zeichenfolge entspricht, gibt die Methode die ursprüngliche Zeichenfolge unverändert zurück.

Weitere Informationen

• Remove(Int32, Int32)
• Replace(Char, Char)
• Trim(Char[])