swift - स्विफ्ट भाषा में एम्परसेंड(&) का क्या अर्थ है?




ampersand inout (3)

इसका मतलब है कि यह एक इन-आउट चर है। आप उस चर के साथ सीधे कुछ कर सकते हैं। इसे पते से पारित किया जाता है, कॉपी के रूप में नहीं।

उदाहरण के लिए:

var temp = 10
func add(inout a: Int){
    a++
}
add(&temp)
temp // 11

मैं एक छोटे से ऑपरेशन के रूप में एम्परसेंड के बारे में जानता हूं लेकिन कभी-कभी मैं इसे चर नामों के सामने देखता हूं। वेरिएबल्स के सामने a & डाल क्या करता है?


जैसा कि अन्य उत्तरों में उल्लेख किया गया है, आप उपसर्ग का उपयोग करते हैं & किसी विधि या फ़ंक्शन कॉल के inout पैरामीटर के मान को पास करने के लिए, जैसा कि फ़ंक्शंस> फ़ंक्शन तर्क लेबल और पैरामीटर नाम> इन-आउट पैरामीटर्स इन द स्विफ्टिंग भाषा । लेकिन इसके अलावा भी बहुत कुछ है।

व्यवहार में, आप स्विफ्ट inout मापदंडों के बारे में सोच सकते हैं और उन्हें C या C ++ पास-बाय-एड्रेस या पास-बाय-रेफरेंस के समान मान सकते हैं। वास्तव में, कंपाइलर लगभग एक ही मैकेनिक्स (खासकर जब आप आयातित C या ObjC API को कॉल कर रहे हैं जो पॉइंटर्स में डील करते हैं) के लिए inout पैरामीटर के कई उपयोगों को ऑप्टिमाइज़ करेंगे। हालाँकि, वे केवल अनुकूलन हैं - एक अर्थ स्तर पर, inout वास्तव में आसपास के पते पास नहीं करता है, जो इस भाषा को और अधिक लचीला और शक्तिशाली बनाने के लिए संकलक को मुक्त करता है।

उदाहरण के लिए, यहां एक ऐसी संरचना है जो अपने गुणों में से एक तक पहुँच को मान्य करने के लिए एक आम रणनीति का उपयोग करती है:

struct Point {
    private var _x: Int
    var x: Int {
        get {
            print("get x: \(_x)")
            return _x
        }
        set {
            print("set x: \(newValue)")
            _x = newValue
        }
    }
    // ... same for y ...
    init(x: Int, y: Int) { self._x = x; self._y = y }
}

("वास्तविक" कोड में, x लिए गेट्टर और सेटर न्यूनतम / अधिकतम मूल्यों को लागू करने जैसी चीजें कर सकता है। या x अन्य कम्प्यूटेड-प्रॉपर्टी ट्रिक्स कर सकता है, जैसे हुड के तहत एक SQL डेटाबेस से बात कर रहा है। यहां हम सिर्फ कॉल और कहते हैं। अंतर्निहित निजी संपत्ति प्राप्त करें / सेट करें।)

अब, जब हम x को inout पैरामीटर से गुजरते हैं तो क्या होता है?

func plusOne(num: inout Int) {
    num += 1
}

var pt = Point(x: 0, y: 1)
plusOne(num: &pt.x)
// prints:
//   get x: 0
//   set x: 1

इसलिए, भले ही x एक गणना की गई संपत्ति है, इसे "संदर्भ द्वारा" एक inout पैरामीटर का उपयोग करके पास करना उसी तरह से काम करता है जैसा कि आप यह उम्मीद करेंगे कि x एक संग्रहीत संपत्ति या स्थानीय चर था।

इसका मतलब है कि आप "संदर्भ द्वारा" सभी प्रकार की चीजों को पारित कर सकते हैं जिन्हें आप C / C ++ / ObjC में भी नहीं मान सकते। उदाहरण के लिए, मानक लाइब्रेरी swap फ़ंक्शन पर विचार करें, जो किसी भी दो को लेता है ... "चीजें" और उनके मूल्यों को स्विच करता है:

var a = 1, b = 2
swap(&a, &b)
print(a, b) // -> 2 1

var dict = [ "Malcolm": "Captain", "Kaylee": "Mechanic" ]
swap(&dict["Malcolm"], &dict["Kaylee"])
print(dict) // -> ["Kaylee": "Captain", "Malcolm": "Mechanic"], fanfic ahoy

let window1 = NSWindow()
let window2 = NSWindow()
window1.title = "window 1"
window2.title = "window 2"
var windows = [window1, window2]
swap(&windows[0], &windows[1])
print(windows.map { $0.title }) // -> ["window 2", "window 1"]

जिस तरह से inout काम करता है, वह आपको मजेदार चीजें करने देता है जैसे नेस्टेड कॉल चेन पर += ऑपरेटर का उपयोग करना:

window.frame.origin.x += 10

... जो CGRect विघटित करने की तुलना में एक अलग x समन्वय के साथ एक नया निर्माण करने के लिए पूरी तरह से सरल है।

inout व्यवहार का यह अधिक बारीक संस्करण, जिसे "कॉल वैल्यू रिजल्ट" कहा जाता है, और यह जिस तरह से सी-स्टाइल को "एड्रेस द्वारा पास" व्यवहार के लिए अनुकूलित कर सकता है, घोषणाओं के तहत कवर किया गया है भाषा


यह वेरिएबल को इन-आउट पैरामीटर बनाने के लिए एक inout रूप में काम करता है। इन-आउट का अर्थ वास्तव में संदर्भ द्वारा मान से गुजरना है, मूल्य से नहीं। और इसे केवल संदर्भ द्वारा मान को स्वीकार करने की आवश्यकता नहीं है, इसे संदर्भ द्वारा पारित करने के लिए, इसलिए इसे केवल foo(myVar) बजाय & - foo(&myVar) साथ पास करें

जैसा कि आप देख सकते हैं कि आप स्विफ्ट में त्रुटि को सौंपने में उपयोग कर सकते हैं, जहां आपको एक त्रुटि संदर्भ बनाना होगा और इसका उपयोग करके फ़ंक्शन को पास करना होगा & फ़ंक्शन त्रुटि मान को पॉप्युलेट करेगा यदि कोई त्रुटि उत्पन्न होती है या चर को वापस पारित करता है जैसा कि पहले था।

हम इसका उपयोग क्यों करते हैं? कभी-कभी एक फ़ंक्शन पहले से ही अन्य मानों को लौटाता है और बस एक दूसरे को (एक त्रुटि की तरह) वापस करना भ्रामक होगा, इसलिए हम इसे एक निष्कासन के रूप में पास करते हैं। अन्य बार हम चाहते हैं कि फ़ंक्शन फ़ंक्शन द्वारा पॉप्युलेट किए जाएं, इसलिए हमें बहुत सारे रिटर्न वैल्यूज़ पर पुनरावृति नहीं करनी है, क्योंकि फ़ंक्शन ने पहले ही हमारे लिए किया था - अन्य संभावित उपयोगों के बीच।

मुझे उम्मीद है कि उससे आप मदद मिलती है!







inout