09. Porozmawiajmy o „stringach”

W tym artykule postaram się przedstawić podstawowe sposoby operowania na łańcuchach znakowych, czyli na tzw. „tekstach”. Jest to bardzo ważne zagadnienie, w zasadzie podstawowe w programowaniu. Za pomocą tekstów nasze programy porozumiewają się z użytkownikiem, systemy bazodanowe prezentują dane, itd.

Typ string

Podstawowym typem danych, który przechowuje łańcuchy znakowe jest, używany przez nas już wielokrotnie w poprzednich częściach kursu, typ „string”.
Prosty przykład użycia.

class KlasaGlowna
{
    static void Main()
    {
        string napis = "Hello world!";
        System.Console.WriteLine(napis);
        System.Console.ReadLine();
    }
}

Klasa Console

Klasa „Console” jest jedną z wielu klas zdefiniowanych w przestrzeni nazw „System”. Jej zadaniem jest obsługa operacji wejścia/wyjścia, a więc między innymi wyświetlanie napisów na ekranie (operacja wyjściowa). Klasa „Console” posiada wiele metod statycznych, więc nie musimy tworzyć obiektów klasy „Console”, aby używać jej metod. Do najważniejszych metod należą „ReadLine()” oraz „WriteLine()”.

„WriteLine()” kieruje do strumienia wyjściowego, w tym przypadku na ekran (prawdopodobnie w naszym kursie nie spotkamy się z innym przypadkiem), łańcuch znakowy wraz ze znakiem nowej linii (nakazuje przejść do nowej linijki po zakończeniu wypisywania tekstu). Bliźniacza metoda „Write()” różni się tylko tym, że nie przesyła znaku nowej linii.

„ReadLine()” pozwala czytać informacje ze strumienia wejściowego (w naszym kursie będzie to klawiatura) dopóki nie pojawi się znak nowej linii. „Read()” natomiast czyta pojedyncze znaki. „ReadLine()” zwraca typ „string”, „Read()” natomiast typ „char” (zamiast „char” można używać „int” – liczby reprezentują znaki).

Napiszmy krótki programik, aby przetestować nowo zdobytą (lub jeszcze nie J ) wiedzę.

class KlasaGlowna
{
    static void Main()
    {
        string napis;
         napis = System.Console.ReadLine();
        System.Console.WriteLine(napis);
        System.Console.ReadLine();
    }
}

Program oczekuje na wprowadzany przez nas tekst, aż do momentu naciśnięcia klawisza Enter, czyli wprowadzenia znaku nowej linii. Następnie za pomocą metody „WriteLine()” wypisuje to, co wprowadziliśmy do zmiennej „napis”.

Konkatenacja

Najczęściej używaną operacją na łańcuchach jest konkatenacja, czyli łączenie. Polega to na złączeniu dwóch łańcuchów znakowych w jeden za pomocą operatora „+”, coś jak „dodawanie” tekstów.
Poniżej prezentuję program, który zawiera kilka przykładów łączenia „stringów”.

class KlasaGlowna
{
    static void Main()
    {
        string napis;
        napis = "Pierwszy napis" + "Drugi napis";
        System.Console.WriteLine(napis);
        System.Console.ReadLine();
    }
}

Wynik wygląda następująco.

Za pomocą operatora „+” możemy także łączyć zmienne typu „string”. Wynik poniższego programu będzie taki sam, jak poprzednio prezentowanego.

class KlasaGlowna
{
    static void Main()
    {
        string napis1 = "Pierwszy napis";
        string napis2 = "Drugi napis";
        string zlaczonyNapis = napis1 + napis2;
        System.Console.WriteLine(zlaczonyNapis);
        System.Console.ReadLine();
    }
}

Czas na bardziej rozbudowany, a zarazem „realny” przykład.

class KlasaGlowna
{
    static void Main()
    {
        System.Console.WriteLine("Jak masz na imię?");
        string napis = System.Console.ReadLine();
        System.Console.WriteLine("Witaj, " + napis + "!");
        System.Console.ReadLine();
    }
}

Podczas wykonania program zapyta nas o imię, a później nas powita J

Następny przykład pokazuje w jaki sposób łączyć łańcuchy znakowe z wartościami innych typów, np. całkowitoliczbowymi, czyli „int”.

class KlasaGlowna
{
    static void Main()
    {
        System.Console.WriteLine("Ile masz lat?");
        string napis = System.Console.ReadLine();
        System.Console.WriteLine("Czy aby napewno masz " + napis + " lat?");
        System.Console.ReadLine();
    }
}

W powyższym programie łączymy łańcuchy znakowe z wartościami całkowitoliczbowymi (liczby całkowite) i jako wynik otrzymujemy inny łańcuch znakowy.

Używając metody “WriteLine()” możemy łączyć łańcuchy w bardziej „wyrafinowany” sposób. Jako parametry podajemy łańcuch oraz inne parametry, które chcemy połączyć z poprzedzającym je łańcuchem.

class KlasaGlowna
{
    static void Main()
    {
        string napis1 = "pierwszy";
        string napis2 = "drugi";
        int ilosc = 3;

        System.Console.WriteLine("Ten łańcuch zawiera {0} oraz {1} parametr. Wszystkich parametrów jest {2}.",  napis1, napis2, ilosc);
        System.Console.ReadLine();
    }
}

Pomiędzy nawiasy „{}” wstawiamy numer parametru, liczony od 0, który chcemy wstawić do łańcucha. A oto wynik wykonania działania programu.

Oprócz wstawiania parametrów w odpowiednie miejsce łańcucha, możemy je odpowiednio formatować, dodając do numeru parametru znak formatowania.

Lista znaków formatujących (można także używać małych liter):

C – formatowanie waluty,
D – liczby dziesiętne, określa minimalną ilość cyfr (brakujące wypełnia zerami),
E – notacja wykładnicza,
F – formatowanie z ustaloną liczbą miejsc po przecinku,
G – ogólne formatowanie,
N – podstawowy format liczbowy,
X – format heksadecymalny.

Poniżej przedstawiam przykład, który ilustruje typy formatowania.

class KlasaGlowna
{
    static void Main()
    {
        System.Console.WriteLine("Formatowanie z C: {0:C}", 777.7777);
        System.Console.WriteLine("Formatowanie z D2: {0:D2}", 777);
        System.Console.WriteLine("Formatowanie z D9: {0:D9}", 777);
        System.Console.WriteLine("Formatowanie z E: {0:E}", 777.7777);
        System.Console.WriteLine("Formatowanie z F2: {0:F2}", 777.7777);
        System.Console.WriteLine("Formatowanie z F9: {0:F9}", 777.7777);
        System.Console.WriteLine("Formatowanie z G: {0:G}", 777.7777);
        System.Console.WriteLine("Formatowanie z N: {0:N}", 777.7777);
        System.Console.WriteLine("Formatowanie z X: {0:X}", 7779);
        System.Console.ReadLine();
    }
}

Znak nowej linii

Jak wcześniej wspomniałem, znak nowej linii nakazuje przejście do nowego wiersza. Dzięki temu nie musimy dla każdego wiersza wywoływać metody „WriteLine()”, a jedynie w łańcuch znakowy wpleść znaki nowej linii. Znak ten zapisuje się następująco „\n”.

class KlasaGlowna
{
    static void Main()
    {
        System.Console.WriteLine("To jest długi napis, \nktóry dzielimy na \nkilka linijek");
        System.Console.ReadLine();
    }
}

Jak łatwo zauważyć, znaki „\n” nie pojawią się na ekranie, tylko wypisywanie tekstu przejdzie do nowej linii.

Inne ważne znaki specjalne:
\a – „dzwonek”, wygenerowany zostanie sygnał dźwiękowy,
\b – „backspace”, skasowanie ostatniego znaku i cofnięcie o jeden znak,
\r – powrót karetki, powrót do początku linii,
\t – tabulacja (odstęp) w poziomie,
\v – tabulacja w pionie,
\’ – znak cudzysłowu (łańcuchy zawieramy w znakach cudzysłowu, a czasami jest potrzeba wypisania na ekranie tego znaku, należy wtedy użyć znaku specjalnego),
\\ - znak „backslash”, czyli „\”.

Ćwiczenie

Napisać program, który pyta użytkownika o imię, wiek, pensję. Następnie wypisuje te dane za pomocą jednego wywołania metody „WriteLine()”. Należy użyć parametrów, formatowania i znaków specjalnych.