String.Replace Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'un caractère Unicode spécifié ou de String dans la chaîne actuelle sont remplacées par un autre caractère Unicode spécifié ou String.

Surcharges

Replace(Char, Char)	Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'un caractère Unicode spécifié dans cette instance sont remplacées par un autre caractère Unicode spécifié.
Replace(String, String)	Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'une chaîne spécifiée dans l'instance actuelle sont remplacées par une autre chaîne spécifiée.
Replace(String, String, StringComparison)	Retourne une nouvelle chaîne dans laquelle toutes les occurrences d’une chaîne spécifique dans l’instance actuelle sont remplacées par une autre chaîne spécifique, à l’aide des informations fournies sur le type de comparaison.
Replace(String, String, Boolean, CultureInfo)	Retourne une nouvelle chaîne dans laquelle toutes les occurrences d’une chaîne spécifique dans l’instance actuelle sont remplacées par une autre chaîne spécifique, à l’aide des informations fournies sur la culture et le respect de la casse.

Replace(Char, Char)

Source:: String.Manipulation.cs

Source:: String.Manipulation.cs

Source:: String.Manipulation.cs

Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'un caractère Unicode spécifié dans cette instance sont remplacées par un autre caractère Unicode spécifié.

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

Paramètres

oldChar: Char

Caractère Unicode à remplacer.

newChar: Char

Caractère Unicode permettant de remplacer toutes les occurrences de oldChar.

Retours

String

Chaîne équivalente à cette instance, sauf que toutes les instances de oldChar sont remplacées par newChar. Si oldChar est introuvable dans l'instance actuelle, la méthode retourne l'instance actuelle sans modification.

Exemples

L’exemple suivant crée une liste de valeurs séparées par des virgules en remplaçant les virgules par les vides entre une série de nombres.

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"

Remarques

Cette méthode effectue une recherche ordinale (respectant la casse et ne respectant pas la culture) pour rechercher oldChar.

Notes

Cette méthode ne modifie pas la valeur de la instance actuelle. Au lieu de cela, il retourne une nouvelle chaîne dans laquelle toutes les occurrences de oldChar sont remplacées par newChar.

Étant donné que cette méthode retourne la chaîne modifiée, vous pouvez enchaîner les appels successifs à la Replace méthode pour effectuer plusieurs remplacements sur la chaîne d’origine. Les appels de méthode sont exécutés de gauche à droite. L'exemple suivant illustre cette situation.

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'

Voir aussi

S’applique à

Replace(String, String)

Source:: String.Manipulation.cs

Source:: String.Manipulation.cs

Source:: String.Manipulation.cs

Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'une chaîne spécifiée dans l'instance actuelle sont remplacées par une autre chaîne spécifiée.

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

Paramètres

oldValue: String

Chaîne à remplacer.

newValue: String

Chaîne permettant de remplacer toutes les occurrences de oldValue.

Retours

String

Chaîne équivalente à la chaîne actuelle, sauf que toutes les instances de oldValue sont remplacées par newValue. Si oldValue est introuvable dans l'instance actuelle, la méthode retourne l'instance actuelle sans modification.

Exceptions

ArgumentNullException

oldValue est null.

ArgumentException

oldValue est la chaîne vide ("").

Exemples

L’exemple suivant montre comment utiliser la Replace méthode pour corriger une erreur d’orthographe.

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

Remarques

Si newValue a la valeur null, toutes les occurrences de oldValue sont supprimées.

Notes

Cette méthode ne modifie pas la valeur de la instance actuelle. Au lieu de cela, il retourne une nouvelle chaîne dans laquelle toutes les occurrences de oldValue sont remplacées par newValue.

Cette méthode effectue une recherche ordinale (respectant la casse et ne respectant pas la culture) pour rechercher 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'

Voir aussi

S’applique à

Replace(String, String, StringComparison)

Source:: String.Manipulation.cs

Source:: String.Manipulation.cs

Source:: String.Manipulation.cs

Retourne une nouvelle chaîne dans laquelle toutes les occurrences d’une chaîne spécifique dans l’instance actuelle sont remplacées par une autre chaîne spécifique, à l’aide des informations fournies sur le type de comparaison.

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

Paramètres

oldValue: String

Chaîne à remplacer.

newValue: String

Chaîne permettant de remplacer toutes les occurrences de oldValue.

comparisonType: StringComparison

Une des valeurs d’énumération qui détermine la façon dont oldValue est recherché dans cette instance.

Retours

String

Exceptions

ArgumentNullException

oldValue est null.

ArgumentException

oldValue est la chaîne vide ("").

Remarques

Si newValue a la valeur null, toutes les occurrences de oldValue sont supprimées.

Notes

Cette méthode ne modifie pas la valeur de la instance actuelle. Au lieu de cela, il retourne une nouvelle chaîne dans laquelle toutes les occurrences de oldValue sont remplacées par newValue.

Cette méthode effectue une recherche à l’aide oldValue de la culture et de la sensibilité à la casse décrites par 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'

S’applique à

Replace(String, String, Boolean, CultureInfo)

Source:: String.Manipulation.cs

Source:: String.Manipulation.cs

Source:: 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

Paramètres

oldValue: String

Chaîne à remplacer.

newValue: String

Chaîne permettant de remplacer toutes les occurrences de oldValue.

ignoreCase: Boolean

true pour ignorer la casse durant la comparaison ; sinon, false.

culture: CultureInfo

Culture à utiliser durant la comparaison. Si culture est null, la culture actuelle est utilisée.

Retours

String

Exceptions

ArgumentNullException

oldValue est null.

ArgumentException

oldValue est la chaîne vide ("").

Remarques

Si newValue a la valeur null, toutes les occurrences de oldValue sont supprimées.

Notes

Cette méthode ne modifie pas la valeur de la instance actuelle. Au lieu de cela, il retourne une nouvelle chaîne dans laquelle toutes les occurrences de oldValue sont remplacées par newValue.

Cette méthode effectue une recherche à l’aide oldValue de la confidentialité fournie culture et ignoreCase de la casse.

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'

S’applique à

Partage via

String.Replace Méthode

Définition

Surcharges

Replace(Char, Char)

Paramètres

Retours

Exemples

Remarques

Voir aussi

S’applique à

Replace(String, String)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Replace(String, String, StringComparison)

Paramètres

Retours

Exceptions

Remarques

S’applique à

Replace(String, String, Boolean, CultureInfo)

Paramètres

Retours

Exceptions

Remarques

S’applique à

Ressources supplémentaires