String.Replace Methode

Quelle:

String.Manipulation.cs

Quelle:

String.Manipulation.cs

Quelle:

String.Manipulation.cs

public:
 System::String ^ Replace(char oldChar, char newChar);

public string Replace (char oldChar, char newChar);

member this.Replace : char * char -> string

Public Function Replace (oldChar As Char, newChar As Char) As String

Parameter

Gibt zurück

Eine Zeichenfolge, die dieser Instanz entspricht, außer dass alle Instanzen von oldChar durch newChar ersetzt werden. Wenn oldChar nicht in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Beispiele

Im folgenden Beispiel wird eine durch Kommas getrennte Wertliste erstellt, indem die Leerzeichen durch Kommas zwischen einer Zahlenreihe ersetzt werden.

using namespace System;
int main()
{
   String^ str = "1 2 3 4 5 6 7 8 9";
   Console::WriteLine( "Original string: \"{0}\"", str );
   Console::WriteLine( "CSV string:      \"{0}\"", str->Replace( ' ', ',' ) );
}

//
// This example produces the following output:
// Original string: "1 2 3 4 5 6 7 8 9"
// CSV string:      "1,2,3,4,5,6,7,8,9"
//

string str = "1 2 3 4 5 6 7 8 9";
Console.WriteLine($"Original string: \"{str}\"");
Console.WriteLine($"CSV string:      \"{str.Replace(' ', ',')}\"");

// This example produces the following output:
// Original string: "1 2 3 4 5 6 7 8 9"
// CSV string:      "1,2,3,4,5,6,7,8,9"

let str = "1 2 3 4 5 6 7 8 9"
printfn $"Original string: \"{str}\""
printfn $"CSV string:      \"{str.Replace(' ', ',')}\""

// This example produces the following output:
// Original string: "1 2 3 4 5 6 7 8 9"
// CSV string:      "1,2,3,4,5,6,7,8,9"

Class stringReplace1
   Public Shared Sub Main()
      Dim str As [String] = "1 2 3 4 5 6 7 8 9"
      Console.WriteLine("Original string: ""{0}""", str)
      Console.WriteLine("CSV string:      ""{0}""", str.Replace(" "c, ","c))
   End Sub
End Class
' This example produces the following output:
' Original string: "1 2 3 4 5 6 7 8 9"
' CSV string:      "1,2,3,4,5,6,7,8,9"

Hinweise

Diese Methode führt eine Ordnungssuche (groß- und kulturunabhängig) durch, um nach zu suchen oldChar.

Da diese Methode die geänderte Zeichenfolge zurückgibt, können Sie aufeinander folgende Aufrufe der Replace -Methode verketten, um mehrere Ersetzungen für die ursprüngliche Zeichenfolge durchzuführen. Methodenaufrufe werden von links nach rechts ausgeführt. Dies wird im folgenden Beispiel veranschaulicht.

string s = new('a', 3);
Console.WriteLine($"The initial string: '{s}'");
s = s.Replace('a', 'b').Replace('b', 'c').Replace('c', 'd');
Console.WriteLine($"The final string: '{s}'");

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

let s = new string('a', 3)
printfn $"The initial string: '{s}'"
let s2 = s.Replace('a', 'b').Replace('b', 'c').Replace('c', 'd')
printfn $"The final string: '{s2}'"

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

Module Example
   Public Sub Main()
      Dim s As New String("a"c, 3)
      Console.WriteLine("The initial string: '{0}'", s)
      s = s.Replace("a"c, "b"c).Replace("b"c, "c"c).Replace("c"c, "d"c)
      Console.WriteLine("The final string: '{0}'", s)
   End Sub
End Module
' The example displays the following output:
'       The initial string: 'aaa'
'       The final string: 'ddd'

Weitere Informationen

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

Quelle:

String.Manipulation.cs

Quelle:

String.Manipulation.cs

Quelle:

String.Manipulation.cs

public:
 System::String ^ Replace(System::String ^ oldValue, System::String ^ newValue);

public string Replace (string oldValue, string newValue);

public string Replace (string oldValue, string? newValue);

member this.Replace : string * string -> string

Public Function Replace (oldValue As String, newValue As String) As String

Parameter

Gibt zurück

Eine Zeichenfolge, die der aktuellen Zeichenfolge entspricht, außer dass alle Instanzen von oldValue durch newValue ersetzt werden. Wenn oldValue nicht in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Sie die Replace -Methode verwenden können, um einen Rechtschreibfehler zu korrigieren.

using namespace System;
int main()
{
   String^ errString = "This docment uses 3 other docments to docment the docmentation";
   Console::WriteLine( "The original string is:\n'{0}'\n", errString );

   // Correct the spelling of S"document".
   String^ correctString = errString->Replace( "docment", "document" );
   Console::WriteLine( "After correcting the string, the result is:\n'{0}'", correctString );
}
//
// This code example produces the following output:
//
// The original string is:
// 'This docment uses 3 other docments to docment the docmentation'
//
// After correcting the string, the result is:
// 'This document uses 3 other documents to document the documentation'
//

string errString = "This docment uses 3 other docments to docment the docmentation";

Console.WriteLine($"The original string is:{Environment.NewLine}'{errString}'{Environment.NewLine}");

// Correct the spelling of "document".
string correctString = errString.Replace("docment", "document");

Console.WriteLine($"After correcting the string, the result is:{Environment.NewLine}'{correctString}'");

// This code example produces the following output:
//
// The original string is:
// 'This docment uses 3 other docments to docment the docmentation'
//
// After correcting the string, the result is:
// 'This document uses 3 other documents to document the documentation'
//

open System

let errString = "This docment uses 3 other docments to docment the docmentation"

printfn $"The original string is:{Environment.NewLine}'{errString}'{Environment.NewLine}"

// Correct the spelling of "document".

let correctString = errString.Replace("docment", "document")

printfn $"After correcting the string, the result is:{Environment.NewLine}'{correctString}'"

// This code example produces the following output:
//
// The original string is:
// 'This docment uses 3 other docments to docment the docmentation'
//
// After correcting the string, the result is:
// 'This document uses 3 other documents to document the documentation'
//

Public Class ReplaceTest
    
    Public Shared Sub Main()
        Dim errString As String = "This docment uses 3 other docments to docment the docmentation"
                
        Console.WriteLine("The original string is:{0}'{1}'{0}", Environment.NewLine, errString)

        ' Correct the spelling of "document".  
        Dim correctString As String = errString.Replace("docment", "document")
      
        Console.WriteLine("After correcting the string, the result is:{0}'{1}'", Environment.NewLine, correctString)
    End Sub
End Class
'
' This code example produces the following output:
'
' The original string is:
' 'This docment uses 3 other docments to docment the docmentation'
'
' After correcting the string, the result is:
' 'This document uses 3 other documents to document the documentation'
'

Hinweise

Wenn newValue ist null, werden alle Vorkommen von oldValue entfernt.

Diese Methode führt eine Ordnungssuche (groß- und kulturunabhängig) durch, um nach zu suchen oldValue.

Da diese Methode die geänderte Zeichenfolge zurückgibt, können Sie aufeinander folgende Aufrufe der Replace -Methode verketten, um mehrere Ersetzungen für die ursprüngliche Zeichenfolge durchzuführen. Methodenaufrufe werden von links nach rechts ausgeführt. Dies wird im folgenden Beispiel veranschaulicht.

string s = "aaa";
Console.WriteLine($"The initial string: '{s}'");
s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d");
Console.WriteLine($"The final string: '{s}'");

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

let s = "aaa"
printfn $"The initial string: '{s}'"
let s2 = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
printfn $"The final string: '{s2}'"

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

Module Example
   Public Sub Main()
      Dim s As String = "aaa"
      Console.WriteLine("The initial string: '{0}'", s)
      s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
      Console.WriteLine("The final string: '{0}'", s)
   End Sub
End Module
' The example displays the following output:
'       The initial string: 'aaa'
'       The final string: 'ddd'

Weitere Informationen

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

Quelle:

String.Manipulation.cs

Quelle:

String.Manipulation.cs

Quelle:

String.Manipulation.cs

public:
 System::String ^ Replace(System::String ^ oldValue, System::String ^ newValue, StringComparison comparisonType);

public string Replace (string oldValue, string? newValue, StringComparison comparisonType);

public string Replace (string oldValue, string newValue, StringComparison comparisonType);

member this.Replace : string * string * StringComparison -> string

Public Function Replace (oldValue As String, newValue As String, comparisonType As StringComparison) As String

Parameter

Gibt zurück

Eine Zeichenfolge, die der aktuellen Zeichenfolge entspricht, außer dass alle Instanzen von oldValue durch newValue ersetzt werden. Wenn oldValue nicht in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Hinweise

Wenn newValue ist null, werden alle Vorkommen von oldValue entfernt.

Diese Methode führt eine Suche nach der oldValue Kultur und Groß-/Kleinschreibung durch, die von beschrieben wird comparisonType.

Da diese Methode die geänderte Zeichenfolge zurückgibt, können Sie aufeinander folgende Aufrufe der Replace -Methode verketten, um mehrere Ersetzungen für die ursprüngliche Zeichenfolge durchzuführen. Methodenaufrufe werden von links nach rechts ausgeführt. Dies wird im folgenden Beispiel veranschaulicht.

string s = "aaa";
Console.WriteLine($"The initial string: '{s}'");
s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d");
Console.WriteLine($"The final string: '{s}'");

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

let s = "aaa"
printfn $"The initial string: '{s}'"
let s2 = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
printfn $"The final string: '{s2}'"

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

Module Example
   Public Sub Main()
      Dim s As String = "aaa"
      Console.WriteLine("The initial string: '{0}'", s)
      s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
      Console.WriteLine("The final string: '{0}'", s)
   End Sub
End Module
' The example displays the following output:
'       The initial string: 'aaa'
'       The final string: 'ddd'

Quelle:

String.Manipulation.cs

Quelle:

String.Manipulation.cs

Quelle:

String.Manipulation.cs

public:
 System::String ^ Replace(System::String ^ oldValue, System::String ^ newValue, bool ignoreCase, System::Globalization::CultureInfo ^ culture);

public string Replace (string oldValue, string? newValue, bool ignoreCase, System.Globalization.CultureInfo? culture);

public string Replace (string oldValue, string newValue, bool ignoreCase, System.Globalization.CultureInfo culture);

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

Public Function Replace (oldValue As String, newValue As String, ignoreCase As Boolean, culture As CultureInfo) As String

Parameter

Gibt zurück

Eine Zeichenfolge, die der aktuellen Zeichenfolge entspricht, außer dass alle Instanzen von oldValue durch newValue ersetzt werden. Wenn oldValue nicht in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

Hinweise

Wenn newValue ist null, werden alle Vorkommen von oldValue entfernt.

Diese Methode führt eine Suche oldValue nach der angegebenen culture Und Groß-/ ignoreCase Kleinschreibung durch.

Da diese Methode die geänderte Zeichenfolge zurückgibt, können Sie aufeinander folgende Aufrufe der Replace -Methode verketten, um mehrere Ersetzungen für die ursprüngliche Zeichenfolge durchzuführen. Methodenaufrufe werden von links nach rechts ausgeführt. Dies wird im folgenden Beispiel veranschaulicht.

string s = "aaa";
Console.WriteLine($"The initial string: '{s}'");
s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d");
Console.WriteLine($"The final string: '{s}'");

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

let s = "aaa"
printfn $"The initial string: '{s}'"
let s2 = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
printfn $"The final string: '{s2}'"

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

Module Example
   Public Sub Main()
      Dim s As String = "aaa"
      Console.WriteLine("The initial string: '{0}'", s)
      s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
      Console.WriteLine("The final string: '{0}'", s)
   End Sub
End Module
' The example displays the following output:
'       The initial string: 'aaa'
'       The final string: 'ddd'