Swift Language
स्विच

पैरामीटर

टिप्पणियों

मूल उपयोग

let number = 3
switch number {
case 1:
    print("One!")
case 2:
    print("Two!")
case 3:
    print("Three!")
default:
    print("Not One, Two or Three")
}

स्विच स्टेटमेंट पूर्णांक के अलावा अन्य डेटा प्रकारों के साथ भी काम करते हैं। वे किसी भी डेटा प्रकार के साथ काम करते हैं। वे एक स्ट्रिंग पर स्विच करने का एक उदाहरण हैं:

let string = "Dog"
switch string {
case "Cat", "Dog":
  print("Animal is a house pet.")
default:
  print("Animal is not a house pet.")
}

यह निम्नलिखित प्रिंट करेगा:

Animal is a house pet.

कई मान मिलान

स्विच स्टेटमेंट में एक एकल मामला कई मूल्यों पर मेल खा सकता है।

let number = 3
switch number {
case 1, 2:
    print("One or Two!")
case 3:
    print("Three!")
case 4, 5, 6:
    print("Four, Five or Six!")
default:
    print("Not One, Two, Three, Four, Five or Six")
}

एक सीमा से मेल खाना

स्विच स्टेटमेंट में एक एकल मामला कई मानों को मिला सकता है।

let number = 20
switch number {
case 0:
    print("Zero")
case 1..<10:
    print("Between One and Ten")
case 10..<20:
    print("Between Ten and Twenty")
case 20..<30:
    print("Between Twenty and Thirty")
default:
    print("Greater than Thirty or less than Zero")
}

एक स्विच में जहां कथन का उपयोग करना

सकारात्मक बयान के लिए आवश्यक अतिरिक्त मानदंड जोड़ने के लिए स्विच केस मैच के भीतर जहां कथन का उपयोग किया जा सकता है। निम्न उदाहरण न केवल सीमा के लिए जाँच करता है, बल्कि यह भी है कि संख्या विषम है या नहीं:

switch (temperature) {
      case 0...49 where temperature % 2 == 0:
        print("Cold and even")

      case 50...79 where temperature % 2 == 0:
        print("Warm and even")

      case 80...110 where temperature % 2 == 0:
        print("Hot and even")

      default:
        print("Temperature out of range or odd")
}

स्विच का उपयोग करके कई बाधाओं में से एक को संतुष्ट करें

आप एक tuple बना सकते हैं और एक स्विच का उपयोग कर सकते हैं जैसे:

var str: String? = "hi"
var x: Int? = 5

switch (str, x) {
case (.Some,.Some):
    print("Both have values")
case (.Some, nil):
    print("String has a value")
case (nil, .Some):
    print("Int has a value")
case (nil, nil):
    print("Neither have values")
}

आंशिक मिलान

स्विच स्टेटमेंट आंशिक मिलान का उपयोग करते हैं।

let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)

switch (coordinates) {
case (0, 0, 0): // 1
  print("Origin")
case (_, 0, 0): // 2
  print("On the x-axis.")
case (0, _, 0): // 3
  print("On the y-axis.")
case (0, 0, _): // 4
  print("On the z-axis.")
default:        // 5
  print("Somewhere in space")
}

1. उस मामले से बिल्कुल मेल खाता है जहां मान (0,0,0) है। यह 3 डी अंतरिक्ष की उत्पत्ति है।
2. Y = 0, z = 0 और x के किसी भी मान से मेल खाता है। इसका मतलब है कि x- अक्ष पर समन्वय है।
3. X = 0, z = 0 से मेल खाता है और y का कोई भी मान है। इसका मतलब है कि वे अक्ष पर हैं।
4. X = 0, y = 0 और z के किसी भी मान से मेल खाता है। इसका मतलब है कि निर्देशांक z- अक्ष पर है।
5. शेष निर्देशांक से मेल खाता है।

नोट: अंडरस्कोर का उपयोग करने का मतलब है कि आप मूल्य के बारे में परवाह नहीं करते हैं।

यदि आप मूल्य को अनदेखा नहीं करना चाहते हैं, तो आप इसे अपने स्विच स्टेटमेंट में उपयोग कर सकते हैं, जैसे:

let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)

switch (coordinates) {
case (0, 0, 0):
  print("Origin")
case (let x, 0, 0):
  print("On the x-axis at x = \(x)")
case (0, let y, 0):
  print("On the y-axis at y = \(y)")
case (0, 0, let z):
  print("On the z-axis at z = \(z)")
case (let x, let y, let z):
  print("Somewhere in space at x = \(x), y = \(y), z = \(z)")
}

यहां, अक्ष के मामले लंबित मानों को बाहर निकालने के लिए सिंटैक्स का उपयोग करते हैं। कोड तब स्ट्रिंग इंटरपोलेशन का उपयोग करके स्ट्रिंग बनाने के लिए मानों को प्रिंट करता है।

नोट: आपको इस स्विच स्टेटमेंट में डिफ़ॉल्ट की आवश्यकता नहीं है। ऐसा इसलिए है क्योंकि अंतिम मामला मूल रूप से डिफ़ॉल्ट है - यह किसी भी चीज से मेल खाता है, क्योंकि ट्यूपल के किसी भी हिस्से पर कोई बाधा नहीं है। यदि स्विच स्टेटमेंट अपने मामलों के साथ सभी संभावित मूल्यों को समाप्त कर देता है, तो कोई डिफ़ॉल्ट आवश्यक नहीं है।

हम अधिक जटिल मामलों का मिलान करने के लिए लेट-सिंटैक्स का भी उपयोग कर सकते हैं। उदाहरण के लिए:

let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)

switch (coordinates) {
case (let x, let y, _) where y == x:
  print("Along the y = x line.")
case (let x, let y, _) where y == x * x:
  print("Along the y = x^2 line.")
default:
break
}

यहां, हम "y बराबर x" और "y बराबर x वर्ग" लाइनों से मेल खाते हैं।

परित्याग स्विच

यह ध्यान देने योग्य है कि तेजी से, अन्य भाषाओं के विपरीत जो लोग परिचित हैं, प्रत्येक केस स्टेटमेंट के अंत में एक अंतर्निहित विराम है। आदेश अगले मामले के माध्यम से पालन करने के लिए आप उपयोग करने की आवश्यकता (यानी कई मामलों पर अमल किया है) fallthrough बयान।

switch(value) {
case 'one':
    // do operation one
    fallthrough
case 'two':
    // do this either independant, or in conjunction with first case
default:
    // default operation
}

यह स्ट्रीम जैसी चीजों के लिए उपयोगी है।

स्विच और एनम

स्विच स्टेटमेंट Enum मान के साथ बहुत अच्छी तरह से काम करता है

enum CarModel {
    case Standard, Fast, VeryFast
}

let car = CarModel.Standard

switch car {
case .Standard: print("Standard")
case .Fast: print("Fast")
case .VeryFast: print("VeryFast")
}

चूंकि हमने कार के प्रत्येक संभावित मूल्य के लिए एक मामला प्रदान किया है, इसलिए हम default मामले को छोड़ देते हैं।

स्विच और वैकल्पिक

कुछ उदाहरण मामलों में जब परिणाम एक वैकल्पिक होता है।

var result: AnyObject? = someMethod()

switch result {
case nil:
    print("result is nothing")
case is String:
    print("result is a String")
case _ as Double:
    print("result is not nil, any value that is a Double")
case let myInt as Int where myInt > 0:
    print("\(myInt) value is not nil but an int and greater than 0")
case let a?:
    print("\(a) - value is unwrapped")
}

स्विच और ट्यूपल्स

स्विच ट्यूपल्स पर स्विच कर सकते हैं:

public typealias mdyTuple = (month: Int, day: Int, year: Int)

let fredsBirthday =   (month: 4, day: 3, year: 1973)




switch theMDY
{
//You can match on a literal tuple:
case (fredsBirthday):
  message = "\(date) \(prefix) the day Fred was born"

//You can match on some of the terms, and ignore others:
case (3, 15, _):
  message = "Beware the Ides of March"

//You can match on parts of a literal tuple, and copy other elements
//into a constant that you use in the body of the case:
case (bobsBirthday.month, bobsBirthday.day, let year) where year > bobsBirthday.year:
  message = "\(date) \(prefix) Bob's \(possessiveNumber(year - bobsBirthday.year))" +
    "birthday"

//You can copy one or more elements of the tuple into a constant and then
//add a where clause that further qualifies the case:
case (susansBirthday.month, susansBirthday.day, let year) 
  where year > susansBirthday.year:
  message = "\(date) \(prefix) Susan's " +
    "\(possessiveNumber(year - susansBirthday.year)) birthday"

//You can match some elements to ranges:.
case (5, 1...15, let year):
  message = "\(date) \(prefix) in the first half of May, \(year)"
}

वर्ग के आधार पर मिलान - तैयारी के लिए महान

आप जिस चीज़ पर स्विच कर रहे हैं, उसके वर्ग के आधार पर आप एक स्विच स्टेटमेंट स्विच भी बना सकते हैं।

एक उदाहरण जहां यह उपयोगी है, prepareForSegue । मैं सेग पहचानकर्ता के आधार पर स्विच करता था, लेकिन यह नाजुक है। यदि आप बाद में अपना स्टोरीबोर्ड बदलते हैं और segue पहचानकर्ता का नाम बदल देते हैं, तो यह आपके कोड को तोड़ देता है। या, यदि आप कई उदाहरणों में एक ही दृश्य नियंत्रक वर्ग (लेकिन अलग-अलग स्टोरीबोर्ड दृश्यों) के लिए सेगमेंट का उपयोग करते हैं तो आप गंतव्य के वर्ग का पता लगाने के लिए सेग पहचानकर्ता का उपयोग नहीं कर सकते हैं।

बचाव के लिए स्विफ्ट स्टेटमेंट।

case let var as Class सिंटैक्स के case let var as Class स्विफ्ट case let var as Class उपयोग करें, जैसे:

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
  switch segue.destinationViewController {
    case let fooViewController as FooViewController:
      fooViewController.delegate = self

    case let barViewController as BarViewController:
      barViewController.data = data

    default:
      break
  }
}

override func prepare(for segue: UIStoryboardSegue, sender: AnyObject?) {       
  switch segue.destinationViewController {
    case let fooViewController as FooViewController:
      fooViewController.delegate = self

    case let barViewController as BarViewController:
      barViewController.data = data

    default:
      break
  }
}