Podstawy String i interpolacja

Łańcuchy znaków są podstawą niemal każdej aplikacji. Typ `String` w Swift poprawnie obsługuje Unicode, jest typem wartościowym i oferuje bardzo duże możliwości. Poznajmy najważniejsze informacje.

Literały łańcuchów znaków zapisuje się w podwójnych cudzysłowach: ```swift let greeting = "Hello, World!" var city = "Istanbul" ``` W przypadku łańcuchów wielowierszowych należy użyć potrójnych cudzysłowów: ```swift let poem = """ Roses are red, Swift is great. """ ```

Łańcuchy znaków można łączyć za pomocą operatora `+` lub `+=`: ```swift let first = "Hello" let second = " World" let full = first + second // "Hello World" var msg = "Hi" msg += " there" // "Hi there" ```

Dowolne wyrażenie można umieścić w łańcuchu znaków za pomocą składni `\(expression)`: ```swift let name = "Alice" let score = 95 print("Player \(name) scored \(score) points") // Player Alice scored 95 points ``` Interpolacja jest bezpieczniejsza i czytelniejsza niż ręczne łączenie łańcuchów znaków.

Można sprawdzić, czy łańcuch znaków jest pusty, lub pobrać liczbę jego znaków: ```swift var text = "" print(text.isEmpty) // true text = "Swift" print(text.count) // 5 ``` Zamiast `text == ""` należy używać `.isEmpty` — jest to bardziej idiomatyczne rozwiązanie w Swift.

```swift let str = "Hello, Swift!" str.uppercased() // "HELLO, SWIFT!" str.lowercased() // "hello, swift!" str.contains("Swift") // true str.hasPrefix("Hello") // true str.hasSuffix("!") // true str.replacingOccurrences(of: "Swift", with: "World") ```

Łańcuchy znaków w Swift są *typami wartościowymi*. Łańcuch znaków zadeklarowany za pomocą `var` można modyfikować, natomiast łańcuch zadeklarowany za pomocą `let` jest niezmienny: ```swift var mutable = "Hello" mutable.append(" World") // ✓ let immutable = "Hello" immutable.append(" World") // ❌ compile error ```

Łańcuchy znaków można porównywać za pomocą operatorów `==`, `<` i `>`; porównanie uwzględnia Unicode: ```swift let a = "apple" let b = "banana" print(a == b) // false print(a < b) // true (lexicographic order) ``` Domyślnie porównania są niezależne od ustawień regionalnych.

Składnia `#"..."#` wyłącza sekwencje ucieczki — jest przydatna na przykład w przypadku wzorców wyrażeń regularnych lub ścieżek: ```swift let pattern = #"\d{3}-\d{4}"# // The backslashes are literal, not escape sequences let path = #"C:\Users\Alice"# ``` Interpolacja nadal działa w surowych łańcuchach znaków — należy użyć w nich `\#(value)`.

```swift let num = 42 let str = String(num) // "42" let back = Int(str) // Optional(42) let invalid = Int("abc") // nil ``` Konwersja z String na typ liczbowy zwraca Optional, ponieważ łańcuch znaków może nie reprezentować prawidłowej liczby.

Najważniejsze informacje: • Literały łańcuchów znaków zapisuje się jako `"..."`, a łańcuchy wielowierszowe jako `"""` • Interpolacji należy używać w postaci `\(expression)` — to najczytelniejszy sposób tworzenia łańcuchów znaków • Łańcuchy znaków zadeklarowane za pomocą `var` można modyfikować, a zadeklarowane za pomocą `let` są niezmienne • Należy używać `.isEmpty`, `.count`, `.contains()`, `.hasPrefix()` i `.hasSuffix()` • Konwersja String → typ liczbowy zwraca Optional Następna lekcja: pętle for-in z zakresami.