Swift Language
tuples

परिचय

टिप्पणियों

ट्यूपल क्या हैं?

टुपल्स एक यौगिक मूल्य में कई मानों को समूहित करता है। टपल के भीतर के मान किसी भी प्रकार के हो सकते हैं और एक दूसरे के समान प्रकार के नहीं होते हैं।

मूल्यों की किसी भी राशि को समूहीकृत करके टुपल्स बनाए जाते हैं:

let tuple = ("one", 2, "three")

// Values are read using index numbers starting at zero
print(tuple.0) // one
print(tuple.1) // 2
print(tuple.2) // three

जब टपल को परिभाषित किया जाता है तब भी व्यक्तिगत मूल्यों का नाम दिया जा सकता है:

let namedTuple = (first: 1, middle: "dos", last: 3)

// Values can be read with the named property
print(namedTuple.first)  // 1
print(namedTuple.middle) // dos

// And still with the index number
print(namedTuple.2)      // 3

उन्हें एक चर के रूप में उपयोग किए जाने पर भी नाम दिया जा सकता है और यहां तक कि अंदर वैकल्पिक मान रखने की क्षमता भी है:

var numbers: (optionalFirst: Int?, middle: String, last: Int)?

//Later On
numbers = (nil, "dos", 3)

print(numbers.optionalFirst)// nil
print(numbers.middle)//"dos"
print(numbers.last)//3

व्यक्तिगत चरों में विघटित होना

निम्न सिंटैक्स के साथ ट्यूल को अलग-अलग चर में विघटित किया जा सकता है:

let myTuple = (name: "Some Name", age: 26)
let (first, second) = myTuple

print(first) // "Some Name"
print(second)  // 26

इस सिंटैक्स का उपयोग किया जा सकता है, भले ही टपल में अनाम गुण हों:

let unnamedTuple = ("uno", "dos")
let (one, two) = unnamedTuple
print(one) // "uno"
print(two) // "dos"

अंडरस्कोर ( _ ) का उपयोग करके विशिष्ट गुणों को अनदेखा किया जा सकता है:

let longTuple = ("ichi", "ni", "san")
let (_, _, third) = longTuple
print(third) // "san"

कार्य के रिटर्न मान के रूप में ट्यूपल्स

कार्य टपल वापस कर सकते हैं:

func tupleReturner() -> (Int, String) {
    return (3, "Hello")
}

let myTuple = tupleReturner()
print(myTuple.0) // 3
print(myTuple.1) // "Hello"

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

func tupleReturner() -> (anInteger: Int, aString: String) {
    return (3, "Hello")
}

let myTuple = tupleReturner()
print(myTuple.anInteger) // 3
print(myTuple.aString) // "Hello"

अपने tuple प्रकार को नाम देने के लिए एक टाइपेलियास का उपयोग करना

कभी-कभी आप अपने कोड में कई स्थानों पर एक ही प्रकार के टपल का उपयोग करना चाह सकते हैं। यह जल्दी से गन्दा हो सकता है, खासकर अगर आपका टपल जटिल है:

// Define a circle tuple by its center point and radius
let unitCircle: (center: (x: CGFloat, y: CGFloat), radius: CGFloat) = ((0.0, 0.0), 1.0)

func doubleRadius(ofCircle circle: (center: (x: CGFloat, y: CGFloat), radius: CGFloat)) -> (center: (x: CGFloat, y: CGFloat), radius: CGFloat) {
    return (circle.center, circle.radius * 2.0)
}

यदि आप एक से अधिक स्थानों पर एक निश्चित प्रकार का उपयोग करते हैं, तो आप अपने tuple प्रकार को नाम देने के लिए typealias कीवर्ड का उपयोग कर सकते हैं।

// Define a circle tuple by its center point and radius
typealias Circle = (center: (x: CGFloat, y: CGFloat), radius: CGFloat)

let unitCircle: Circle = ((0.0, 0.0), 1)

func doubleRadius(ofCircle circle: Circle) -> Circle {
    // Aliased tuples also have access to value labels in the original tuple type.
    return (circle.center, circle.radius * 2.0)
}

यदि आप स्वयं को ऐसा करते हुए पाते हैं, तो आपको इसके बजाय एक struct का उपयोग करने पर विचार करना चाहिए।

स्वैपिंग मान

अस्थायी वेरिएबल का उपयोग किए बिना टुपल्स 2 (या अधिक) चर के बीच मूल्यों को स्वैप करने के लिए उपयोगी हैं।

2 चर के साथ उदाहरण

2 चर दिए

var a = "Marty McFly"
var b = "Emmett Brown"

हम आसानी से मूल्यों की अदला-बदली कर सकते हैं

(a, b) = (b, a)

परिणाम:

print(a) // "Emmett Brown" 
print(b) // "Marty McFly"

4 चर के साथ उदाहरण

var a = 0
var b = 1
var c = 2
var d = 3

(a, b, c, d) = (d, c, b, a)

print(a, b, c, d) // 3, 2, 1, 0

स्विच में केस के रूप में ट्यूपल्स

एक स्विच में tuples का उपयोग करें

let switchTuple = (firstCase: true, secondCase: false)
   
switch switchTuple {   
 case (true, false):
    // do something
 case (true, true):
    // do something
 case (false, true):
    // do something
 case (false, false):
    // do something
}

या आकार वर्ग के साथ उदाहरण के लिए एक Enum के साथ संयोजन में:

    let switchTuple = (UIUserInterfaceSizeClass.Compact, UIUserInterfaceSizeClass.Regular)
    
    switch switchTuple {
    case (.Regular, .Compact):
        //statement
    case (.Regular, .Regular):
        //statement
    case (.Compact, .Regular):
        //statement
    case (.Compact, .Compact):
        //statement
    }