Preface
This article mainly introduces to you about Swift access control, which restricts access to other code source files and module parts. This feature allows you to hide your code implementation and specify the preferred interface through which the code can be accessed and used.
class, structure and enumeration can all specify access levels, of course, property, method, initializer and subscript of this type. protocol can be limited to a certain context, global variables, variables and functions.
In addition, Swift also provides default usage levels for typical usage scenarios. Indeed, if you write a single-target app, you probably don't need to specify the access control level explicitly at all.
Modules and source files
Swift's access control model is based on the concept of modules and source files.
A module is a single code distribution unit—a framework or application is compiled and passed as a single unit. They can be imported by other modules through the Swift import keyword.
In Swift, each build target of Xcode (such as an app bundle or framework) is treated as a separate module.
Although it is usually practiced to define different types in different source files, a source file can actually contain different definitions of types, functions, etc.
Access level
Swift provides 5 different access levels for your code entity:
- Open access and public access allow entities to be used in any source files from a decisive module, or from other imported modules. Usually open or public is used to specify the public interface of the framework. The differences between the two will be described below.
- Internal access allows entities to be used in any source files in which they define the model, but cannot be used in any source files outside the module. Usually, internal access is used when defining the internal structure of an app or framework.
- File-private access restricts the use of entities in defined source files. Use file-private access to hide implementation details of specific features when used throughout the file.
- Private access restricts the use of entities to a closed statement. Use private access to hide implementation details of specific features when used in a single declaration.
Open access is the highest access level, and private is the lowest access level (maximum restriction).
Open access is only used for class and class members. The difference between it and public access is as follows:
- Classes accessed using public, or other more restrictive access levels, can only create subclasses within defined modules.
- Class members accessed using public, or other more restrictive access levels, can only be rewritten by their subclasses within defined modules.
- The Open class can be defined modules or other subclasses where the module is imported.
- Open class members can be rewrited by a module defined or other subclasses created in the place where the module is imported.
Simply put, the difference between public and open is that public has less permissions for class inheritance and class member rewriting than open.
Guidelines for access level
In Swift, the access level follows the general guidelines: no entity can be defined within another entity with a lower access level (more restrictions).
For example:
- Public variables cannot be defined as having internal, file-private or private types, because this type may not be used anywhere public variables are used.
- Functions cannot have higher access levels than other parameter types and return types, because the function can be used if its constituent type is not available to surrounding code.
There will be a more detailed introduction below.
Default access level
If you do not specify an explicit access level yourself, all entities in your code have a default internal access level. As a result, in many cases you do not need to specify an explicit access level to your code.
Access level for single target applications
If you are writing an i simple single-objective program, then your program code is a typical self-contained program and does not need to be used outside the program module. The default access level internal already meets this requirement. Therefore, you don't need to specify an access level. However, you may need to mark some of your code as file-private or private, so that other code in the program module hides their implementation details.
Frameworks access level
When you develop a framework, tag open or public so that it can be accessed by other modules, such as when a program introduces this framework. This public-oriented interface is the framework's programming interface (or API).
It is worth noting that any internal implementation details of the framework can also use the default internal access level, or can be identified as private or file private level, if you want to hide them from other internal codes of the framework. Only if you want an entity to be part of your framework's API, then you need to identify the entity as open or public.
Access level for unit test targets
When you are writing a program that contains unit test objectives, you need to enable the code in your program to be used by the test module for easy testing. Generally speaking, only entities identified as open or public can be accessed by other modules. However, if you add the @testable attribute before the product's module import declaration and compile the product module under the test option on, the unit test target can access any internal entity.
Access level syntax
Define access levels for entities:
public class SomePublicClass {}
internal class SomeInternalClass {}
fileprivate class SomeFilePrivateClass {}
private class SomePrivateClass {}
public var somePublicVariable = 0
internal let someInternalConstant = 0
fileprivate func someFilePrivateFunction() {}
private func somePrivateFunction() {}
Unless otherwise specified, the default access is basically internal, which means that SomeInternalClass and someInternalConstant can also have internal access levels without explicit access level modifiers:
class SomeInternalClass {} // Implicit internallet someInternalConstant = 0 // Implicit internal
Summarize
The above is the entire content of this article. I hope the content of this article will be of some help to your study or work. If you have any questions, you can leave a message to communicate. Thank you for your support.
Translated from:/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/#//apple_ref/doc/uid/TP40014097-CH41-ID3