스위프트 4 / 스위프트 5

Swift Documentation-Access Control에 언급 된대로 Swift에는 5 가지 액세스 제어가 있습니다 .

• open 및 public : 모듈의 엔티티 및 정의 모듈을 가져 오는 모든 모듈의 엔티티에서 액세스 할 수 있습니다.

• internal : 모듈의 엔티티에서만 액세스 할 수 있습니다. 기본 액세스 수준입니다.

• fileprivate 및 private : 사용자가 정의한 제한된 범위 내에서만 제한적으로 액세스 할 수 있습니다.

공개 와 공개 의 차이점은 무엇입니까 ?

open 은 이전 버전의 Swift에서 공개 된 것과 동일하며 다른 모듈의 클래스가이를 사용하고 상속 할 수 있습니다. 즉, 다른 모듈에서 서브 클래 싱 될 수 있습니다. 또한 다른 모듈의 구성원이이를 사용하고 대체 할 수 있습니다. 모듈에도 동일한 논리가 적용됩니다.

public 은 다른 모듈의 클래스가 클래스를 사용하도록 허용하지만 상속 하지는 않습니다 . 즉, 다른 모듈에서 서브 클래 싱 할 수 없습니다 . 또한 다른 모듈의 구성원이이를 사용할 수 있지만 대체하지는 않습니다. 모듈의 경우 동일한 개방형 논리를 갖습니다 (클래스가 클래스를 사용하고 상속 할 수 있도록 허용합니다.

fileprivate 와 private 의 차이점은 무엇입니까 ?

fileprivate 는 전체 파일에서 액세스 할 수 있습니다.

private 은 단일 선언 및 동일한 파일에있는 해당 선언의 확장 으로 만 액세스 할 수 있습니다 . 예를 들어 :

// 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!"
    }
}

Swift 3과 Swift 4 액세스 제어의 차이점은 무엇입니까?

SE-0169 제안서에 언급 된 바와 같이 , Swift 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 전체 파일에 액세스 할 수는.

답변

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)"
  }
}

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

var myClass:MyClass = MyClassImplementation()

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