Szövegek kezelése, formázása

C# esetén a string típus tartalmazza a szövegkezeléshez szükséges metódusokat. Az alábbiakban megismerkedünk a legfontosabb szövegkezelő metódusokkal. A teljes szöveg típus dokumentáció a https://msdn.microsoft.com/en-us/library/system.string%28v=vs.110%29.aspx címen lelhető fel.

A szöveg típus felfogható úgy, mint karakterek sorozata. A szövegen belül lehetőségünk van egyes karakterek kinyerésére és lekérdezésére is. Azon metódusok, amelyek megadott indexű karakterrel dolgoznak vagy indexel dolgoznak azok esetén az indexelés 0-tól kezdődik. Tehát az Alma szóban az A karakter indexe 0, míg az a karakteré 3.

bool Contains(string s)

Igaz értéket ad vissza, ha a paraméterként megadott szövegrészletet tartalmazza a szöveg.

bool EndsWith(string s)

Igaz értéket ad vissza, ha a szöveg a megadott szövegrészlettel végződik.

int IndexOf(char c)
int IndexOf(String s)

A paraméterként megadott karakter vagy szövegrészlet első előfordulásának indexét adja vissza.

int LastIndexOf(char c)
int LastIndexOf(String s)

A paraméterként megadott karakter vagy szövegrészlet utolsó előfordulásának indexét adja vissza.

int Length;

A szöveg hosszának lekérdezésére szolgáló tulajdonság.

string PadRight(int totalWidth)
string PadRight(int totalWidth, char paddingChar)

Egy új szöveget hoz létre, amely a paraméterként megadott számú karakterből áll. A megadott szöveg szélességen belül úgy igazítja a szöveget, hogy az balra igazított legyen, tehát az eredeti szöveg utolsó karaktere után annyi szóközt illeszt (jobb oldalról bővíti), hogy a szöveg a paraméternek megadott számú karakterből álljon. Kétparaméteres változatában a második paraméter a kitöltő karaktert határozza meg.

string PadLeft(int totalWidth)
string PadLeft(int totalWidth, char paddingChar)

Hasonló a PadRight metódushoz. Ez azonban a szöveget jobbra igazítja, tehát a szóközökkel való feltöltés az eredeti szöveg első karaktere előtt kezdődik meg (bal oldalról bővíti). A kétparaméteres változatban a második paraméter a kitöltő karaktert határozza meg.

string Remove(int startIndex)
string Remove(int startIndex, int count)

A megadott index pozíciótól kezdve törli a szöveg karaktereit és az eredményt egy új szövegként adja vissza. Kétparaméteres változatában a második paraméter a törlendő karakterek számát határozza meg. Az egyparaméteres változat a megadott indextől a szöveg végéig töröl.

string Replace(string oldValue, string newValue)
string Replace(char oldChar, char newChar)

Az első paraméter által megadott szövegrészlet vagy karakter cseréje a szövegben a második paraméter által meghatározott szövegrészletre vagy karakterre. Az eredményt egy új szövegként adja vissza.

string[] Split(params char[] separator)

A megadott elválasztó karakterek alapján a szöveget felszeleteli szövegekből álló tömbre.

bool StartsWith(string value)

Igaz értéket ad vissza, ha a szöveg a megadott szövegrészlettel kezdődik.

string Substring(int startIndex)

A megadott indextől kezdve a szöveg karaktereit egy új szövegbe másolja, majd ezt adja vissza eredményül.

string ToLower()

A szövegben található összes nagybetűs karaktert kicseréli a karakterhez tartozó kisbetűs változatra. Az eredményt új szövegként adja vissza.

string ToUpper()

A szövegben található összes kisbetűs karaktert kicseréli a karakterhez tartozó nagybetűs változatra. Az eredményt új szövegként adja vissza.

string Trim()
string Trim(params char[] trimChars)

A szöveg elejéről és végéről eltávolítja az összes szóköz és tabulátor karaktert. Az eredményt új szövegként adja vissza. Paraméteres változatában a paraméterek a szöveg elejéről és végéről eltávolítandó karaktereket határozzák meg.

string TrimStart(params char[] trimChars)
string TrimEnd(params char[] trimChars)

Hasonlók a Trim metódus paraméteres változatához. A Start változat csak a szöveg elejéről távolít el, míg az End változat csak a végéről.

Szövegek formázása

A szöveg típus rendelkezik egy speciális metódussal, amely a Format nevet kapta. Segítségével különböző objektumokat tudunk formázottan szöveggé alakítani.

String Format(String, Object[])

Formázottan ír ki egy objektumot. Első paramétere a formátumot határozza meg, a további paraméterei pedig az objektumokat, amelyeket ki szeretnénk írni. A Format metódus használatát az alábbi példa szemlélteti:

using System;

namespace PeldaStringFormat
{
    class Program
    {
        static void Main(string[] args)
        {
            int ma = 21;
            int tegnap = 18;
            var szoveg = string.Format("Ma {0} fok volt, tegnap pedig {1}", ma, tegnap);

            Console.WriteLine(szoveg);

            Console.WriteLine("Így is lehet: {0}, {1}", ma, tegnap);
            Console.ReadKey();
        }
    }
}

A program kimenete:

Ma 21 fok volt, tegnap pedig 18
Így is lehet: 21, 18

A Format metódusban kapcsos zárójelek közötti számokkal hivatkozhatunk a Format további paramétereire. Ezen helyőrzők helyére fogja beilleszteni a megadott számú argumentum értékét szöveggé konvertálva. Tehát a {0} helyőrzőre a formátum szöveget követő első argumentum, a ma változó értéke kerül, az {1} helyőrzőre pedig a tegnap változó értéke.

Ahogy a példában is látszik, a Console osztály WriteLine metódusa is képes formátumos kiírásra, tehát konzol képernyőre íráskor nem feltétlen kell alkalmaznunk egy külön ideiglenes változót, ami majd a szöveget tartalmazza.

Ez még nem nagy formázás. Éppen ezért a Format metódus képes további vezérlő karakterek értelmezésesre is a kapcsos zárójelekben meghatározott formátum jelölők esetén. A numerikus formátum jelölők:

• C, c (Pénz)

  Pénz formátum kód, minden szám típussal működik. A Pénzjel karaktert a területi és nyelvi beállítások határozzák meg. A C karaktert követő számjegy a tizedes jegyeket határozza meg.

• D, d (Decimális)

  Egész szám típusokon használható formátum jelölő. A D karaktert követő számjegy a szükséges számjegyek számát határozza meg. Ha a számunk három karakteren jeleníthető meg, de mi fixen 6-ot szeretnénk, akkor a számot bevezető nullákkal tölti fel.

• E, e (Exponenciális)

  Minden számformátummal működik. A számokat hatvány alakban írja ki. Alapértelmezetten lebegőtípusú (float, double) számoknál van bekapcsolva, ha több, mint 6 számjegyet szeretnénk kiírni. Az E karaktert követő számjegy a tizedes vessző utáni karaktereket határozza meg.

• F, f (Fixpontos)

  Fixpontos szám formátum, minden szám típus esetén működik. Az F karakter utáni számjegy a tizedes vessző utáni számjegyeket határozza meg.

• G, g (Általános)

  Általános szám. Exponenciális, Fixpontos, vagy Decimális megjelenítést alkalmaz. Arra törekszik, hogy a legkompaktabb formátumban írjon ki. A G karaktert követő számjegy a kiírt számjegyek számát határozza meg.

• N, n (Szám)

  Szám formátum, ami minden szám típuson alkalmazható. Az N betűt követő számjegy a tizedes helyek számát határozza meg.

• P, p (Százalék)

  Szám típusok esetén alkalmazható. A számot megszorozza 100-al, majd a kiírás végére beilleszti a százalékjelet. A P karaktert követő számjegy a kiírt számjegyek számát határozza meg.

• R, r (Round-Trip)

  Float és Double típusok esetén használható. Ezen kiírási módszerrel az összes számjegyét kiírja ezen típusok esetén a program kerekítés nélkül.

• X, x (Hexa)

  Egész szám típusok esetén használható. A számot hexadecimális formában jeleníti meg. Az X karaktert követő számjegy a szükséges számjegyek számát hatázozza meg. Ha a szám 2 karakeren írható le hexadecimális alakban, de mi 4 karaktert kérünk, akkor bevezető nullákat illeszt a szám elé.

Az általános számformátum (G) esetén a megjelenített számjegyek száma típusonként eltér. Az alábbi táblázat ezt foglalja össze:

A formátum leírók a kettőspont segítségével kapcsolhatóak a mezőkódhoz. Az alábbi példa a numerikus formátumkódok használatát mutatja be:

using System;

namespace PeldaStringNumformat
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Pénz: {0:C1}", 3148);
            Console.WriteLine("Százalék: {0:P3}", 0.123456);
            Console.WriteLine("Általános: {0:G}", 132354);
            Console.WriteLine("Exponenciális: {0:E}", 132354);
            Console.WriteLine("Hexa: {0:X}", 255);
            Console.ReadKey();
        }
    }
}

A program kimenete a következő lesz:

Pénz: 3 148,0 Ft
Százalék: 12,346%
Általános: 132354
Exponenciális: 1,323540E+005
Hexa: FF

A korábban ismertetett formázási beállítások mellett saját, egyedi formátum megjelenítőket is írhatunk a Format metódus segítségével. Erre az alábbi karaktereket használhatjuk fel:

A Csoport elválasztó olyan esetekben hasznos, ha a pozitív és negatív számokat eltérő formázással szeretnénk megjeleníteni. Tételezzük fel, hogy adott a következő formátum kódunk: {0:foo;bar;baz}

Ez a formátumkód a behelyettesített érték helyett foo szöveget ír ki, ha az érték nagyobb, mint nulla, bar szöveget, ha az érték kisebb, mint nulla és baz szöveget, ha az érték egyenlő nullával.

Szöveges mezők esetén használható a vessző formátum karakter, ami után egy számnak kell állnia. A szám a mező szélességét határozza meg. Ha a szám pozitív, akkor a mezőbe írandó szöveg jobbra lesz igazítva. Negatív szám esetén pedig balra.

Az alábbi példa az egyedi formátum jelölők használatát mutatja be:

using System;

namespace PeldaStringEgyedi
{
    class Program
    {
        static void Main(string[] args)
        {
            double d = 1500.42;

            //1500,4200
            Console.WriteLine("{0:00.0000}", d);
            //(1500),42
            Console.WriteLine("{0:(#).##}", d);
            //1500,4
            Console.WriteLine("{0:0.0}", d);
            //1 500
            Console.WriteLine("{0:0,0}", d);
            //150042%
            Console.WriteLine("{0:0%}", d);
            //[Foo  ], 5 szélességre formázva, balra igazítva
            Console.WriteLine("[{0,-5}]", "Foo");
            //[  Foo], 5 szélességre formázva, jobbra igazítva
            Console.WriteLine("[{0,5}]", "Foo");

            //pozitív
            Console.WriteLine("{0:pozitív;negatív;nulla}", 4);
            //negatív
            Console.WriteLine("{0:pozitív;negatív;nulla}", -4);
            //nulla
            Console.WriteLine("{0:pozitív;negatív;nulla}", 0);
            Console.ReadKey();
        }
    }
}

A program kimenete:

1500,4200
(1500),42
1500,4
1 500
150042%
[Foo  ]
[  Foo]
pozitív
negatív
nulla

Speciális karakterek

Előfordulhat, hogy a szövegünkben speciális karaktert szeretnénk használni. Speciális karakter például a sortörés, illetve a tabulátor, illetve minden olyan karakter, ami az ASCII és UTF kódtáblában 32-nél kisebb értékkel rendelkezik. Ezek a karakter kódok az úgynevezett vezérlő kódok, amik eredetileg modemek és nyomtatók vezérlésére szolgáltak. Mára ezek közül csak pár használt. Az alábbi táblázat ezeknek a megadását foglalja össze.

A sortörés karakter értelmezése platformonként eltérő. Linux esetén a szöveges fájlokban a \n karakter jelöli az új sor kezdetét, míg Windows rendszereken a \r és \n karakter kombinációja. Ebből adódik, hogy a Windows korábbi változatain ha egy Linux alatt mentett szövegfájlt (txt) akartunk megnyitni jegyzettömbbel, akkor a formázás teljesen szétcsúszott.

A sípolás értelem szerűen nem nyomtatható és terminál függő, hog hogy viselkedik, de egy beep (sípoló) hangot kellene eredményeznie.

Ha a szövegünkben egy elérési útvonalat szeretnénk megadni, amiben Windows-on van \ jel, mint mappa elválasztó, akkor két lehetőségünk van. Vagy \ jelet használunk, vagy @ jellel kezdjük a szövegünket, még az idézőjelek előtt. A @ jel arra utasítja fordítót, hogy úgy értelmezze a szöveget, ahogy be van írva a forrásfájlba és ne próbálja a \ jel után megadott karaktereket másként értelmeznmi.

var elso = "c:\\teszt\\foo";
//picivel egyszerűbb:
var masodik = @"c:\teszt\foo";

Raw string literal

A C# 11 egyik újdonsága a Raw string literal bevezetése volt. Ezek a szövegek három darab idézőjellel """ kezdődnek és végződnek. Az ezek között lévő szöveget pedig úgy, ahogy vannak szövegként kezeli a fordító, tehát ha a szöveg tartalmaz mondjuk egy idézőjelek közötti szövegeket, akkor azok a " is tartalomként értelmeződnek úgy, mint a speciális karakterek is. Például:

string raw = 
    """
    ez egy
    több soros
    szöveg!\t:)
    """;
Console.WriteLine(raw);

Az alábbi kimenetet produkálja:

ez egy
több soros
szöveg!\t:)

Raw string literal esetén is van lehetőségünk string interpolationt használni, de ebben az esetben nem egy darab $ jellel kell kezdenünk a szöveget, hanem kettővel, illetve a behelyettesített paramétereket dupla kapcsos zárójellel kell jeleznünk:

int sorok = 3;
string raw = 
    $$"""
    ez egy interpolált
        {{sorok}} soros
    szöveg!\t:)
    """;
Console.WriteLine(raw);

Kimenete:

ez egy interpolált
3 soros
szöveg!\t:)