~ = - operator in Swift

Habe ich vor kurzem heruntergeladen Erweiterte NSOperations - Beispiel-app von Apple und fand diesen code...

//Operators to use in the switch statement.
private func ~=(lhs: (String, Int, String?), rhs: (String, Int, String?)) -> Bool {
    return lhs.0 ~= rhs.0 && lhs.1 ~= rhs.1 && lhs.2 == rhs.2
}

private func ~=(lhs: (String, OperationErrorCode, String), rhs: (String, Int, String?)) -> Bool {
    return lhs.0 ~= rhs.0 && lhs.1.rawValue ~= rhs.1 && lhs.2 == rhs.2
}

Scheint es zu verwenden, die ~= Betreiber gegen Strings und Ints aber ich habe noch nie gesehen es vor.

Was ist es?

InformationsquelleAutor Fogmeister | 2016-07-14

43

Es ist ein operator, der verwendet wird für die Mustererkennung in einem case - Anweisung.

Können Sie einen Blick hier, um zu wissen, wie Sie verwenden können, und nutzen es bietet eine eigene Implementierung:
- http://oleb.net/blog/2015/09/swift-pattern-matching/
- http://austinzheng.com/2014/12/17/custom-pattern-matching/
Hier ist ein einfaches Beispiel für die Definition einer eigenen und die, die es verwenden:
```
struct Person {
    let name : String
}

//Function that should return true if value matches against pattern
func ~=(pattern: String, value: Person) -> Bool {
    return value.name == pattern
}

let p = Person(name: "Alessandro")

switch p {
//This will call our custom ~= implementation, all done through type inference
case "Alessandro":
    print("Hey it's me!")
default:
    print("Not me")
}
//Output: "Hey it's me!"

if case "Alessandro" = p {
    print("It's still me!")
}
// Output: "It's still me!"
```
- Ist die switch-Anweisung die einzige Stelle, wo dieser operator wird verwendet? Wie wäre for case let item in items {...} etc.?
- Sie haben völlig Recht, es funktioniert in jedem case - Anweisung. Ich habe meinen Beitrag aktualisiert.
- VORSICHT: Das, was Sie switch über muss der 2. parameter der ~= überlastung. Bedeutung func ~=(value: Person, pattern: String) -> Bool{ return value.name == pattern } würde dieser Fehler generieren: Ausdruck-Muster des Typs 'String' kann nicht übereinstimmen, die Werte vom Typ 'Person'
- ja, es ist ein bit-Zähler intuitive. Das Muster ist der 1. parameter, während der Wert zum Spiel gegen die 2te. Mein Beispiel ist korrekt.
- Ja, dein Beispiel ist richtig. Das war neu für mich und ich war nur Herumspielen mit den ~= und ändern die Namen der parameter und nicht irgendwelche Probleme. Aber wenn ich vertauscht die position von dem Typen dann lief ich in ein Problem. Nicht sicher, ob dies korrekt ist, aber es scheint, dass es irgendwie ignoriert den parameter 'Namen' und bezieht sich nur auf, wie Sie mit Ihrer 'position' in der Funktion Signatur. Ich Frage mich, wie Swift zieht diese aus.
- Das ist normal, Swift erfordert, dass man die Parameter in der Reihenfolge der Funktionssignatur.
- Nur ein Kommentar... kann man eigentlich überschreiben der ~= in beide Richtungen (d.h. die person, auf die Links, string rechts und Umgekehrt.) Tun, passen Sie in jede Ordnung und löst das problem erwähnt in dem Kommentar oben.
- dies gilt nur, wenn Sie explizit mit dem operator in deinem code. Sie tun, was Sie sagen, hat keine Wirkung für case Aussagen
- das ist eigentlich nicht wahr. Ich habe gerade deinen obigen code, schrieb die zweite version, dass die Person das Muster-und String-der Wert, dann der Schalter, ich habe 'switch 'Alessandro' mit einem 'Fall p' und er passte gut. Die einzige Voraussetzung ist, Sie haben eine version des '~=' mit dem richtigen Muster und Wert-Typen zu testen, gegen. Dann können Sie es in den switch-case-Anweisung oder sonst irgendwo.
- gut, das funktioniert natürlich, aber löst nicht das problem erwähnt in den Kommentaren oben. Das problem war, dass es verwirrend ist, dass passend switch p .... case "Alessandro" schreiben Sie func ~=(pattern: String, value: Person) statt func ~=(value: Person, pattern: String). Die ~= muss das Muster als ersten param, nicht der Wert, und das ist die Quelle der Verwirrung für viele Benutzer. Wieder Lesen, was Honig geschrieben und du verstehst, was ich meine 😉 .
- Aber die Kommentare wirklich nicht sprechen über ein problem mit pattern-matching. Sie sprechen über ein problem, wo Sie fälschlicherweise dachten, Sie könnten den Parameter neu anordnen, was natürlich nicht der Fall ist. Das ist ein Swift-Sprache-Einschränkung, die durch eine Menge von anderen. Mein Punkt über mein Kommentar oben war einfach, dass, wenn Sie erstellen ein pattern-matching - ~ = - Funktion, ist es eine gute Idee, um die reverse-da kann man dann passend in jede Richtung, die Sie wollen.
- ja, ich Stimme zu, dass dies gibt Ihnen mehr Flexibilität. Aber in deinem ursprünglichen Kommentar, auf den Sie schrieb solves the problem mentioned in the comment above das ist nicht wahr. Oder besser, er löst das problem, indem alle möglichen Permutationen, so dass einer von Ihnen ist sicher die richtige version, auch wenn der andere möglicherweise nie benötigt werden.
- Aber es nicht lösen das problem speziell erwähnt in dem Kommentar. Wenn Sie Hinzugefügt, dass die reverse-Funktion, Sie würden nicht sehen, die Fehler, dass Sie immer Tat, wenn Sie eingeschaltet, um Sachen
InformationsquelleAutor Alessandro Orrù

Verwenden Sie einfach eine Verknüpfung zu "Angebot": können Sie konstruieren eine Reihe und "~=" bedeutet "enthält".
(andere können hinzufügen, mehr theoretische details, aber der Sinn ist dieser). Lesen Sie es als "enthält"

let n: Int = 100

//verify if n is in a range, say: 10 to 100 (included)

if n>=10 && n<=100 {
    print("inside!")
}

//using "patterns"
if 10...100 ~= n {
    print("inside! (using patterns)")

}

versuchen mit einige Werte von n.

Ist weit verbreitet, zum Beispiel in HTTP-Antwort:

if let response = response as? HTTPURLResponse , 200...299 ~= response.statusCode {
                let contentLength : Int64 = response.expectedContentLength
                completionHandler(contentLength)
            } else {
                completionHandler(nil)

InformationsquelleAutor ingconti

1

Können Sie Einblick in Definieren Swift
```
func ~=<I : IntervalType>(pattern: I, value: I.Bound) -> Bool
func ~=<T>(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool
func ~=<T : Equatable>(a: T, b: T) -> Bool
func ~=<I : ForwardIndexType where I : Comparable>(pattern: Range<I>, value: I) -> Bool
```
- Das ist gut zu wissen, aber nicht wirklich erklären was es ist. Was macht es gleichsetzen zu true oder false? Ich kann sehen, dass es ausgeführt werden kann, gegen Equatable Variablen des gleichen Typs, aber das sagt mir nichts über die Umsetzung.
InformationsquelleAutor Rahul Tripathi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.