Kako funkcioniraju stringovi u C#?

Question

Accepted Answer

U C#-u, **`string`** je nepromjenjiv referentni tip koji predstavlja tekst. Stringovi podržavaju interpolaciju, bogatu biblioteku metoda, i — važno za performanse — `StringBuilder` za učinkovitu ponovljenu izmjenu.

## Interpolacija stringova i kreiranje

```csharp
string name = "Ann";
int age = 30;

// string interpolation ($) — embed expressions directly
string msg = $"Hello {name}, you are {age} years old";
string formatted = $"Price: {price:C2}";    // {value:format} — C2 = currency, 2 decimals

// verbatim strings (@) — no escaping, multi-line
string path = @"C:\Users\Ann";               // backslashes literal, no \ needed
string multi = """
    Raw string literal
    preserves formatting (C# 11)
    """;
```

**Interpolacija stringova** (`$"..."`) je moderan, čitljiv način za izgradnju stringova s ugrađenim vrijednostima i specifikatorima formata. Verbalni (`@`) stringovi onemogućavaju escape znakove (odličan za putanje/regex), a raw string literali (`"""`) obrađuju višeredni tekst.

## Stringovi su nepromjenjivi

```csharp
string s = "Hello";
s.ToUpper();        // returns a NEW string "HELLO"; s is unchanged
s = s + " World";    // creates a NEW string; the old "Hello" is discarded
```

Svaka operacija koja "mijenja" string zapravo kreira **novi** string (nepromjenjivost). Ovo je sigurno ali ima cijenu u performansama za ponovljenu izmjenu.

## StringBuilder za učinkovitu izgradnju

```csharp
// ❌ string concatenation in a loop — creates a new string each iteration (slow, O(n²))
string result = "";
for (int i = 0; i < 10000; i++) result += i;

// ✅ StringBuilder mutates a buffer — efficient (O(n))
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++) sb.Append(i);
string final = sb.ToString();
```

Za izgradnju stringova u petljama, **`StringBuilder`** izbjegava kreiranje više međustringova — ključna praksa performansi.

## Česte metode stringova

```csharp
s.Length; s.ToUpper(); s.Trim(); s.Substring(0, 5);
s.Contains("x"); s.IndexOf("x"); s.Replace("a", "b");
s.Split(','); string.Join(",", items);
string.IsNullOrEmpty(s); string.IsNullOrWhiteSpace(s);
```

## Zašto je to važno

Manipulacija stringovima je sveprisutna u programiranju (izgradnja izlaza, obrada unosa, formatiranje podataka), pa je razumijevanje C# stringova bitno svakodnevno znanje.

Moderne mogućnosti su važne za produktivnost: **interpolacija stringova** (`$"..."`) je čist, čitljiv način za izgradnju stringova s ugrađenim vrijednostima i formatiranjem, a verbalni/raw string literali elegantno obrađuju putanje i višeredni tekst.

Kritično, razumijevanje da su **stringovi nepromjenjivi** (svaka "izmjena" kreira novi string) objašnjava ključno razmatranje performansi: naivno **nadovezivanje stringova u petljama** je rasipno (O(n²), stvarajući mnogo međustringova), i znanje da se koristi **`StringBuilder`** za ponovljenu izmjenu (koja učinkovito mutira interni bafer) je važna praktična optimizacija koja direktno proizlazi iz razumijevanja nepromjenjivosti.

Znanje o bogatoj biblioteci metoda stringova (pretraživanje, zamjena, razdvajanje/spajanje, formatiranje), modernu sintatxu interpolacije, i praksu StringBuilder-a koju vodi nepromjenjivost je temeljno znanje za konstantan rad sa stringovima koji programiranje uključuje — fluencija ovdje, posebno pogodnost interpolacije i ispravka performansi StringBuilder-a, je temeljno za pisanje čistog, učinkovitog C#-a.