Swift Academy · Lekcja

Operatory logiczne i ewaluacja z krótkim spięciem

Łączenie warunków za pomocą &&, || i ! oraz poznanie ewaluacji z krótkim spięciem.

Lekcja 3 z 413 kroki

Operatory logiczne i ewaluacja z krótkim spięciem to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Operatory logiczne

Operatory logiczne łączą wartości typu Bool: AND &&, OR || i NOT !. Są niezbędne do budowania warunków.

let isWeekend = true
let isSunny = false
print(isWeekend && isSunny)
print(isWeekend || isSunny)
print(!isSunny)

Logiczne NOT

Operator ! odwraca wartość logiczną: true zmienia się w false, a false w true.

let loggedIn = false
if !loggedIn {
    print("Please log in")
}

Logiczne AND

Operator && ma wartość true tylko wtedy, gdy oba operandy mają wartość true. Należy go używać, gdy każdy warunek musi być spełniony.

let hasTicket = true
let hasID = true
let canEnter = hasTicket && hasID
print("Can enter:", canEnter)

Logiczne OR

Operator || ma wartość true, gdy co najmniej jeden operand ma wartość true. Należy go używać, gdy wystarczy spełnienie dowolnego warunku.

let isAdmin = false
let isOwner = true
let canEdit = isAdmin || isOwner
print("Can edit:", canEdit)

Łączenie operatorów AND i OR

Operatory można łączyć. Operator && ma wyższy priorytet niż ||, ale nawiasy ułatwiają czytanie złożonych warunków.

let age = 20
let hasGuardian = false
let allowed = (age >= 18) || hasGuardian
print("Allowed:", allowed)

Ewaluacja zwarciowa operatora AND

Swift stosuje ewaluację zwarciową: w wyrażeniu a && b, jeśli a ma wartość false, Swift nigdy nie oblicza b, ponieważ wynik jest już znany i wynosi false.

func sideEffect() -> Bool {
    print("sideEffect ran")
    return true
}
let result = false && sideEffect()
print("Result:", result)

Ewaluacja zwarciowa operatora OR

Podobnie w wyrażeniu a || b, jeśli a ma wartość true, Swift pomija b. Prawa strona jest sprawdzana tylko wtedy, gdy jest to konieczne.

func sideEffect() -> Bool {
    print("sideEffect ran")
    return false
}
let result = true || sideEffect()
print("Result:", result)

Dlaczego ewaluacja zwarciowa ma znaczenie

Ewaluacja zwarciowa pozwala umieścić najpierw tani lub bezpieczny warunek ochronny, który zabezpiecza następujące po nim kosztowne lub ryzykowne sprawdzenie. Kolejność operandów ma znaczenie.

let numbers = [10, 20, 30]
let index = 5
if index < numbers.count && numbers[index] > 0 {
    print("Safe access")
} else {
    print("Index out of bounds guarded")
}

Kolejność ewaluacji od lewej do prawej

Operandy są obliczane od lewej do prawej. Umieszczenie warunku rozstrzygającego jako pierwszego może zapobiec wykonaniu zbędnego lub niebezpiecznego kodu.

func check(_ label: String, _ value: Bool) -> Bool {
    print("checking", label)
    return value
}
let r = check("A", false) && check("B", true)
print("Final:", r)

Budowanie złożonych warunków

Rzeczywiste programy łączą wiele sprawdzeń. Należy grupować je za pomocą nawiasów, aby wyrazić dokładną logikę i zachować czytelność kodu.

let temp = 25
let humidity = 40
let comfortable = (temp >= 18 && temp <= 26) && (humidity < 60)
print("Comfortable:", comfortable)

Negowanie złożonych warunków

Umieszczenie warunku w !(...) odwraca jego całość. Zgodnie z prawami de Morgana wyrażenie !(a && b) jest równe !a || !b.

let a = true
let b = false
print(!(a && b))
print(!a || !b)

Szybkie sprawdzenie

Proszę przeanalizować działanie ewaluacji zwarciowej.

Podsumowanie: operatory logiczne i ewaluacja zwarciowa

Poznano operatory &&, || i !, zasadę, że && zatrzymuje się przy pierwszej wartości false, a || przy pierwszej wartości true, oraz sposób, w jaki ta ewaluacja zwarciowa od lewej do prawej pozwala warunkowi ochronnemu zabezpieczyć następujące po nim sprawdzenie.

let list = [1, 2, 3]
let i = 10
let safe = i < list.count && list[i] == 2
print("Safe and matched:", safe)
Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
122
Lekcje
409

Często zadawane pytania

Czy lekcja „Operatory logiczne i ewaluacja z krótkim spięciem” jest bezpłatna?

Tak — pełny tekst „Operatory logiczne i ewaluacja z krótkim spięciem” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Operatory logiczne i ewaluacja z krótkim spięciem”?

Łączenie warunków za pomocą &&, || i ! oraz poznanie ewaluacji z krótkim spięciem. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Operatory logiczne i ewaluacja z krótkim spięciem”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Operatory arytmetyczne i przypisania złożone
  2. Operatory porównania i tożsamości
  3. Operatory logiczne i ewaluacja z krótkim spięciem
  4. Operatory bitowe i przepełnienia
← Powrót do Swift Academy