String.Replace Metoda

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego znaku Unicode lub String w bieżącym ciągu są zastępowane innym określonym znakiem Unicode lub String.

Przeciążenia

Replace(Char, Char)	Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego znaku Unicode w tym wystąpieniu są zastępowane innym określonym znakiem Unicode.
Replace(String, String)	Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem.
Replace(String, String, StringComparison)	Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem przy użyciu podanego typu porównania.
Replace(String, String, Boolean, CultureInfo)	Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem przy użyciu podanej kultury i poufności liter.

Replace(Char, Char)

Źródło:

String.Manipulation.cs

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego znaku Unicode w tym wystąpieniu są zastępowane innym określonym znakiem Unicode.

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

Parametry

oldChar

Char

Znak Unicode, który ma zostać zastąpiony.

newChar

Char

Znak Unicode, aby zastąpić wszystkie wystąpienia elementu oldChar.

Zwraca

String

Ciąg, który jest odpowiednikiem tego wystąpienia, z wyjątkiem tego, że wszystkie wystąpienia obiektu oldChar są zastępowane ciągiem newChar. Jeśli oldChar nie zostanie znaleziony w bieżącym wystąpieniu, metoda zwróci bieżące wystąpienie bez zmian.

Przykłady

Poniższy przykład tworzy listę wartości rozdzielanych przecinkami, zastępując przecinkami wartości puste między serią liczb.

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"

Uwagi

Ta metoda wykonuje wyszukiwanie porządkowe (rozróżniane wielkość liter i niewrażliwe na kulturę) w celu znalezienia oldChar.

Uwaga

Metoda ta nie modyfikuje wartości bieżącego wystąpienia. Zamiast tego zwraca nowy ciąg, w którym wszystkie wystąpienia oldChar są zastępowane przez .newChar

Ponieważ ta metoda zwraca zmodyfikowany ciąg, można połączyć kolejne wywołania metody w Replace celu wykonania wielu zamian w oryginalnym ciągu. Wywołania metody są wykonywane od lewej do prawej. Poniższy przykład stanowi ilustrację.

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'

Zobacz też

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

Replace(String, String)

Źródło:

String.Manipulation.cs

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem.

public:
 System::String ^ Replace(System::String ^ oldValue, System::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

Parametry

oldValue

String

Ciąg, który ma zostać zastąpiony.

newValue

String

Ciąg, który zastąpi wszystkie wystąpienia elementu oldValue.

Zwraca

String

Ciąg, który jest odpowiednikiem bieżącego ciągu, z wyjątkiem tego, że wszystkie wystąpienia elementu oldValue są zastępowane ciągiem newValue. Jeśli oldValue nie zostanie znaleziony w bieżącym wystąpieniu, metoda zwróci bieżące wystąpienie bez zmian.

Wyjątki

ArgumentNullException

oldValue to null.

ArgumentException

oldValue jest pustym ciągiem ("").

Przykłady

W poniższym przykładzie pokazano, jak można użyć metody w Replace celu skorygowania błędu pisowni.

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'
'

Uwagi

Jeśli newValue jest to null, wszystkie wystąpienia oldValue są usuwane.

Uwaga

Metoda ta nie modyfikuje wartości bieżącego wystąpienia. Zamiast tego zwraca nowy ciąg, w którym wszystkie wystąpienia oldValue są zastępowane przez .newValue

Ta metoda wykonuje wyszukiwanie porządkowe (rozróżniane wielkość liter i niewrażliwe na kulturę) w celu znalezienia oldValue.

Ponieważ ta metoda zwraca zmodyfikowany ciąg, można połączyć kolejne wywołania metody w Replace celu wykonania wielu zamian w oryginalnym ciągu. Wywołania metody są wykonywane od lewej do prawej. Poniższy przykład stanowi ilustrację.

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'

Zobacz też

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

Replace(String, String, StringComparison)

Źródło:

String.Manipulation.cs

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem przy użyciu podanego typu porównania.

public:
 System::String ^ Replace(System::String ^ oldValue, System::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

Parametry

oldValue

String

Ciąg, który ma zostać zastąpiony.

newValue

String

Ciąg, który zastąpi wszystkie wystąpienia elementu oldValue.

comparisonType

StringComparison

Jedna z wartości wyliczenia określająca sposób oldValue wyszukiwania w tym wystąpieniu.

Zwraca

String

Ciąg, który jest odpowiednikiem bieżącego ciągu, z wyjątkiem tego, że wszystkie wystąpienia elementu oldValue są zastępowane ciągiem newValue. Jeśli oldValue nie zostanie znaleziony w bieżącym wystąpieniu, metoda zwróci bieżące wystąpienie bez zmian.

Wyjątki

ArgumentNullException

oldValue to null.

ArgumentException

oldValue jest pustym ciągiem ("").

Uwagi

Jeśli newValue jest to null, wszystkie wystąpienia oldValue są usuwane.

Uwaga

Metoda ta nie modyfikuje wartości bieżącego wystąpienia. Zamiast tego zwraca nowy ciąg, w którym wszystkie wystąpienia oldValue są zastępowane przez .newValue

Ta metoda wykonuje wyszukiwanie, aby znaleźć oldValue przy użyciu kultury i poufności liter opisanych przez comparisonType.

Ponieważ ta metoda zwraca zmodyfikowany ciąg, można połączyć kolejne wywołania metody w Replace celu wykonania wielu zamian w oryginalnym ciągu. Wywołania metody są wykonywane od lewej do prawej. Poniższy przykład stanowi ilustrację.

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'

Replace(String, String, Boolean, CultureInfo)

Źródło:

String.Manipulation.cs

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem przy użyciu podanej kultury i poufności liter.

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);

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

Parametry

oldValue

String

Ciąg, który ma zostać zastąpiony.

newValue

String

Ciąg, który zastąpi wszystkie wystąpienia elementu oldValue.

ignoreCase

Boolean

true ignorowanie wielkości liter podczas porównywania; false Inaczej.

culture

CultureInfo

Kultura do użycia podczas porównywania. Jeśli culture jest to null, jest używana bieżąca kultura.

Zwraca

String

Ciąg, który jest odpowiednikiem bieżącego ciągu, z wyjątkiem tego, że wszystkie wystąpienia elementu oldValue są zastępowane ciągiem newValue. Jeśli oldValue nie zostanie znaleziony w bieżącym wystąpieniu, metoda zwróci bieżące wystąpienie bez zmian.

Wyjątki

ArgumentNullException

oldValue to null.

ArgumentException

oldValue jest pustym ciągiem ("").

Uwagi

Jeśli newValue jest to null, wszystkie wystąpienia oldValue są usuwane.

Uwaga

Metoda ta nie modyfikuje wartości bieżącego wystąpienia. Zamiast tego zwraca nowy ciąg, w którym wszystkie wystąpienia oldValue są zastępowane przez .newValue

Ta metoda wykonuje wyszukiwanie, aby znaleźć oldValue przy użyciu podanej culture i ignoreCase poufności liter.

Ponieważ ta metoda zwraca zmodyfikowany ciąg, można połączyć kolejne wywołania metody w Replace celu wykonania wielu zamian w oryginalnym ciągu. Wywołania metody są wykonywane od lewej do prawej. Poniższy przykład stanowi ilustrację.

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'