String.Replace Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

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

Źródło:: String.Manipulation.cs

Ź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ż

Dotyczy

.NET 9 i inne wersje

Produkt	Wersje
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework	1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP	10.0

Replace(String, String)

Źródło:: String.Manipulation.cs

Źródło:: String.Manipulation.cs

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

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.

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ż

Dotyczy

.NET 9 i inne wersje

Produkt	Wersje
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework	1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP	10.0

Replace(String, String, StringComparison)

Źródło:: String.Manipulation.cs

Źródło:: String.Manipulation.cs

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

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

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.

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'

Dotyczy

.NET 9 i inne wersje

Produkt	Wersje
.NET	Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Standard	2.1

Replace(String, String, Boolean, CultureInfo)

Źródło:: String.Manipulation.cs

Źródło:: String.Manipulation.cs

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

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

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.

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'

Dotyczy

.NET 9 i inne wersje

Produkt	Wersje
.NET	Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Standard	2.1

Udostępnij za pośrednictwem

String.Replace Metoda

Definicja

Przeciążenia

Replace(Char, Char)

Parametry

Zwraca

Przykłady

Uwagi

Zobacz też

Dotyczy

Replace(String, String)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Replace(String, String, StringComparison)

Parametry

Zwraca

Wyjątki

Uwagi

Dotyczy

Replace(String, String, Boolean, CultureInfo)

Parametry

Zwraca

Wyjątki

Uwagi

Dotyczy

Dodatkowe zasoby