pdf阅读器 swift

2020-05-20 20:56:16 weixin_43987915 阅读数 112

使用 PDFkit 开发PDF阅读器(iOS 开发)

使用swift开发
结尾有百度网盘源码

在这里插入图片描述
注意:这里的 Class 要手敲 PDFView,如果在创建 Outlet 的时候再改会出错
在这里插入图片描述

主要注意可选类型使用以及可选类型的强制解析
以下两个代码块功能一样

  • 一个直接强制解析
  • 一个使用可选绑定
import UIKit
import PDFKit
class ViewController: UIViewController {
    
    @IBOutlet weak var label: UILabel!
    @IBOutlet weak var pdfView: PDFView!
    @IBOutlet weak var pdfThumbailView: PDFThumbnailView!

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.

        let documentURL = Bundle.main.url(forResource: "pdf", withExtension: "pdf")
            let document = PDFDocument(url: documentURL!)
            let page = document!.page(at: 20)

            pdfView.document = document
            pdfView.autoScales = true
            pdfView.backgroundColor = UIColor.lightGray

            pdfThumbailView.pdfView = pdfView

            var pdfThuHorizental = PDFThumbnailLayoutMode.horizontal
            pdfThumbailView.layoutMode = pdfThuHorizental

    }
}
import UIKit
import PDFKit
class ViewController: UIViewController {
    
    @IBOutlet weak var label: UILabel!
    @IBOutlet weak var pdfView: PDFView!
    @IBOutlet weak var pdfThumbailView: PDFThumbnailView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
       if let documentURL = Bundle.main.url(forResource: "pdf", withExtension: "pdf"),
        let document = PDFDocument(url: documentURL),
        let page = document.page(at: 20){
                
                pdfView.document = document
                pdfView.autoScales = true
                pdfView.backgroundColor = UIColor.lightGray
                
                pdfThumbailView.pdfView = pdfView
                
                var pdfThuHorizental = PDFThumbnailLayoutMode.horizontal
                pdfThumbailView.layoutMode = pdfThuHorizental
        }
    }
}

百度网盘链接:

链接: https://pan.baidu.com/s/1MF4OZ3b_fil86QQ_FgI8kg
密码: g9ag

2018-07-28 04:15:47 weixin_34205076 阅读数 22

上一篇文章里,我们已经完成了 AST 的创建。接下来我们开始具体的来定义 Parser,并且会给出一个通用的单字符 Parser 的实现。如果有疑问,可以对照着项目代码的实现一起阅读。

定义 Parser 的正确姿势

根据本例中的需求,所谓 Parser,就是完成接受字符串,并解析成 AST 结构的过程。用一个函数来定义它,就是:

Parser : String -> AST
复制代码

因为解析过程是逐步的解析,并不能一瞬间就完成所有的解析,为了表示逐步的思想,我们得出一个改进版本的 Parser:

Parser : String -> (AST, String)
复制代码

输入的是一个 String,输出的是一个 tuple,前面是解析出的 AST。后面的 String 代表解析完前面的 AST 后还剩下的 String。

继续细化,既然是逐步解析的,那即便是一个最普通的 AST,比如之前的 Exp.Constant(1234),也是得先解析出一个个的单个数字,再将其组合成一个整数,然后再形成 AST。为了表示更加细化的,比如解析单个数字这样的形式。我们继续改进:

Parser : String -> (a,String)
复制代码

和上一个版本相比,我们把 AST,换成了a, a是泛型变量,代表任意类型。也就是说 Parser 解析的结果可以是character, string, Int, AST 等等。

现在看来,我们已经有了看起来不错的形式。现在问题来了,我们如何来表示解析失败呢?返回某种特殊的 (ERROR, String) ? 还是返回(a,"") ? 为了表示解析失败,我们把结构修改如下:

Parser : String -> [(a,String)]
复制代码

和上一个版本相比,我们把返回一个 tuple 改为了返回一个 tuple 的 list。这样就可以用空 list [] 来表示解析失败。 如果解析成功,就返回一个包含单个 tuple 的 list。 至于为何不用上述两种方法,读者可以带着这个问题看下来的文章。

在 Swift 中定义 Parser

根据我们 Parser 定义的形式,不能想象所谓 Parser 的类型就是一个函数。为了方便书写,我们把它放在结构体中。

函数式编程一个重要的思想方法就是从类型开始思考代码的意义。

struct Parser<a>{
    let p : String -> [(a,String)]
}
复制代码

来审视 Parser 结构:

  • 首先需要一个泛型参数a,代表这个 Parser 解析的结果的类型。
  • 有一个成员变量, p 其类型是一个函数,该函数接受一个 String 为输入,返回一个[(a,String)]

实现第一个 Parser

我们从最简单的例子,比如要定义一个解析字符"H"的 Parser。什么意思呢? 就是这个 parser 会尝试去字符串里解析一个字符 H 出来(从字符串的开头开始),如果解析成功,则返回[("H",剩下的字符串)], 如果解析失败则返回[].

换句话来说,这个 Parser 会检测字符串首字母是否是 H,如果是则成功,否则就失败。

let par1 = Parser<Character> { x in
    guard let head = x.characters.first where head == "H" else{
        return []
    }
    return [("H",String(x.characters.dropFirst()))]
}
复制代码

要创建一个 Parser,首先就是要用结构体的构造器并指定泛型的类型。 比如Parser<Character>(...)。 因为结构体只有一个成员且这个成员是一个函数类型,所以...的部分要传入的就是一个闭包。也就是Parser<Character>({....}),又因为 Swift 的尾闭包特性,闭包可以从()移动到外面,所以构造 Parser 的最终形式就是Parser<Character>{x in ...}, 上面的代码便是这样的结构,最终把创建好的Parser 赋值给了变量 par1

现在我们来看,创建这个 Parser 的闭包长什么样。我们都知道这个闭包是String->[(a,String)]的类型,我们把输入的参数命名为x,代表要解析的 String,我们通过一个 guard 来看他的首字母是否是 H,如果不是则解析失败,返回[],否则就构造[(a,String)]返回。这里的 a,就是字符"H", String 则是去除首字母剩下的字符串(因为解析成功的话,输入字符串对应的部分要被消费掉)。

测试一下。

print(par1.p("HELLO WORLD"))
print(par1.p("NIHAO"))
复制代码

输出:

[("H", "ELLO WORLD")]
[]
复制代码

我们分别用 par1去尝试解析了两个字符串,第一个首字母是 H 所以解析成功,返回了 H 和剩下的”ELLO WORLD“组成的tuple,另一个解析失败了。

Parser 生成器

仔细想一下,我们刚才的 par1,其实并没什么卵用。现在尝试修改一下形式,来让它稍微有点用:

func parserChar(c : Character) -> Parser<Character>{
    return Parser { x in
        guard let head = x.characters.first where head == c else{
            return []
        }
        return [(c,String(x.characters.dropFirst()))]
    }
}
复制代码

我们定义了一个函数,parserChar,依然是从他的类型来分析他的工作原理。它接受一个单个字符,然后返回一个 Parser,相当于parserChar是一个“解析单个字符 Parser ” 的构造器,比如我们调用 parserChar("E")就能生成一个解析字符E的 Parser。这看起来似乎就是我们刚才 hardcode 版本实现的 parser 通用多了。

按照惯例,我们还是来测试一下:

let result = parserChar("H").p("HELLO WORLD")
print(result)
let result1 = parserChar("E").p(result[0].1)
print(result1)
复制代码

输出:

[("H", "ELLO WORLD")]
[("E", "LLO WORLD")]
复制代码

这里我们把第一个 parser 的结果,喂给了第二个 parser。然后第二个 parser 在此基础上成功解析出了字符“E”。

抽象无止境

还是在单字符 Parser 的前提下。在解析中,我们往往解析的不仅仅是某个特定的字符,而是某一类字符,比如解析所有的数字字符,或者运算符字符。对于这样的需求,我们第一次抽象的结果parserChar似乎就不够用了。我们来稍微修改一下:

func satisfy(condition : Character -> Bool) -> Parser<Character>{
    return Parser { x in
        guard let head = x.characters.first where condition(head) else{
            return []
        }
        return [(head,String(x.characters.dropFirst()))]
    }
}
复制代码

为了更通用,我们把函数的名字改为了satisfy, 其实内部实现都差不多。区别就是现在不再是接受一个单个字符的参数,而是接受一个函数condition, 什么样的函数呢? 还是从他的类型看起:Character->Bool ,代表判断某个字符是否符合条件,符合返回 true,否则返回 false。相当于我们可以通过这个condition 函数,来定义字符的范围。然后在实现的时候,我们不再是用首字母去做某种判等,而是把首字母传给 condition 函数,让这个函数来告诉 Parser 首字母是否符合条件。

比如,假设存在isDigit(Character) -> Bool这样一个函数,来判断一个字符是否是数字。 我们就可以通过 satisy(isDigit) 来构造一个识别任何数字的 Parser。 让我们来试一下:

首先实现 isDigit

func isDigit(c : Character) -> Bool{
    let s = String(c)
    return Int(s) != nil
}
复制代码

然后通过satisfy构造 Parser

let pNum = satisfy(isDigit)
print(pNum.p("abcde"))
print(pNum.p("1asd"))
print(pNum.p("6asd"))
print(pNum.p("12asd"))
复制代码

输出:

[]
[("1", "asd")]
[("6", "asd")]
[("1", "2asd")]
复制代码

isDigit实现很简单就不讲了,后来我们通过satisfy构造了一个识别任何数字的 Parser pNum, 然后分别尝试解析了4个字符串,第1个并不包含数字,所以失败了。后面分别都解析出了不同的数字。至少最后一个例子里后面的2为什么没有一起解析出来,是因为目前还没有实现多字符的逻辑。

整理一下今天的任务

今天说了很多,其实在 Parser 的实现上的进展来看,我们只是增加了如下代码:

struct Parser<a>{
    let p : String -> [(a,String)]

}

func isDigit(c : Character) -> Bool{
    let s = String(c)
    return Int(s) != nil
}

func satisfy(condition : Character -> Bool) -> Parser<Character>{
    return Parser { x in
        guard let head = x.characters.first where condition(head) else{
            return []
        }
        return [(head,String(x.characters.dropFirst()))]
    }
}
复制代码

PS:

  • 函数式编程前期理解起来可能会比较绕,但熟悉了以后很容易就能写出非常简洁的代码。
  • satisfy 其实非常强大。可多试试看配合不同的 condition 来产生不同的 Parser

有多强大?可以下载完整项目, 先查看一下都是被怎么用的。


想看更多内容? 可以关注我的知乎

2018-08-01 10:33:34 Philm_iOS 阅读数 3596

该文章翻译自Apple官方文档: The Swift 4 Programming Language

Guards翻译组 正在翻译Swift 4的全套文档, 这是该文档第一章节的上半部分, 下半部分我们将于明天下午发布. 如果你感兴趣, 可以关注我们的简书.
原文链接: The Basics

Swift 是一门开发 iOS, macOS, watchOS 和 tvOS 应用的新语言。即便如此,如果你有 C 或者 Objective-C 开发经验,你会发现 Swift 的有很多你熟悉的内容。Swift 提供了与 C 和 Objective-C 上所有基础数据类型,如整型Int; 浮点型Double和Float; 布尔型值Bool;文本型数据String 。 Swift 还提供了三个基本的集合类型,Array ,Set和 Dictionary ,详见集合类型。

和 C 语言类似,Swift 使用变量来进行存储并通过变量名来关联对应的值。在 Swift 中,不可变的变量非常常用,它们就是常量,而且比 C 语言的常量更强大。在 Swift 中,如果你要处理的值不需要改变,那使用常量可以让你的代码更加安全并且更清晰地表达你的意图。

除了我们熟悉的类型,Swift 还增加了 Objective-C 中没有的高阶数据类型, 比如元组Tuples。元组可以让你创建或者传递一组数据,当函数需要返回单一复合值时,你可以用一个元组可以返回多个值。

Swift 还增加了Optional类型(译者注: Optional类型即可选类型),用于处理值不存在的情况。可选的意思是 “这里有一个值,并且它等于x ” 或 “这里没有值” 。可选有点像在 Objective-C 中使用nil ,但是它可以用在任何类型上,不仅仅是类。可选类型比 Objective-C 中的 nil指针更加安全也更具表现力,它是 Swift 许多强大特性的重要组成部分。
Swift 是一门类型安全的语言,这意味着 Swift 可以让你清楚地知道值的类型。如果你的代码期望得到一个String ,类型安全会阻止你错误地传入一个Int。同样的,如果你的代码期望得到一个 String,类型安全会阻止你意外传入一个可选的 String 。类型安全可以帮助你在开发阶段尽早发现并修正错误。

常量和变量

常量和变量把一个名字(比如maximumNumberOfLoginAttempts或者 welcomeMessage)和一个指定类型的值(比如数字 10或者字符串”Hello”)关联起来。常量的值一旦设定就不能改变,而变量的值可以随意更改。

声明常量和变量

常量和变量必须在使用前声明,用 关键字let来声明常量和关键字 var来声明变量。下面的例子展示了如何用常量和变量来记录用户尝试登录的次数:

  let maximumNumberOfLoginAttempts = 10
  var currentLoginAttempt = 0

这两行代码可以被理解为:
“声明一个名字是maximumNumberOfLoginAttempts的新常量,并给它一个值 10。然后,声明一个名字是currentLoginAttempt的变量并将它的值初始化为0 ”。

在这个例子中,允许的最大尝试登录次数被声明为一个常量,因为这个值不会改变。当前尝试登录次数被声明为一个变量,因为每次尝试登录失败的时候都需要增加这个值。
你可以在一行中声明多个常量或者多个变量,用逗号隔开:

  var x = 0.0, y = 0.0, z = 0.0

Note:如果你的代码中有不需要改变的值,请使用 let 关键字将它声明为常量。只将需要改变的值声明为变量。

类型标注

当你声明常量或者变量的时候可以加上 类型标注 (type annotation),说明常量或者变量中要存储的值的类型。通过在常量或变量名后面接一个冒号来写一个类型标注,后跟一个空格,后跟要使用的类型的名称。

这个例子给welcomeMessage 变量添加了类型标注,表示这个变量可以存储 String类型的值:

   var welcomeMessage: String

声明中的冒号代表着“xx是xx类型”,所以这行代码可以被理解为:

声明一个类型为 String,名字为welcomeMessage的变量。
类型为 String ”的意思是“可以存储任意 String 类型的值。

welcomeMessage 变量现在可以被正确地设置成任意字符串:

  welcomeMessage = "Hello"

你可以在一行中定义多个同样类型的变量,用逗号分割,并在最后一个变量名之后添加类型标注:

  var red, green, blue: Double

Note:一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值,Swift可以推断出这个常量或者变量的类型,请参考类型安全和类型推断。在上面的例子中,没有给 welcomeMessage
赋初始值,所以变量 welcomeMessage
的类型是通过一个类型标注指定的,而不是通过初始值推断的。
常量和变量的命名

你可以用任何你喜欢的字符作为常量和变量名,包括 Unicode 字符:

let π = 3.14159
let 你好 = "你好世界"
let  = "dogcow"

常量与变量名不能包含空格,数学符号,箭头,保留的(或者非法的)Unicode 码位,连线与制表符。不能以数字开头,但是可以在常量与变量名的其他地方包含数字。
一旦你将常量或者变量声明为确定的类型,你就不能使用相同的名字再次进行声明,或者改变其存储的值的类型。同时,你也不能将常量与变量进行互转。

Note:如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名,你可以使用反引号(`)将关键字包围的方式将其作为名字使用。无论如何,你应当避免使用关键字作为常量或变量名,除非你别无选择。
你可以更改现有的变量值为其他同类型的值,在下面的例子中,friendlyWelcome的值从”Hello!”改为了”Bonjour!”:

var friendlyWelcome = "Hello!"
friendlyWelcome = "Bonjour!"
// friendlyWelcome 现在是 "Bonjour!"

与变量不同,常量的值一旦被确定就不能更改了。尝试这样做会导致编译时报错:

let languageName = "Swift"
languageName = "Swift++"
// 这会报编译时错误 - languageName 不可改变

输出常量和变量

你可以用print(_:separator:terminator:)
函数来输出当前常量或变量的值:

print(friendlyWelcome)// 输出 "Bonjour!"

print(:separator:terminator:)是一个用来输出一个或多个值到适当输出区的全局函数。在 Xcode中,print(:separator:terminator:)将会输出内容到“console”面板上。separator和 terminator参数具有默认值,因此你调用这个函数的时候可以忽略它们。默认情况下,该函数通过添加换行符来结束当前行。如果不想换行,可以传递一个空字符串给 terminator 参数–例如,print(someValue, terminator:”“)
。关于参数默认值的更多信息,请参考默认参数值。

Swift 用字符串插值(string interpolation)的方式把常量名或者变量名当做占位符加入到长字符串中,Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中,并在开括号前使用反斜杠将其转义:

print("The current value of friendlyWelcome is \(friendlyWelcome)")
// 输出 "The current value of friendlyWelcome is Bonjour!

Note:字符串插值所有可用的选项,请参考字符串插值。
注释

请将你的代码中的非执行文本注释成提示或者笔记以方便你将来阅读。Swift 的编译器将会在编译代码时自动忽略掉注释部分。
Swift 中的注释与 C 语言的注释非常相似。单行注释以双正斜杠 (//)
作为起始标记:

  // 这是一个注释
  ```
行注释的起始标记为单个正斜杠后跟随一个星号(/*),终止标记为一个星号后跟随单个正斜杠(*/):

/* 这是一个,多行注释 */

C 语言多行注释不同,Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块,然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记,然后再插入第一个注释块的终止标记:

/* 这是第一个多行注释的开头
/* 这是第二个被嵌套的多行注释 */
这是第一个多行注释的结尾 */


通过运用嵌套多行注释,你可以方便快速的注释掉一大段代码,即使这段代码之中已经含有了多行注释块。

#### 分号

与其他大部分编程语言不同,Swift 并不强制要求你在每条语句的结尾处使用分号(;),当然,你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号,即你打算在同一行内写多条独立的语句:

let cat = “”;
print(cat)// 输出 “”

#### 整数

整数就是没有小数部分的数字,比如 42和 -23 。整数可以是 有符号(正数、零和负数)或者无符号(正数、零)。
Swift 提供了8163264位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像,比如8位无符号整数类型是UInt8,32位有符号整数类型是Int32。就像 Swift 的其他类型一样,整数类型采用大写命名法。

#### 整数范围

你可以访问不同整数类型的 minmax 属性来获取对应类型的最小值和最大值:

let minValue = UInt8.min // minValue 为 0,是 UInt8 类型
let maxValue = UInt8.max // maxValue 为 255,是 UInt8 类型

这些属性的值具有适当大小的数字类型(例如上例中的UInt8),因此可以与表达式一起使用同一类型的其他值。

#### Int

大多数情况下,你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型Int,长度与当前平台的原生字长相同:

在32位平台上,Int和 Int32长度相同。
在64位平台上,Int和 Int64长度相同。
除非你需要特定长度的整数,一般来说使用 Int就够了。这可以提高代码一致性和可复用性。即使是在32位平台上,Int 可以存储的整数范围也可以达到 -2,147,483,648 ~ 2,147,483,647,大多数时候这已经足够大了。

#### UInt

Swift 也提供了一个特殊的无符号类型 UInt,长度与当前平台的原生字长相同:

在32位平台上,UInt 和 UInt32长度相同。
在64位平台上,UInt 和 UInt64长度相同。
Note:尽量不要使用UInt,除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况,最好使用Int,即使你要存储的值已知是非负的。统一使用Int可以提高代码的可复用性,避免不同类型数字之间的转换,并且匹配数字的类型推断,请参考类型安全和类型推断。
##### 浮点数

浮点数是有小数部分的数字,比如 3.141590.1 和 -273.15。
浮点类型比整数类型表示的范围更广,可以存储比Int
类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型:

Double表示64位浮点数。
Float表示32位浮点数。
Note:Double精确度很高,至少有15位数字,而Float只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围,在两种类型都可以选择的情况下,将优先选择 Double。
##### 类型安全和类型推断

Swift 是一个类型安全(type-safe)的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个String,你绝对不可能错误地传进去一个Int。

由于 Swift 是类型安全的,所以它会在编译你的代码时进行类型检查(type checks),并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。

当你要处理不同类型的值时,类型检查可以帮你避免错误。然而,这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型,Swift 会使用类型推断(type inference)来选择合适的类型。有了类型推断,编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单,只要检查你赋的值即可。

因为有了类型推断,和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型,但是大部分工作并不需要你自己来完成。

当你声明常量或者变量并赋初值的时候类型推断非常有用。当你在声明常量或者变量的时候赋给它们一个确定值(literal value 或 literal)即可触发类型推断。(字面量就是会直接出现在你代码中的值,比如 423.14159。)
例如,如果你给一个新常量赋值42并且没有标明类型,Swift 可以推断出常量类型是 Int,因为你给它赋的初始值看起来像一个整数:

let meaningOfLife = 42// meaningOfLife 会被推测为 Int 类型

同理,如果你没有给浮点数标明类型,Swift 会推断你想要的是Double

let pi = 3.14159// pi 会被推测为 Double 类型

当推断浮点数的类型时,Swift 总是会优先选择 Double而不是Float。如果表达式中同时出现了整数和浮点数,会被推断为 Double
类型:

let anotherPi = 3 + 0.14159 // anotherPi 会被推测为 Double 类型

原始值3 没有显式声明类型,而表达式中出现了一个浮点数,所以表达式会被推断为 Double类型。

#### 数值型字面量

整数字面量可以被写作:

一个十进制数,没有前缀
一个二进制数,前缀是0b
一个八进制数,前缀是0o
一个十六进制数,前缀是0x
下面的所有整数字面量的十进制值都是17

let decimalInteger = 17
let binaryInteger = 0b10001 // 二进制的17
let octalInteger = 0o21 // 八进制的17
let hexadecimalInteger = 0x11 // 十六进制的17

浮点字面量可以是十进制(没有前缀)或者是十六进制(前缀是 0x )。小数点两边必须有至少一个十进制数字(或者是十六进制的数字)。十进制浮点数也可以有一个可选的指数(exponent),通过大写或者小写的 e来指定;十六进制浮点数必须有一个指数,通过大写或者小写的 p来指定。如果一个十进制数的指数为 exp,那这个数相当于基数和10^exp的乘积:

1.25e2 表示 1.25 × 10^2,等于 125.0。
1.25e-2 表示 1.25 × 10^-2,等于 0.0125。

如果一个十六进制数的指数为exp,那这个数相当于基数和2^exp的乘积:

0xFp2 表示 15 × 2^2,等于 60.0。
0xFp-2 表示 15 × 2^-2,等于 3.75。

下面的这些浮点字面量都等于十进制的12.1875:

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线,并不会影响字面量:

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

#### 数值型类型转换

通常来讲,即使代码中的整数常量和变量已知非负,也请使用Int类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推断。

只有在必要的时候才使用其他整数类型,比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。

##### 整数转换

不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128~127,而UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围,编译的时候会报错:

let cannotBeNegative: UInt8 = -1// UInt8 类型不能存储负数,所以会报错
let tooBig: Int8 = Int8.max + 1// Int8 类型不能存储超过最大值的数,所以会报错

由于每种整数类型都可以存储不同范围的值,所以你必须根据不同情况选择性使用数值型类型转换。这种选择性使用的方式,可以预防隐式转换的错误并让你的代码中的类型转换意图变得清晰。

为了将一种数字类型转换成另一种,你要用当前值来初始化一个期望类型的新数字,这个数字的类型就是你的目标类型。在下面的例子中,常量twoThousand是UInt16类型,然而常量one是UInt8类型。它们不能直接相加,因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化,然后使用这个新数字来计算:

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
“`
现在两个数字的类型都是 UInt16,可以进行相加。输出常量 twoThousandAndOne 的类型被推断为 UInt16,因为它是两个 UInt16值的和。

SomeType(ofInitialValue)是调用Swift类型的初始化器并传入初始值的默认方式。
在语言内部,UInt16有接受一个UInt8的值,这个初始化器用来从现有的UInt8中创建一个新的UInt16。然而,你并不能传入任意类型的值,只能传入UInt16类型的值。不过你可以扩展现有的类型来让它可以接收其他类型的值(包括自定义类型),请参考扩展。

整数和浮点数转换

整数和浮点数的转换必须显式指定类型:

let three = 3let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine // pi 等于 3.14159,所以被推测为 Double 类型
这个例子中,常量 three的值被用来创建一个Double类型的值,所以加号两边的数类型须相同。如果不进行转换,两者无法相加。浮点数到整数的反向转换同样行,整数类型可以用` Double 或者Float类型来初始化:

let integerPi = Int(pi)// integerPi 等于 3,所以被推测为 Int 类型
当用浮点类型来初始化一个新的整数值时,浮点值会被截断。也就是说 4.75会变成 4,-3.9会变成 -3。

Note:结合数字类常量和变量不同于结合数字类字面量。字面量3可以直接和字面量0.14159相加,因为数字字面量本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。

类型别名

类型别名type aliases就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

当你想要给现有类型起一个更合适的名字时,类型别名非常有用。比如你正在处理特定长度的外部资源的数据:

typealias AudioSample = UInt16

定义了一个类型别名之后,你可以在任何使用原始名的地方使用别名:

var maxAmplitudeFound = AudioSample.min// maxAmplitudeFound 现在是 0

本例中,AudioSample被定义为UInt16的一个别名。因为它是别名,AudioSample.min实际上是UInt16.min,所以会给maxAmplitudeFound赋一个初值0。

布尔值

Swift 有一个基本的布尔Boolean类型,叫做Bool。布尔值指逻辑上的值,因为它们只能是真或者假。Swift 有两个布尔常量,true和false:

let orangesAreOrange = truelet
turnipsAreDelicious = false

orangesAreOrange和turnipsAreDelicious 的类型会被推断为 Bool,因为它们的初值是布尔字面量。就像之前提到的 Int 和 Double一样,如果创建变量的时候给它们赋值 true或者false,那你不需要将常量或者变量声明为Bool类型。初始化常量或者变量的时候如果所赋的值类型已知,就可以触发类型推断,这让 Swift 代码更加简洁并且可读性更高。当你编写条件语句比如 if 语句的时候,布尔值非常有用:

if turnipsAreDelicious {
     print("Mmm, tasty turnips!")
} else {
     print("Eww, turnips are horrible.")
}

// 输出 “Eww, turnips are horrible.”
条件语句,例如if,请参考控制流。

如果你在需要使用 Bool类型的地方使用了非布尔值,Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误:

let i = 1if i { // 这个例子不会通过编译,会报错}

然而,下面的例子是合法的:

let i = 1
if i == 1 {
    // 这个例子会编译成功
}

i == 1 的比较结果是 Bool类型,所以第二个例子可以通过类型检查。类似i ==1这样的比较,请参考基本操作符。和 Swift 中的其他类型安全的例子一样,这个方法可以避免错误,并确保特定代码的意图总是清晰的。

元组

元组tuples把多个值组合成一个复合值。元组内的值可以是任意类型,并不要求是相同类型。

下面这个例子中,(404, “Not Found”)是一个描述 HTTP 状态码HTTP status code的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特定值。如果你请求的网页不存在就会返回一个 404 Not Found 状态码。

let http404Error = (404, "Not Found")
// http404Error 的类型是 (Int, String),值是 (404, "Not Found")

404, “Not Found”元组把一个 Int 值和一个String值组合起来表示HTTP状态码的两个部分:一个数字和一个人类可读的描述。这个元组被定义为“一个类型为 (Int, String)的元组”。
你可以把任意顺序的类型组合成一个元组,这个元组可以包含所有类型。你可以创建任何一个类型为(Int, Int, Int)或者 (String, Bool) 或者其他任何你想要的组合的元组。你可以将一个元组内容分解(decompose)成单独的常量和变量,然后你就可以正常使用它们了:

let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// 输出 "The status code is 404"
print("The status message is \(statusMessage)")
// 输出 "The status message is Not Found"

如果你只需要一部分元组值,分解的时候可以把要忽略的部分用下划线(_
)表示:

let (justTheStatusCode, \_) = http404Error
print("The status code is \(justTheStatusCode)")
// 输出 "The status code is 404"

此外,你还可以通过下标来访问元组中的单个元素,下标从零开始:

print("The status code is \(http404Error.0)")
// 输出 "The status code is 404"
print("The status message is \(http404Error.≥   1)")
// 输出 "The status message is Not Found"

你可以在定义元组的时候给单个元素命名:

let http200Status = (statusCode: 200, description: "OK")

给元组中的元素命名后,你可以通过名字来获取这些元素的值:

print("The status code is \(http200Status.statusCode)")
// 输出 "The status code is 200"
print("The status message is \(http200Status.description)")
// 输出 "The status message is OK"

作为函数返回值时,元组非常有用。一个用来获取网页的函数可能会返回一个(Int, String) 元组来描述是否获取成功。和只能返回一个类型的值比较起来,一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考函数参数与返回值。

Note:元组在临时组织值的时候很有用,但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用,请使用类或者结构体而不是元组。请参考类和结构体。
The Basics 上半部分完结, 下半部分我们将于明天下午发布.