स्विफ्ट में एक टुकड़ा क्या है?

Question 1

स्विफ्ट में एक टुकड़ा क्या है और यह एक सरणी से कैसे भिन्न होता है?

प्रलेखन से, सबस्क्रिप्ट (रेंज) का प्रकार हस्ताक्षर है:

subscript(Range<Int>) -> Slice<T>

एक के Array<T>बजाय दूसरा क्यों नहीं लौटा Slice<T>?

ऐसा लगता है कि मैं एक सरणी के साथ एक टुकड़ा कर सकते हैं:

var list = ["hello", "world"]
var slice: Array<String> = [] + list[0..list.count]

लेकिन यह त्रुटि पैदा करता है:

प्रदत्त तर्कों को स्वीकार करने वाले 'सबस्क्रिप्ट' के लिए अधिभार नहीं मिला

var list = ["hello", "world"]
var slice: Array<String> = list[0..list.count]

एक टुकड़ा क्या है?

Question 2

टुकड़ा सरणी में इंगित करता है। जब कोई सरणी पहले से मौजूद है तो कोई अन्य सरणी नहीं बना सकता है और टुकड़ा केवल इसके वांछित भाग का वर्णन कर सकता है।

इसके अतिरिक्त निहित जबरदस्ती का कारण बनता है, इसलिए यह काम करता है। अपना असाइनमेंट कार्य करने के लिए, आपको ज़बरदस्ती करनी होगी:

var list = ["hello", "world"]
var slice: Array<String> = Array(list[0..<list.count])

Question 3

नोट: यह उत्तर स्विफ्ट बीटा 3 के रूप में खुशी से अमान्य है, क्योंकि सरणियाँ अब सही मूल्य प्रकार हैं।

@matt सही है, ऊपर - Slice<T>सरणी में बिंदु। जिस तरह से स्विफ्ट हमारे साथ काम कर रहे अन्य सभी प्रकार के डेटा को संभालती है, उसके विपरीत लगता है, क्योंकि इसका मतलब है कि स्लाइस का मूल्य बदल सकता है, भले ही इसे एक स्थिर के रूप में घोषित किया गया हो:

var arr = ["hello", "world", "goodbye"]    // ["hello", "world", "goodbye"]
let slice = arr[0..2]                      // ["hello", "world"]
arr[0] = "bonjour"
println(slice)                             // ["bonjour", "world"]

सबसे बुरी बात यह है कि टुकड़ा एक सरणी की तरह काम करता है। यह देखते हुए कि स्विफ्ट में हमारे पास अपरिवर्तनीयता की उम्मीद है यह खतरनाक लगता है कि स्लाइस के उप-निर्धारक मान बिना किसी चेतावनी के बदल सकते हैं:

println(slice[1])                          // "world"
arr[1] = "le monde"
println(slice[1])                          // "le monde"

लेकिन अगर अंतर्निहित सरणी बहुत तेजी से बदलती है, तो वे अप्रकाशित हो जाते हैं:

arr.removeAtIndex(0)                       // this detaches slice from arr
println(slice)                             // ["bonjour", "le monde"]
arr[0] = "hola"
println(slice)                             // ["bonjour", "le monde"]

Question 4

सारांश:

उपरोक्त उत्तर बीटा 3 तक सही थे (और भविष्य के रिलीज में फिर से बदल सकते हैं)

स्लाइस अब केवल एक सरणी की तरह काम करता है, लेकिन जैसा @ मट्ट ने ऊपर कहा, प्रभावी रूप से हुड के नीचे एक सरणी के लिए एक उथले प्रतिलिपि है, जब तक कि एक बदलाव नहीं किया जाता है। स्लाइस (अब) मूल मूल्यों का एक स्नैपशॉट देखें,

यह भी ध्यान दें कि स्लाइस सिंटैक्स बदल गया है:

[from..upToButNotIncluding] -> [from..<upToButNotIncluding]

उदाहरण:

var arr = ["hello", "world", "goodbye"] // ["hello", "world", "goodbye"]
var arrCopy = arr
let slice = arr[0..<2]                  // ["hello", "world"]
arr[0] = "bonjour"
arr                                     // ["bonjour", "world", "goodbye"]
arrCopy                                 // ["hello", "world", "goodbye"]
slice                                   // ["hello", "world"]

यह बहुत अधिक समान प्रसंस्करण की अनुमति देता है, क्योंकि यह अजगर की सूची सूची प्रसंस्करण के लिए सरल (IMHO) है - दूसरे को बनाने के लिए एक सूची को छानना। बीटा 3 से पहले मैट के जवाब के अनुसार, आपको एक स्लाइस को मैप करने के लिए एक अस्थायी सरणी बनानी होगी। नया कोड अब सरल है:

class NameNumber {
    var name:String = ""
    var number:Int = 0

    init (name:String, number:Int) {
        self.name = name
        self.number = number
    }
}

var number = 1
let names = ["Alan", "Bob", "Cory", "David"]
let foo = names[0..<2].map { n in NameNumber(name:n, number:number++) }
foo     // [{name "Alan" number 1}, {name "Bob" number 2}]

(हालांकि निष्पक्ष होने के लिए, फू अभी भी एक टुकड़ा है)

संदर्भ:

http://adcdownload.apple.com//Developer_Tools/xcode_6_beta_3_lpw27r/xcode_6_beta_3_release_notes__.pdf

महत्वपूर्ण परिवर्तन, जारी किए गए मुद्दे, - स्विफ्ट भाषा, अनुच्छेद 1

"स्विफ्ट में ऐरे को डिक्शनरी और स्ट्रिंग ... एम" जैसे पूर्ण मूल्य शब्दार्थ के लिए पूरी तरह से नया रूप दिया गया है।