Řetězce jazyka C#

Tip

Tento článek je součástí části Základy pro vývojáře, kteří už znají aspoň jeden programovací jazyk a učí se jazyk C#. Pokud s programováním teprve začínáte, začněte nejprve kurzy Začínáme .

Pocházíte z Java nebo C++? Jazyk C# string je neměnný referenční typ založený na String. UTF-16 je kódování v paměti podobné Java String. Na rozdíl od jazyka C/C++ nejsou řetězce ukončeny hodnotou null a nerozkládají se do ukazatelů.

Řetězec je posloupnost znaků. V jazyce C# string je klíčové slovo jazyka System.String pro typ. Každý řetězcový literál který napíšete vytvoří instanci System.String.

string Vs. String

Klíčové string slovo a String název typu odkazují na stejný typ. Jsou kompilovány do stejného mezikódu (IL).

// The 'string' keyword is an alias for System.String. The two are identical.
string a = "hello";
String b = "hello";

Console.WriteLine(a == b);                // True
Console.WriteLine(typeof(string) == typeof(String)); // True

string Upřednostněte klíčové slovo ve vlastním kódu. Je konzistentní s jinými integrovanými klíčovými slovy typu (int, bool, double) a funguje bez direktivy using System; .

Řetězce jsou neměnné

Immutable znamená, že hodnotu nelze po vytvoření změnit. Po vytvoření stringnemůžete změnit jeho znaky. Metody jako ToUpperInvariant, Replace, Substring a Trim vracejí nový řetězec, který obsahuje upravenou hodnotu. Původní instance zůstane stejná.

string greeting = "hello";

// ToUpper returns a *new* string. The original is unchanged.
string shouted = greeting.ToUpperInvariant();

Console.WriteLine(greeting);  // hello
Console.WriteLine(shouted);   // HELLO

Protože řetězce jsou neměnné, můžete je bezpečně sdílet mezi metodami a vlákny. Tato neměnnost vysvětluje, proč se string typ chová jako typ hodnoty v každodenním použití, i když se jedná o odkazový typ.

Když ve smyčce sestavujete řetězec z mnoha malých částí, použijte StringBuilder pro průběžné připojování, abyste nakonec vytvořili jediný řetězec:

// For many sequential edits, StringBuilder avoids allocating a new string each time.
var builder = new StringBuilder();
for (int i = 1; i <= 3; i++)
{
    builder.Append("item ").Append(i).Append(';');
}
string result = builder.ToString();
Console.WriteLine(result);    // item 1;item 2;item 3;

Řetězcové literály

Jazyk C# nabízí čtyři literální formuláře. Každý formulář vyhovuje jinému obsahu. Jako rychlý průvodce:

  • Používejte obyčejné literály pro krátký a jednoduchý text s nejvýše několika únikovými sekvencemi.
  • Používejte literály verbatim, pokud obsahuje převážně zpětná lomítka, například cesty ve Windows nebo vzory regulárních výrazů.
  • Pro víceřádkový nebo strukturálně formátovaný text, jako jsou vložené bloky JSON, SQL, XML nebo formátované bloky zpráv, použijte nezpracované řetězcové literály .
  • Přidejte předponu $ k některému z výše uvedených literálů, abyste získali interpolovaný řetězec , když potřebujete vložit hodnoty.
  • Přidejte k literálu příponu u8 , která vytvoří sekvenci bajtů UTF-8 (a ReadOnlySpan<T> of byte) pro bajtová rozhraní API. Podrobnosti najdete v referenční příručce jazyka v části řetězcové literály UTF-8.

Běžné literály a řídicí sekvence

Běžný řetězcový literál je uzavřený do dvojitých uvozovek. Zpětné lomítko uvozuje únikovou sekvenci:

// Common escape sequences inside a regular string literal.
string tabbed   = "name:\tAda";          // \t  tab
string twoLines = "line 1\nline 2";      // \n  newline
string quoted   = "She said \"hi\".";    // \"  literal quote
string path     = "C:\\src\\app";        // \\  literal backslash

Console.WriteLine(tabbed);
Console.WriteLine(twoLines);
Console.WriteLine(quoted);
Console.WriteLine(path);

Mezi běžné únikové sekvence patří \n (nový řádek), \t (tabulátor), \" (uvozovka jako znak), \\ (zpětné lomítko jako znak), \0 (nulový znak) a únikové sekvence Unicode (\uXXXX, \UXXXXXXXX).

Počínaje jazykem C# 13 \e představuje řídicí znak ESC (U+001B). Jedná se o počáteční bajt pro řídicí sekvence terminálu ANSI:

// Beginning in C# 13, \e represents the ESC control character (U+001B).
// It's used to start ANSI terminal escape sequences.
string esc = "\e[31mError\e[0m: file missing";

Console.WriteLine(esc);                  // ESC[31mError ESC[0m: file missing
Console.WriteLine((int)'\e');          // 27

Použijte běžný literál, pokud je text krátký a obsahuje pouze několik escape sekvencí. Jakmile začne být únikových sekvencí více než viditelných znaků, přepněte na doslovný nebo syrový literál.

Doslovné literály

Doslovný literál má předponu @. Zpětná lomítka jsou interpretována doslovně, což je užitečné pro cesty ve Windows a vzory regulárních výrazů:

// A verbatim string literal (@) treats backslashes literally.
// Useful for Windows paths and regular expressions.
string winPath = @"C:\src\app\readme.md";
string pattern = @"\d{3}-\d{4}";

Console.WriteLine(winPath);
Console.WriteLine(pattern);

Chcete-li do řetězce verbatim vložit znak uvozovky, zdvojte jej: @"She said ""hi"".". Doslovné řetězce mohou také zahrnovat více fyzických řádků.

Doslovné literály jsou vhodnou volbou, pokud jsou zpětná lomítka součástí obsahu, ale není v něm mnoho vložených uvozovek. U víceřádkového textu nebo obsahu s uvozovkami jsou nezpracované řetězcové literály obvykle jasnější.

Nezpracované řetězcové literály

U každého literálu, který obsahuje uvozovky, zpětné lomítka nebo více řádků, upřednostňujte nezpracované řetězcové literály. Eliminují řídicí šum zcela, díky čemuž se nejlépe hodí pro vložený kód JSON, SQL, XML, vzory regulárních výrazů a formátované textové bloky, ve kterých by měl zdroj vypadat jako výstup:

// Raw string literals use three or more quotes and need no escaping.
// The source looks like the output, which is ideal for inline JSON, SQL, XML, and the like.
string json = """
    {
        "name": "Ada",
        "roles": ["admin", "editor"]
    }
    """;

string sql = """
    SELECT Id, Name
    FROM   Users
    WHERE  Name = 'O''Brien'
    """;

Console.WriteLine(json);
Console.WriteLine(sql);

Literály syrových řetězců téměř eliminují escape sekvence a umožňují použít libovolné formátování i uvozovky, které potřebujete. Úplná pravidla najdete v řetězcových literálech raw.

Interpolované řetězce

$ Předpona změní literál na interpolovaný řetězec. Výrazy v {} dírách se vyhodnocují a vloží se jejich výsledky a můžete použít standardní specifikátory formátu a zarovnání uvnitř otvorů. Interpolaci lze také kombinovat s ostatními formami literálů — pomocí $@"..." můžete interpolovat doslovný literál nebo pomocí $"""...""" raw řetězcový literál pro výstup s bohatým formátováním:

// The $ prefix evaluates expressions inside { } and inserts their values.
string name = "Ada";
int score = 92;

string greeting = $"Hello, {name}! Your score is {score}.";
// Format specifiers and alignment work inside the holes.
string formatted = $"pi = {Math.PI:F3}, padded = |{name,10}|";

// Combine $ and """ for richly formatted multiline output.
string report = $"""
    Report for {name}
    -----------------
    Score : {score}
    Grade : {(score >= 90 ? "A" : "B")}
    """;

Console.WriteLine(greeting);
Console.WriteLine(formatted);
Console.WriteLine(report);

Interpolace je doporučený způsob, jak vytvářet řetězce z hodnot v každodenním kódu.

Indexování a char

A string je posloupnost jednotek kódu UTF-16. Indexer vrátí jednu System.Char, která představuje jednu jednotku kódu UTF-16, nikoli nutně kompletní bod kódu Unicode. Length vrátí počet jednotek kódu.

// A string is a sequence of UTF-16 code units. s[i] returns one char.
string word = "café";

Console.WriteLine(word.Length);          // 4
Console.WriteLine(word[0]);              // c

foreach (char c in word)
{
    Console.Write($"{c} ");              // c a f é
}
Console.WriteLine();

Pro text, který může obsahovat emoji nebo znaky mimo základní vícejazyčnou rovinu, iterujte po rune pomocí Rune nebo po grapémových klastrech pomocí StringInfo. Prostá char iterace funguje pro většinu textů v západních jazycích a pro obsah, v němž převažuje ASCII.

Rovnost řetězců

Rovnost u string porovnává posloupnosti znaků, nikoli reference:

// String equality compares character sequences, not references.
string left  = "hello";
string right = string.Concat("hel", "lo");

Console.WriteLine(left == right);                                      // True
Console.WriteLine(left.Equals(right, StringComparison.Ordinal));       // True

Pro porovnání, která závisí na národním prostředí nebo zohledňují velikost písmen, předejte explicitní hodnotu StringComparison. Používá se StringComparison.Ordinal pro hodnoty protokolu, identifikátory a další nejazyčný text.

Běžné operace s řetězci

Následující tabulka slouží jako rychlá příručka k každodenním operacím řetězců v jazyce C#:

Kategorie Co zahrnuje
Search Vyhledání znaků nebo podřetěžců, testovacích předpon a přípon
Rozděleno Rozdělení řetězce na podřetězce u oddělovačů
Sloučit Kombinování řetězců – +, interpolace, Concat, Join
Modify Vytvoří transformovanou kopii — Replace, TrimSubstring
Porovnat Testovat rovnost a uspořádání pomocí správného StringComparison

Úplná plocha rozhraní API – každé přetížení, každá metoda – je zdokumentovaná v String odkazu.

Viz také

  • Last updated on