Praktyczny przewodnik po manipulacji stringami dla Ferryt Deweloperów

W programowaniu aplikacji, zwłaszcza w środowiskach low-code, takich jak Ferryt, operacje na stringach są nieodłączną częścią codziennej praktyki deweloperskiej. Umiejętność manipulowania tekstem jest kluczowa dla efektywnego i sprawnego pisania kodu. Dlatego w tym artykule omówimy podstawowe i nieco bardziej zaawansowane metody stringowe w C#, by poznać korzyści, jakie niesie za sobą ich sprytne wykorzystanie w codziennej pracy z platformą Ferryt.

Stringi, czyli łańcuchy znaków, są podstawowym budulcem w  procesie kodowania. Mając swoje indeksy, pozwalają nam precyzyjnie zarządzać każdym znakiem w ciągu. Dzięki różnorodnym metodom, jakie oferuje nam język C#, wzbogacamy  możliwości manipulowania znakami danego ciągu, co z kolei zwiększa wydajność naszej pracy. Metody te umożliwiają  dokonywanie różnorodnych operacji, takich jak  wycinanie fragmentów tekstu, łączenie stringów, zmiana wielkości liter czy  wyszukiwanie określonych podciągów. Dzięki nim, jako deweloperzy platformy Ferryt, możemy szybko i efektywnie dostosowywać dane tekstowe do naszych potrzeb, co przyczynia się do szybszego tworzenia aplikacji i zwiększa naszą produktywność.

 W dalszej części artykułu przyjrzymy się najbardziej przydatnym metodom manipulacji stringiem, podkreślając ich znaczenie dla efektywnego zarządzania danymi tekstowymi oraz wydajnego tworzenia aplikacji w Ferryt.

Metody do manipulacji łańcuchami znaków – stringami

Manipulacja tekstem to kluczowy element programowania, zwłaszcza gdy mamy do czynienia z dużą liczbą danych tekstowych. W języku C# istnieje kilka przydatnych metod, które pozwalają nam skutecznie nimi zarządzać. Poniżej przedstawiamy  trzy z najczęściej używanych:

Substring()

Metoda Substring() pozwala na wyodrębnienie fragmentu tekstu na podstawie dwóch możliwych do przekazania argumentów indeksu początkowego oraz ilości znaków.

Dla przykładu przyjmijmy, że pracujemy z polem stringowym, które przechowuje adres klienta:

PF.AdresKlienta; // przechowuje wartość pobraną z API : "ul. Wielka 13/56"

Metoda ta pozwala na wyodrębnienie stringa na podstawie podanego indexu początkowego łańcucha znaków, który chcemy wyodrębnić np. numer lokalu klienta:

PF.NumerLokalu = PF.AdresKlienta.Substring(14); // Wynik: "56"

Metoda ta może być również wykorzystana do wyodrębnienia fragmentu o określonej długości. W takim przypadku podajemy dwa argumenty : index początkowy wyrazu, który chcemy wyodrębnić z głównego stringa oraz liczbę znaków tego wyrazu :

PF.NazwaUlicy = PF.AdresKlienta.Substring(4, 6); // Wynik: "Wielka"

Concat()

Metoda Concat() służy do łączenia dwóch lub więcej stringów w jeden.

Dla przykładu przyjmijmy, że pracujemy z dwoma polami stringowymi, które przechowują imię i nazwisko klienta:

PF.ImieKlienta = "Jan";
PF.NazwiskoKlienta = "Nowak";

Metoda ta pozwala połączyć te dwa pola ze spacją pomiędzy:

PF.ImieNazwiskoKlienta = string.Concat(PF.ImieKlienta, " ", PF.NazwiskoKlienta); // Wynik: "Jan Nowak"

Ekwiwalentem tej metody może być użycie zapisu z wykorzystaniem znaku „+”:

PF.ImieNazwiskoKlienta = PF.ImieKlienta + " " + PF.NazwiskoKlienta; // Wynik: "Jan Nowak"

Replace()

Metoda Replace() umożliwia zamianę określonego fragmentu tekstu (podciągu) na inny. Funkcja ta przyjmuje dwa argumenty: pierwszy stanowi fragment stringa, który chcemy zmienić, drugi zaś to fragment, który chcemy aby się w tym miejscu pojawił.

Dla przykładu przyjmijmy, że pracujemy z polem stringowym, które przechowuje wersję silnika Ferryta:

PF.SilnikFerryta = "Ferryt 1.0";

Metoda ta pozwala na zmianę samego numeru wersji np. z 1.0 na 2.0:

PF.AktualnySilnikFerryta = PF.SilnikFerryta.Replace("1.0", "2.0"); // Wynik: "Ferryt 2.0"

Przyjmijmy, że pracujemy z polem stringowym przechowującym datę urodzenia, którą chcemy przedstawić w formacie „dd.MM.yyyy”:

PF.DataUrodzenia = "10/29/1988";

Metoda ta pozwala na zmianę formatu z rozdzielenia ukośnikami na kropki:

PF.SformatowanaDataUrodzenia = PF.DataUrodzenia.Replace("/", "."); // Wynik: "10.29.1988"

 

• Przykład usunięcia białych znaków:

PF.SilnikFerrytaBezSpacji = PF.SilnikFerryta.Replace(" ", ""); // Wynik: "Ferryt1.0"

• Przykład usunięcie niechcianych fraz np. tagów HTML:

PF.NazwaKonta = "<span><b>Rachunek ROR</b></span>";
PF.NazwaKontaBezTagow = PF.NazwaKonta.Replace("<span>", "").Replace("</span>", "").Replace("<b>", "").Replace("</b>", ""); 
// Wynik: "Rachunek ROR"

Te trzy metody są podstawowymi narzędziami do manipulacji tekstem w C#, które znajdują szerokie zastosowanie w praktyce ferrytowej.

Metody do wyszukiwania i porównywania

Wyszukiwanie i porównywanie są kluczowymi operacjami podczas pracy z danymi. W języku C# istnieją metody, które ułatwiają te zadania i pozwalają na sprawne zarządzanie stringami. Poniżej przedstawiamy trzy z najczęściej używanych metod w tej kategorii, wraz z przykładami ich zastosowania oraz opisem argumentów, jakie przyjmują.

Contains()

Metoda Contains() służy do sprawdzenia, czy dany tekst zawiera określony podciąg. Przyjmuje jako argument podciąg, który chcemy znaleźć w tekście. Funkcja ta zwraca wartość logiczną true, jeśli podciąg jest obecny w tekście, w przeciwnym razie zwraca false.

Przyjmijmy, że pracujemy z polem stringowym przechowującym tytuł przelewu:

PF.TytulPrzelewu = "wpłata za fakturę nr FA/123/123";

Metoda ta pozwala sprawdzić, czy w łańcuchu znaków zawiera się wskazany string:

bool CzyTytulPrzelewuZawieraNumerFaktury = PF.TytulPrzelewu.Contains("FA/123/123"); // Zwraca true

Equals() i StringComparison

Metoda Equals() służy do porównywania dwóch stringów pod kątem identyczności. Może przyjmować drugi argument StringComparison, który określa sposób porównywania, np. StringComparison.OrdinalIgnoreCase ignoruje różnice w wielkości liter. Domyślnie Equals() uwzględnia różnice kulturowe i wielkość liter, ale z pomocą StringComparison można kontrolować to zachowanie.

Przyjmijmy, że pracujemy z dwoma polami stringowymi, które powinny przechowywać nazwisko klienta:

PF.NazwiskoKlienta = "Kowalski";
PF.NazwiskoKlienta2 = "kowalski";

Metoda ta pozwala sprawdzić, czy stringi są identyczne, uwzględniając wielkość znaków:

bool czyTakieSameNazwiska = PF.NazwiskoKlienta.Equals(PF.NazwiskoKlienta2); // Zwraca false

lub pomijając w porównaniu wielkość znaków:

bool czyTakieSameNazwiska = PF.NazwiskoKlienta.Equals(PF.NazwiskoKlienta2, StringComparison.OrdinalIgnoreCase); 
// Zwraca true

Wydajne wykorzystanie tych metod i przykładów operacji na stringach pozwala na bardziej efektywne i elastyczne zarządzanie danymi tekstowymi w aplikacjach tworzonych na platformie Ferryt, co w konsekwencji przekłada się na lepszą organizację kodu i bardziej intuicyjne działania programistów.

Metody do Rozdzielania i Formatowania

Metody stringowe do rozdzielania i formatowania odgrywają istotną rolę w przekształcaniu, analizowaniu i prezentowaniu informacji tekstowych. Pozwalają one na łatwe dzielenie ciągów na mniejsze części, modyfikowanie ich struktury oraz dopasowywanie do określonych wzorców i standardów.

Split()

Metoda Split() służy do dzielenia danego tekstu na fragmenty na podstawie określonego separatora. W przypadku braku podania separatora, domyślnym separatorem jest znak spacji. Metoda ta zwraca dane typu tablicowego.

Dla przykładu przyjmijmy, że pracujemy z polem stringowym, które przechowuje imiona klienta:

PF.ImionaKlienta = "Jan Adam";

Dzięki metodzie Split() możemy utworzyć tablicę, w której każde imię będzie stanowiło osobny element posiadający swój indeks:

PF.ImionaSkladowe = PF.ImionaKlienta.Split(); // Wynik: tablica ["Jan", "Adam"]

Możemy również wskazać separator inny od domyślnego (spacja). Przyjmijmy, że pracujemy z polem stringowym przechowującym datę wymagalności zobowiązania:

PF.DataWymagalnosci = "29/10/2024";

Poprzez przekazanie separatora w argumencie metoda podzieli ten łańcuch znaków relatywnie do występowania tego separatora, w tym przykładzie oddzieli do osobnych elementów tablicy dzień, miesiąc i rok:

PF.DataSkladowe = PF.DataWymagalnosci.Split("/"); // Wynik: tablica ["29", "10", "2024"]

ToUpper() i ToLower()

Metoda ToUpper() zamienia wszystkie litery w tekście na duże litery, natomiast metoda ToLower() zamienia je na małe litery.

Dla przykładu przyjmijmy, że pracujemy z polem stringowym, które przechowuje symbol waluty:

PF.Waluta = "Pln";

Metody te pozwolą na sformatowanie każdego znaku tego łańcucha znaków do litery małej lub wielkiej:

PF.WalutaUpperCase = PF.Waluta.ToUpper(); // Wynik: "PLN"
PF.WalutaLowerCase = PF.Waluta.ToLower(); // Wynik: "pln"

Format()

Metoda Format() umożliwia formatowanie tekstu na podstawie określonego wzorca. Wzorzec jest definiowany przez łańcuch znaków, który zawiera specjalne znaczniki zastępcze {0}, {1}, itd., które są zastępowane przez wartości argumentów podanych we wzorcu. Ta metoda jest często używana do tworzenia dynamicznych ciągów znaków, takich jak komunikaty, logi czy generowanie raportów.

Dla przykładu przyjmijmy, że chcemy utworzyć pole stringowe, które poza statyczną częścią będzie miało zagnieżdżone elementy dynamiczne, np. numer konta i status konta:

PF.NumerKonta = "123123";
PF.StatusKonta = "aktywny";
PF.Komunikat = string.Format("Klient o numerze {0} posiada status: {1}.", PF.NumerKonta, PF.StatusKonta); 
// Wynik: "Klient o numerze 123123 posiada status aktywny."

Trim(), TrimEnd() oraz TrimStart()

Metody z rodziny Trim służą do usuwania białych znaków (np. spacji, tabulatorów, znaków nowej linii) z początku, końca lub obu końców tekstu. Trim() usuwa białe znaki z obu końców tekstu, TrimEnd() usuwa je tylko z końca, a TrimStart() tylko z początku. Te metody są przydatne, gdy chcemy usunąć niepotrzebne białe znaki z tekstu, co często jest potrzebne podczas przetwarzania danych wejściowych, np. z formularzy.

Dla przykładu przyjmijmy, że pracujemy z polem stringowym przesłanym poprzez formularz przez użytkownika, który zostawił w nim na końcu i na początku białe znaki (spacje):

PF.ImieNazwiskoZFormularza = " Adam Nowak ";

Dzięki metodom z rodziny Trim możemy dokonać oczyszczenia tego pola z białych znaków:

PF.trimmedImieNazwiskoZFormularza = PF.ImieNazwiskoZFormularza.Trim(); // Wynik: "Adam Nowak"
PF.trimmedEndImieNazwiskoZFormularza = PF.ImieNazwiskoZFormularza.TrimEnd(); // Wynik: " Adam Nowak"
PF.trimmedStartImieNazwiskoZFormularza = PF.ImieNazwiskoZFormularza.TrimStart(); // Wynik: "Adam Nowak "

Ważne!

Zanim użyjemy którejś metody stringowej na danym polu tekstowym w Ferrycie, musimy upewnić się, że nie jest ono nullem. Sprawdzenie, czy wartość stringa nie jest nullem, jest kluczowe, aby uniknąć potencjalnych błędów wykonania, które mogą prowadzić do wyświetlenia komunikatu o błędzie, np. dobrze znane każdemu Ferryt Developerowi „prosimy o kontakt z administratorem”. Sytuacja, gdy próbujemy wywołać metodę na stringu, który jest nullem, może znacząco wpłynąć na doświadczenie użytkownika, dlatego warto wdrożyć proste mechanizmy walidacji.

Poniżej znajduje się przykładowy kod warunku walidacyjnego, który pokazuje, jak sprawdzić, czy string nie jest nullem przed zastosowaniem na nim metody stringowej:

PF.NumerNIP = null; // pole to jest nullem

//warunek walidacyjny
if (!string.IsNullOrEmpty(PF.NumerNIP))
{
    PF.NumerNIP = PF.NumerNIP.Replace("-", ""); 
    // kod ten się nie wykona, ponieważ nie jest spełniony warunek, że pole PF.NumerNIP posiada wartość, czyli nie jest nullem
};

Nowoczesne Techniki Formatowania Tekstu

Interpolacja Stringa:

Interpolacja stringa to technika umożliwiająca dynamiczne wstawianie wartości zmiennych bezpośrednio wewnątrz ciągu tekstowego. W C#, interpolacja jest realizowana poprzez przedrostek znaku dolara $ przed cudzysłowem oraz umieszczenie wyrażenia w nawiasach klamrowych {}. Wewnątrz nawiasów można umieścić dowolne wyrażenie, które zostanie obliczone i zastąpione jego wartością w tekście. Ta metoda formatowania tekstu jest bardziej czytelna i wygodna niż tradycyjne metody, takie jak konkatenacja czy wykorzystanie metody String.Format().

Dla przykładu przyjmijmy, że chcemy utworzyć pole stringowe przechowujące personalizowane życzenia urodzinowe dla klienta, które poza statyczną częścią będzie miało zagnieżdżone elementy dynamiczne tj. imię i wiek klienta:

PF.ImieKlienta = "Jan";
PF.WiekKlienta = 30;
PF.KomunikatUrodzinowy = $"Dzień dobry {PF.ImieKlienta}, wszystkiego najlepszego z okazji {PF.WiekKlienta} urodzin."; 
// Wynik: "Dzień dobry Jan, wszystkiego najlepszego z okazji 30 urodzin."

Interpolacja stringa umożliwia bezpośrednie wstawienie wartości zmiennych PF.ImieKlienta i PF.WiekKlienta wewnątrz tekstu w nawiasie klamrowym, co czyni kod bardziej czytelnym i łatwiejszym w utrzymaniu.

Werbalizacja Stringa:

Werbalizacja stringa pozwala na tworzenie wielolinijkowych ciągów znaków bez konieczności używania specjalnych znaków escape, takich jak:

• nowa linia \n
• tabulator \t
• użycie cudzysłowu, backslascha \", \\

W C#, werbalizacja stringa jest realizowana poprzez użycie symbolu @ przed cudzysłowem. Dzięki temu wszystkie znaki wewnątrz ciągu znaków są traktowane dosłownie, a nie jako znaki specjalne.

Dla przykładu przyjmijmy, że chcemy utworzyć pole stringowe przechowujące tekst wielolinijkowy, w którym nie chcemy używać znaków specjalnych:

PF.TekstWielolinijkowy = @"Witaj, 
To jest tekst Podzielony na 
kilka 
Linijek 
I tak zostanie wyświetlony."; // Nie trzeba używać znaków specjalnych \n, wynik będzie wielolinijkowy

Werbalizacja stringa ułatwia tworzenie wielolinijkowych ciągów znaków oraz zwiększa czytelność kodu, ponieważ nie trzeba martwić się o znaki specjalne.

Podsumowanie

Opanowanie tych kilku metod stringowych w C# może znacząco zwiększyć efektywność pracy Ferryt Developera. Warto eksperymentować z metodami i iteracyjnie dostosowywać ich dobór do własnych potrzeb, aby jeszcze lepiej wykorzystać potencjał manipulacji tekstem w swoim projekcie. Działanie w oparciu o metody stringowe może przełożyć się na szybsze tworzenie aplikacji oraz zwiększenie naszej satysfakcji z pracy.