Technologische Neuigkeiten, Bewertungen und Tipps!

Switch Aussagen in Swift Explained

Hinweis: Der folgende Artikel hilft Ihnen weiter: Switch Aussagen in Swift Explained

Zurück zum Blog

Mit der switch-Anweisung in Swift können Sie einen Wert überprüfen und ihn mit einer Reihe von Fällen abgleichen. Dies ist besonders effektiv, um präzise Entscheidungen auf der Grundlage einer Variablen zu treffen, die mehrere mögliche Werte enthalten kann. Die Verwendung der switch-Anweisung führt oft zu prägnanterem Code, der leichter zu lesen ist.

In diesem Tutorial zur App-Entwicklung erfahren Sie, wie Sie die switch-Anweisung in Swift verwenden. Wir werden darauf eingehen:

  • Was die switch-Anweisung ist und wozu sie dient
  • So richten Sie die verschiedenen Fälle für den Switch ein
  • Verwendung von Standardwerten, zusammengesetzten Fällen und Fallthrough
  • So passen Sie den Schalter an Intervall- und Bereichsfälle an
  • So arbeiten Sie mit Tupeln in einer Switch-Anweisung
  • Verwendung von where in der switch-Anweisung

Das sagt der Swift Language Guide zur switch-Anweisung:

Eine Switch-Anweisung berücksichtigt einen Wert und vergleicht ihn mit mehreren möglichen Übereinstimmungsmustern.

Lassen Sie uns anhand eines Beispiels herausfinden, was das bedeutet. Betrachten Sie die folgende Aufzählung:

Enum Compass {
Fall Norden
Fall Osten
Fall Süden
Fall Westen
}

Wenn Sie sich orientieren möchten, können Sie diesen Code verwenden:

let heading = Compass.south

wenn Überschrift == .north {
print(„Du gehst nach Norden!“)
} sonst wenn Überschrift == .east {
print(„Du gehst nach Osten!“)
} sonst wenn Überschrift == .south {
print(„Du gehst nach Süden!“)
} sonst wenn Überschrift == .west {
print(„Du gehst nach Westen!“)
}

Der obige Code verwendet eine if-Anweisung, um den Wert der Überschrift auszuwerten und die entsprechende Textzeile auszugeben.

So können Sie dasselbe mit einer switch-Anweisung tun:

Überschrift wechseln {
Fall .north:
print(„Du gehst nach Norden!“)
Fall .east:
print(„Du gehst nach Osten!“)
Fall .south:
print(„Du gehst nach Süden!“)
Fall .west:
print(„Du gehst nach Westen!“)
}

Die Syntax der switch-Anweisung ist einfach:

  • Zuerst das Schlüsselwort „switch“ und dann ein Ausdruck, beispielsweise die Überschrift der Konstante. Dies ist der Wert, der vom Schalterblock berücksichtigt wird.
  • Dann eine Reihe von Fällen mit Fall. Im obigen Beispiel berücksichtigen wir jeden möglichen Wert der Compass-Aufzählung.

Die switch-Anweisung ist viel leistungsfähiger als es scheint, insbesondere im Vergleich zur if-Anweisung. Einer seiner Vorteile besteht darin, dass jeder Schalterblock vollständig sein muss.

Sehen Sie sich hier an, was passiert, wenn wir vergessen, .east einzubinden:

Überschrift wechseln {
Fall .north:
print(„Du gehst nach Norden!“)
Fall .south:
print(„Du gehst nach Süden!“)
Fall .west:
print(„Du gehst nach Westen!“)
}

Die Ausgabe lautet: Fehler: Schalter muss vollständig sein.

Hoppla! Das bedeutet, dass wir jeden Wert von Compass bewerten müssen. Wenn wir dies nicht tun, wird ein Fehler bei der Kompilierung angezeigt. Dies ist besonders hilfreich, wenn Sie später in Ihrer App eine Aufzählung ändern. Sie würden keine Warnung erhalten, wenn Sie if-Anweisungen verwendet hätten.

Die Vorteile der switch-Anweisung gehen über die bloße Überprüfung von Aufzählungen auf Vollständigkeit hinaus (Scrabble-Wort!). Die Fälle werden zur Kompilierzeit überprüft, sodass Sie zahlreiche Fehler erkennen können, bevor Ihre App ausgeführt wird.

Auch wenn eine Switch-Anweisung erschöpfend sein muss, müssen Sie nicht jede Option explizit angeben.

Betrachten Sie hier die folgende Autorisierungsaufzählung:

Enum-Autorisierung {
Fall stattgegeben
Fall unbestimmt
Fall nicht autorisiert
Fall abgelehnt
Fall eingeschränkt
}

Wenn Sie einem Benutzer basierend auf seinem Autorisierungsstatus Zugriff auf eine Ressource gewähren möchten, können Sie Folgendes tun:

Zustand wechseln {
Fall .erteilt:
print(“Zugriff gewährt. Sie können fortfahren.”)
Standard:
print(“DU SOLLST NICHT PASSIEREN!!”)
}

Der obige Code verwendet den Standardfall, um auf alle Fälle zu reagieren, die nicht behandelt werden. Dies macht den Wechsel erschöpfend.

  • Wenn der Status gleich .granted ist, wird der erste Fall ausgeführt.
  • Wenn state einen anderen Wert als .granted hat, wird der Standardfall ausgeführt.

Und Sie können auch zusammengesetzte Fälle verwenden, etwa so:

Zustand wechseln {
Fall .erteilt:
print(“Zugriff gewährt. Sie können fortfahren.”)
Fall .unbestimmt:
print(“Bitte geben Sie Ihren Freigabecode an.”)
Fall .unauthorized, .denied, .restricted:
print(“Zugriff verweigert!”)
}

Der letzte Fall fasst mehrere Fälle in einer Zeile zusammen. Jeder dieser .unautorisierten, .verweigerten und .eingeschränkten Fälle löst die Meldung „Zugriff verweigert!“ aus. Antwort.

Und zu guter Letzt werfen wir einen Blick auf den impliziten Fallthrough. In den meisten Programmiersprachen „fallen“ Switch-Anweisungsfälle implizit zum nächsten Fall durch. Die Ausführung beginnt mit dem ersten passenden Fall und wird fortgesetzt, bis Sie die Ausführung explizit mit „break“ stoppen.

Bei Swift ist es genau umgekehrt. Jeder Schaltvorgang wird automatisch angehalten. Sie müssen break nicht verwenden, da Swift-Switch-Anweisungen nicht implizit durchfallen.

Dies ist eine bewusste Designentscheidung. In den meisten Fällen möchten Sie nicht, dass Ihr Fall scheitert. Wenn Sie dies tun, können Sie Fallthrough explizit verwenden. So was:

var message = „Antwort:“
let state = Authorization.undetermined

Zustand wechseln {
Fall .erteilt:
Nachricht += „Zugriff gewährt. Sie können fortfahren.“
Fall .unbestimmt:
Nachricht += „Bitte geben Sie Ihren Freigabecode an. ”
durchfallen
Standard:
Nachricht += „Zugriff verweigert!“
}

drucken (Nachricht)

Im obigen Beispiel geht der Fall „.undetermined“ auf den Fall „Default“ über. Wenn der Status also „.unbestimmt“ ist, werden beide Fälle ausgeführt und der Nachricht werden zwei Zeichenfolgen hinzugefügt, was zu dieser Ausgabe führt:

Ausgabe: Antwort: Bitte geben Sie Ihren Freigabecode an. Zugriff abgelehnt!
Und das liegt am Fallthrough-Schlüsselwort im .undetermined-Case-Block.

Sie müssen einen Case-Block nicht explizit unterbrechen, aber wenn Sie einen bestimmten Case vorzeitig beenden möchten, können Sie break verwenden. Genauso wie bei for- und while-Schleifen.

Sie können die Switch-Anweisungen verwenden, um Intervalle und Bereiche abzugleichen. Bedenken Sie zum Beispiel, wie Menschen sichtbares Licht mit unterschiedlichen Wellenlängen wahrnehmen:

Wir können überprüfen, ob eine bestimmte Wellenlänge die Farbe Violett oder Orange erzeugt. So was:

Sei die Wellenlänge = 398

wenn Wellenlänge >= 380 && Wellenlänge < 450 { print("Es ist violett!") } sonst wenn Wellenlänge >= 590 && Wellenlänge < 620 { print("Es ist orange!") } Sie können sich das vorstellen, wenn wir eine if-Anweisung verwenden, um Überprüfen Sie die Wellenlängen der Farben Violett, Blau, Grün, Gelb, Orange und Rot. Die Bedingung wird ziemlich chaotisch. Stattdessen tun wir dies mit der switch-Anweisung: letWavelength = 620 SwitchWavelength { case 380..<450: print("Purple!") case 450..<495: print("Blue!") case 495..< 570: print("Grün!") case 570..<590: print("Yellow!") case 590..<620: print("Orange!") case 620..<750: print("Red!" ) Standard: print("Nicht im sichtbaren Spektrum") }
Sehen Sie, was hier passiert? Für jeden Wellenlängenbereich definieren wir ein Intervall mit dem halboffenen Bereichsoperator a.

Hier wird es interessant! Sie können die switch-Anweisung in Swift mit Tupeln verwenden.

Ein Tupel ist eine einfache geordnete Liste von zwei oder mehr Werten. Es wird in Klammern geschrieben, etwa so:

let Flight = (747, „SFO“)

Der Flugtyp ist (Int, String). Sobald ein Tupel definiert ist, können Sie seine Reihenfolge oder seinen Typ nicht mehr ändern. Tupel eignen sich hervorragend zur Übergabe mehrerer zusammengehöriger Werte in einer Variablen.

Sie können wie folgt auf die Werte eines Tupels mit einer Indexnummer zugreifen:

print(flight.1)
// Ausgabe: SFO

Es ist bequemer, die Werte des Tupels zu benennen. So was:

let Flight = (Flugzeug: 747, Flughafen: „SFO“)
print(flgith.airplane)
// Ausgabe: 747

Sie können Tupel zusammen mit Switch-Anweisungen verwenden. So was:

für i in 1…100
{
Schalter (i % 3 == 0, i % 5 == 0)
{
Fall (wahr, falsch):
print(“Fizz”)
Fall (falsch, wahr):
print(“Buzz”)
Fall (wahr, wahr):
print(“FizzBuzz”)
Standard:
drucken(i)
}
}

Der obige Code ist Teil einer Codierungsherausforderung namens FizzBuzz.

Im obigen Code erstellen wir ein Tupel aus zwei Werten, dem Ergebnis von i % 3 == 0 und i % 5 == 0. Da es sich um boolesche Operationen handelt, ist der Typ des Tupels (wahr, wahr).

Wir können jetzt auf verschiedene Tupelwerte reagieren, wie zum Beispiel (wahr, falsch) und (wahr, wahr). Daher geschieht Folgendes im Code:

  • Wenn i durch 3 teilbar ist, geben Sie „Fizz“ aus.
  • Wenn i durch 5 teilbar ist, geben Sie „Buzz“ aus.
  • Wenn i durch 3 und 5 teilbar ist, geben Sie „FizzBuzz“ aus.
  • Wenn keiner dieser Fälle zutrifft, geben Sie einfach den Wert von i aus

Da wir switch zum Auswerten eines Tupels verwenden, können wir auf verschiedene übereinstimmende Werte im Tupel reagieren.

Schauen Sie sich das hier an:

let plane = (Typ: „737-800“, Überschrift: „LAX“)

Flugzeug wechseln {
Fall („737-800“, _):
print („Dieses Flugzeug ist ein 737-800-Modell.“)
case (let-Typ, „LAX“):
print(„Dieser \(Typ) ist auf dem Weg zum Los Angeles Intl. Airport“)
Standard:
print(“Unbekanntes Flugzeug und unbekannter Kurs.”)
}

Im obigen Code reagieren wir auf drei verschiedene Fälle:

  1. Wenn es sich bei dem Flugzeugtyp um eine 737-800 handelt, lautet der Code: Dieses Flugzeug ist ein 737-800-Modell. Sehen Sie, wie der Unterstrich _ mit einem beliebigen Wert für Airplane.heading übereinstimmt?
  2. Wenn der Flugkurs LAX lautet, lautet der Code unabhängig vom Flugzeugtyp wie folgt: „This … is headed for Los Angeles Intl.“ Flughafen.
  3. Ansonsten gibt der Code „Unbekanntes Flugzeug und unbekannter Kurs“ aus.

Überlegen Sie, was im obigen Szenario passiert, wenn der Wert des Flugzeugs (Typ: „737-800“, Überschrift: „LAX“) ist. Welcher der 3 Fälle wird ausgeführt?

Es ist der erste Fall, denn das ist der erste Fall, der übereinstimmt. Der Flugzeugtyp ist 373-800. Auch wenn die LAX-Überschrift möglicherweise mit dem zweiten Fall übereinstimmen könnte, wird („737-800“, _) früher gefunden. Vergessen Sie nicht, dass Ihr Code Zeile für Zeile von oben nach unten ausgeführt wird!

Überlegen Sie dann, was passiert, wenn der Wert des Flugzeugs (Typ: „747“, Überschrift: „LAX“) ist. Jetzt wird der zweite Fall ausgeführt, da die Überschrift LAX lautet.

Der let-Typ im Fall (let-Typ, „LAX“): wird als Wertbindung bezeichnet. Dadurch wird der Wert des Tupels vorübergehend an einen konstanten Typ gebunden. Innerhalb des Schaltergehäuses können Sie diese Konstante nun verwenden, beispielsweise ausdrucken. Sauber!

OK, es gibt noch eine letzte Möglichkeit, die switch-Anweisung zu verwenden, die Sie kennen lernen müssen. Es geht darum, wo zu verwenden.

Schauen Sie sich hier den folgenden Swift-Code an:

Enum-Antwort {
case error(Int, String)
Fallerfolg
}

sei httpResponse = Response.success

httpResponse { wechseln
case .error(let code, let status) wobei Code > 399:
print(“HTTP-Fehler: \(code) \(status)”)
Fall .error:
print(“HTTP-Anfrage fehlgeschlagen”)
Fall .Erfolg:
print(„HTTP-Anfrage war erfolgreich“)
}

// Ausgabe: HTTP-Anfrage war erfolgreich

Im obigen Code passieren zwei Dinge:

  1. Wir definieren eine Enumeration namens Response, die zwei Fälle hat: .error und .success. Der .error-Fall hat zwei zugehörige Werte, eine Ganzzahl und eine Zeichenfolge.
    Wir werten den Wert von httpResponse mit einer Switch-Anweisung aus und reagieren auf verschiedene Werte der Response-Enumeration.
  2. Im obigen Code definieren wir zwei Fälle, die klar sind, nämlich .error und .success. Stellen Sie sich vor, dass der Wert „Response“ zurückkommt und wir einfach prüfen möchten, ob die Antwort in Ordnung ist oder nicht. Dafür verwenden wir .error und .success.

Überlegen Sie, was passiert, wenn Sie den Wert von httpResponse ändern in:

let httpResponse = Response.error(404, „Not Found“)
// Ausgabe: HTTP-Fehler: 404 Nicht gefunden
Und dazu:

let httpResponse = Response.error(301, „Permanent verschoben“)
// Ausgabe: HTTP-Anfrage fehlgeschlagen

Was passiert da?

Es gibt einen .error-Fall, der uns besonders interessiert, nämlich einen Fehlercode, der größer als 399 ist.

Hier ist der entsprechende Code:

case .error(let code, let status) wobei Code > 399:
print(“HTTP-Fehler: \(code) \(status)”)

Die offiziellen HTTP-Statuscodes, die im Internet verwendet werden, weisen darauf hin, dass Statuscodes ab 400 Client- und Serverfehler sind. Anders ausgedrückt: Wenn man eines davon bekommt, ist etwas schief gelaufen.

Im obigen Code binden wir die Code- und Statuskonstanten an die zugehörigen Werte der Response-Enumeration. Wir verwenden außerdem das Schlüsselwort „where“, um anzugeben, dass dieser Fall für jeden Codewert ausgeführt werden soll, der größer als 399 ist.

Man kann das fast wörtlich als „Fehlerfälle, bei denen der Code größer als 399 ist“ lesen. Es ist ziemlich intuitiv und macht deutlich, dass wir speziell an diesen Fehlercodes interessiert sind.

Die if-Anweisung ist nicht die einzige Möglichkeit, Entscheidungen in Ihrem Code zu treffen. Die switch-Anweisung bietet zahlreiche Möglichkeiten, einen Wert zu berücksichtigen und ihn mit passenden Mustern zu vergleichen.

Und es ist besonders leistungsstark, wenn es mit Tupeln, Mustervergleich, Bereichen, Wertbindungen usw. kombiniert wird!

Table of Contents