Fileprivate vs private: Giải thích sự khác biệt

Fileprivate vs private in Swift: The differences explained

Fileprivate and private are part of the access control modifiers in Swift. These keywords, together with internal, public, and open, make it possible to restrict access to parts of your code from code in other source files and modules.
The private access level is the lowest and most restrictive level whereas open access is the highest and least restrictive. The documentation of Swift will explain all access levels in detail to you, but in this blog post, I’m going to explain the differences between two close friends: fileprivate and private.

Open access is the highest (least restrictive) access level and private access is the lowest (most restrictive) access level.

This will improve readability and makes it easier to use and understand your code for others.

When to use fileprivate

Although the keywords are almost the same, there is a clear difference in their use cases. Fileprivate access restricts the use of an entity within the same defined source file. The only reason you would use fileprivate is when you want to access your code within the same file from different classes or structs.
In the following example, we have an ImageProvider and an ImageViewController. We can use fileprivate if they’re defined within the same file and we want to allow access to the image view from the image provider.

final class ImageViewController: UIViewController {

    fileprivate var imageView: UIImageView!

}

struct ImageProvider {

    let newImage: UIImage

    func updateImage(in viewController: ImageViewController) {
        viewController.imageView.image = newImage
    }
}

However, if we would create a separated file for the `ImageProvider` struct, we would get a compiler error:

Inaccessible image view due to fileprivate

In my opinion, this makes it a very small use case. It’s often better for the structure of your project to define entities in their own files.

When to use private

The private keyword is used a lot more and restricts the use of an entity to the enclosing declaration and its extensions. The extensions, however, have to be defined within the same file. In other words, private declarations will not be visible outside the file. You can use this keyword to only expose the minimal code needed to interact with the entity. This will improve readability and makes it easier to use and understand your code for others.