क्या स्विफ्ट में मॉडिफायर्स हैं?

Question

ऑब्जेक्टिव-सी इंस्टेंस में डेटा हो सकता है public, protectedया private। उदाहरण के लिए:

@interface Foo : NSObject
{
  @public
    int x;
  @protected:
    int y;
  @private:
    int z;
  }
-(int) apple;
-(int) pear;
-(int) banana;
@end

मुझे स्विफ्ट संदर्भ में एक्सेस संशोधक का कोई उल्लेख नहीं मिला है। क्या स्विफ्ट में डेटा की दृश्यता को सीमित करना संभव है?

Comments

न ही मैं। सेब को कम से कम निजी लोगों के लिए शिष्टाचार का परिचय देना चाहिए, जैसे अजगर में वे अंडरस्कोर के साथ उपसर्ग करते हैं।

— २१:

Xcode 6.1.1 के अंतिम संस्करण के

— holroy

स्विफ्ट 4 अपडेटेड उत्तर ।

— अहमद एफ

Answer 1

स्विफ्ट 3.0.1 के रूप में , पहुँच के 4 स्तर हैं , सबसे नीचे (सबसे कम प्रतिबंधात्मक) से निम्नतम (सबसे अधिक प्रतिबंधात्मक) तक वर्णित है।

---

1. openऔरpublic

एक इकाई को परिभाषित मॉड्यूल (लक्ष्य) के बाहर उपयोग करने के लिए सक्षम करें। आप सार्वजनिक इंटरफ़ेस को किसी फ़्रेमवर्क में निर्दिष्ट करते समय आमतौर पर उपयोग openया publicएक्सेस करते हैं।

हालाँकि, openपहुँच केवल कक्षाओं और वर्ग के सदस्यों पर लागू होती है , और यह publicनिम्नानुसार पहुँच से भिन्न होती है:

• public कक्षाओं और वर्ग के सदस्यों को केवल परिभाषित मॉड्यूल (लक्ष्य) के भीतर ही उपवर्गित और ओवरराइड किया जा सकता है।
• open कक्षाओं और वर्ग के सदस्यों को परिभाषित मॉड्यूल (लक्ष्य) के भीतर और बाहर दोनों ही उपवर्गित और अधिभूत किया जा सकता है।

// First.framework – A.swift

open class A {}

// First.framework – B.swift

public class B: A {} // ok

// Second.framework – C.swift

import First

internal class C: A {} // ok

// Second.framework – D.swift

import First

internal class D: B {} // error: B cannot be subclassed

2। internal

एक इकाई को परिभाषित मॉड्यूल (लक्ष्य) के भीतर उपयोग करने में सक्षम बनाता है। आप आमतौर पर internalकिसी ऐप या किसी ढांचे की आंतरिक संरचना को परिभाषित करते समय पहुंच का उपयोग करते हैं।

// First.framework – A.swift

internal struct A {}

// First.framework – B.swift

A() // ok

// Second.framework – C.swift

import First

A() // error: A is unavailable

3। fileprivate

किसी इकाई के उपयोग को उसकी परिभाषित स्रोत फ़ाइल में प्रतिबंधित करता है। आप आम तौर पर fileprivateकार्यक्षमता के एक विशिष्ट टुकड़े के कार्यान्वयन के विवरण को छिपाने के लिए उपयोग करते हैं जब उन विवरणों को एक संपूर्ण फ़ाइल के भीतर उपयोग किया जाता है।

// First.framework – A.swift

internal struct A {

    fileprivate static let x: Int

}

A.x // ok

// First.framework – B.swift

A.x // error: x is not available

4। private

एक इकाई के उपयोग को इसके संलग्न घोषणा में प्रतिबंधित करता है। आप आम तौर पर privateकार्यक्षमता के एक विशिष्ट टुकड़े के कार्यान्वयन विवरण को छिपाने के लिए उपयोग करते हैं जब उन विवरणों को केवल एक घोषणा के भीतर उपयोग किया जाता है।

// First.framework – A.swift

internal struct A {

    private static let x: Int

    internal static func doSomethingWithX() {
        x // ok
    }

}

A.x // error: x is unavailable

Comments

क्या कोई मुझे समझा सकता है कि यह एक बड़ी बात क्यों नहीं है?

— ज़ाकी जर्मन

ओओपी में हमेशा कुछ तरीके या चर होते हैं जो निजी या संरक्षित होने चाहिए। यह SOLID डिजाइन को लागू करने की अनुमति देता है , क्योंकि बड़े तरीकों को कई छोटे लोगों को विभाजित किया जाता है, प्रत्येक की अपनी जिम्मेदारी होती है, जिसे ओवरराइड किया जा सकता है, लेकिन केवल "मुख्य" विधि सार्वजनिक उपयोग के लिए उपलब्ध होनी चाहिए।

— अकाशिव्स्की

मैं, व्यक्तिगत रूप से अंडरस्कोर / विशेष-चार प्रमुख "निजी" विधियों के साथ समाधान पसंद नहीं करता हूं। यहां तक ​​कि अगर यह गारंटी दी जाती है कि मैं खुद के लिए इस कोड पर नज़र रखने वाला एकमात्र व्यक्ति होगा, तो यह कोड को अधिक त्रुटियों को कम / कम करता है, जिससे त्रुटियों का कारण बनता है कंपाइलर बस आपको उन चीजों को करने से रोकेगा जो आपको नहीं करना चाहिए। इसलिए मुझे लगता है कि उन्हें जितनी जल्दी हो सके "एक्सेस कंट्रोल मैकेनिज्म" से बाहर निकलना चाहिए, इसलिए लोगों को बुरी आदतों की आदत नहीं होगी।

— जोनास एसचमन

Xcode 6 बीटा रिलीज़ नोट कहते हैं: "एक्सेस कंट्रोल (सार्वजनिक / निजी सदस्य) इस बीज में सक्षम नहीं है। (15747445)"

— मार्टिन

@alcalde एक सार्वजनिक इंटरफ़ेस का विचार अत्यधिक मूल्यवान है। यदि आप चाहते हैं कि किसी वर्ग के सभी कोड सार्वजनिक API का हिस्सा हैं, तो मुझे लगता है कि यह काफी सीमित है। दूसरी ओर, एक निर्दिष्ट सार्वजनिक एपीआई होने से उपभोक्ताओं को बाधित किए बिना कार्यान्वयन को बदलने (निजी तरीकों के उपयोग सहित) की अनुमति मिलती है। अगर किसी को आंतरिक वर्ग विधि का उपयोग करने के लिए 'जरूरत' है तो मुझे लगता है कि वे वर्ग की कार्यक्षमता की सीमाओं को गलत समझ रहे हैं (या एक छोटी कक्षा का उपयोग करने की कोशिश कर रहे हैं)।

— जिंगलथूला

Answer 2

स्विफ्ट 4 / स्विफ्ट 5

स्विफ्ट डॉक्यूमेंटेशन - एक्सेस कंट्रोल में बताए अनुसार स्विफ्ट के 5 एक्सेस कंट्रोल हैं :

• खुला और सार्वजनिक : अपने मॉड्यूल की संस्थाओं और किसी भी मॉड्यूल की संस्थाओं से पहुँचा जा सकता है जो परिभाषित मॉड्यूल को आयात करता है।

• आंतरिक : केवल उनके मॉड्यूल की संस्थाओं से ही पहुँचा जा सकता है। यह डिफ़ॉल्ट एक्सेस स्तर है।

• फ़ाइलपाइप और निजी : केवल एक सीमित दायरे में ही सीमित किया जा सकता है जहाँ आप उन्हें परिभाषित करते हैं।

---

खुले और सार्वजनिक के बीच क्या अंतर है ?

खुला स्विफ्ट के पिछले संस्करणों में सार्वजनिक के समान है, वे अन्य मॉड्यूल से कक्षाओं का उपयोग करने और उन्हें विरासत में देने की अनुमति देते हैं, अर्थात: उन्हें अन्य मॉड्यूल से उपवर्गित किया जा सकता है। साथ ही, वे अन्य मॉड्यूल से सदस्यों को उपयोग करने और उन्हें ओवरराइड करने की अनुमति देते हैं। एक ही तर्क उनके मॉड्यूल के लिए जाता है।

जनता अन्य मॉड्यूल से कक्षाओं का उपयोग करने की अनुमति देती है, लेकिन उन्हें विरासत में नहीं देती है, अर्थात: उन्हें अन्य मॉड्यूल से उपवर्गित नहीं किया जा सकता है। इसके अलावा, वे अन्य मॉड्यूल से सदस्यों को उनका उपयोग करने की अनुमति देते हैं, लेकिन उन्हें ओवरराइड करने के लिए नहीं। अपने मॉड्यूल के लिए, उनके पास समान खुले तर्क हैं (वे कक्षाओं का उपयोग करने और उन्हें विरासत में लेने की अनुमति देते हैं; वे सदस्यों को उनका उपयोग करने और उन्हें ओवरराइड करने की अनुमति देते हैं)।

फ़ाइलपेयर और प्राइवेट में क्या अंतर है ?

फ़ाइलपाइप को उनकी संपूर्ण फ़ाइलों से एक्सेस किया जा सकता है।

निजी को केवल उनकी एकल घोषणा से और उस घोषणा के एक्सटेंशन तक पहुँचा जा सकता है जो एक ही फ़ाइल में हैं; उदाहरण के लिए:

// Declaring "A" class that has the two types of "private" and "fileprivate":
class A {
    private var aPrivate: String?
    fileprivate var aFileprivate: String?

    func accessMySelf() {
        // this works fine
        self.aPrivate = ""
        self.aFileprivate = ""
    }
}

// Declaring "B" for checking the abiltiy of accessing "A" class:
class B {
    func accessA() {
        // create an instance of "A" class
        let aObject = A()

        // Error! this is NOT accessable...
        aObject.aPrivate = "I CANNOT set a value for it!"

        // this works fine
        aObject.aFileprivate = "I CAN set a value for it!"
    }
}

---

स्विफ्ट 3 और स्विफ्ट 4 एक्सेस कंट्रोल के बीच अंतर क्या हैं?

जैसा कि SE-0169 प्रस्ताव में उल्लेख किया गया है, स्विफ्ट 4 में केवल शोधन जोड़ा गया है, निजी एक्सेस कंट्रोल स्कोप को उसी फ़ाइल में उस घोषणा के विस्तार से सुलभ होने के लिए विस्तारित किया गया है ; उदाहरण के लिए:

struct MyStruct {
    private let myMessage = "Hello World"
}

extension MyStruct {
    func printMyMessage() {
        print(myMessage)
        // In Swift 3, you will get a compile time error:
        // error: 'myMessage' is inaccessible due to 'private' protection level

        // In Swift 4 it should works fine!
    }
}

तो, वहाँ घोषित करने के लिए कोई जरूरत नहीं है myMessageके रूप में fileprivate पूरी फ़ाइल में पहुंच योग्य।

Answer 3

जब कोई Swift या ObjC (या माणिक या जावा या…) में "प्राइवेट मेथड" बनाने की बात करता है, तो वे तरीके वास्तव में निजी नहीं होते हैं । उनके आसपास कोई वास्तविक अभिगम नियंत्रण नहीं है। कोई भी भाषा जो थोड़ा सा आत्मनिरीक्षण प्रदान करती है, डेवलपर्स को उन मूल्यों के वर्ग से बाहर जाने देती है यदि वे वास्तव में चाहते हैं।

तो हम वास्तव में यहाँ जिस बारे में बात कर रहे हैं वह एक सार्वजनिक-सामना करने वाले इंटरफ़ेस को परिभाषित करने का एक तरीका है जो केवल उस कार्यक्षमता को प्रस्तुत करता है जिसे हम चाहते हैं, और बाकी को "छुपाता है" जिसे हम "निजी" मानते हैं।

इंटरफेस घोषित करने के लिए स्विफ्ट तंत्र है protocol, और इसका उपयोग इस उद्देश्य के लिए किया जा सकता है।

protocol MyClass {
  var publicProperty:Int {get set}
  func publicMethod(foo:String)->String
}

class MyClassImplementation : MyClass {
  var publicProperty:Int = 5
  var privateProperty:Int = 8

  func publicMethod(foo:String)->String{
    return privateMethod(foo)
  }

  func privateMethod(foo:String)->String{
    return "Hello \(foo)"
  }
}

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

इस प्रकार, जब तक आप अपने पैरामीटर प्रकारों के MyClassबजाय उपयोग MyClassImplementationकरते हैं, आदि तब तक यह सब काम करना चाहिए:

func breakingAndEntering(foo:MyClass)->String{
  return foo.privateMethod()
  //ERROR: 'MyClass' does not have a member named 'privateMethod'
}

प्रत्यक्ष असाइनमेंट के कुछ मामले हैं जहां आपको स्विफ्ट पर भरोसा करने के बजाय इसे टाइप करने के लिए स्पष्ट होना चाहिए, लेकिन यह मुश्किल से एक ब्रेकर लगता है:

var myClass:MyClass = MyClassImplementation()

प्रोटोकॉल का उपयोग करना इस तरह से शब्दार्थ है, यथोचित रूप से संक्षिप्त है, और मेरी आँखों के लिए क्लास एक्स्टेंशन की तरह बहुत कुछ दिखता है जिसका उपयोग हम ओब्जेक्ट में इस उद्देश्य के लिए कर रहे हैं।

Comments

यदि प्रोटोकॉल हमें डिफ़ॉल्ट तर्क की अनुमति नहीं देते हैं, तो मैं वैकल्पिक मापदंडों के साथ एक सार्वजनिक विधि कैसे बना सकता हूं जो अभी भी प्रोटोकॉल का अनुपालन करता है?

— बेदुराओ

मुझे समझ नहीं आ रहा है कि आपका क्या मतलब है। निम्न वैकल्पिक पैरामीटर के साथ एक सार्वजनिक विधि बनाता है। कोई समस्या प्रतीत नहीं होती है: gist.github.com/anonymous/17d8d2d25a78644046b6

— jemmons

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

— भादुरो

हम सभी जानते हैं कि कुछ भी हैक करने योग्य है। हमें बस कुछ आदेशों की आवश्यकता है, जिसके लिए हमें एक्सेस मॉडिफायर्स की आवश्यकता है

— कैनबैक्स

Answer 4

जहां तक ​​मैं बता सकता हूं, कोई भी कीवर्ड 'सार्वजनिक', 'निजी' या 'संरक्षित' नहीं हैं। यह सुझाव देगा कि सब कुछ सार्वजनिक है।

हालांकि Apple लोगों से " प्रोटोकॉल " (शेष दुनिया द्वारा इंटरफेस कहा जाता है) और कारखाने के डिजाइन पैटर्न को लागू करने के प्रकार का विवरण छिपाने के लिए उपयोग करने की उम्मीद कर सकता है ।

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

Comments

यह अच्छा है क्योंकि यह युग्मन को भी कम करता है और परीक्षण को आसान बना सकता है।

— स्क्रूज

अगर प्रोटोकॉल के कार्यान्वयन वर्ग को छिपाने का एक तरीका होता तो बेहतर होता, लेकिन ऐसा प्रतीत नहीं होता।

— डेविड मोल्स

क्या कोई इस पैटर्न का उदाहरण दे सकता है?

— ब्लैडरमिल्क

खैर, यह उत्तर पिछले स्विफ्ट संस्करण (ओं) में मान्य था, ऐसा लगता है कि यह अब मान्य नहीं है :) कृपया मेरे उत्तर की जांच करें ।

— अहमद एफ

Answer 5

प्रोटोकॉल, क्लोजर और नेस्टेड / इनर वर्ग के संयोजन का उपयोग करके, स्विफ्ट में जानकारी छिपाने के लिए मॉड्यूल पैटर्न की तर्ज पर कुछ का उपयोग करना संभव है। यह सुपर साफ या पढ़ने में अच्छा नहीं है, लेकिन यह काम करता है।

उदाहरण:

protocol HuhThing {
  var huh: Int { get set }
}

func HuhMaker() -> HuhThing {
   class InnerHuh: HuhThing {
    var innerVal: Int = 0
    var huh: Int {
      get {
        return mysteriousMath(innerVal)
      }

      set {
       innerVal = newValue / 2
      }
    }

    func mysteriousMath(number: Int) -> Int {
      return number * 3 + 2
    }
  }

  return InnerHuh()
}

HuhMaker()
var h = HuhMaker()

h.huh      // 2
h.huh = 32 
h.huh      // 50
h.huh = 39
h.huh      // 59

इनरव्हील और रहस्यमयमैथ बाहरी उपयोग से यहां छिपे हुए हैं और ऑब्जेक्ट में अपना रास्ता खोदने का प्रयास करने के परिणामस्वरूप त्रुटि हो सकती है।

मैं स्विफ्ट डॉक्स के अपने पढ़ने के माध्यम से रास्ते का ही हिस्सा हूं इसलिए अगर यहां कोई दोष है तो कृपया इसे इंगित करें, यह जानना अच्छा लगेगा।

Comments

ठीक है, मैंने इस समाधान के बारे में भी सोचा, लेकिन मुझे समझाएं, मैं h.huh.innerVal के साथ क्यों नहीं आरोप लगा सकता हूं?

— सैम

स्विफ्ट टाइप-सेफ है और एच के बारे में बाहरी दुनिया को केवल एक चीज पता है कि वह हुहिंगहिंग का अनुपालन करती है। हुहिंगहोंग में इनरवैल नामक संपत्ति के बारे में कोई जानकारी शामिल नहीं है और इसलिए इसे एक्सेस करने का प्रयास एक त्रुटि है।

— डेव कप

अभी भी सुलभ: पीreflect(h)[0].1.value // 19

— जॉन एस्ट्रोपिया

अच्छा लगता है वहाँ जॉन - मैं प्रतिबिंबित के बारे में पता नहीं था। Tuples में वस्तुओं को चालू करने के लिए लगता है - क्या उस फ़ंक्शन या स्विफ्ट में अन्य मेटाप्रोग्रामिंग सामान पर कोई आधिकारिक दस्तावेज है? मैंने iBooks पर भाषा गाइड के माध्यम से एक नज़र डाली, लेकिन मैं इसे नहीं देख रहा हूं।

— डेव कप

@ जॉनोस्ट्रोपिया मुझे नहीं लगता कि प्रतिबिंब मायने रखता है। जावा (एक अधिक भाषा परिपक्व) में, वहाँ रहे हैं पहुँच संशोधक, लेकिन वे या तो प्रतिबिंब चाल को रोकने नहीं है।

— 11684

Answer 6

Xcode 6 बीटा 4 के रूप में, स्विफ्ट के पास संशोधक हैं। जारी नोटों से:

स्विफ्ट एक्सेस कंट्रोल के तीन एक्सेस स्तर हैं:

• निजी संस्थाओं को केवल स्रोत फ़ाइल के भीतर से ही एक्सेस किया जा सकता है जहां वे परिभाषित हैं।
• आंतरिक संस्थाओं को लक्ष्य के भीतर कहीं भी एक्सेस किया जा सकता है जहां उन्हें परिभाषित किया गया है।
• सार्वजनिक संस्थाओं को लक्ष्य के भीतर और वर्तमान लक्ष्य के मॉड्यूल को आयात करने वाले किसी अन्य संदर्भ से कहीं से भी एक्सेस किया जा सकता है।

निहित डिफ़ॉल्ट है internal, इसलिए एक एप्लिकेशन लक्ष्य के भीतर आप एक्सेस मॉडिफ़ाइर्स को छोड़ सकते हैं सिवाय इसके कि आप और अधिक प्रतिबंधक कहां रहना चाहते हैं। एक फ्रेमवर्क लक्ष्य में (जैसे यदि आप किसी ऐप और साझा या आज के दृश्य एक्सटेंशन के बीच कोड साझा करने के लिए एक फ्रेमवर्क एम्बेड कर रहे हैं), publicतो एपीआई का उपयोग करें जिसे आप अपने फ्रेमवर्क के ग्राहकों को उजागर करना चाहते हैं।

Comments

खैर, यह उत्तर पिछले स्विफ्ट संस्करण (ओं) में मान्य था, ऐसा लगता है कि यह अब मान्य नहीं है :) कृपया मेरे उत्तर की जांच करें ।

— अहमद एफ

Answer 7

स्विफ्ट 3.0 पांच अलग-अलग अभिगम नियंत्रण प्रदान करता है:

1. खुला हुआ
2. जनता
3. अंदर का
4. fileprivate
5. निजी

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

आंतरिक पहुंच संस्थाओं को उनके परिभाषित मॉड्यूल से किसी भी स्रोत फ़ाइल के भीतर उपयोग करने में सक्षम बनाता है, लेकिन उस मॉड्यूल के बाहर किसी भी स्रोत फ़ाइल में नहीं। आप आमतौर पर ऐप या फ्रेमवर्क की आंतरिक संरचना को परिभाषित करते समय आंतरिक पहुंच का उपयोग करते हैं।

फ़ाइल-निजी पहुंच एक इकाई के उपयोग को अपने स्वयं के परिभाषित स्रोत फ़ाइल के लिए प्रतिबंधित करती है। कार्यक्षमता के एक विशिष्ट टुकड़े के कार्यान्वयन के विवरण को छिपाने के लिए फ़ाइल-निजी पहुंच का उपयोग करें जब उन विवरणों को एक संपूर्ण फ़ाइल के भीतर उपयोग किया जाता है।

निजी पहुंच एक इकाई के उपयोग को संलग्न घोषणा में प्रतिबंधित करता है। कार्यक्षमता के एक विशिष्ट टुकड़े के कार्यान्वयन विवरण को छिपाने के लिए निजी पहुंच का उपयोग करें जब उन विवरणों को केवल एक घोषणा के भीतर उपयोग किया जाता है।

ओपन एक्सेस उच्चतम (सबसे कम प्रतिबंधात्मक) एक्सेस स्तर है और निजी एक्सेस सबसे कम (सबसे अधिक प्रतिबंधात्मक) एक्सेस स्तर है।

डिफ़ॉल्ट पहुँच स्तर

आपके कोड में सभी इकाइयाँ (कुछ विशिष्ट अपवादों के साथ) यदि आपके पास एक स्पष्ट पहुँच स्तर निर्दिष्ट नहीं है तो आपके पास आंतरिक का एक डिफ़ॉल्ट पहुँच स्तर है। नतीजतन, कई मामलों में आपको अपने कोड में एक स्पष्ट पहुंच स्तर निर्दिष्ट करने की आवश्यकता नहीं है।

विषय पर रिलीज नोट:

सार्वजनिक घोषित की गई कक्षाओं को अब उनके परिभाषित मॉड्यूल के बाहर उप-वर्ग नहीं किया जा सकता है, और सार्वजनिक घोषित किए गए तरीकों को अब उनके परिभाषित मॉड्यूल के बाहर ओवरराइड नहीं किया जा सकता है। किसी वर्ग को बाहरी रूप से उपवर्गित होने की अनुमति देने के लिए या बाहरी तौर पर अतिप्रश्न करने के लिए एक विधि की अनुमति देने के लिए, उन्हें खुले रूप में घोषित करें, जो जनता से परे एक नया पहुंच स्तर है। इंपोर्टेड ऑब्जेक्टिव-सी क्लासेस और तरीके अब सभी पब्लिक के बजाय ओपन के तौर पर इंपोर्ट किए जाते हैं। इकाई परीक्षण जो @testable आयात का उपयोग करके मॉड्यूल का आयात करते हैं, उन्हें अभी भी सार्वजनिक या आंतरिक कक्षाओं के साथ-साथ सार्वजनिक या आंतरिक विधियों को ओवरक्लाइड करने की अनुमति दी जाएगी। (एसई 0117)

अधिक जानकारी और विवरण: स्विफ्ट प्रोग्रामिंग भाषा (अभिगम नियंत्रण)

Comments

खैर, यह उत्तर पिछले स्विफ्ट संस्करण (ओं) में मान्य था, ऐसा लगता है कि यह अब मान्य नहीं है :) कृपया मेरे उत्तर की जांच करें ।

— अहमद एफ

Answer 8

बीटा 6 में, प्रलेखन बताता है कि तीन अलग-अलग पहुंच संशोधक हैं:

• जनता
• अंदर का
• निजी

और ये तीनों वर्गों, प्रोटोकॉल, कार्यों और गुणों पर लागू होते हैं।

public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}

अधिक के लिए, एक्सेस कंट्रोल की जाँच करें ।

Comments

एक संरक्षित संशोधक होना चाहिए था जो अधिक सुरक्षा के साथ कक्षाएं बनाने में आसानी करता है।

— कुमार सी।

खैर, यह उत्तर पिछले स्विफ्ट संस्करण (ओं) में मान्य था, ऐसा लगता है कि यह अब मान्य नहीं है :) कृपया मेरे उत्तर की जांच करें ।

— अहमद एफ

Answer 9

अब बीटा 4 में, उन्होंने स्विफ्ट में एक्सेस मॉडिफायर जोड़ दिया है।

से Xcode 6 बीटा 4 realese नोट :

स्विफ्ट एक्सेस कंट्रोल के तीन एक्सेस स्तर हैं:

• private संस्थाओं को केवल स्रोत only ले के भीतर से एक्सेस किया जा सकता है, जहां वे। ned हैं।
• internal संस्थाओं को लक्ष्य के भीतर कहीं भी पहुँचा जा सकता है जहाँ वे be ned हैं।
• public संस्थाओं को लक्ष्य के भीतर और वर्तमान लक्ष्य के मॉड्यूल को आयात करने वाले किसी अन्य संदर्भ से कहीं से भी एक्सेस किया जा सकता है।

डिफ़ॉल्ट रूप से, स्रोत have le में अधिकांश संस्थाओं में आंतरिक पहुंच होती है। यह एप्लिकेशन डेवलपर्स को फ्रेमवर्क डेवलपर्स को फ्रेमवर्क एपीआई पर पूर्ण नियंत्रण की अनुमति देते हुए बड़े पैमाने पर पहुंच नियंत्रण की अनदेखी करने की अनुमति देता है।

Comments

क्या आप इसके लिए लिंक पोस्ट कर सकते हैं?

— स्नोमैन

खैर, यह उत्तर पिछले स्विफ्ट संस्करण (ओं) में मान्य था, ऐसा लगता है कि यह अब मान्य नहीं है :) कृपया मेरे उत्तर की जांच करें ।

— अहमद एफ

Answer 10

एक्सेस कंट्रोल मेकेनिज्म जैसा कि Xcode 6 में पेश किया गया है :

स्विफ्ट आपके कोड के भीतर संस्थाओं के लिए तीन अलग-अलग पहुंच स्तर प्रदान करता है। ये पहुँच स्तर स्रोत फ़ाइल के सापेक्ष होते हैं जिसमें एक इकाई परिभाषित होती है, और उस स्रोत फ़ाइल के मॉड्यूल के सापेक्ष भी होती है।

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

सार्वजनिक पहुँच उच्चतम (सबसे कम प्रतिबंधात्मक) पहुँच स्तर है और निजी पहुँच निम्नतम (या सबसे अधिक प्रतिबंधात्मक) पहुँच स्तर है।

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

मेरे लिए एक और मुद्दा बनाया गया है, जो ऊपर दिए गए लिंक में टिप्पणी करता है, वह है आप एक्सेस स्तर को 'अपग्रेड' नहीं कर सकते। यदि आप किसी चीज़ को उपवर्गित करते हैं, तो आप इसे और अधिक प्रतिबंधित कर सकते हैं, लेकिन दूसरे तरीके से नहीं।

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

Comments

खैर, यह उत्तर पिछले स्विफ्ट संस्करण (ओं) में मान्य था, ऐसा लगता है कि यह अब मान्य नहीं है :) कृपया मेरे उत्तर की जांच करें ।

— अहमद एफ

Answer 11

स्विफ्ट 3 और 4 चर और तरीकों के उपयोग के स्तर के लिए भी बहुत बदलाव लाए। स्विफ्ट 3 और 4 में अब 4 अलग-अलग पहुँच स्तर हैं, जहाँ खुला / सार्वजनिक पहुँच उच्चतम (सबसे कम प्रतिबंधात्मक) पहुँच स्तर है और निजी पहुँच निम्नतम (सबसे अधिक प्रतिबंधात्मक) पहुँच स्तर है:

• निजी कार्यों और सदस्यों को केवल इकाई के दायरे के भीतर से ही पहुँचा जा सकता है (संरचना, वर्ग, ...) और इसके एक्सटेंशन (स्विफ्ट 3 में भी एक्सटेंशन प्रतिबंधित थे)
• फ़ाइलपाइप फ़ंक्शंस और सदस्यों को केवल स्रोत फ़ाइल के भीतर से एक्सेस किया जा सकता है जहां वे घोषित किए जाते हैं।
• आंतरिक फ़ंक्शन और सदस्य (जो डिफ़ॉल्ट है, यदि आप स्पष्ट रूप से एक एक्सेस स्तर कुंजी शब्द नहीं जोड़ते हैं) को लक्ष्य के भीतर कहीं भी एक्सेस किया जा सकता है जहां वे परिभाषित हैं। Thats क्यों TestTarget स्वचालित रूप से सभी स्रोतों तक पहुँच नहीं है, उन्हें xCode के फ़ाइल निरीक्षक के रूप में सुलभ के रूप में चिह्नित किया जाना है।
• खुले या सार्वजनिक कार्यों और सदस्यों को लक्ष्य के भीतर और वर्तमान लक्ष्य के मॉड्यूल को आयात करने वाले किसी भी अन्य संदर्भ से कहीं से भी एक्सेस किया जा सकता है।

दिलचस्प:

हर एक विधि या सदस्य को "निजी" के रूप में चिह्नित करने के बजाय, आप किसी वर्ग / संरचना के विस्तार में कुछ विधियों (जैसे आमतौर पर सहायक कार्यों) को कवर कर सकते हैं और पूरे विस्तार को "निजी" के रूप में चिह्नित कर सकते हैं।

class foo { }

private extension foo {
    func somePrivateHelperFunction01() { }
    func somePrivateHelperFunction02() { }
    func somePrivateHelperFunction03() { }
}

बेहतर रखरखाव योग्य कोड प्राप्त करने के लिए यह एक अच्छा विचार हो सकता है। और आप आसानी से केवल एक शब्द को बदलकर गैर-निजी (जैसे इकाई परीक्षण के लिए) स्विच कर सकते हैं।

Apple प्रलेखन

Comments

खैर, यह उत्तर पिछले स्विफ्ट संस्करण (ओं) में मान्य था, ऐसा लगता है कि यह अब मान्य नहीं है :) कृपया मेरे उत्तर की जांच करें ।

— अहमद एफ

Answer 12

स्विफ्ट 1-3 के लिए:

नहीं, यह संभव नहीं है। किसी भी निजी / संरक्षित तरीके और चर बिल्कुल भी नहीं हैं।

सब कुछ सार्वजनिक है।

स्विफ्ट 4 के बाद से अपडेट करें , इस थ्रेड में अन्य उत्तरों को देखना संभव है

Comments

यह टिप्पणी वर्तमान बीज के लिए सटीक है।

— जेसपर

वर्तमान बीज के लिए। यह भविष्य में दिखाई देगा ।

— जेसपर

"सार्वजनिक" / "संरक्षित" / "निजी" वर्तमान में मौजूद नहीं है, लेकिन आप क्लोजर, प्रोटोकॉल और आंतरिक कक्षाओं का उपयोग करके चीजों को छिपा सकते हैं - यह कुछ हद तक जावास्क्रिप्ट में उपयोग किए जाने वाले मॉड्यूल पैटर्न की तरह बनाता है। ऐसा करने के तरीके के लिए कृपया मेरे उत्तर पर अपना नमूना कोड देखें। अगर मैं गलत हूं कि यह कैसे काम करता है और मेरा उदाहरण गलत है तो कृपया ध्यान दें कि मैं अभी भी सीख रहा हूं। :)

— डेव कप

ऐसा लगता है कि यह अब मान्य नहीं है :) कृपया मेरे उत्तर की जांच करें ।

— अहमद एफ

Answer 13

आपके द्वारा उपयोग किए जा सकने वाले विकल्पों में से एक है, उदाहरण निर्माण को एक फंक्शन में लपेटना और एक कंस्ट्रक्टर में उपयुक्त गेटर्स और सेटर की आपूर्ति करना:

class Counter {
    let inc: () -> Int
    let dec: () -> Int

    init(start: Int) {
        var n = start

        inc = { ++n }
        dec = { --n }
    }
}


let c = Counter(start: 10)

c.inc()  // 11
c.inc()  // 12
c.dec()  // 11

Answer 14

भाषा व्याकरण कीवर्ड के सार्वजनिक ',' निजी 'या' सुरक्षित 'नहीं है। यह सुझाव देगा कि सब कुछ सार्वजनिक है। बेशक, उन खोजशब्दों के बिना पहुँच संशोधक को निर्दिष्ट करने का कुछ वैकल्पिक तरीका हो सकता है, लेकिन मैं इसे भाषा के संदर्भ में नहीं पा सकता।

Answer 15

उन लोगों के लिए कुछ समय बचाने की उम्मीद है जो संरक्षित विधियों के लिए कुछ करना चाहते हैं:

अन्य उत्तरों के अनुसार, स्विफ्ट अब 'निजी' संशोधक प्रदान करता है - जो कि वर्ग-वार के बजाय फ़ाइल-वार के रूप में परिभाषित किया गया है जैसे कि जावा या C # उदाहरण के लिए। इसका मतलब है कि यदि आप संरक्षित तरीके चाहते हैं, तो आप इसे तेज निजी तरीकों से कर सकते हैं यदि वे एक ही फ़ाइल में हैं

1. 'संरक्षित' तरीके (वास्तव में निजी) रखने के लिए एक आधार वर्ग बनाएं
2. इसी वर्ग का उपयोग करने के लिए इस वर्ग को उपवर्गित करें
3. अन्य फ़ाइलों में आप बेस क्लास के तरीकों का उपयोग नहीं कर सकते हैं, तब भी जब आप या तो उपवर्ग करते हैं

उदाहरण के लिए फ़ाइल 1:

class BaseClass {
    private func protectedMethod() {

    }
}

class SubClass : BaseClass {
    func publicMethod() {
        self.protectedMethod()  //this is ok as they are in same file
    }
}

फ़ाइल 2:

func test() {
    var a = BaseClass()
    a.protectedMethod() //ERROR


    var b = SubClass()
    b.protectedMethod() //ERROR
}

class SubClass2 : BaseClass {
    func publicMethod() {
        self.protectedMethod() //ERROR
    }

}

Answer 16

https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AccessControl.html#//apple_ref/doc/uid/TP40014097-CH41-ID3

स्टार्टिंग स्विफ्ट 2.2;)

• जनता
• अंदर का
• निजी

डिफ़ॉल्ट रूप से आंतरिक

Answer 17

स्विफ्ट 2.0 तक केवल तीन एक्सेस लेवल [पब्लिक, इंटरनल, प्राइवेट] थे, लेकिन स्विफ्ट में 3.0 ऐप्पल ने दो नए एक्सेस लेवल जोड़े, जो कि [ओपन, फाइल टाइप] हैं, इसलिए अब स्विफ्ट 3.0 में 5 एक्सेस लेवल हैं, यहां मैं रोल क्लियर करना चाहता हूं इन दो एक्सेस लेवल 1. ओपन: यह पब्लिक के समान है लेकिन अंतर केवल इतना है कि पब्लिक सबक्लास और ओवरराइड एक्सेस कर सकता है, और ओपन एक्सेस लेवल एक्सेस नहीं कर सकता है कि यह इमेज मीडियम वेबसाइट से ली गई है और यह अंतर का वर्णन करता है खुली और सार्वजनिक पहुंच के बीच

अब दूसरे नए एक्सेस लेवल पर 2. फ़िलाटाइप आंतरिक की तुलना में निजी या कम एक्सेस स्तर का बड़ा संस्करण है। फ़ाइल टाइप [क्लास, स्ट्रक्चर, एनम] के विस्तारित हिस्से तक पहुंच सकता है और प्राइवेट कोड के विस्तारित हिस्से तक नहीं पहुंच सकता है। लेक्सिकल स्कोप यह इमेज मीडियम वेबसाइट से ली गई है और यह फाइल टाइप और प्राइवेट एक्सेस लेवल के बीच के अंतर का वर्णन करता है