Ersättningar i reguljära uttryck
Ersättningar är språkelement som endast identifieras inom ersättningsmönster. De använder ett mönster för reguljära uttryck för att definiera hela eller delar av texten som ska ersätta matchad text i indatasträngen. Ersättningsmönstret kan bestå av en eller flera ersättningar tillsammans med literaltecken. Ersättningsmönster tillhandahålls för överlagringar av metoden Regex.Replace som har en replacement parameter och metoden Match.Result . Metoderna ersätter det matchade mönstret med det mönster som definieras av parametern replacement .
.NET definierar de ersättningselement som anges i följande tabell.
| Ersättning | beskrivning |
|---|---|
| $ Nummer | Innehåller den sista delsträngen som matchas av insamlingsgruppen som identifieras med tal, där talet är ett decimalvärde, i ersättningssträngen. Mer information finns i Ersätta en numrerad grupp. |
| ${ namn } | Innehåller den sista delsträngen som matchas av den namngivna gruppen som har angetts efter namn i ersättningssträngen(?<.> ) Mer information finns i Ersätta en namngiven grupp. |
| $$ | Innehåller en enda "$" literal i ersättningssträngen. Mer information finns i Ersätta en $-symbol. |
| $& | Innehåller en kopia av hela matchningen i ersättningssträngen. Mer information finns i Ersätta hela matchningen. |
| $` | Innehåller all text i indatasträngen före matchningen i ersättningssträngen. Mer information finns i Substituting the Text before the Match. |
| $' | Innehåller all text i indatasträngen efter matchningen i ersättningssträngen. Mer information finns i Ersätta text efter matchningen. |
| $+ | Innehåller den sista gruppen som samlats in i ersättningssträngen. Mer information finns i Ersätta den senast insamlade gruppen. |
| $_ | Innehåller hela indatasträngen i ersättningssträngen. Mer information finns i Ersätta hela indatasträngen. |
Ersättningselement och ersättningsmönster
Ersättningar är de enda specialkonstruktioner som identifieras i ett ersättningsmönster. Inget av de andra språkelementen för reguljära uttryck, inklusive teckenutrymningar och perioden (.), som matchar något tecken, stöds. På samma sätt identifieras ersättningsspråkelement endast i ersättningsmönster och är aldrig giltiga i reguljära uttrycksmönster.
Det enda tecken som kan visas antingen i ett reguljärt uttrycksmönster eller i en ersättning är $ tecknet, även om det har en annan betydelse i varje kontext. I ett reguljärt uttrycksmönster $ är ett fästpunkt som matchar slutet av strängen. I ett ersättningsmönster $ anger början av en ersättning.
Kommentar
För funktioner som liknar ett ersättningsmönster i ett reguljärt uttryck använder du en backreference. Mer information om backreferences finns i Backreference-konstruktioner.
Ersätta en numrerad grupp
Talspråkelementet innehåller den sista delsträngen som matchas av nummerfångsgruppen i ersättningssträngen, där talet är indexet för insamlingsgruppen.$ Ersättningsmönstret $1 anger till exempel att den matchade delsträngen ska ersättas av den första insamlade gruppen. Mer information om numrerade grupper finns i Grupperingskonstruktioner.
Alla siffror som följer $ tolkas som tillhörande nummergruppen . Om detta inte är din avsikt kan du ersätta en namngiven grupp i stället. Du kan till exempel använda ersättningssträngen ${1}1$11 i stället för att definiera ersättningssträngen som värdet för den första insamlade gruppen tillsammans med talet "1". Mer information finns i Ersätta en namngiven grupp.
Insamling av grupper som inte uttryckligen tilldelas namn med namnsyntaxen (?<>)numreras från vänster till höger med början vid ett. Namngivna grupper numreras också från vänster till höger, med början vid ett större än indexet för den senaste namnlösa gruppen. I det reguljära uttrycket (\w)(?<digit>\d)är till exempel indexet för den namngivna digit gruppen 2.
Om talet inte anger en giltig insamlingsgrupp som definierats i mönstret $för reguljära uttryck tolkas talet som en literal teckensekvens som används för att ersätta varje matchning.
I följande exempel används talersättningen $ för att ta bort valutasymbolen från ett decimalvärde. Den tar bort valutasymboler som finns i början eller slutet av ett monetärt värde och identifierar de två vanligaste decimalavgränsarna ("." och "").
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*";
string replacement = "$1";
string input = "$16.32 12.19 £16.29 €18.29 €18,29";
string result = Regex.Replace(input, pattern, replacement);
Console.WriteLine(result);
}
}
// The example displays the following output:
// 16.32 12.19 16.29 18.29 18,29
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*"
Dim replacement As String = "$1"
Dim input As String = "$16.32 12.19 £16.29 €18.29 €18,29"
Dim result As String = Regex.Replace(input, pattern, replacement)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16.32 12.19 16.29 18.29 18,29
Mönster för \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* reguljära uttryck definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\p{Sc}* |
Matcha noll eller fler valutasymboltecken. |
\s? |
Matcha noll eller ett blankstegstecken. |
\d+ |
Matcha en eller flera decimaler. |
[.,]? |
Matcha noll eller en punkt eller kommatecken. |
\d* |
Matcha noll eller fler decimalsiffror. |
(\s?\d+[.,]?\d*) |
Matcha ett tomt blanksteg följt av en eller flera decimaler, följt av noll eller en punkt eller komma, följt av noll eller fler decimalsiffror. Det här är den första insamlingsgruppen. Eftersom ersättningsmönstret är $1ersätter anropet Regex.Replace till metoden hela den matchade delsträngen med den här insamlade gruppen. |
Ersätta en namngiven grupp
Namnspråkelementet ${ersätter den sista delsträngen som matchas av namnfångsgruppen, där namnet är namnet på en insamlingsgrupp som definieras av (?<namnspråkelementet>).} Mer information om namngivna insamlingsgrupper finns i Grupperingskonstruktioner.
Om namnet inte anger en giltig namngiven insamlingsgrupp som definierats i mönstret för reguljära uttryck, men består av siffror, ${tolkas namnet} som en numrerad grupp.
Om namnet varken anger en giltig namngiven insamlingsgrupp eller en giltig numrerad insamlingsgrupp som definierats i mönstret ${för reguljära uttryck tolkas namnet} som en literal teckensekvens som används för att ersätta varje matchning.
I följande exempel används namnersättningen ${}för att ta bort valutasymbolen från ett decimalvärde. Den tar bort valutasymboler som finns i början eller slutet av ett monetärt värde och identifierar de två vanligaste decimalavgränsarna ("." och "").
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*";
string replacement = "${amount}";
string input = "$16.32 12.19 £16.29 €18.29 €18,29";
string result = Regex.Replace(input, pattern, replacement);
Console.WriteLine(result);
}
}
// The example displays the following output:
// 16.32 12.19 16.29 18.29 18,29
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*"
Dim replacement As String = "${amount}"
Dim input As String = "$16.32 12.19 £16.29 €18.29 €18,29"
Dim result As String = Regex.Replace(input, pattern, replacement)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16.32 12.19 16.29 18.29 18,29
Mönster för \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* reguljära uttryck definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\p{Sc}* |
Matcha noll eller fler valutasymboltecken. |
\s? |
Matcha noll eller ett blankstegstecken. |
\d+ |
Matcha en eller flera decimaler. |
[.,]? |
Matcha noll eller en punkt eller kommatecken. |
\d* |
Matcha noll eller fler decimalsiffror. |
(?<amount>\s?\d[.,]?\d*) |
Matcha ett tomt utrymme följt av en eller flera decimaltal följt av noll eller en punkt eller kommatecken följt av noll eller fler decimalsiffror. Det här är insamlingsgruppen med namnet amount. Eftersom ersättningsmönstret är ${amount}ersätter anropet Regex.Replace till metoden hela den matchade delsträngen med den här insamlade gruppen. |
Ersätta ett $-tecken
Ersättningen $$ infogar ett literalt $-tecken i den ersatta strängen.
I följande exempel används NumberFormatInfo objektet för att fastställa den aktuella kulturens valutasymbol och dess placering i en valutasträng. Sedan skapas både ett mönster för reguljära uttryck och ett ersättningsmönster dynamiskt. Om exemplet körs på en dator vars aktuella kultur är en-US genererar det reguljära uttrycksmönstret \b(\d+)(\.(\d+))? och ersättningsmönstret $$ $1$2. Ersättningsmönstret ersätter den matchade texten med en valutasymbol och ett blanksteg följt av de första och andra insamlade grupperna.
using System;
using System.Globalization;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
// Define array of decimal values.
string[] values= { "16.35", "19.72", "1234", "0.99"};
// Determine whether currency precedes (True) or follows (False) number.
bool precedes = NumberFormatInfo.CurrentInfo.CurrencyPositivePattern % 2 == 0;
// Get decimal separator.
string cSeparator = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator;
// Get currency symbol.
string symbol = NumberFormatInfo.CurrentInfo.CurrencySymbol;
// If symbol is a "$", add an extra "$".
if (symbol == "$") symbol = "$$";
// Define regular expression pattern and replacement string.
string pattern = @"\b(\d+)(" + cSeparator + @"(\d+))?";
string replacement = "$1$2";
replacement = precedes ? symbol + " " + replacement : replacement + " " + symbol;
foreach (string value in values)
Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement));
}
}
// The example displays the following output:
// 16.35 --> $ 16.35
// 19.72 --> $ 19.72
// 1234 --> $ 1234
// 0.99 --> $ 0.99
Imports System.Globalization
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
' Define array of decimal values.
Dim values() As String = {"16.35", "19.72", "1234", "0.99"}
' Determine whether currency precedes (True) or follows (False) number.
Dim precedes As Boolean = (NumberFormatInfo.CurrentInfo.CurrencyPositivePattern Mod 2 = 0)
' Get decimal separator.
Dim cSeparator As String = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator
' Get currency symbol.
Dim symbol As String = NumberFormatInfo.CurrentInfo.CurrencySymbol
' If symbol is a "$", add an extra "$".
If symbol = "$" Then symbol = "$$"
' Define regular expression pattern and replacement string.
Dim pattern As String = "\b(\d+)(" + cSeparator + "(\d+))?"
Dim replacement As String = "$1$2"
replacement = If(precedes, symbol + " " + replacement, replacement + " " + symbol)
For Each value In values
Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement))
Next
End Sub
End Module
' The example displays the following output:
' 16.35 --> $ 16.35
' 19.72 --> $ 19.72
' 1234 --> $ 1234
' 0.99 --> $ 0.99
Mönster för \b(\d+)(\.(\d+))? reguljära uttryck definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen i början av en ordgräns. |
(\d+) |
Matcha en eller flera decimaler. Det här är den första insamlingsgruppen. |
\. |
Matcha en period (decimalavgränsaren). |
(\d+) |
Matcha en eller flera decimaler. Det här är den tredje insamlingsgruppen. |
(\.(\d+))? |
Matcha noll eller en förekomst av en period följt av en eller flera decimalsiffror. Det här är den andra insamlingsgruppen. |
Ersätta hela matchningen
Ersättningen $& innehåller hela matchningen i ersättningssträngen. Ofta används den för att lägga till en delsträng i början eller slutet av den matchade strängen. Ersättningsmönstret ($&) lägger till exempel parenteser till början och slutet av varje matchning. Om det inte finns någon matchning har ersättningen $& ingen effekt.
I följande exempel används ersättningen $& för att lägga till citattecken i början och slutet av boktitlar som lagras i en strängmatris.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"^(\w+\s?)+$";
string[] titles = { "A Tale of Two Cities",
"The Hound of the Baskervilles",
"The Protestant Ethic and the Spirit of Capitalism",
"The Origin of Species" };
string replacement = "\"$&\"";
foreach (string title in titles)
Console.WriteLine(Regex.Replace(title, pattern, replacement));
}
}
// The example displays the following output:
// "A Tale of Two Cities"
// "The Hound of the Baskervilles"
// "The Protestant Ethic and the Spirit of Capitalism"
// "The Origin of Species"
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^(\w+\s?)+$"
Dim titles() As String = {"A Tale of Two Cities", _
"The Hound of the Baskervilles", _
"The Protestant Ethic and the Spirit of Capitalism", _
"The Origin of Species"}
Dim replacement As String = """$&"""
For Each title As String In titles
Console.WriteLine(Regex.Replace(title, pattern, replacement))
Next
End Sub
End Module
' The example displays the following output:
' "A Tale of Two Cities"
' "The Hound of the Baskervilles"
' "The Protestant Ethic and the Spirit of Capitalism"
' "The Origin of Species"
Mönster för ^(\w+\s?)+$ reguljära uttryck definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
^ |
Starta matchningen i början av indatasträngen. |
(\w+\s?)+ |
Matcha mönstret för ett eller flera ordtecken följt av noll eller ett blankstegstecken en eller flera gånger. |
$ |
Matcha slutet av indatasträngen. |
Ersättningsmönstret "$&" lägger till ett citattecken i början och slutet av varje matchning.
Ersätta texten före matchningen
Ersättningen $` ersätter den matchade strängen med hela indatasträngen före matchningen. Den duplicerar alltså indatasträngen fram till matchningen samtidigt som den matchade texten tas bort. All text som följer den matchade texten ändras inte i resultatsträngen. Om det finns flera matchningar i en indatasträng härleds ersättningstexten från den ursprungliga indatasträngen i stället för från strängen där texten har ersatts av tidigare matchningar. (Exemplet innehåller en bild.) Om det inte finns någon matchning har ersättningen $` ingen effekt.
I följande exempel används mönster \d+ för reguljära uttryck för att matcha en sekvens med en eller flera decimaler i indatasträngen. Ersättningssträngen $` ersätter dessa siffror med texten som föregår matchningen.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "aa1bb2cc3dd4ee5";
string pattern = @"\d+";
string substitution = "$`";
Console.WriteLine("Matches:");
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
Console.WriteLine("Input string: {0}", input);
Console.WriteLine("Output string: " +
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Matches:
// 1 at position 2
// 2 at position 5
// 3 at position 8
// 4 at position 11
// 5 at position 14
// Input string: aa1bb2cc3dd4ee5
// Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "aa1bb2cc3dd4ee5"
Dim pattern As String = "\d+"
Dim substitution As String = "$`"
Console.WriteLine("Matches:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
Console.WriteLine("Input string: {0}", input)
Console.WriteLine("Output string: " + _
Regex.Replace(input, pattern, substitution))
End Sub
End Module
' The example displays the following output:
' Matches:
' 1 at position 2
' 2 at position 5
' 3 at position 8
' 4 at position 11
' 5 at position 14
' Input string: aa1bb2cc3dd4ee5
' Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee
I det här exemplet innehåller indatasträngen "aa1bb2cc3dd4ee5" fem matchningar. I följande tabell visas hur ersättningen $` gör att motorn för reguljära uttryck ersätter varje matchning i indatasträngen. Infogad text visas i fetstil i resultatkolumnen.
| Matchning | Position | Sträng före matchning | Resultatsträng |
|---|---|---|---|
| 1 | 2 | Aa | aa aabb2cc3dd4ee5 |
| 2 | 5 | aa1bb | aaaabbaa1bbcc3dd4ee5 |
| 3 | 8 | aa1bb2cc | aaaabbaa1bbccaa1bb2ccdd4ee5 |
| 4 | 11 | aa1bb2cc3dd | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5 |
| 5 | 14 | aa1bb2cc3dd4ee | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee |
Ersätta texten efter matchningen
Ersättningen $' ersätter den matchade strängen med hela indatasträngen efter matchningen. Den duplicerar alltså indatasträngen efter matchningen samtidigt som den matchade texten tas bort. All text som föregår den matchade texten ändras inte i resultatsträngen. Om det inte finns någon matchning har ersättningen $' ingen effekt.
I följande exempel används mönster \d+ för reguljära uttryck för att matcha en sekvens med en eller flera decimaler i indatasträngen. Ersättningssträngen $' ersätter dessa siffror med texten som följer matchningen.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "aa1bb2cc3dd4ee5";
string pattern = @"\d+";
string substitution = "$'";
Console.WriteLine("Matches:");
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(" {0} at position {1}", match.Value, match.Index);
Console.WriteLine("Input string: {0}", input);
Console.WriteLine("Output string: " +
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Matches:
// 1 at position 2
// 2 at position 5
// 3 at position 8
// 4 at position 11
// 5 at position 14
// Input string: aa1bb2cc3dd4ee5
// Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "aa1bb2cc3dd4ee5"
Dim pattern As String = "\d+"
Dim substitution As String = "$'"
Console.WriteLine("Matches:")
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(" {0} at position {1}", match.Value, match.Index)
Next
Console.WriteLine("Input string: {0}", input)
Console.WriteLine("Output string: " + _
Regex.Replace(input, pattern, substitution))
End Sub
End Module
' The example displays the following output:
' Matches:
' 1 at position 2
' 2 at position 5
' 3 at position 8
' 4 at position 11
' 5 at position 14
' Input string: aa1bb2cc3dd4ee5
' Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee
I det här exemplet innehåller indatasträngen "aa1bb2cc3dd4ee5" fem matchningar. I följande tabell visas hur ersättningen $' gör att motorn för reguljära uttryck ersätter varje matchning i indatasträngen. Infogad text visas i fetstil i resultatkolumnen.
| Matchning | Position | Sträng efter matchning | Resultatsträng |
|---|---|---|---|
| 1 | 2 | bb2cc3dd4ee5 | aabb2cc3dd4ee5bb2cc3dd4ee5 |
| 2 | 5 | cc3dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5 |
| 3 | 8 | dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5 |
| 4 | 11 | ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5 |
| 5 | 14 | String.Empty | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee |
Ersätta den senast insamlade gruppen
Ersättningen $+ ersätter den matchade strängen med den senast insamlade gruppen. Om det inte finns några insamlade grupper eller om värdet för den senast insamlade gruppen är String.Emptyhar ersättningen $+ ingen effekt.
I följande exempel identifieras duplicerade ord i en sträng och ersättningen $+ används för att ersätta dem med en enda förekomst av ordet. Alternativet RegexOptions.IgnoreCase används för att säkerställa att ord som skiljer sig åt i fall men som annars är identiska betraktas som dubbletter.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\w+)\s\1\b";
string substitution = "$+";
string input = "The the dog jumped over the fence fence.";
Console.WriteLine(Regex.Replace(input, pattern, substitution,
RegexOptions.IgnoreCase));
}
}
// The example displays the following output:
// The dog jumped over the fence.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\w+)\s\1\b"
Dim substitution As String = "$+"
Dim input As String = "The the dog jumped over the fence fence."
Console.WriteLine(Regex.Replace(input, pattern, substitution, _
RegexOptions.IgnoreCase))
End Sub
End Module
' The example displays the following output:
' The dog jumped over the fence.
Mönster för \b(\w+)\s\1\b reguljära uttryck definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
(\w+) |
Matcha ett eller flera ordtecken. Det här är den första insamlingsgruppen. |
\s |
Matcha ett blankstegstecken. |
\1 |
Matcha den första insamlade gruppen. |
\b |
Avsluta matchningen vid en ordgräns. |
Ersätta hela indatasträngen
Ersättningen $_ ersätter den matchade strängen med hela indatasträngen. Det vill: den tar bort den matchade texten och ersätter den med hela strängen, inklusive den matchade texten.
Följande exempel matchar en eller flera decimaler i indatasträngen. Den använder ersättningen $_ för att ersätta dem med hela indatasträngen.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "ABC123DEF456";
string pattern = @"\d+";
string substitution = "$_";
Console.WriteLine("Original string: {0}", input);
Console.WriteLine("String with substitution: {0}",
Regex.Replace(input, pattern, substitution));
}
}
// The example displays the following output:
// Original string: ABC123DEF456
// String with substitution: ABCABC123DEF456DEFABC123DEF456
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "ABC123DEF456"
Dim pattern As String = "\d+"
Dim substitution As String = "$_"
Console.WriteLine("Original string: {0}", input)
Console.WriteLine("String with substitution: {0}", _
Regex.Replace(input, pattern, substitution))
End Sub
End Module
' The example displays the following output:
' Original string: ABC123DEF456
' String with substitution: ABCABC123DEF456DEFABC123DEF456
I det här exemplet innehåller indatasträngen "ABC123DEF456" två matchningar. I följande tabell visas hur ersättningen $_ gör att motorn för reguljära uttryck ersätter varje matchning i indatasträngen. Infogad text visas i fetstil i resultatkolumnen.
| Matchning | Position | Matchning | Resultatsträng |
|---|---|---|---|
| 1 | 3 | 123 | ABCABC123DEF456DEF456 |
| 2 | 5 | 456 | ABCABC123DEF456DEF ABC123DEF456 |
Se även
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för