Swift中的Bool类型是许多原始函数的基础。所以基于它可以展示一个有趣的如何构建基本类型的示例。这篇文章的主旨是在Swift中创建一个类似Bool类型的新类型MyBool。我们希望通过这个简单的示例,能让你更清晰的了解Swift语言的工作原理。

让我们从最基本的定义开始。我们用枚举来定义MyBool类型的模型,它有两个不同的case

enum MyBool {
    case myTrue, myFalse
}

为了使大家不会产生混淆,这篇文章中我们将MyBool的两个case命名为myTruemyFalse。我们希望MyBool的构造函数MyBool()将其自身赋值为false,所以我们提供了如下init方法:

extension MyBool {
    init() { self = .myFalse }
}

Swift中的枚举会隐式的在它们自身内申明其枚举检索器的范围,允许我们使用MyBool.myFalse这种语法调用其成员,如果根据上下文可以推断出类型的话,我们甚至可以使用.myFalse调用其成员。但是在真正使用中,我们还是希望使用原始的truefalse关键字。想要做到这一点,我们的新类型MyBool需要遵循BooleanLiteralConvertible协议,像这样:

extension MyBool : BooleanLiteralConvertible {
    static func convertFromBooleanLiteral(value: Bool) -> MyBool {
        return value ? myTrue : myFalse
    }
}

// 我们现在就可以给MyBool类型的变量赋值为true或false.
var a : MyBool = true

通过以上设置,我们有了自己的基本类型,但是目前我们用它还做不了什么。布尔值需要通过if条件语句进行测试。在Swift中,我们通过BooleanType协议来做到这一点,该协议允许任意类型用于进行逻辑判断:

extension MyBool : BooleanType {
    func getBooleanType() -> Bool {
        switch self {
        case .myTrue: return true
        case .myFalse: return false
        }
    }   
}

// 现在我们就可以将MyBool类型的变量a用于'if'和'while'语句中进行测试.
if a {}

我们更希望所有遵循了BooleanType协议的类型都要强制转换为MyBool类型,所以我们可以这样写:

extension MyBool {
    // MyBool类型构造函数的参数设定为BooleanType类型.
    init(_ v : BooleanType) {
        if v.getBooleanType() {
            self = .myTrue
        } else {
            self = .myFalse
        }
    }
}

// 现在我们就可以这样进行转换了.
var basicBool : Bool = true
a = MyBool(basicBool)

注意构造函数里的_,它可以使我们在使用构造函数时省略参数命名。可以使用MyBool(x)这种语法,而不用使用MyBool(v: x)这种啰嗦的语法。

现在我们有了基本的功能,现在让我们来定义它的操作符,先来看看如何定义==操作符。没有关联数据的简单的枚举(像MyBool一样)是由编译器自动认为遵循Equatable协议进行编译的,所以没有必须要实现额外的代码。尽管如此,你也可以让任意类型遵循Equatable协议,并实现==操作符。比如我们的MyBool类型:

extension MyBool : Equatable {
}

func ==(lhs: MyBool, rhs: MyBool) -> Bool {
    switch (lhs, rhs) {
    case (.myTrue,.myTrue), (.myFalse,.myFalse):
        return true
    default:
        return false
    }
}

// 现在我们就可以使用==和!=进行比较了.
if a == a {}
if a != a {}

这里我们在swich语句中使用简单的匹配模式来处理。由于MyBool现在遵循了Equatable协议,所以他已经自动实现了!=操作符。再让我们加一些二进制运算符:

func &(lhs: MyBool, rhs: MyBool) -> MyBool {
    if lhs {
        return rhs
    }
    return false
}

func |(lhs: MyBool, rhs: MyBool) -> MyBool {
    if lhs {
        return true
    }
    return rhs
}

func ^(lhs: MyBool, rhs: MyBool) -> MyBool {
    return MyBool(lhs != rhs)
}

有了基本的运算符后,我们就可以实现各种有用的一元和复合赋值运算符,比如:

prefix func !(a: MyBool) -> MyBool {
    return a ^ true
}

// 复合赋值(按位)
func &=(inout lhs: MyBool, rhs: MyBool) {
    lhs = lhs & rhs
}

&=运算符将左边的运算对象作为inout对象,因为要对它进行读写操作,并且其效果对于操作者是可见的。Swift提供的值类型,使我们可以完全掌控丰富多变的各种操作,比如enumstruct

至此,简单的MyBool类型已经具备了基本的运算符操作。希望这篇文章能给你一些思路,使你能够在自己的代码中构建更高级更复杂的类型。

原文地址:Boolean

在我们的ios应用中,UITableViewController往往是项目中最大的文件,它们包含了许多冗余的、不必要的代码。所以有很多代码的复用率非常低。这篇学习笔记可以让我们构建出轻量级的UITableViewController,以及可复用的UITableViewDataSource

示例代码猛戳这里

把DataSource分离出来

我们的示例很简单,就是先展示一个UITableViewController,然后点击某行,推出第二个UITableViewController
项目结构:
示例

StoryBoard结构:
示例

运行截图:
示例

FirstTableViewController类中有以下几个方法:

override func tableView(tableView: UITableView!, numberOfRowsInSection section: Int) -> Int {

    return firstCellData!.datas.count;

}

override func tableView(tableView: UITableView!, cellForRowAtIndexPath indexPath: NSIndexPath!) -> UITableViewCell! {

    var cell = tableView.dequeueReusableCellWithIdentifier(cellIdentifier, forIndexPath: indexPath) as UITableViewCell!;

    cell.textLabel.text = firstCellData?.datas[indexPath.row];

    return cell;

}

override func tableView(tableView: UITableView!, didSelectRowAtIndexPath indexPath: NSIndexPath!) {

    let stvc = SecondTableViewController();

    self.navigationController.pushViewController(stvc, animated: true);

}

SecondTableViewController类中有以下几个方法:

override func tableView(tableView: UITableView!, numberOfRowsInSection section: Int) -> Int {

    return secondCellData!.titleDatas.count;

}

override func tableView(tableView: UITableView!, cellForRowAtIndexPath indexPath: NSIndexPath!) -> UITableViewCell! {

    var cell = tableView.dequeueReusableCellWithIdentifier(cellIdentifier, forIndexPath: indexPath) as UITableViewCell!;

    cell.textLabel.text = secondCellData?.titleDatas[indexPath.row];
    cell.detailTextLabel.text = secondCellData?.subtitleDatas[indexPath.row];

    return cell;

}

从上面两个类的代码片段中可以看出,它们都重写了UITableViewDataSource最基本的两个方法,即设定每个Section有多少行和生成Cell并装配数据。更准确的说这些方法都是针对数组做一些事情。所以我们可以尝试把处理数组相关的代码移到单独的类中。对于Cell的设置,我们可以通过闭包来实现。

我们可以创建一个CustomDataSource类(其实命名为ArrayDataSource更好),继承NSObject并遵循UITableViewDataSource协议。

import Foundation
import UIKit

class CustomDataSource: NSObject, UITableViewDataSource {

    var cellData: Array<AnyObject>?;
    var cellIdentifier: String?;
    var configureCell: ((AnyObject,AnyObject) -> ())?;

    init(cellData: Array<AnyObject>, cellIdentifier: String, configureCell: (AnyObject,AnyObject) -> ()) {

        super.init();
        self.cellData = cellData;
        self.cellIdentifier = cellIdentifier;
        self.configureCell = configureCell;

    }

    func tableView(tableView: UITableView!, numberOfRowsInSection section: Int) -> Int {

        return cellData!.count;

    }

    func tableView(tableView: UITableView!, cellForRowAtIndexPath indexPath: NSIndexPath!) -> UITableViewCell! {

        var cell = tableView.dequeueReusableCellWithIdentifier(cellIdentifier, forIndexPath: indexPath) as UITableViewCell!;

        configureCell!(cell,cellData![indexPath.row]);

        return cell;

    }

}

现在,你就可以把UITableViewController的这两个方法去掉了。取而代之,你可以创建一个CustomDataSource类的实例作为UITableViewControllerDataSource

//FirstTableViewController

 func setupTableView() {

    customDataSource = CustomDataSource(cellData: items, cellIdentifier: cellIdentifier, configureCell: {(cell, firstCellData) in

        var firstCell = cell as FirstCell;
        firstCell.configureForCell(firstCellData as FirstCellData);

        });

    self.tableView.dataSource = customDataSource;

}





// SecondTableViewController

 func setupTableView() {

    customDataSource = CustomDataSource(cellData: items, cellIdentifier: cellIdentifier, configureCell: {(cell, secondCellData) in

        var secondCell = cell as SecondCell;
        secondCell.configureForCell(secondCellData as SecondCellData);

        });

    self.tableView.dataSource = customDataSource;

}

设置Cell的代码在对应的View层实现。

class FirstCell: UITableViewCell {

    func configureForCell(item: FirstCellData!) {

        self.textLabel.text = item.title;

    }

}





class SecondCell: UITableViewCell {

    func configureForCell(item: SecondCellData!) {

        self.textLabel.text = item.title;
        self.detailTextLabel.text = item.subtitle;

    }

}

现在每次你想把数组显示在某些Table View中的时候都可以复用DataSource的这些代码,当然也可以举一反三,将DataSource中处理其他数据类型的代码也分离出来,划分为多个处理不同数据类型或业务逻辑的DataSource,形成Data Source Pool,以后就可以随意复用啦。

总结:

在MVC设计模式中,我们应该把代码放置在合适、正确的位置,比如不要在View Controller中做网络请求的逻辑,你应该将它们封装在Model层的类中。也不应该在View Controller中构建复杂的View,而是应该将它们封装在View层的UIView子类中等等。

虽然以上技巧并不适用于所有项目的任何角落,但是我们作为程序员要本着写可维护的代码、写可让别人看懂的代码为遵旨。通过这些小技巧我们至少可以将笨重的View Controller变得小巧、整洁。

参考文献:Lighter View Controllers

文件和初始化

到目前为止,大多数开发者已经可以写出简单的Swift应用或者在Playground实验Swift语言的新特性。也许你也经历过这种情况,当你将Playground中运行正常的代码拷贝到Swift源文件中却发生了编译错误,“这到底是怎么回事?Playground文件和Swift源文件之间到底有什么不同?” 这篇文将告诉你们如何处理Swift项目中的各种文件,以及如何初始化全局数据。

应用中的文件

一个Swift应用必定会包含很多个源文件,基本上每个源文件中都有构成该应用的函数、类和其他一些申明等。Swift应用中的大多数源文件都是不需要按顺序访问的,都是无顺序的,你甚至可以在某个模块的最底部导入需要的源文件(虽然Swift不推荐这种编码风格)。

不管怎样,在大多数Swift的源文件中是不允许有最顶层级别的代码的。这里解释一下顶层代码,任何写在函数体、类之外,或被封装供他人调用的可执行语句我们称为顶层代码。我们之所以不允许出现顶层代码,是因为它会影响我们判断程序是从哪里开始运行的。

Playground,REPL,顶层代码

你可能会奇怪,为什么下面的代码在Playground中可以完美执行。由于它并没有包含任何其他东西,所以它必然是顶层代码:

println("Hello world")

上面的单行程序在没有任何其他代码的情况就可以正常运行,是因为Playground支持执行顶层代码。并且在Playground中引入的文件或者代码是按自上而下的顺序执行的。比如说,你不能在定义某个类型之前去使用它。当然,在Swift的Playground中也可以定义函数、类和其他在Swift中合法的任何类型,但并没有必要这么做。Playground的目的在于让开发者们能更简单、更快速的学习Swift语言和实验新的API,而不用创建大量Swift源文件去做这些事。

除了Playground,顶层代码也可以在REPL(Read-Eval-Print-Loop)中运行或作为脚本在Swift文件启动时运行。通过脚本使用Swift时,你可以在终端中用#!/usr/bin/xcrun swift或者xcrun swift myFile.swift的方式使用Swift文件。

应用程序的入口与“main.swift”

你可能也注意到了,在上面的文章中,我们提到在大多数的源文件中是不允许使用顶层代码的。但对一个文件除外,那就是main.swift文件,该文件的作用类似于Playground,但是它是随着你应用的其他源文件一起编译的。main.swift文件中允许顶层代码并且执行顺序是自上而下的。实际上,main.swift文件中的第一行代码就默认为是程序的入口。正因为如此,所以我们才能看到在Swift最小的程序只有一行代码,但它必须要在main.swift文件中。

在Xcode中,Mac程序模板文件中就包含一个main.swift文件,但在iOS程序的项目模板中是通过在Swift文件中添加@UIApplicationMain标签注明项目入口的。这样做会让编译器忽略main.swift入口文件,而将标注有@UIApplicationMain标签的文件当做入口文件。

全局变量

我们已经知道了Swift是如何判断程序的执行入口,那么全局变量是如何工作的呢?下面的这行代码,在运行时需要初始化吗?

var someGlobal = foo()

在单文件的程序中,代码是自上而下执行的,这类似于函数中变量的执行方式。这虽然看起来很简单,但是在复杂的程序中我们就不是很好回答这个问题了。我们从下面三个方面来考虑:

  1. 限制初始化,像简单的常量表达式,比如C语言。
  2. 任意初始化,在应用程序加载执行静态构造函数时初始化,比如C++语言。
  3. 延迟初始化,当全局变量第一次被使用的时候初始化,比如Java语言。

我们基本排除第一种情况,因为在Swift中不需要像C语言中的常量表达式。在Swift中,常量通常是在函数调用的时候执行的(内联)。而且也有更好的理由使用复杂的初始化方法,比如设置一个单例或者实例化一个字典。

第二种情况我们也基本排除,因为它在大型、复杂的程序中的效率很差。因为所有的初始化都要在应用程序启动之前,但是我们无法预测初始化的顺序,所以会有问题。

Swift采用第三种情况,这是最好的方法:允许自定义初始化,在程序启动时不会因为要进行大量初始化而降低效率,并且我们也可以预知每次初始化完成的顺序。

延迟初始化的全局变量(也包括结构体和枚举中的静态成员)是在第一次访问他们的时候才初始化的,并且以dispatch_once运行,确保了线程安全。你可以更酷的使用dispatch_once:只需要申明一个全局变量并初始化,再将其访问级别申明为private

总结

Swift语言的设计使得它可以很方便的在Playground中进行试验或快捷的编写脚本。一个完整的程序可以只有一行代码。当然,你也可以使用Swift编写出各种复杂的应用程序。你可以通过main.swift掌控各种初始化的完成时机,或者通过@UIApplicationMain标签指定你的iOS应用的程序入口。

本文翻译自Swift官方博客,原文地址:Files and Initialization

Objective-C和C语言经常需要使用到指针。Swift中的数据类型由于良好的设计,使其可以和基于指针的C语言API无缝混用。同时Swift也可以自动处理大多数将指针作为参数的情况。在这篇文章里,我们可以看到在Swift语言中如何将变量、数组、字符串当做C语言中的指针参数来使用。

将输入输出参数作为指针参数

C和Objective-C不支持多类型的返回值。所以Cocoa API就使用指针作为函数的输入输出参数,以用来传递多类型的数据。Swift允许使用指针参数进行类似inout参数的处理,所以你可以使用&语法将一个var变量的引用作为指针参数进行传递。比如说,UIColorgetRed(_:green:blue:alpha:)方法,使用4个CGFloat*指针用来接收颜色的组成元素。我们可以使用&将这几个颜色组成部分装配在本地变量中。

var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
color.getRed(&r, green: &g, blue: &b, alpha: &a)

另外一个常见的情况出现在Cocoa NSError类的使用中。很多方法都使用一个NSError**参数来保存异常信息。比如说,我们可以通过NSFileManager类的contentsOfDirectoryAtPath(_:error:)方法,挪列出指定目录中的信息,一旦出现疑似异常信息,就将其保存在NSError?类型的变量中。

var maybeError: NSError?
if let contents = NSFileManager.defaultManager()
    .contentsOfDirectoryAtPath("/usr/bin", error: &maybeError) {
    // Work with the directory contents
} else if let error = maybeError {
    // Handle the error
}

为安全起见,Swift要求在使用&传值时,变量必须是已经被初始化的。这是因为Swift无法知道也无法判断在操作指针之前,该指针是否确实在内存有指向的地址。

将数组作为指针参数

在C语言中,指针与数组是水乳交融,纠缠不清的。那么为了在Swift中能无缝的使用C语言中基于数组的一些API,Swift允许将Array作为指针参数。一个不可变数组的值可以作为一个const指针参数直接传递,可变数组可以使用&作为一个非const指针参数进行传递,就inout参数一样。比如,我们使用Accelerate框架中的vDSP_vadd函数对数组a和数组b进行相加,将结果写入result数组:

import Accelerate

let a: [Float] = [1, 2, 3, 4]
let b: [Float] = [0.5, 0.25, 0.125, 0.0625]
var result: [Float] = [0, 0, 0, 0]

vDSP_vadd(a, 1, b, 1, &result, 1, 4)

// result now contains [1.5, 2.25, 3.125, 4.0625]

将字符串作为指针参数

C语言中,传递字符串的主要方式是通过const char*指针。在Swift中,String也可以被用作const char*指针,用它可以向函数传递空字符串或UTF-8编码的字符串。比如,我们可以在标准的C语言和POSIX的库函数中直接使用字符串作为参数传递:

puts("Hello from libc")
let fd = open("/tmp/scratch.txt", O_WRONLY|O_CREAT, 0o666)

if fd < 0 {
    perror("could not open /tmp/scratch.txt")
} else {
    let text = "Hello World"
    write(fd, text, strlen(text))
    close(fd)
}

指针参数转换的安全性

Swift一直在努力让我们可以方便的、无缝的使用C语言中的指针,因为在Cocoa中已经使用的非常普遍了。虽然Swift是一个类型安全的语言,对指针参数的转换的安全性也有保障,但是相比Swift原生的其他代码来说,还是存在着一定的不安全性。所以我们在使用时要格外小心。比如说:

  • 如果调用者在指针返回之后保存了指针指向的对象,那么再去使用这个对象时是不安全的。这些被转换的指针参数只能在调用过程中或者发送消息过程中保证其有效性。即时你使用相同的变量、数组或者字符串作为多指针参数进行传递,你每次接收到的指针都是不同的。除非是全局或者静态变量。你可以安全的使用全局或静态变量的指针的参数,比如KVO上下文参数。
  • 当将数组或字符串作为指针参数传递时,Swift不会检查其边界值。在C语言中,数组和字符串的大小是不能增长的,所以当你将数组或字符串作为指针参数传递时,要确保它们有足够的大小,或者适合当前场景的大小。

如果你使用的基于指针的API不在这篇指导内,或者你需要重写接收指针参数的Cocoa方法,那么你可以直接使用Swift原始内存中的不安全的指针。我们会在以后的文章中介绍更多Swift的特性。

本文翻译自Swift官方博客,原文地址:Interacting with C Pointers

苹果在发布了Xcode 6 Bate 4后为Swift添加了新的特性–访问控制(Access Control),并且更新了The Swift Programming Language文档,我抽空把这篇文档翻译了一下,下面让我们来详细了解一下Access Control。

访问控制

访问控制可以限定你在源文件或模块中访问代码的级别,也就是说可以控制哪些代码你可以访问,哪些代码你不能访问。这个特性可以让我们隐藏功能实现的一些细节,并且可以明确的指定我们提供给其他人的接口中哪些部分是他们可以使用的,哪些是他们看不到的。

你可以明确的给类、结构体、枚举、设置访问级别,也可以给属性、函数、初始化方法、基本类型、下标索引等设置访问级别。协议也可以被限定在一定的范围内使用,包括协议里的全局常量、变量和函数。

在提供了不同访问级别的同时,Swift并没有规定我们要在任何时候都要在代码中明确指定访问级别。其实,如果我们作为独立开发者在开发我们自己的app,而不是在开发一些Framework的时候,我们完全可以不用明确的指定代码的访问级别。

注意:为方便起见,在代码中可以设置访问级别的它们(属性、基本类型、函数等)在下面的章节中我们称之为“实体”。

模块和源文件

Swift中的访问控制模型基于模块和源文件这两个概念。

模块指的是FrameworkApp bundle。在Swift中,可以用import关键字引入自己的工程。

在Swift中,FramewordkApp bundle被作为模块处理。如果你是为了实现某个通用的功能,或者是为了封装一些常用方法而将代码打包成Framework,这个Framework在Swift中就被称为模块。不论它被引入到某个App工程或者其他的Framework,它里面的一切(属性、函数等)都属于这个模块。

源文件指的是Swift中的Swift File,就是编写Swift代码的文件,它通常属于一个模块。通常一个源文件包含一个,在中又包含函数属性等类型。

访问级别

Swift提供了三种不同的访问级别。这些访问级别相对于源文件中定义的实体,同时也相对于这些源文件所属的模块。

  • Public:可以访问自己模块或应用中源文件里的任何实体,别人也可以访问引入该模块中源文件里的所有实体。通常情况下,某个接口或Framework是可以被任何人使用时,你可以将其设置为public级别。
  • Internal:可以访问自己模块或应用中源文件里的任何实体,但是别人不能访问该模块中源文件里的实体。通常情况下,某个接口或Framework作为内部结构使用时,你可以将其设置为internal级别。
  • Private:只能在当前源文件中使用的实体,称为私有实体。使用private级别,可以用作隐藏某些功能的实现细节。

Public为最高级访问级别,Private为最低级访问级别。

访问级别的使用原则

在Swift中,访问级别有如下使用原则:访问级别统一性。
比如说:

  • 一个public访问级别的变量,不能将它的类型定义为internalprivate的类型。因为变量可以被任何人访问,但是定义它的类型不可以,所以这样就会出现错误。
  • 函数的访问级别不能高于它的参数、返回类型的访问级别。因为如果函数定义为public而参数或者返回类型定义为internalprivate,就会出现函数可以被任何人访问,但是它的参数和返回类型不可以,同样会出现错误。

默认访问级别

代码中的所有实体,如果你不明确的定义其访问级别,那么它们默认为internal级别。在大多数情况下,我们不需要明确的设置实体的访问级别,因为我们大多数时候都是在开发一个App bundle。

单目标应用程序的访问级别

当你编写一个单目标应用程序时,该应用的所有功能都是为该应用服务,不需要提供给其他应用或者模块使用,所以我们不需要明确设置访问级别,使用默认的访问级别internal即可。但是如果你愿意,你也可以使用private级别,用于隐藏一些功能的实现细节。

Framework的访问级别

当你开发Framework时,就需要把一些实体定义为public级别,以便其他人导入该Framework后可以正常使用其功能。这些被你定义为public的实体,就是这个Framework的API。

注意:Framework的内部实现细节依然可以使用默认的internal级别,或者也可以定义为private级别。只有你想将它作为API的实体,才将其定义为public级别。

访问控制语法

通过修饰符publicinternalprivate来声明实体的访问级别:

public class SomePublicClass {}
internal class SomeInternalClass {}
private class SomePrivateClass {}

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

除非有特殊的说明,否则实体都使用默认的访问级别internal,可以查阅默认访问级别这一节。这意味着SomeInternalClasssomeInternalConstant不用明确的使用修饰符声明访问级别,但是他们任然拥有隐式的访问级别internal

class SomeInternalClass {}              // 隐式访问级别internal
var someInternalConstant = 0            // 隐式访问级别 internal

自定义类型

如果你想为一个自定义类型指定一个明确的访问级别,那么你要明确一点。那就是你要确保新类型的访问级别和它实际的作用域相匹配。比如说,如果某个类里的属性、函数、返回值它们的作用域仅在当前的源文件中,那么你就可以将这个类申明为private类,而不需要申明为public或者internal类。

类的访问级别也可以影响到类成员(属性、函数、初始化方法等)的默认访问级别。如果你将类申明为private类,那么该类的所有成员的默认访问级别也会成为private。如果你将类申明为public或者internal类(或者不明确的指定访问级别,而使用默认的internal访问级别),那么该类的所有成员的访问级别是internal

注意:上面提到,一个public类的所有成员的访问级别默认为internal级别,而不是public级别。如果你想将某个成员申明为public级别,那么你必须使用修饰符明确的申明该成员。这样做的好处是,在你定义公共接口API的时候,可以明确的选择哪些属性或方法是需要公开的,哪些是内部使用的,可以避免将内部使用的属性方法公开成公共API的错误。

public class SomePublicClass {          // 显示的 public 类
    public var somePublicProperty = 0    // 显示的 public 类成员 
    var someInternalProperty = 0         // 隐式的 internal 类成员 
    private func somePrivateMethod() {}  // 显示的 private 类成员 
}

class SomeInternalClass {               // 隐式的 internal 类
    var someInternalProperty = 0         // 隐式的 internal 类成员 
    private func somePrivateMethod() {}  // 显示的 private 类成员 
}

private class SomePrivateClass {        // 显示的 private 类
    var somePrivateProperty = 0          // 隐式的 private 类成员 
    func somePrivateMethod() {}          // 隐式的 private 类成员 
}

元组类型

元组的访问级别使用是所有类型的访问级别使用中最为严谨的。比如说,如果你构建一个包含两种不同类型元素的元组,其中一个元素类型的访问级别为internal,另一个为private级别,那么这个元组的访问级别为private。也就是说元组的访问级别遵循它里面元组中最低级的访问级别。

注意:元组不同于类、结构体、枚举、函数那样有单独的定义。元组的访问级别是在它被使用时自动推导出的,而不是明确的申明。

函数类型

函数的访问级别需要根据该函数的参数类型访问级别、返回类型访问级别得出。如果根据参数类型和返回类型得出的函数访问级别不符合上下文,那么就需要明确的申明该函数的访问级别。

下面的例子中定义了一个全局函数名为someFunction,并且没有明确的申明其访问级别。你也许会认为该函数应该拥有默认的访问级别internal,但事实并非如此。事实上,如果按下面这种写法,编译器是无法编译通过的:

func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // function implementation goes here
}

我们可以看到,这个函数的返回类型是一个元组,该元组中包含两个自定义的类(可查阅自定义类型)。其中一个类的访问级别是internal,另一个的访问级别是private,所以根据元组访问级别的原则,该元组的访问级别是private(元组的访问级别遵循它里面元组中最低级的访问级别)。

因为该函数返回类型的访问级别是private,所以你必须使用private修饰符,明确的申请该函数:

private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
    // function implementation goes here
}

将该函数申明为publicinternal,或者使用默认的访问级别internal都是错误的,因为如果把该函数当做publicinternal级别来使用的话,是无法得到private级别的返回值的。

枚举类型

枚举中成员的访问级别继承自该枚举,你不能为枚举中的成员指定访问级别。
比如下面的例子,枚举CompassPoint被明确的申明为public级别,那么它的成员NorthSouthEastWest的访问级别同样也是public

public enum CompassPoint {
    case North
    case South
    case East
    case West
}

原始值和关联值

用于枚举定义中的任何原始值,或关联的值类型必须有一个访问级别,至少要高于枚举的访问级别。比如说,你不能在一个internal访问级别的枚举中定义private级别的原始值类型。

嵌套类型

如果在private级别的类型中定义嵌套类型,那么该嵌套类型就自动拥有private访问级别。如果在public或者internal级别的类型中定义嵌套类型,那么该嵌套类型自动拥有internal访问级别。如果想让嵌套类型拥有public访问级别,那么需要对该嵌套类型进行明确的访问级别申明。

子类

子类的访问级别不得高于父类的访问级别。比如说,父类的访问级别是internal,子类的访问级别就不能申明为public
此外,在满足子类不高于父类访问级别以及遵循各访问级别作用域(即模块或源文件)的前提下,你可以重写任意类成员(方法、属性、初始化方法、下标索引等)。

如果我们无法直接访问某个类中的属性或函数等,那么可以继承该类,从而可以更容易的访问到该类的类成员。下面的例子中,类A的访问级别是public,它包含一个函数someMethod,访问级别为private。类B继承类A,并且访问级别申明为internal,但是在类B中重写了类A中访问级别为private的方法someMethod,并重新申明为internal级别。通过这种方式,我们就可以访问到某类中private级别的类成员,并且可以重新申明其访问级别,以便其他人使用:

public class A {
    private func someMethod() {}
}

internal class B: A {
    override internal func someMethod() {}
}

只要满足子类不高于父类访问级别以及遵循各访问级别作用域的前提下(即private的作用域在同一个源文件中,internal的作用域在同一个模块下),我们甚至可以在子类中,用子类成员访问父类成员,哪怕父类成员的访问级别比子类成员的要低:

public class A {
    private func someMethod() {}
}

internal class B: A {
    override internal func someMethod() {
        super.someMethod()
    }
}

因为父类A和子类B定义在同一个源文件中,所以在类B中可以在重写的someMethod方法中调用super.someMethod()

常量、变量、属性、下标

常量、变量、属性不能拥有比它们的类型更高的访问级别。比如说,你定义一个public级别的属性,但是它的类型是private级别的,这是编译器不允许的。同样,下标也不能拥有比索引类型或返回类型更高的访问级别。

如果常量、变量、属性、下标索引的定义类型是private级别的,那么它们必须要明确的申明访问级别为private

private var privateInstance = SomePrivateClass()

Getter和Setter

常量、变量、属性、下标索引的GettersSetters的访问级别继承自它们所属成员的访问级别。

Setter的访问级别可以低于对应的Getter的访问级别,这样就可以控制变量、属性或下标索引的读写权限。在varsubscript定义作用域之前,你可以通过private(set)internal(set)先为它门的写权限申明一个较低的访问级别。

注意:这个规定适用于用作存储的属性或用作计算的属性。即使你不明确的申明存储属性的GetterSetter,Swift也会隐式的为其创建GetterSetter,用于对该属性进行读取操作。使用private(set)internal(set)可以改变Swift隐式创建的Setter的访问级别。在计算属性中也是同样的。

下面的例子中定义了一个结构体名为TrackedString,它记录了value属性被修改的次数:

struct TrackedString {
    private(set) var numberOfEdits = 0
    var value: String = "" {
    didSet {
        numberOfEdits++
    }
    }
}

TrackedString结构体定义了一个用于存储的属性名为value,类型为String,并将初始化值设为""(即一个空字符串)。该结构体同时也定义了另一个用于存储的属性名为numberOfEdits,类型为Int,它用于记录属性value被修改的次数。这个功能的实现通过属性valuedidSet方法实现,每当给value赋新值时就会调用didSet方法,给numberOfEdits加一。

结构体TrackedString和它的属性value均没有明确的申明访问级别,所以它们都拥有默认的访问级别internal。但是该结构体的numberOfEdits属性使用private(set)修饰符进行申明,这意味着numberOfEdits属性只能在定义该结构体的源文件中赋值。numberOfEdits属性的Getter依然是默认的访问级别internal,但是Setter的访问级别是private,这表示该属性只有在当前的源文件中是可读可写的,在当前源文件所属的模块中它只是一个可读的属性。

如果你实例化TrackedString结构体,并且多次对value属性的值进行修改,你就会看到numberOfEdits的值会随着修改次数更改:

var stringToEdit = TrackedString()
stringToEdit.value = "This string will be tracked."
stringToEdit.value += " This edit will increment numberOfEdits."
stringToEdit.value += " So will this one."
println("The number of edits is \(stringToEdit.numberOfEdits)")
// prints "The number of edits is 3"

虽然你可以在其他的源文件中实例化该结构体并且获取到numberOfEdits属性的值,但是你不能对其进行赋值。这样就能很好的告诉使用者,你只管使用,而不需要知道其实现细节。

初始化

我们可以给自定义的初始化方法指定访问级别,但是必须要低于或等于它所属类的访问级别。但如果该初始化方法是必须要使用的话,那它的访问级别就必须和所属类的访问级别相同。

如同函数或方法参数,初始化方法参数的访问级别也不能低于初始化方法的访问级别。

默认初始化方法

Swift为结构体、类都提供了一个默认的无参初始化方法,用于给它们的所有属性提供赋值操作,但不会给出具体值。默认初始化方法可以参阅Default Initializers。默认初始化方法的访问级别与所属类型的访问级别相同。

注意:如果一个类型被申明为public级别,那么默认的初始化方法的访问级别为internal。如果你想让无参的初始化方法在其他模块中可以被使用,那么你必须提供一个具有public访问级别的无参初始化方法。

结构体的默认成员初始化方法

如果结构体中的任一存储属性的访问级别为private,那么它的默认成员初始化方法访问级别就是private。尽管如此,结构体的初始化方法的访问级别依然是internal

如果你想在其他模块中使用该结构体的默认成员初始化方法,那么你需要提供一个访问级别为public的默认成员初始化方法。

协议

如果你想为一个协议明确的申明访问级别,那么有一点需要注意,就是你要确保该协议只在你申明的访问级别作用域中使用。

协议中的每一个必须要实现的函数都具有和该协议相同的访问级别。这样才能确保该协议的使用者可以实现它所提供的函数。

注意:如果你定义了一个public访问级别的协议,那么实现该协议提供的必要函数也会是public的访问级别。这一点不同于其他类型,比如,public访问级别的其他类型,他们成员的访问级别为internal

协议继承

如果定义了一个新的协议,并且该协议继承了一个已知的协议,那么新协议拥有的访问级别最高也只和被继承协议的访问级别相同。比如说,你不能定义一个public的协议而去继承一个internal的协议。

协议一致性

类可以采用比自身访问级别低的协议。比如说,你可以定义一个public级别的类,可以让它在其他模块中使用,同时它也可以采用一个internal级别的协议,并且只能在定义了该协议的模块中使用。

采用了协议的类的访问级别遵循它本身和采用协议中最低的访问级别。也就是说如果一个类是public级别,采用的协议是internal级别,那个采用了这个协议后,该类的访问级别也是internal

如果你采用了协议,那么实现了协议必须的方法后,该方法的访问级别遵循协议的访问级别。比如说,一个public级别的类,采用了internal级别的协议,那么该类实现协议的方法至少也得是internal

注意:在Swift中和Objective-C中一样,协议的一致性保证了一个类不可能在同一个程序中用不同的方法采用同一个协议。

扩展

你可以在条件允许的情况下对类、结构体、枚举进行扩展。扩展成员应该具有和原始类成员一致的访问级别。比如你扩展了一个公共类型,那么你新加的成员应该具有和原始成员一样的默认的internal访问级别。

或者,你可以明确申明扩展的访问级别(比如使用private extension)给该扩展内所有成员指定一个新的默认访问级别。这个新的默认访问级别仍然可以被单独成员所指定的访问级别所覆盖。

协议的扩展

如果一个扩展采用了某个协议,那么你就不能对该扩展使用访问级别修饰符来申明了。该扩展中实现协议的方法都会遵循该协议的访问级别。

泛型

泛型类型或泛型函数的访问级别遵循泛型类型、函数本身、泛型类型参数三者中访问级别最低的级别。

类型别名

任何被你定义的类型别名都会认为是不同的类型进行访问控制。一个类型别名的访问级别低于或等于这个类型的访问级别。比如说,一个private级别的类型别名可以设定给一个publicinternalprivate的类型,但是一个public级别的类型别名只能设定给一个public级别的类型,不能设定给internalprivate的类类型。

注意:这条规则也适用于为满足协议一致性而给相关类型命名别名。

相关链接