Kako delujejo nizi v C#?

Question

Accepted Answer

V C# je **`string`** nespremenljiv referenčni tip, ki predstavlja besedilo. Nizi podpirajo interpolacijo, bogato knjižnico metod in — pomembno za zmogljivost — `StringBuilder` za učinkovito ponavljajočo se spreminjanje.

## Interpolacija in ustvarjanje nizov

```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 nizov** (`$"..."`) je sodoben, berljiv način za gradnjo nizov z vdejanimi vrednostmi in specifikatorji oblike. Dobesedni (`@`) nizi onemogočijo izogibanje (odličko za poti/regex), in surovi nizovni literali (`"""`) obravnavajo večvrstno besedilo.

## Nizi so nespremenljivi

```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
```

Vsaka operacija, ki "spreminja" niz, dejansko ustvari **nov** niz (nespremenljivost). To je varno, vendar ima stroške zmogljivosti za ponavljajočo se spreminjanje.

## StringBuilder za učinkovito gradnjo

```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 gradnjo nizov v zankami **`StringBuilder`** preprečuje ustvarjanje številnih vmesnih nizov — ključna praksa zmogljivosti.

## Pogoste metode nizov

```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);
```

## Zakaj je to pomembno

Manipulacija nizov je zelo pogosta pri programiranju (gradnja izhodov, obdelava vhodov, oblikovanje podatkov), zato je razumevanje C# nizov bistveno vsakodnevno znanje.

Sodobe funkcije so pomembne za produktivnost: **interpolacija nizov** (`$"..."`) je čist, berljiv način za gradnjo nizov z vdejanimi vrednostmi in oblikovanjem, in dobesedni/surovi nizovni literali elegantno obravnavajo poti in večvrstno besedilo.

Kritično je razumevanje, da so **nizi nespremenljivi** (vsaka "sprememba" ustvari nov niz), kar pojasnjuje ključno razmislek o zmogljivosti: naivna **povezava nizov v zankah** je raztratna (O(n²), ustvarjanje številnih vmesnih nizov), in vedeti, da je treba uporabiti **`StringBuilder`** za ponavljajočo se spreminjanje (ki učinkovito mutira notranji medpomnilnik), je pomembna praktična optimizacija, ki izhaja neposredno iz razumevanja nespremenljivosti.

Podpornost bogate knjižnice metod nizov (iskanje, zamenjava, razdelitev/spojitev, oblikovanje), sodobne sintakse interpolacije in prakse StringBuilder, pogojene z nespremenljivostjo, je temeljno znanje za stalno delo z nizi, ki ga vključuje programiranje — plavajoči položaj tukaj, posebej priročnost interpolacije in popravek zmogljivosti StringBuilder, je temeljni za pisanje čistega, učinkovitega C#.