मुझे तेजी से अंडरस्कोर की आवश्यकता क्यों है?

Question

Here यह कहते हैं, "ध्यान दें: _ का अर्थ है" मुझे लगता है कि मूल्य के बारे में परवाह नहीं है "", लेकिन जावास्क्रिप्ट से आ रही, मुझे समझ नहीं आता कि क्या मतलब है।

func divmod(_ a: Int, _ b:Int) -> (Int, Int) { 
    return (a/b, a % b) 
} 

print(divmod(7, 3)) 
print(divmod(5, 2)) 
print(divmod(12,4)) 

अंडरस्कोर मैं इसे इस तरह लिखने की किसी भी त्रुटि से बचने के लिए बिना::

func divmod(a: Int, b:Int) -> (Int, Int) { 
    return (a/b, a % b) 
} 

print(divmod(a: 7, b: 3)) 
print(divmod(a: 5, b: 2)) 
print(divmod(a: 12,b: 4)) 

एक ही रास्ता मैं प्रिंट करने के लिए इन कार्यों प्राप्त कर सकते हैं मापदंडों से पहले अंडरस्कोर का उपयोग करके किया गया

मैं इस अंडरस्कोर उपयोग समझ में नहीं आता। कब, मैं इन अंडरस्कोर का उपयोग कैसे और क्यों करूं?

Answer 1

है विभिन्न उपयोग मामलों के लिए कुछ बारीकियों हैं, लेकिन आम तौर पर एक अंडरस्कोर "इस पर ध्यान न दें" का अर्थ है।

---

जब एक नया समारोह घोषणा करते हुए एक अंडरस्कोर स्विफ्ट बताता है कि पैरामीटर कोई लेबल जब कहा जाता है होना चाहिए - यह मामला आप देख रहे हैं है। एक पूर्ण कार्य घोषणा इस तरह दिखती है:

func myFunc(label name: Int) // call it like myFunc(label: 3) 

"लेबल" एक तर्क लेबल है, और जब आप फ़ंक्शन को कॉल करते हैं तो उपस्थित होना चाहिए। (और स्विफ्ट 3 के बाद से, डिफ़ॉल्ट रूप से सभी तर्कों के लिए लेबल आवश्यक हैं।) "नाम" उस तर्क के लिए परिवर्तनीय नाम है जिसे आप फ़ंक्शन के अंदर उपयोग करते हैं। एक छोटा रूप इस तरह दिखता है:

func myFunc(name: Int) // call it like myFunc(name: 3) 

यह एक शॉर्टकट आप दोनों बाह्य तर्क लेबल और आंतरिक पैरामीटर नाम के लिए एक ही शब्द का उपयोग करने देता है। यह func myFunc(name name: Int) के बराबर है।

आप अपने समारोह पैरामीटर लेबल के बिना प्रतिदेय होना चाहते हैं, तो आप कुछ भी नहीं लेबल/नजरअंदाज कर दिया हो बनाने के लिए अंडरस्कोर _ का उपयोग करें। (यदि आप पैरामीटर का उपयोग करने में सक्षम होना चाहते हैं तो उस स्थिति में आपको एक आंतरिक नाम देना होगा।)

func myFunc(_ name: Int) // call it like myFunc(3) 

---

एक काम बयान में एक अंडरस्कोर का अर्थ है "कुछ भी करने के लिए आवंटित नहीं है"। यदि आप एक फ़ंक्शन को कॉल करना चाहते हैं तो आप इसका उपयोग कर सकते हैं जो परिणाम देता है लेकिन लौटाए गए मूल्य की परवाह नहीं करता है।

_ = someFunction() 

या, जैसे लेख में आप के लिए, एक लौट आए टपल का एक तत्व की उपेक्षा से जुड़ा हुआ:

let (x, _) = someFunctionThatReturnsXandY() 

---

जब आप एक बंद है कि कुछ निर्धारित फ़ंक्शन प्रकार लागू करता है लिखते हैं, आप कर सकते हैं कुछ मानकों को अनदेखा करने के लिए अंडरस्कोर का उपयोग करें।

PHPhotoLibrary.performChanges({ /* some changes */ }, 
    completionHandler: { success, _ in // don't care about error 
     if success { print("yay") } 
    }) 

इसी प्रकार, जब एक समारोह है कि एक प्रोटोकॉल को गोद ले या एक सुपर क्लास विधि ओवरराइड करता है की घोषणा, आप _ पैरामीटर के लिए नाम मानकों की अनदेखी करने के लिए उपयोग कर सकते हैं। चूंकि प्रोटोकॉल/सुपरक्लास यह भी परिभाषित कर सकता है कि पैरामीटर में कोई लेबल नहीं है, इसलिए आप पंक्ति में दो अंडरस्कोर भी समाप्त कर सकते हैं।

class MyView: NSView { 
    override func mouseDown(with _: NSEvent) { 
     // don't care about event, do same thing for every mouse down 
    } 
    override func draw(_ _: NSRect) { 
     // don't care about dirty rect, always redraw the whole view 
    } 
} 

---

कुछ हद तक पिछले दो शैलियों से संबंधित: जब एक प्रवाह नियंत्रण निर्माण कि एक स्थानीय चर बांधता का उपयोग कर/निरंतर, आप _ का उपयोग इसे अनदेखा कर सकते हैं।

for _ in 1...20 { // or 0..<20 
    // do something 20 times 
} 

---

आप एक स्विच बयान में टपल मामलों बाध्यकारी रहे हैं, अंडरस्कोर वाइल्डकार्ड के रूप में काम कर सकते हैं, इस में के रूप में: उदाहरण के लिए, आप अपने सदस्यों के लिए उपयोग की जरूरत के बिना एक दृश्य पुनरावृति करना चाहते हैं उदाहरण (The Swift Programming Language में से एक से छोटा):

switch somePoint { // somePoint is an (Int, Int) tuple 
case (0, 0): 
    print("(0, 0) is at the origin") 
case (_, 0): 
    print("(\(somePoint.0), 0) is on the x-axis") 
case (0, _): 
    print("(0, \(somePoint.1)) is on the y-axis") 
default: 
    print("(\(somePoint.0), \(somePoint.1)) isn't on an axis") 
} 

Answer 2

स्विफ्ट 3 के बाद से, समारोह कॉल पर पैरामीटर नाम निर्दिष्ट करने अनिवार्य बन गया है - यहां तक ​​कि पहले के लिए। तो, क्योंकि है कि तेजी से 2 में लिखे कोड को भारी समस्या का कारण बन सकता है, तो आप एक अंडरस्कोर घोषणा पर फोन पर पैरामीटर नाम लिखने के लिए होने को रोकने के लिए उपयोग कर सकते हैं। तो इस मामले में, यह कह रहा है "बाहरी पैरामीटर नाम की परवाह नहीं है"। जहां बाहरी पैरामीटर नाम वह है जिसे आप फ़ंक्शन (कॉल पर) के अंदर पैरामीटर कहते हैं, अंदर नहीं। इन बाहरी पैरामीटर नामों को तर्क लेबल कहा जाता है। http://ericasadun.com/2016/02/09/the-trouble-with-argument-labels-some-thoughts/ ... देखें कि पैरामीटर को दो नाम दिए गए हैं? अच्छी तरह से पहला है जहां अंडरस्कोर जा रहा है। उम्मीद है कि यह मदद करता है, और पूछें कि अभी भी उलझन में है या नहीं।

Answer 3

func divmod(_ a: Int, _ b:Int) -> (Int, Int) { 
    return (a/b, a % b) 
} 

func divmod(a: Int, b:Int) -> (Int, Int) { 
    return (a/b, a % b) 
} 

_ पैरामीटर नाम के लिए एक प्लेसहोल्डर है। दूसरे उदाहरण में, आप उन्हें अलग-अलग कॉल करते हैं, आपको पैरामीटर नाम a: 1 लिखना होगा।

स्विफ्ट का फ़ंक्शन नाम सम्मेलन funcName(param1:param2:) है, और इसे फ़ंक्शन का नाम बनाने के लिए प्लेसहोल्डर के रूप में _ की आवश्यकता है।

पहला नाम में, नाम

divmod(_:_:) 

जबकि दूसरा

divmod(a:b:)