翻译细节与 markdown 统一格式修改 (#779)
* 修正全角逗号、句号的使用 * 修正逗号使用 * 修正一处代码空格错误 * 修正斜体范围，引用的空格使用 * 修正示例代码错误 * 修正标点，修正示例代码 * 修正标点 * 修正标点 * 添加 Swift 3.1 的更新 * 修改 Swift 3.0.1 位置 * 添加 Swift 4.0.3 更新 * 添加 Swift 4.1 更新 * 修正示例代码 * 修正 markdown 引用语法，优化翻译语句 * 修正示例代码 * 修正标点使用，优化翻译语句 * 修正示例代码 * 修正示例代码 * 优化翻译语句，修正示例代码语法 * 更新示例代码以符合 Swift 4.1 * 优化 markdown 引用格式的使用 * 优化 markdown 行内代码块使用，代码块与正文使用空格分隔 * 人工校验 markdown 行内代码块使用 * 中英文空格分隔 * 移除行末空格 * 人工校验 markdown 行内代码块使用 * 修正 markdown 无序列表使用
This commit is contained in:
BqLin
安正超
@ -5,15 +5,15 @@
|
||||
|
||||
如果您之前没有接触过权限控制，先来听一个小故事：
|
||||
|
||||
> 小明是五道口工业学院的一个大一新生，最近他有点烦恼，因为同屋经常用他的热水壶，好像那是自己家的一样，可是碍于同学情面，又不好意思说。直到有一天，他和学姐小K吐槽。
|
||||
> 小明是五道口工业学院的一个大一新生，最近他有点烦恼，因为同屋经常用他的热水壶，好像那是自己家的一样，可是碍于同学情面，又不好意思说。直到有一天，他和学姐小 K 吐槽。
|
||||
|
||||
> 学姐听了之后，说：大学集体生活里面，大部分东西都是默认室友可以共用的。如果你不想别人拿，我可以帮你做封印，只要打上private标记，它们就看不到你的东西，更加用不了你的东西了。
|
||||
> 学姐听了之后，说：大学集体生活里面，大部分东西都是默认室友可以共用的。如果你不想别人拿，我可以帮你做封印，只要打上 private 标记，它们就看不到你的东西，更加用不了你的东西了。
|
||||
|
||||
> 小明说哇靠学姐你还会妖法......
|
||||
|
||||
Swift语言从Xcode 6 beta 5版本起，加入了对权限控制（Access Control）的支持。其实权限控制和小明的物品一样，你可以设定水壶是只有自己能用，还是只有宿舍里的人能用，还是全校都可以用。
|
||||
Swift 语言从 Xcode 6 beta 5版本起，加入了对权限控制（Access Control）的支持。其实权限控制和小明的物品一样，你可以设定水壶是只有自己能用，还是只有宿舍里的人能用，还是全校都可以用。
|
||||
|
||||
从此以后，你可以好像神盾局局长一样，完全掌控自己的代码块的”保密级别“，哪些是只能在本文件引用，哪些能用在整个项目里，你还可以发挥大爱精神，把它开源成只要导入你的框架，大家都可以使用的API。
|
||||
从此以后，你可以好像神盾局局长一样，完全掌控自己的代码块的”保密级别“，哪些是只能在本文件引用，哪些能用在整个项目里，你还可以发挥大爱精神，把它开源成只要导入你的框架，大家都可以使用的 API。
|
||||
|
||||
这三种权限分别是：
|
||||
|
||||
@ -23,29 +23,29 @@ Swift语言从Xcode 6 beta 5版本起，加入了对权限控制（Access Contro
|
||||
|
||||
- #####internal 内部的
|
||||
|
||||
标记为internal的代码块，在整个应用（App bundle）或者框架（framework）的范围内都是可以访问的。
|
||||
标记为 internal 的代码块，在整个应用（App bundle）或者框架（framework）的范围内都是可以访问的。
|
||||
|
||||
- #####public 公开的
|
||||
|
||||
标记为public的代码块一般用来建立API，这是最开放的权限，使得任何人只要导入这个模块，都可以访问使用。
|
||||
标记为 public 的代码块一般用来建立 API，这是最开放的权限，使得任何人只要导入这个模块，都可以访问使用。
|
||||
|
||||
如果要把所有的爱加上一个期限，噢不，是给所有的代码块都标记上权限，不累死才怪。还好swift里面所有代码实体的默认权限，都是最常用的internal。所以当你开发自己的App时，可能完全不用管权限控制的事情。
|
||||
如果要把所有的爱加上一个期限，噢不，是给所有的代码块都标记上权限，不累死才怪。还好 swift 里面所有代码实体的默认权限，都是最常用的 internal。所以当你开发自己的 App 时，可能完全不用管权限控制的事情。
|
||||
|
||||
但当你需要写一个公开API的时候，就必须对里面的代码块进行“隐身对其可见”的public标记，要么其他人是用不到的。
|
||||
但当你需要写一个公开 API 的时候，就必须对里面的代码块进行“隐身对其可见”的 public 标记，要么其他人是用不到的。
|
||||
|
||||
Private（私有级别）的权限最严格，它可以用来隐藏某些功能的细节实现方式。合理构筑你的代码，你就可以安全地使用extension和高级功能，又不把它们暴露给项目内的其他文件。
|
||||
Private（私有级别）的权限最严格，它可以用来隐藏某些功能的细节实现方式。合理构筑你的代码，你就可以安全地使用 extension 和高级功能，又不把它们暴露给项目内的其他文件。
|
||||
|
||||
除了可以给整个声明设权限，Swift还允许大家在需要的时候，把某个属性（property）的取值权限比赋值权限设得更加开放。
|
||||
除了可以给整个声明设权限，Swift 还允许大家在需要的时候，把某个属性（property）的取值权限比赋值权限设得更加开放。
|
||||
|
||||
#####举个例子：
|
||||
```swift
|
||||
public class ListItem {
|
||||
|
||||
// ListItem这个类，有两个公开的属性
|
||||
// ListItem 这个类，有两个公开的属性
|
||||
public var text: String
|
||||
public var isComplete: Bool
|
||||
|
||||
// 下面的代码表示把变量UUID的赋值权限设为private，对整个app可读，但值只能在本文件里写入
|
||||
// 下面的代码表示把变量 UUID 的赋值权限设为 private，对整个 app 可读，但值只能在本文件里写入
|
||||
private(set) var UUID: NSUUID
|
||||
|
||||
public init(text: String, completed: Bool, UUID: NSUUID) {
|
||||
@ -54,7 +54,7 @@ Private（私有级别）的权限最严格，它可以用来隐藏某些功能
|
||||
self.UUID = UUID
|
||||
}
|
||||
|
||||
// 这段没有特别标记权限，因此属于默认的internal级别。在框架目标内可用，但对于其他目标不可用
|
||||
// 这段没有特别标记权限，因此属于默认的 internal 级别。在框架目标内可用，但对于其他目标不可用
|
||||
func refreshIdentity() {
|
||||
self.UUID = NSUUID()
|
||||
}
|
||||
@ -68,15 +68,15 @@ Private（私有级别）的权限最严格，它可以用来隐藏某些功能
|
||||
}
|
||||
```
|
||||
|
||||
当我们使用Objective-C和Swift混合开发时，需要注意：
|
||||
当我们使用 Objective-C 和 Swift 混合开发时，需要注意：
|
||||
|
||||
- 如果你在写的是一个应用，Xcode会生成一个头文件来保证两者的可互访性，而这个生成的头文件会包含public和internal级别的声明。
|
||||
- 如果你在写的是一个应用，Xcode 会生成一个头文件来保证两者的可互访性，而这个生成的头文件会包含 public 和 internal 级别的声明。
|
||||
|
||||
- 如果你的最终产品是一个Swift框架，头文件里只会出现标记为public级别的声明。（因为框架的头文件，属于公开的Objective-C接口的一部分，只有public部分对Objective-C可用。）
|
||||
- 如果你的最终产品是一个 Swift 框架，头文件里只会出现标记为 public 级别的声明。（因为框架的头文件，属于公开的 Objective-C 接口的一部分，只有 public 部分对 Objective-C 可用。）
|
||||
|
||||
虽然Swift不推荐大家传播和使用第三方的框架，但对于建立和分享源文件形式的框架是支持的。对于需要写框架，方便应用与多个项目的开发者来说，要记得把API标记为public级别。
|
||||
虽然 Swift 不推荐大家传播和使用第三方的框架，但对于建立和分享源文件形式的框架是支持的。对于需要写框架，方便应用与多个项目的开发者来说，要记得把 API 标记为 public 级别。
|
||||
|
||||
如果您想了解更多关于权限控制的内容，可以查看苹果官方最新的《The Swift Language》和《Using Swift with Cocoa and Objective-C》指南，
|
||||
这两本指南在iBooks里面可以下载更新喔。
|
||||
这两本指南在 iBooks 里面可以下载更新喔。
|
||||
|
||||
本文由翻译自Apple Swift Blog ：https://developer.apple.com/swift/blog/?id=5
|
||||
本文由翻译自 Apple Swift Blog ：https://developer.apple.com/swift/blog/?id=5
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# 造个类型不是梦-白话Swift类型创建
|
||||
# 造个类型不是梦-白话 Swift 类型创建
|
||||
-----------------
|
||||
|
||||
> 翻译：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)
|
||||
@ -9,17 +9,17 @@
|
||||
- [自定义原型](#prototype)
|
||||
- [实现默认值](#imp-default)
|
||||
- [支持基本布尔型初始化](#init-by-bool)
|
||||
- [支持Bool类型判断](#condition-by-bool)
|
||||
- [支持 Bool 类型判断](#condition-by-bool)
|
||||
- [支持兼容各们各派的类型](#support-all-type)
|
||||
- [完善OCBool的布尔基因体系](#make-up-type)
|
||||
- [完善 OCBool 的布尔基因体系](#make-up-type)
|
||||
|
||||
小伙伴们，Swift中的Bool类型有着非常重要的语法功能，并支撑起了整个Swift体系中的逻辑判断体系，经过老码的研究和学习， Bool类型本身其实是对基础Boolean类型封装，小伙伴们可能咬着手指头问老码，怎么一会Bool类型，一会Boolean类型，其区别在于，前者是基于枚举的组合类型，而后者则是基本类型，只有两种true和false。
|
||||
小伙伴们，Swift 中的 Bool 类型有着非常重要的语法功能，并支撑起了整个 Swift 体系中的逻辑判断体系，经过老码的研究和学习， Bool 类型本身其实是对基础 Boolean 类型封装，小伙伴们可能咬着手指头问老码，怎么一会 Bool 类型，一会 Boolean 类型，其区别在于，前者是基于枚举的组合类型，而后者则是基本类型，只有两种 true 和 false。
|
||||
|
||||
<a name="prefix_expressions"></a>
|
||||
####自定义原型
|
||||
|
||||
接下老码根据Bool的思想来创建一个OCBool类型，来让小伙伴们了解一下Swift中到底是怎么玩儿的。
|
||||
来我们先看一下OCBool的定义。
|
||||
接下老码根据 Bool 的思想来创建一个 OCBool 类型，来让小伙伴们了解一下 Swift 中到底是怎么玩儿的。
|
||||
来我们先看一下 OCBool 的定义。
|
||||
|
||||
#####代码示例如下：
|
||||
|
||||
@ -32,13 +32,13 @@ case ocFalse
|
||||
|
||||
#####注意：
|
||||
|
||||
- 代码中第2行和第3行，可以合并到一行写，如苹果官方Blog所写的一样
|
||||
- 代码中命名需要注意：OCBool是类型名，所以首字母必须大写，而case中的ocTrue和ocFalse是小类型则需要首字母小写。
|
||||
- 代码中第2行和第3行，可以合并到一行写，如苹果官方 Blog 所写的一样
|
||||
- 代码中命名需要注意：OCBool 是类型名，所以首字母必须大写，而 case 中的 ocTrue 和 ocFalse 是小类型则需要首字母小写。
|
||||
|
||||
<a name="imp-default"></a>
|
||||
####实现默认值
|
||||
|
||||
行，我们给了一个漂亮的定义，不过按照传统语言的经验，Bool值默认情况下是假， 所以我们的OCBool也应该如此，我们使用类型扩展技术增加这个默认特性：
|
||||
行，我们给了一个漂亮的定义，不过按照传统语言的经验，Bool 值默认情况下是假， 所以我们的 OCBool 也应该如此，我们使用类型扩展技术增加这个默认特性：
|
||||
```swift
|
||||
extension OCBool{
|
||||
init(){
|
||||
@ -49,9 +49,9 @@ extension OCBool{
|
||||
|
||||
#####注意：
|
||||
|
||||
- 代码中第1行：extension关键字，非常强大，小伙伴们可以通过此创造出许多好玩的东西，建议各位去Github上看一个名为“Swiftz”的项目，它将扩展用到了极致。
|
||||
- 代码中第3行：self = .ocFalse语法，刚入门的小伙伴们很迷糊，为什么会有奇怪的点语法，因为大牛Chris在Swift中增加了类型智能推断功能，在苹果Blog中，提到了“Context”概念，就是这个意思，因为这行语句是在枚举OCBool中的，其上下文就是OCBool的定义体，编译器当然知道.ocFalse就是OCBool.ocFalse了，所以这里直接点语法，非常整齐。
|
||||
现在我们可以使用如下方法使用这个Bool类型。
|
||||
- 代码中第1行：extension 关键字，非常强大，小伙伴们可以通过此创造出许多好玩的东西，建议各位去 Github 上看一个名为“Swiftz”的项目，它将扩展用到了极致。
|
||||
- 代码中第3行：self = .ocFalse 语法，刚入门的小伙伴们很迷糊，为什么会有奇怪的点语法，因为大牛 Chris 在 Swift 中增加了类型智能推断功能，在苹果 Blog 中，提到了“Context”概念，就是这个意思，因为这行语句是在枚举 OCBool 中的，其上下文就是 OCBool 的定义体，编译器当然知道.ocFalse 就是 OCBool.ocFalse 了，所以这里直接点语法，非常整齐。
|
||||
现在我们可以使用如下方法使用这个 Bool 类型。
|
||||
|
||||
#####代码示例如下：
|
||||
|
||||
@ -63,7 +63,7 @@ var result1:OCBool = .ocTrue
|
||||
<a name="init-by-bool"></a>
|
||||
####支持基本布尔型初始化
|
||||
|
||||
正如上述代码所述，我们只能通过类型或者枚举项目赋值，这是组合类型的用法，但是编码的日子里，我们总是希望和true，false直接打交道，也就是说，我们希望这么做，
|
||||
正如上述代码所述，我们只能通过类型或者枚举项目赋值，这是组合类型的用法，但是编码的日子里，我们总是希望和 true，false 直接打交道，也就是说，我们希望这么做，
|
||||
代码示例如下：
|
||||
```swift
|
||||
var isSuccess:OCBool = true
|
||||
@ -97,7 +97,7 @@ var isSuccess:OCBool = true
|
||||
|
||||
#####注意：
|
||||
|
||||
- 代码中的第11行是重点，我的类型OCBool支持了BooleanLiteralConvertible协议，这个协到底是干什么的呢，小伙伴们在Xcode代码编辑器，按住Command键，然后点击第11行中的BooleanLiteralConvertible协议名，则会进入它的定义，
|
||||
- 代码中的第11行是重点，我的类型 OCBool 支持了 BooleanLiteralConvertible 协议，这个协到底是干什么的呢，小伙伴们在 Xcode 代码编辑器，按住 Command 键，然后点击第11行中的 BooleanLiteralConvertible 协议名，则会进入它的定义，
|
||||
#####其定义如下：
|
||||
```swift
|
||||
protocol BooleanLiteralConvertible {
|
||||
@ -106,10 +106,10 @@ protocol BooleanLiteralConvertible {
|
||||
}
|
||||
```
|
||||
|
||||
- 这个定义中有个类方法convertFromBooleanLiteral，它的参数为BooleanLiteralType类型，也就是我传入的Bool类型， 且返回值为实现这个协议的类型本身，在我们的OCBool类型中，其返回值就是OCBool本身。经过这个定义，我们可以直接对OCBool类型直接进行布尔字面量初始化了。
|
||||
- 这个定义中有个类方法 convertFromBooleanLiteral，它的参数为 BooleanLiteralType 类型，也就是我传入的 Bool 类型， 且返回值为实现这个协议的类型本身，在我们的 OCBool 类型中，其返回值就是 OCBool 本身。经过这个定义，我们可以直接对 OCBool 类型直接进行布尔字面量初始化了。
|
||||
|
||||
<a name="condition-by-bool"></a>
|
||||
####支持Bool类型判断
|
||||
####支持 Bool 类型判断
|
||||
|
||||
小伙伴们不安分， 肯定想着我怎么用它实现逻辑判断，所以如果你这么写，
|
||||
|
||||
@ -127,7 +127,7 @@ if isSuccess {
|
||||
```
|
||||
/Users/tyrion-OldCoder/Documents/Learning/BoolType/BoolType/main.swift:27:4: Type 'OCBool' does not conform to protocol 'LogicValue'
|
||||
```
|
||||
OCBool现在只能用bool类型初始化，而不能直接返回bool型，小火把们还记得在《老码说编程之白话Swift江湖》中，老码多次提到，妈妈再也不担心我们 if a = 1{}的写法了， 因为等号不支持值返回了， 所以在if判断是后面的条件必须有返回值，OCBool没有，所以编译器哭了。我们解决这个问题。
|
||||
OCBool 现在只能用 bool 类型初始化，而不能直接返回 bool 型，小火把们还记得在《老码说编程之白话 Swift 江湖》中，老码多次提到，妈妈再也不担心我们 if a = 1{}的写法了， 因为等号不支持值返回了， 所以在 if 判断是后面的条件必须有返回值，OCBool 没有，所以编译器哭了。我们解决这个问题。
|
||||
|
||||
#####代码示例如下：
|
||||
|
||||
@ -178,14 +178,14 @@ Program ended with exit code: 0
|
||||
|
||||
#####注意：
|
||||
|
||||
- 如果小伙伴们现在用的是Beta版的Xcode，注意苹果官方Blog中，在代码第17行如果在Xcode Beta4下是错误的，这里的协议是，LogicValue而不是BooleanVue，所以记得看错误提示才是好习惯。
|
||||
- 注意代码第34行，完美支持if判断，且输出结果为“老码请你吃火锅”，老码也是说说而已，请不要当真。
|
||||
- 如果小伙伴们现在用的是 Beta 版的 Xcode，注意苹果官方 Blog 中，在代码第17行如果在 Xcode Beta4下是错误的，这里的协议是，LogicValue 而不是 BooleanVue，所以记得看错误提示才是好习惯。
|
||||
- 注意代码第34行，完美支持 if 判断，且输出结果为“老码请你吃火锅”，老码也是说说而已，请不要当真。
|
||||
|
||||
<a name="support-all-type"></a>
|
||||
|
||||
####支持兼容各们各派的类型
|
||||
|
||||
小伙伴们，江湖风险，门派众多，老码有自己的OCBool类型，可能嵩山少林有自己的SSBool类型，甚至连郭美美都可能有自己的MMBool类型，所以OCBool必须能够识别这些类型，这些各门各派的类型，只要支持LogicValue协议，就应该可以被识别，看老码怎么做，
|
||||
小伙伴们，江湖风险，门派众多，老码有自己的 OCBool 类型，可能嵩山少林有自己的 SSBool 类型，甚至连郭美美都可能有自己的 MMBool 类型，所以 OCBool 必须能够识别这些类型，这些各门各派的类型，只要支持 LogicValue 协议，就应该可以被识别，看老码怎么做，
|
||||
|
||||
#####代码示例如下：
|
||||
|
||||
@ -218,16 +218,16 @@ Hello, World!
|
||||
老码没钱，郭美美请你吃火锅！
|
||||
Program ended with exit code: 0
|
||||
```
|
||||
漂亮！我们的OCBool类型现在支持了所有的逻辑变量初始化。
|
||||
漂亮！我们的 OCBool 类型现在支持了所有的逻辑变量初始化。
|
||||
|
||||
#####注意：
|
||||
|
||||
- 代码中第2行：“_”下横杠的用法，这是一个功能强大的小强，在此的目的是屏蔽外部参数名，所以小伙伴们可以直接：var ocResult:OCBool = OCBool(mmResult)而不是：var ocResult:OCBool = OCBool(v: mmResult)，小伙伴们惊呆了！这个init函数中本来就没有外部参数名啊，还记得老码在书里说过没，Swift的初始化函数会默认使用内部参数名，作为外部参数名。
|
||||
- 代码中第2行：“_”下横杠的用法，这是一个功能强大的小强，在此的目的是屏蔽外部参数名，所以小伙伴们可以直接：var ocResult:OCBool = OCBool(mmResult)而不是：var ocResult:OCBool = OCBool(v: mmResult)，小伙伴们惊呆了！这个 init 函数中本来就没有外部参数名啊，还记得老码在书里说过没，Swift 的初始化函数会默认使用内部参数名，作为外部参数名。
|
||||
|
||||
<a name="make-up-type"></a>
|
||||
####完善OCBool的布尔基因体系：
|
||||
####完善 OCBool 的布尔基因体系：
|
||||
|
||||
小伙伴们，bool类型的价值就是在于各种判断，诸如==，!=, &，|,^,!，以及各种组合逻辑运算，我们OCBool也要具备这些功能，否则就会基因缺陷，且看老码如何实现：
|
||||
小伙伴们，bool 类型的价值就是在于各种判断，诸如==，!=, &，|,^,!，以及各种组合逻辑运算，我们 OCBool 也要具备这些功能，否则就会基因缺陷，且看老码如何实现：
|
||||
|
||||
```swift
|
||||
extension OCBool: Equatable{
|
||||
@ -294,6 +294,6 @@ if (isHasMoney | isHasHealty) & isHasHealty{
|
||||
}
|
||||
```
|
||||
|
||||
好了，到这里就到这里了，窗外的雷声叫醒了老码，现在应该去吃饭了，以上老码给大家展示了如果制造一个自己的类型，记得老码的示例是在Xcode6 Beta4下测试的，至于Beta5的改变还没有涉及，小伙伴们要好生练习，以后各种自定类型都是基于这个思想。还有这个章节不是老码的原创，老码认真的阅读了苹果的官方博客，且自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌，还是看不懂请到老码官方微博：http://weibo.com/u/5241713117咆哮。
|
||||
好了，到这里就到这里了，窗外的雷声叫醒了老码，现在应该去吃饭了，以上老码给大家展示了如果制造一个自己的类型，记得老码的示例是在 Xcode6 Beta4下测试的，至于 Beta5的改变还没有涉及，小伙伴们要好生练习，以后各种自定类型都是基于这个思想。还有这个章节不是老码的原创，老码认真的阅读了苹果的官方博客，且自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌，还是看不懂请到老码官方微博：http://weibo.com/u/5241713117咆哮。
|
||||
|
||||
本文由翻译自Apple Swift Blog ：https://developer.apple.com/swift/blog/?id=8
|
||||
本文由翻译自 Apple Swift Blog ：https://developer.apple.com/swift/blog/?id=8
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
# WWDC里面的那个“大炮打气球”
|
||||
# WWDC 里面的那个“大炮打气球”
|
||||
|
||||
> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)
|
||||
> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)
|
||||
> 校对：[老码团队翻译组-](Jame)
|
||||
|
||||
|
||||
|
||||
很多小伙伴说，对WWDC上介绍Swift语言时，演示的那个“大炮打气球”的Ballons项目很感兴趣。
|
||||
很多小伙伴说，对 WWDC 上介绍 Swift 语言时，演示的那个“大炮打气球”的 Ballons 项目很感兴趣。
|
||||
|
||||
Ballons不但展现了playgrounds许多很赞的特性，还让我们看到写代码的过程，原来可以这么互动，这么好玩。
|
||||
Ballons 不但展现了 playgrounds 许多很赞的特性，还让我们看到写代码的过程，原来可以这么互动，这么好玩。
|
||||
|
||||
现在你可以下载这个[Ballons.playground](https://developer.apple.com/swift/blog/downloads/Balloons.zip)的教学版本，学习这些有趣的效果是怎么实现的。教学版本里除了源文件，还有相关说明文档，我们还出了一些小小的实验题，你可以动手修改代码，然后在右侧马上看到效果。
|
||||
|
||||
这个playground文件用到了SpriteKit的新特性，因此需要最新beta版本的Xcode 6和Yosemite系统来支持它运行。
|
||||
这个 playground 文件用到了 SpriteKit 的新特性，因此需要最新 beta 版本的 Xcode 6和 Yosemite 系统来支持它运行。
|
||||
|
||||
本文由翻译自Apple Swift Blog的博文：[Ballons](https://developer.apple.com/swift/blog/?id=9)
|
||||
本文由翻译自 Apple Swift Blog 的博文：[Ballons](https://developer.apple.com/swift/blog/?id=9)
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
# Swift与C语言指针友好合作
|
||||
# Swift 与 C 语言指针友好合作
|
||||
-----------------
|
||||
|
||||
> 翻译：[老码团队翻译组-Relly](http://weibo.com/penguinliong/)
|
||||
> 翻译：[老码团队翻译组-Relly](http://weibo.com/penguinliong/)
|
||||
> 校对：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)
|
||||
|
||||
本页包含内容：
|
||||
@ -11,16 +11,16 @@
|
||||
- [用作字符串参数的指针](#string-as-para-pointer)
|
||||
- [指针参数转换的安全性](#security-of-pointer-cast)
|
||||
|
||||
Objective-C和C的API常常会需要用到指针。Swift中的数据类型都原生支持基于指针的Cocoa API，不仅如此，Swift会自动处理部分最常用的将指针作为参数传递的情况。这篇文章中，我们将着眼于在Swift中让C语言指针与变量、数组和字符串共同工作。
|
||||
Objective-C 和 C 的 API 常常会需要用到指针。Swift 中的数据类型都原生支持基于指针的 Cocoa API，不仅如此，Swift 会自动处理部分最常用的将指针作为参数传递的情况。这篇文章中，我们将着眼于在 Swift 中让 C 语言指针与变量、数组和字符串共同工作。
|
||||
|
||||
####用以输入/输出的参数指针
|
||||
|
||||
C和Objective-C并不支持多返回值，所以Cocoa API中常常将指针作为一种在方法间传递额外数据的方式。Swift允许指针被当作`inout`参数使用，所以你可以用符号`&`将对一个变量的引用作为指针参数传递。举例来说：`UIColor`中的`getRed(_:green:blue:alpha:)`方法需要四个`CGFloat*`指针来接收颜色的组成信息，我们使用`&`来将这些组成信息捕获为本地变量：
|
||||
C 和 Objective-C 并不支持多返回值，所以 Cocoa API 中常常将指针作为一种在方法间传递额外数据的方式。Swift 允许指针被当作 `inout` 参数使用，所以你可以用符号 `&` 将对一个变量的引用作为指针参数传递。举例来说：`UIColor` 中的 `getRed(_:green:blue:alpha:)` 方法需要四个 `CGFloat*` 指针来接收颜色的组成信息，我们使用 `&` 来将这些组成信息捕获为本地变量：
|
||||
```swift
|
||||
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`的`contentOfDirectoryAtPath(_:error:)`方法来将目录下的内容列表，并将潜在的错误指向一个`NSError?`变量：
|
||||
另一种常见的情况是 Cocoa 中 `NSError` 的习惯用法。许多方法会使用一个 `NSError**` 参数来储存可能的错误的信息。举例来说：我们用 `NSFileManager` 的 `contentOfDirectoryAtPath(_:error:)` 方法来将目录下的内容列表，并将潜在的错误指向一个 `NSError?` 变量：
|
||||
```swift
|
||||
var maybeError: NSError?
|
||||
if let contents = NSFileManager.defaultManager()
|
||||
@ -30,11 +30,11 @@ if let contents = NSFileManager.defaultManager()
|
||||
// Handle the error
|
||||
}
|
||||
```
|
||||
为了安全性，Swift要求被使用`&`传递的变量已经初始化。因为无法确定这个方法会不会在写入数据前尝试从指针中读取数据。
|
||||
为了安全性，Swift 要求被使用 `&` 传递的变量已经初始化。因为无法确定这个方法会不会在写入数据前尝试从指针中读取数据。
|
||||
|
||||
####作为数组使用的参数指针
|
||||
|
||||
在C语言中，数组和指针的联系十分紧密，而Swift允许数组能够作为指针使用，从而与基于数组的C语言API协同工作更加简单。一个固定的数组可以使用一个常量指针直接传递，一个变化的数组可以用`&`运算符将一个非常量指针传递。就和输入/输出参数指针一样。举例来说：我们可以用Accelerate框架中的`vDSP_vadd`方法让两个数组`a`和`b`相加，并将结果写入第三个数组`result`。
|
||||
在 C 语言中，数组和指针的联系十分紧密，而 Swift 允许数组能够作为指针使用，从而与基于数组的 C 语言 API 协同工作更加简单。一个固定的数组可以使用一个常量指针直接传递，一个变化的数组可以用 `&` 运算符将一个非常量指针传递。就和输入/输出参数指针一样。举例来说：我们可以用 Accelerate 框架中的 `vDSP_vadd` 方法让两个数组 `a` 和 `b` 相加，并将结果写入第三个数组 `result`。
|
||||
```swift
|
||||
import Accelerate
|
||||
|
||||
@ -49,7 +49,7 @@ vDSP_vadd(a, 1, b, 1, &result, 1, 4)
|
||||
|
||||
## 用作字符串参数的指针
|
||||
|
||||
C语言中用`cont char*`指针来作为传递字符串的基本方式。Swift中的`String`可以被当作一个无限长度UTF-8编码的`const char*`指针来传递给方法。举例来说：我们可以直接传递一个字符串给一个标准C和POSIX库方法
|
||||
C 语言中用 `cont char*` 指针来作为传递字符串的基本方式。Swift 中的 `String` 可以被当作一个无限长度 UTF-8编码的 `const char*` 指针来传递给方法。举例来说：我们可以直接传递一个字符串给一个标准 C 和 POSIX 库方法
|
||||
```swift
|
||||
puts("Hello from libc")
|
||||
let fd = open("/tmp/scratch.txt", O_WRONLY|O_CREAT, 0o666)
|
||||
@ -65,9 +65,9 @@ if fd < 0 {
|
||||
|
||||
## 指针参数转换的安全性
|
||||
|
||||
Swift很努力地使与C语言指针的交互更加便利，因为它们广泛地存在于Cocoa之中，同时保持一定的安全性。然而，相比你的其他Swift代码与C语言的指针交互具有潜在的不安全性，所以务必要小心使用。其中特别要注意：
|
||||
- 如果被调用者为了在其返回值之后再次使用而保存了C指针的数据，那么这些转换使用起来并不安全。转换后的指针仅在调用期间保证有效。甚至你将同样的变量、数组或字符串作为多指针参数再次传递，你每次都会收到一个不同的指针。这个异常将全局或静态地储存为变量。你可以安全地将这段地址当作永久唯一的指针使用。例如：作为一个KVO上下文参数使用的时候。
|
||||
Swift 很努力地使与 C 语言指针的交互更加便利，因为它们广泛地存在于 Cocoa 之中，同时保持一定的安全性。然而，相比你的其他 Swift 代码与 C 语言的指针交互具有潜在的不安全性，所以务必要小心使用。其中特别要注意：
|
||||
- 如果被调用者为了在其返回值之后再次使用而保存了 C 指针的数据，那么这些转换使用起来并不安全。转换后的指针仅在调用期间保证有效。甚至你将同样的变量、数组或字符串作为多指针参数再次传递，你每次都会收到一个不同的指针。这个异常将全局或静态地储存为变量。你可以安全地将这段地址当作永久唯一的指针使用。例如：作为一个 KVO 上下文参数使用的时候。
|
||||
|
||||
- 当指针类型为`Array`或`String`时，溢出检查不是强制进行的。 基于C语言的API无法增加数组和字符串大小，所以在你将其传递到基于C语言的API之前，你必须确保数组或字符的大小正确。
|
||||
- 当指针类型为 `Array` 或 `String` 时，溢出检查不是强制进行的。 基于 C 语言的 API 无法增加数组和字符串大小，所以在你将其传递到基于 C 语言的 API 之前，你必须确保数组或字符的大小正确。
|
||||
|
||||
如果你需要使用基于指针的API时没有遵守以上指导，或是你重写了接受指针参数的Cocoa方法，于是你可以在Swift中直接用不安全的指针来使用未经处理的内存。在未来的文章中我们将着眼于更加高级的情况。
|
||||
如果你需要使用基于指针的 API 时没有遵守以上指导，或是你重写了接受指针参数的 Cocoa 方法，于是你可以在 Swift 中直接用不安全的指针来使用未经处理的内存。在未来的文章中我们将着眼于更加高级的情况。
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
# Swift里的值类型与引用类型
|
||||
# Swift 里的值类型与引用类型
|
||||
-----------------
|
||||
|
||||
> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)
|
||||
> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)
|
||||
> 校对：[老码团队翻译组-Jame](http://weibo.com/u/5241713117)
|
||||
|
||||
本页包含内容：
|
||||
@ -10,10 +10,10 @@
|
||||
- [Mutation（修改）在安全中扮演的角色](#act-in=mutation)
|
||||
- [如何选择类型](#how-to-choose)
|
||||
|
||||
### Swift里面的类型分为两种：
|
||||
### Swift 里面的类型分为两种：
|
||||
|
||||
* **值类型(Value Types)**：每个实例都保留了一分独有的数据拷贝，一般以结构体 `（struct）`、`枚举（enum）` 或者`元组（tuple）`的形式出现。
|
||||
* **引用类型(Reference Type)**：每个实例共享同一份数据来源，一般以`类（class）`的形式出现。
|
||||
* **值类型(Value Types)**：每个实例都保留了一分独有的数据拷贝，一般以结构体 `（struct）`、` 枚举（enum）` 或者 `元组（tuple）`的形式出现。
|
||||
* **引用类型(Reference Type)**：每个实例共享同一份数据来源，一般以 `类（class）`的形式出现。
|
||||
|
||||
在这篇博文里面，我们会介绍两种类型各自的优点，以及应该怎么选择使用。
|
||||
|
||||
@ -26,8 +26,8 @@
|
||||
// 下面是一个值类型的例子
|
||||
struct S { var data: Int = -1 }
|
||||
var a = S()
|
||||
var b = a // b是a的拷贝
|
||||
a.data = 42 // 更改a的数据，b的不受影响
|
||||
var b = a // b 是 a 的拷贝
|
||||
a.data = 42 // 更改 a 的数据，b 的不受影响
|
||||
println("\(a.data), \(b.data)") // 输出结果 "42, -1"
|
||||
```
|
||||
|
||||
@ -39,24 +39,24 @@
|
||||
// 下面是一个引用类型的例子
|
||||
class C { var data: Int = -1 }
|
||||
var x = C()
|
||||
var y = x // y是x的拷贝
|
||||
x.data = 42 // 更改x的数据，等于同时修改了y
|
||||
var y = x // y 是 x 的拷贝
|
||||
x.data = 42 // 更改 x 的数据，等于同时修改了 y
|
||||
println("\(x.data), \(y.data)") // 输出结果 "42, 42"
|
||||
```
|
||||
|
||||
<a name="act-in=mutation"></a>
|
||||
#### Mutation（修改）在安全中扮演的角色
|
||||
|
||||
值类型较引用类型来说，会让你更容易在大量代码中理清状况。如果你总是得到一个独立的拷贝出来的实例，你就可以放心它不会被你app里面的其他部分代码默默地修改。这在多线程的环境里面是尤为重要的，因为另外一个线程可能会在暗地里修改你的数据。因此可能会造成严重的程序错误，这在调试过程中非常难以排除。
|
||||
值类型较引用类型来说，会让你更容易在大量代码中理清状况。如果你总是得到一个独立的拷贝出来的实例，你就可以放心它不会被你 app 里面的其他部分代码默默地修改。这在多线程的环境里面是尤为重要的，因为另外一个线程可能会在暗地里修改你的数据。因此可能会造成严重的程序错误，这在调试过程中非常难以排除。
|
||||
|
||||
由于差别主要在于修改数据的后果，那么当实例的数据只读，不存在需要更改的情况下，用哪种类型都是没有分别的。
|
||||
|
||||
你可能在想，有的时候我可能也需要一个完全不变的类。这样使用`Cocoa NSObject`对象的时候会比较容易，又可以保留值语义的好处。在今天，你可以通过只使用不可变的存储属性，和避开任何可以修改状态的API，用Swift写出一个不可变类`（immutable class）`。实际上，很多基本的Cocoa类，例如`NSURL`，都是设计成不可变类的。然而，Swift语言目前只强制`struct`和`enum`这种值类型的不可变性，对类这种引用类型则没有。（例如还不支持强制将子类的限制为不可变类）
|
||||
你可能在想，有的时候我可能也需要一个完全不变的类。这样使用 `Cocoa NSObject` 对象的时候会比较容易，又可以保留值语义的好处。在今天，你可以通过只使用不可变的存储属性，和避开任何可以修改状态的 API，用 Swift 写出一个不可变类 `（immutable class）`。实际上，很多基本的 Cocoa 类，例如 `NSURL`，都是设计成不可变类的。然而，Swift 语言目前只强制 `struct` 和 `enum` 这种值类型的不可变性，对类这种引用类型则没有。（例如还不支持强制将子类的限制为不可变类）
|
||||
|
||||
<a name="how-to-choose"></a>
|
||||
#### 如何选择类型？
|
||||
|
||||
所以当我们想要建立一个新的类型的时候，怎么决定用值类型还是引用类型呢？当你使用Cocoa框架的时候，很多API都要通过NSObject的子类使用，所以这时候必须要用到引用类型class。在其他情况下，有下面几个准则：
|
||||
所以当我们想要建立一个新的类型的时候，怎么决定用值类型还是引用类型呢？当你使用 Cocoa 框架的时候，很多 API 都要通过 NSObject 的子类使用，所以这时候必须要用到引用类型 class。在其他情况下，有下面几个准则：
|
||||
|
||||
* **什么时候该用值类型**：
|
||||
* 要用==运算符来比较实例的数据时
|
||||
@ -67,9 +67,9 @@
|
||||
* 要用==运算符来比较实例身份的时候
|
||||
* 你希望有创建一个共享的、可变对象的时候
|
||||
|
||||
在Swift里面，数组(Array)、字符串(String)、字典(Dictionary)都属于值类型。它们就像C语言里面简单的int值，是一个个独立的数据个体。你不需要花任何功夫来防范其他代码在暗地里修改它们。更重要的是，你可以在线程之间安全的传递变量，而不需要特地去同步。在Swift高安全性的精神下，这个模式会帮助你用Swift写出更可控的代码。
|
||||
在 Swift 里面，数组(Array)、字符串(String)、字典(Dictionary)都属于值类型。它们就像 C 语言里面简单的 int 值，是一个个独立的数据个体。你不需要花任何功夫来防范其他代码在暗地里修改它们。更重要的是，你可以在线程之间安全的传递变量，而不需要特地去同步。在 Swift 高安全性的精神下，这个模式会帮助你用 Swift 写出更可控的代码。
|
||||
|
||||
-----------------
|
||||
本章节不是老码的原创，老码认真的阅读了苹果的官方博客，且自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌，还是看不懂请到老码[官方微博](http://weibo.com/u/5241713117)咆哮。
|
||||
本章节不是老码的原创，老码认真的阅读了苹果的官方博客，且自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌，还是看不懂请到老码[官方微博](http://weibo.com/u/5241713117)咆哮。
|
||||
|
||||
##### 本文由翻译自Apple Swift Blog ：[Value and Reference Types](https://developer.apple.com/swift/blog/?id=10)
|
||||
##### 本文由翻译自 Apple Swift Blog ：[Value and Reference Types](https://developer.apple.com/swift/blog/?id=10)
|
||||
|
||||
@ -1,33 +1,33 @@
|
||||
# 访问控制和protected
|
||||
# 访问控制和 protected
|
||||
-----------------
|
||||
|
||||
> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)
|
||||
> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)
|
||||
> 校对：[老码团队翻译组-Jame](http://weibo.com/u/5241713117)
|
||||
|
||||
原文再续，书折第一回。
|
||||
|
||||
很多其他编程语言都有一种”protected“设定，可以限制某些类方法只能被它的子类所使用。
|
||||
|
||||
Swift支持了访问控制后，大家给我们的反馈都很不错。而有的开发者问我们：“为什么Swift没有类似protected的选项？”
|
||||
Swift 支持了访问控制后，大家给我们的反馈都很不错。而有的开发者问我们：“为什么 Swift 没有类似 protected 的选项？”
|
||||
|
||||
**当我们在设计Swift访问控制的不同等级时，我们认为有两种主要场景：**
|
||||
**当我们在设计 Swift 访问控制的不同等级时，我们认为有两种主要场景：**
|
||||
|
||||
* 在一个APP里：隐藏某个类的私密细节。
|
||||
* 在一个开源框架里：不让导入这个框架的APP，随便接触框架的内部实现细节。
|
||||
* 在一个 APP 里：隐藏某个类的私密细节。
|
||||
* 在一个开源框架里：不让导入这个框架的 APP，随便接触框架的内部实现细节。
|
||||
|
||||
上面的两种常见情况，对应着private和internal这两个等级。
|
||||
上面的两种常见情况，对应着 private 和 internal 这两个等级。
|
||||
|
||||
而protected相当于把访问控制和继承特性混在一起，把访问控制的等级设定增加了一个维度，使之复杂化。即使设定了protected，子类还是可以通过新的公开方法、新的属性来接触到所谓“protected”了的API。另一方面，我们可以在各种地方重写一个方法，所谓的保护却没有提供优化机制。这种设定往往在做不必要的限制 一 protected允许了子类，但又禁止所有其他别的类（包括那些帮助子类实现某些功能的类）接触父类的成员。
|
||||
而 protected 相当于把访问控制和继承特性混在一起，把访问控制的等级设定增加了一个维度，使之复杂化。即使设定了 protected，子类还是可以通过新的公开方法、新的属性来接触到所谓“protected”了的 API。另一方面，我们可以在各种地方重写一个方法，所谓的保护却没有提供优化机制。这种设定往往在做不必要的限制 一 protected 允许了子类，但又禁止所有其他别的类（包括那些帮助子类实现某些功能的类）接触父类的成员。
|
||||
|
||||
有的开发者指出，apple的框架有时候也会把给子类用的API分隔出来。这时候protected不就有用了吗？我们研究后发现，这些方法一般属于下面两种情况：一是这些方法对子类以外的类没啥用，所以不需要严格保护（例如上面说的协助实现某些功能的类）。二是这些方法就是设计出来被重写，而不是直接用的。举个例子，`drawRect(_:) `就是在UIKit基础上使用的方法，但它不能在UIKit以外应用。
|
||||
有的开发者指出，apple 的框架有时候也会把给子类用的 API 分隔出来。这时候 protected 不就有用了吗？我们研究后发现，这些方法一般属于下面两种情况：一是这些方法对子类以外的类没啥用，所以不需要严格保护（例如上面说的协助实现某些功能的类）。二是这些方法就是设计出来被重写，而不是直接用的。举个例子，`drawRect(_:)` 就是在 UIKit 基础上使用的方法，但它不能在 UIKit 以外应用。
|
||||
|
||||
除此之外，如果有了protected，它要怎么样和extension相互作用呢？一个类的extension能接触它的protected成员吗？一个子类的extension可以接触父类的protected成员吗？extension声明的位置对访问控制等级有没有影响呢？（复杂到要哭了是不是？）
|
||||
除此之外，如果有了 protected，它要怎么样和 extension 相互作用呢？一个类的 extension 能接触它的 protected 成员吗？一个子类的 extension 可以接触父类的 protected 成员吗？extension 声明的位置对访问控制等级有没有影响呢？（复杂到要哭了是不是？）
|
||||
|
||||
对访问控制的设计，也依循了Objective－C开发者（包括apple内外的）的常规做法。Objective－C方法和属性一般在.h头文件里声明，但也可以写在.m实现文件里。假如有一个公开的类，想把里面某些部分设为只有框架内可以获取时，开发者一般会创建另一个头文件给内部使用。以上三种访问级别，就对应了Swift里面的public，private和internal。
|
||||
对访问控制的设计，也依循了 Objective－C 开发者（包括 apple 内外的）的常规做法。Objective－C 方法和属性一般在.h 头文件里声明，但也可以写在.m 实现文件里。假如有一个公开的类，想把里面某些部分设为只有框架内可以获取时，开发者一般会创建另一个头文件给内部使用。以上三种访问级别，就对应了 Swift 里面的 public，private 和 internal。
|
||||
|
||||
Swift的访问控制等级和继承无关，是单维度、非常清楚明了的。我们认为这样的模式更简洁，同时满足了最主要的需求：将一个类、或一个框架的实现细节隔离保护起来。这可能和你以前用过的不同，但我们鼓励你试试看。
|
||||
Swift 的访问控制等级和继承无关，是单维度、非常清楚明了的。我们认为这样的模式更简洁，同时满足了最主要的需求：将一个类、或一个框架的实现细节隔离保护起来。这可能和你以前用过的不同，但我们鼓励你试试看。
|
||||
|
||||
-----------------
|
||||
本章节不是老码的原创，是老码认真的阅读了苹果的官方博客，自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌。还是看不懂？请到老码[官方微博](http://weibo.com/u/5241713117)咆哮。
|
||||
本章节不是老码的原创，是老码认真的阅读了苹果的官方博客，自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌。还是看不懂？请到老码[官方微博](http://weibo.com/u/5241713117)咆哮。
|
||||
|
||||
##### 本文由翻译自Apple Swift Blog ：[Access Control and Protected](原文地址：https://developer.apple.com/swift/blog/?id=11)
|
||||
##### 本文由翻译自 Apple Swift Blog ：[Access Control and Protected](原文地址：https://developer.apple.com/swift/blog/?id=11)
|
||||
|
||||
@ -1,24 +1,24 @@
|
||||
# 可选类型完美解决占位问题
|
||||
-----------------
|
||||
|
||||
> 翻译：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)
|
||||
> 翻译：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)
|
||||
> 校对：[老码团队翻译组-Ayra](http://weibo.com/littlekok/)
|
||||
|
||||
本页包含内容：
|
||||
|
||||
- [为Dictionary增加objectsForKeys函数](#add-function)
|
||||
- [Swift中更简便的方法](##easy-function)
|
||||
- [为 Dictionary 增加 objectsForKeys 函数](#add-function)
|
||||
- [Swift 中更简便的方法](##easy-function)
|
||||
- [内嵌可选类型](#nested-optional)
|
||||
- [提供一个默认值](#provide-default)
|
||||
|
||||
可选类型是Swift中新引入的，功能很强大。在这篇博文里讨论的，是在Swift里，如何通过可选类型来保证强类型的安全性。作为例子，我们来创建一个Objective-C API的Swift版本，但实际上Swift本身并不需要这样的API。
|
||||
可选类型是 Swift 中新引入的，功能很强大。在这篇博文里讨论的，是在 Swift 里，如何通过可选类型来保证强类型的安全性。作为例子，我们来创建一个 Objective-C API 的 Swift 版本，但实际上 Swift 本身并不需要这样的 API。
|
||||
|
||||
<a name="#add-function"></a>
|
||||
#### 为Dictionary增加objectsForKeys函数
|
||||
#### 为 Dictionary 增加 objectsForKeys 函数
|
||||
|
||||
在Objective-C中，```NSDictionary```有一个方法```-objectsForKeys:NoFoundMarker:```, 这个方法需要一个```NSArray```数组作为键值参数，然后返回一个包含相关值的数组。文档里写到："返回数组中的第N个值，和输入数组中的第N个值相对应"，那如果有某个键值在字典里不存在呢？于是就有了```notFoundMarker```作为返回提示。比如第三个键值没有找到，那么在返回数组中第三个值就是这个```notFoundMarker```，而不是字典中的第三个值，但是这个值只是用来提醒原字典中没有找到对应值，但在返回数组中该元素存在，且用```notFoundMarker```作为占位符，因为这个对象不能直接使用，所以在Foundation框架中有个专门的类处理这个情况：```NSNull```。
|
||||
在 Objective-C 中，```NSDictionary```有一个方法```-objectsForKeys:NoFoundMarker:```, 这个方法需要一个```NSArray```数组作为键值参数，然后返回一个包含相关值的数组。文档里写到："返回数组中的第 N 个值，和输入数组中的第 N 个值相对应"，那如果有某个键值在字典里不存在呢？于是就有了```notFoundMarker```作为返回提示。比如第三个键值没有找到，那么在返回数组中第三个值就是这个```notFoundMarker```，而不是字典中的第三个值，但是这个值只是用来提醒原字典中没有找到对应值，但在返回数组中该元素存在，且用```notFoundMarker```作为占位符，因为这个对象不能直接使用，所以在 Foundation 框架中有个专门的类处理这个情况：```NSNull```。
|
||||
|
||||
在Swift中，```Dictionary```类没有类似```objectsForKeys```的函数，为了说明问题，我们动手加一个，并且使其成为操作字典值的通用方法。我们可以用```extension```来实现：
|
||||
在 Swift 中，```Dictionary```类没有类似```objectsForKeys```的函数，为了说明问题，我们动手加一个，并且使其成为操作字典值的通用方法。我们可以用```extension```来实现：
|
||||
|
||||
```swift
|
||||
extension Dictionary{
|
||||
@ -28,7 +28,7 @@ extension Dictionary{
|
||||
}
|
||||
```
|
||||
|
||||
以上就是我们实现的Swift版本，这个和Objective-C版本有很大区别。在Swift中，因为其强类型的原因限制了返回的结果数组只能包含单一类型的元素，所以我们不能放```NSNull```在字符串数组中，但是，Swift有更好的选择，我们可以返回一个可选类型数据。我们所有的值都封包在可选类型中，而不是```NSNull```, 我们只用```nil```就可以了。
|
||||
以上就是我们实现的 Swift 版本，这个和 Objective-C 版本有很大区别。在 Swift 中，因为其强类型的原因限制了返回的结果数组只能包含单一类型的元素，所以我们不能放```NSNull```在字符串数组中，但是，Swift 有更好的选择，我们可以返回一个可选类型数据。我们所有的值都封包在可选类型中，而不是```NSNull```, 我们只用```nil```就可以了。
|
||||
|
||||
```swift
|
||||
extension Dictionary{
|
||||
@ -44,9 +44,9 @@ extension Dictionary{
|
||||
```
|
||||
|
||||
<a name="#easy-function"></a>
|
||||
#### Swift中更简便的方法
|
||||
#### Swift 中更简便的方法
|
||||
|
||||
小伙伴们可能会问，为什么Swift中不需要实现这么一个API呢？其实其有更简单的实现，如下面代码所示：
|
||||
小伙伴们可能会问，为什么 Swift 中不需要实现这么一个 API 呢？其实其有更简单的实现，如下面代码所示：
|
||||
|
||||
```swift
|
||||
extension Dictionary {
|
||||
@ -56,7 +56,7 @@ extension Dictionary {
|
||||
}
|
||||
```
|
||||
|
||||
上述方式实现的功能和最开始的方法实现的功能相同，虽然核心的功能是封装了```map```的调用，这个例子也说明了为什么Swift没有提供轻量级的API接口，因为小伙伴们简单的调用```map```就可以实现。
|
||||
上述方式实现的功能和最开始的方法实现的功能相同，虽然核心的功能是封装了```map```的调用，这个例子也说明了为什么 Swift 没有提供轻量级的 API 接口，因为小伙伴们简单的调用```map```就可以实现。
|
||||
|
||||
接下来，我们实验几个例子：
|
||||
|
||||
@ -102,7 +102,7 @@ var last:T? { get }
|
||||
|
||||
很明显```last```属性的类型是数组元素类型的可选类型，这种情况下，因为元素类型是```(String?)```，那么再结合返回的类型，于是其结果就是```String??```了，这就是所谓的嵌套可选类型。但嵌套可选类型本质是什么意思呢？
|
||||
|
||||
如果在Objective-C中重新调用上述方法，我们将使用```NSNull```作为占位符，Objective-C的调用语法如下所示：
|
||||
如果在 Objective-C 中重新调用上述方法，我们将使用```NSNull```作为占位符，Objective-C 的调用语法如下所示：
|
||||
|
||||
```swift
|
||||
[dict valuesForKeys:@[@"1", @"4"] notFoundMarker:[NSNull null]].lastObject
|
||||
@ -113,7 +113,7 @@ var last:T? { get }
|
||||
// nil
|
||||
```
|
||||
|
||||
不管是Swift版本还是Objective-C版本，返回值为```nil```都意味数组是空的，所以它就没有最后一个元素。 但是如果返回是```Optional(nil)```或者Objective-C中的```NSNull```都表示数组中的最后一个元素存在，但是元素的内容是空的。在Objective-C中只能借助```NSNull```作为占位符来达到这个目的，但是Swift却可以语言系统类型的角度的实现。
|
||||
不管是 Swift 版本还是 Objective-C 版本，返回值为```nil```都意味数组是空的，所以它就没有最后一个元素。 但是如果返回是```Optional(nil)```或者 Objective-C 中的```NSNull```都表示数组中的最后一个元素存在，但是元素的内容是空的。在 Objective-C 中只能借助```NSNull```作为占位符来达到这个目的，但是 Swift 却可以语言系统类型的角度的实现。
|
||||
|
||||
<a name="#provide-default"></a>
|
||||
#### 提供一个默认值
|
||||
@ -132,9 +132,9 @@ extension Dictionary {
|
||||
dict.valuesForKeys(["1", "5"], notFoundMarker: "Anonymous")
|
||||
```
|
||||
|
||||
和Objective-C相比，其需要占位符来达到占位的目的，但是Swift却已经从语言类型系统的层面原生的支持了这种用法，同时提供了丰富的语法功能。这就是Swift可选类型的强大之处。同时注意上述例子中用到了空合运算符```??```。
|
||||
和 Objective-C 相比，其需要占位符来达到占位的目的，但是 Swift 却已经从语言类型系统的层面原生的支持了这种用法，同时提供了丰富的语法功能。这就是 Swift 可选类型的强大之处。同时注意上述例子中用到了空合运算符```??```。
|
||||
|
||||
-----------------
|
||||
本章节不是老码的原创，是老码认真的阅读了苹果的官方博客，自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌。还是看不懂？请到老码[官方微博](http://weibo.com/u/5241713117)咆哮。
|
||||
本章节不是老码的原创，是老码认真的阅读了苹果的官方博客，自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌。还是看不懂？请到老码[官方微博](http://weibo.com/u/5241713117)咆哮。
|
||||
|
||||
##### 本文由翻译自Apple Swift Blog ：[Optionals Case Study: valuesForKeys](https://developer.apple.com/swift/blog/?id=12)
|
||||
##### 本文由翻译自 Apple Swift Blog ：[Optionals Case Study: valuesForKeys](https://developer.apple.com/swift/blog/?id=12)
|
||||
|
||||
Reference in New Issue
Block a user