स्विफ्ट 2.2 (3.0)

Question

में ऑब्जेक्ट्स की सरणी संशोधित करें, मैं प्रत्येक तत्व के माध्यम से लूप किए बिना फ्लाई स्विफ्ट के map का उपयोग करके ऑब्जेक्ट्स की अपनी सरणी को संशोधित करने में सक्षम होना चाहता हूं।

यहाँ से पहले (कुछ इस तरह अधिक जानकारी के here में वर्णित करने में सक्षम थे:

gnomes = gnomes.map { (var gnome: Gnome) -> Gnome in 
    gnome.age = 140 
    return gnome 
} 

एरिका Sadun के लिए धन्यवाद और अन्य लोगों, नए प्रस्तावों के माध्यम से चले गए हैं और अब हम सी-शैली से छुटकारा पाने रहे हैं छोरों और पाश अंदर var का उपयोग कर।

मेरे मामले में मैं पहली बार तो एक त्रुटि में var दूर करने के लिए एक चेतावनी हो रही है मेरी gnome एक निरंतर है (स्वाभाविक रूप से)

मेरा सवाल है: हम स्विफ्ट 3.0 के लिए पूरी तरह तैयार होने के लिए map या नए स्टाइल लूप के अंदर सरणी कैसे बदल सकते हैं?

Answer 1

आपको लगता है कि वाक्य रचना रखना चाहते हैं, बस एक (परिवर्तनशील) अस्थायी चर

gnomes = gnomes.map { (gnome: Gnome) -> Gnome in 
    var mutableGnome = gnome 
    mutableGnome.age = 140 
    return mutableGnome 
} 

Answer 2

(नीचे इस मामले में जहां Gnome एक संदर्भ प्रकार है इस प्रकार है, एक वर्ग - जब से तुम हमें पता चला है नहीं किया है कि कैसे आप Gnome परिभाषित किया है इस मामले में जहां Gnome मान प्रकार (एक struct) के रूप में, देखने के लिए @। vadian: रों जवाब)

---

var को हटाने संदर्भ प्रकार की वस्तुओं की एक सरणी के परिवर्तनशील सदस्यों उत्परिवर्तित को .map का उपयोग कर लागू नहीं होंगे। यानी, आप बस अपने पुराने दृष्टिकोण का उपयोग कर सकते हैं (हालांकि var.map क्लोजर हस्ताक्षर में छोड़कर)।

class Gnome { 
    var age = 42 
} 

var gnomes = [Gnome(), Gnome(), Gnome()] 

gnomes = gnomes.map { 
    $0.age = 150 
    return $0 
} 

/* result */ 
gnomes.forEach { print($0.age) } // 3x 150 

हालांकि, मामले में आप सिर्फ बल्कि एक नई सरणी के लिए .map का परिणाम बताए से अपने मूल सरणी संशोधित करना चाहते हैं, .forEach.map से अधिक उपयुक्त विकल्प हो सकता है।

gnomes.forEach { $0.age = 140 } 

/* result */ 
gnomes.forEach { print($0.age) } // 3x 140 

Answer 3

को देखते हुए का उपयोग करें:

struct Gnome { 
    var age: Int = 0 
} 

var gnomes = Array(count: 5, repeatedValue: Gnome()) 

... वहाँ दो सभ्य विकल्प हैं।

gnomes = gnomes.map{ 
    var gnome = $0 
    gnome.age = 70 
    return gnome 
} 

दूसरा जबकि "बुढ़ापे" private पर नियंत्रण रखता है और कॉल के बिंदु पर मानचित्रण सरल: पहले के रूप में @vadian डाल दिया है

struct Gnome { 
    private(set) var age: Int = 0 

    func aged(age: Int) -> Gnome { 
     var gnome = self 
     gnome.age = age 
     // any other ageing related changes 
     return gnome 
    } 
} 

gnomes = gnomes.map{ $0.aged(140) } 

बेशक

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