2016-07-14 37 views
12

Recentemente ho scaricato il avanzata NSOperations campione app da Apple e ha trovato questo codice ...~ = operatore in Swift

// 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 
} 

sembra di utilizzare l'operatore ~= contro Strings e Ints ma non ho mai visto prima.

Che cos'è?

risposta

20

Si tratta di un operatore utilizzato per il pattern matching in un comunicato case.

È possibile dare uno sguardo qui per sapere come è possibile utilizzare e sfruttare lo fornisce la propria implementazione:

Ecco un semplice esempio di definizione di un costume uno e utilizzandolo:

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!" 
+0

L'istruzione switch è l'unico posto in cui viene utilizzato questo operatore? Che ne dite di 'per caso lasciare l'oggetto negli elementi {...}' ecc.? –

+0

@RoboRobok hai perfettamente ragione, funzionerà con qualsiasi istruzione 'case'. Ho aggiornato il mio post. –

+0

ATTENZIONE: Quello che devi passare è il 2 ° parametro del tuo overload '~ ='. Significato 'func ~ = (valore: Person, pattern: String) -> Bool { return valore.name == modello }' genererebbe questo errore: ** modello di espressione di tipo 'String' non può corrispondere ai valori di tipo 'Person '** – Honey

1

si può guardare in Define 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 
+0

Questo è bene sapere, ma in realtà non spiega di cosa si tratta. Cosa lo rende uguale a 'true' o' false'? Posso vedere da questo che può essere eseguito contro variabili 'Equitable' dello stesso tipo ma questo non mi dice nulla dell'implementazione. – Fogmeister

3

usa semplicemente una scorciatoia per variare, puoi costruire un intervallo e "~ =" contiene. (altri possono aggiungere ulteriori dettagli teorici, ma il senso è questo). Leggilo come "contiene"

let n: Int = 100 

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

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

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

} 

provare con alcuni valori di n.

è ampiamente utilizzato per esempio in risposta HTTP:

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