Liczby, wartości logiczne i znaki

Swift oferuje bogaty zestaw wbudowanych typów liczbowych, typ logiczny oraz typ Character do reprezentowania pojedynczych skalarów Unicode. Przyjrzyjmy się każdemu z nich.

Swift udostępnia liczby całkowite ze znakiem i bez znaku o różnych szerokościach bitowych: ```swift let a: Int = -42 // platform width (64-bit) let b: Int8 = 127 let c: UInt = 255 let d: UInt8 = 200 ``` Używaj `Int` do ogólnych zastosowań; typów o określonym rozmiarze używaj wtedy, gdy ma znaczenie układ pamięci.

Każdy typ całkowitoliczbowy udostępnia swoje wartości graniczne: ```swift print(Int.min) // -9223372036854775808 on 64-bit print(Int.max) // 9223372036854775807 print(UInt8.max) // 255 ``` Przekroczenie tych zakresów powoduje błąd w czasie wykonywania (do zamierzonego przepełnienia używaj operatorów przepełnienia &+, &-).

```swift let pi: Double = 3.14159265358979 // 64-bit, ~15 decimal digits let e: Float = 2.71828 // 32-bit, ~6 decimal digits ``` W większości przypadków należy używać `Double`. `Float` należy stosować tylko wtedy, gdy rozmiar zajmowanej pamięci ma kluczowe znaczenie, na przykład w przypadku dużych tablic wartości.

Swift obsługuje standardowe operatory arytmetyczne: ```swift let sum = 10 + 3 // 13 let diff = 10 - 3 // 7 let prod = 10 * 3 // 30 let quot = 10 / 3 // 3 (integer division) let rem = 10 % 3 // 1 ``` Należy pamiętać: dzielenie dwóch wartości typu Int obcina wynik w kierunku zera.

```swift var isLoggedIn: Bool = false isLoggedIn = true if isLoggedIn { print("Welcome back!") } ``` Wartości logiczne w Swift są ściśle typowane — nie można używać liczb całkowitych jako wartości truthy/falsy, tak jak w języku C.

Trzy podstawowe operatory logiczne: ```swift let a = true && false // AND → false let b = true || false // OR → true let c = !true // NOT → false ``` Ewaluacja ze skracaniem: w operatorze `&&` prawa strona jest obliczana tylko wtedy, gdy lewa ma wartość `true`.

Wartość `Character` przechowuje pojedynczy rozszerzony klaster grafemów, czyli znak czytelny dla człowieka: ```swift let letter: Character = "A" let emoji: Character = "🚀" let accented: Character = "é" ``` Literały typu Character zapisuje się w podwójnych cudzysłowach, tak samo jak String.

`String` to sekwencja wartości typu `Character`: ```swift let str = "Hello" for ch in str { print(ch) // H, e, l, l, o } ``` String można utworzyć z wartości Character za pomocą `String(character)` lub przez dodawanie znaków do zmiennej typu String.

Jeśli potrzebne jest zamierzone przepełnienie, na przykład podczas sprzętowej manipulacji bitami, należy użyć operatorów przepełnienia: ```swift var x: UInt8 = 255 x = x &+ 1 // wraps to 0 instead of crashing ``` Operatory `&+`, `&-` i `&*` nigdy nie zgłaszają błędu przepełnienia.

Który operator logiczny Swift zwraca `true` tylko wtedy, gdy **oba** operandy mają wartość `true`?

Najważniejsze informacje: • Liczby całkowite: `Int` do ogólnych zastosowań, typy o określonym rozmiarze (`Int8`, `UInt8`…) w razie potrzeby • Liczby zmiennoprzecinkowe: preferowany `Double` (64-bitowy); `Float` (32-bitowy) w tablicach, w których istotne jest ograniczenie zużycia pamięci • `Bool` jest typem ścisłym — obsługuje tylko `true`/`false`, bez niejawnej konwersji liczb całkowitych • `Character` przechowuje jeden klaster grafemów Unicode • Operatorów `&+`, `&-` i `&*` należy używać do zamierzonego przepełnienia Następnie: łańcuchy znaków i interpolacja.