Udostępnij za pośrednictwem


String.Replace Metoda

Definicja

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

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

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

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

oldValue to null.

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ż

Dotyczy

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

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

oldValue to null.

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'

Dotyczy

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

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

oldValue to null.

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'

Dotyczy