जब हम स्प्रिंग

Question

में एकाधिक मान वापस करने के लिए सरणी का उपयोग कर सकते हैं तो टुपल्स का उपयोग क्यों करें आज मैं कुछ मूलभूत अवधारणाओं के माध्यम से जा रहा था और उन अवधारणाओं को समझने के लिए कुछ उदाहरणों के साथ काम कर रहा था। अभी मैंने टुपल्स का अध्ययन पूरा कर लिया है।

मुझे एक संदेह है i.e, tuples का उपयोग करने की आवश्यकता क्या है? हां मैंने यहां कुछ खुदाई की है जो मुझे मिली:

हम किसी फ़ंक्शन से कई मान वापस करने में सक्षम हो सकते हैं। ठीक है लेकिन हम एक सरणी लौटकर भी ऐसा कर सकते हैं।

ऐरे ठीक है लेकिन हम विभिन्न प्रकार के कई मान वापस कर सकते हैं। ठीक है शांत लेकिन यह भी AnyObject की सरणी से इस तरह किया जा सकता है:

func calculateStatistics (scores:[Int])->[AnyObject] 
{ 
    var min = scores[0] 
    var max = scores[0] 
    var sum = 0 

    for score in scores 
    { 
     if score > max{ 
      max = score 
     } 
     else if score < min{ 
      min = score 
     } 
     sum += score 
    } 
    return [min,max,"Hello"] 
} 

let statistics = calculateStatistics([25,39,78,66,74,80]) 

var min = statistics[0] 
var max = statistics[1] 
var msg = statistics[2] // Contains hello 

हम वस्तुओं tuples में मौजूद नाम कर सकते हैं। ठीक है लेकिन मैं AnyObject के शब्दकोश का उपयोग कर सकता हूं।

मैं यह नहीं कह रहा हूं कि जब हमें यह मिल गया तो टुपल्स का उपयोग क्यों करें। लेकिन कुछ ऐसा होना चाहिए जो केवल टुपल करने में सक्षम हो या केवल टुपल्स के साथ ऐसा करना आसान हो। इसके अलावा, जो लोग अच्छे कारण नहीं थे, वे तेजी से झुकाव में शामिल नहीं होते थे। इसलिए उनमें शामिल होने के लिए कुछ अच्छा कारण होना चाहिए था।

तो कृपया मुझे बताएं कि क्या कोई विशिष्ट मामला है जहां टुपल्स सर्वश्रेष्ठ शर्त हैं।

अग्रिम धन्यवाद।

Answer 1

टुपल्स अज्ञात structs हैं जिनका उपयोग कई तरीकों से किया जा सकता है, और उनमें से एक फ़ंक्शन से कई मानों को वापस करना आसान है।

एक सरणी के बजाय एक टपल का उपयोग कर के लाभ हैं:

• अनेक प्रकार के एक टपल में संग्रहित किया जा सकता है, जबकि एक सरणी में आप केवल (जब तक आप [AnyObject] का उपयोग करें)
एक प्रकार तक ही सीमित हैं मूल्यों की
• निश्चित संख्या: आप कम या अधिक मापदंडों उम्मीद से पारित नहीं हो सकता है, जबकि एक सरणी में आप तर्क
• के किसी भी संख्या डाल दृढ़ता से टाइप किया जा सकता है: विभिन्न प्रकार के मापदंडों गलत पदों में पारित कर रहे हैं, संकलक की पहचान करेगा कि , जबकि एक सरणी का उपयोग करना जो
01 नहीं होगा
• रिफैक्टरिंग: यदि पैरामीटर या उनके प्रकार, परिवर्तन की संख्या, संकलक, एक प्रासंगिक संकलन त्रुटि का उत्पादन जबकि सरणियों के साथ कि पारित करेंगे होगा किसी का ध्यान नहीं
• नामित: यह प्रत्येक पैरामीटर

• के साथ एक नाम संबद्ध करने के लिए संभव है काम अधिक आसान और सुविधाजनक है - उदाहरण के लिए, वापसी मान एक टपल को सौंपा जा सकता:

  let tuple = functionReturningTuple() 
  

  या सभी मापदंडों स्वचालित रूप से निकाला जा सकता है और चर करने के लिए सौंपा

  let (param1, param2, param3) = functionReturningTuple() 
  

  और यह समारोह पैरामीटर के साथ कुछ मान

  let (param1, _, _) = functionReturningTuple() 
  

• समानता की अनदेखी करने के लिए संभव है: जब एक समारोह में कहा जाता है, पैरामीटर पारित वास्तव में एक टपल हैं। उदाहरण:

  // SWIFT 2 
  func doSomething(number: Int, text: String) { 
      println("\(number): \(text)") 
  } 
  
  doSomething(1, "one") 
  
  // SWIFT 3  
  func doSomething(number: Int, text: String) { 
      print("\(number): \(text)") 
  } 
  
  doSomething(number: 1, text: "one") 
  

  (स्विफ्ट 2 में पदावनत) समारोह के रूप में भी लागू किया जा सकता है:

  let params = (1, "one") 
  doSomething(params) 
  

इस सूची में शायद संपूर्ण नहीं है, लेकिन मुझे लगता है कि आप tuples के पक्ष में करने के लिए पर्याप्त है एकाधिक मानों को वापस करने के लिए सरणी

Answer 2

ट्यूपल एक डेटास्ट्रक्चर है जो विषम ऐरे की तुलना में हल्का वजन है। यद्यपि वे इंडेक्स द्वारा तत्वों तक पहुंचने में बहुत समान हैं, लेकिन फायदे स्विफ्ट में टुप्स को बहुत आसानी से बनाया जा सकता है। और इस (ट्यूपल) डेटा संरचना को पेश/इंटरपोल करने का इरादा एकाधिक रिटर्न प्रकार है। कम से कम प्रयास के साथ 'कैली' से कई डेटा लौटाना, यह ट्यूपल्स होने का लाभ है। उम्मीद है की यह मदद करेगा!

Answer 3

उदाहरण के लिए, इस सरल उदाहरण पर विचार करें:

enum MyType { 
    case A, B, C 
} 

func foo() -> (MyType, Int, String) { 
    // ... 
    return (.B, 42, "bar") 
} 

let (type, amount, desc) = foo() 

Array का उपयोग करना, एक ही परिणाम प्राप्त करने के लिए, तो आप इस करना है:

func foo() -> [Any] { 
    // ... 
    return [MyType.B, 42, "bar"] 
} 

let result = foo() 
let type = result[0] as MyType, amount = result[1] as Int, desc = result[2] as String 

टपल बहुत सरल और सुरक्षित है, 'isn यह नहीं है?