swift30教程pdf

1. swift 教程 swift介绍

1、要使用swift须拥有一台苹果电脑。因为集成开发环境XCode只能运行在OS X系统上。电脑系统必须在OS 10.9.3及以上，电脑必须安装Xcode集成开发环境。

2、下载完成后，双击下载的 dmg 文件安装，安装完成后我们将 Xcode 图标踢移动到应用文件夹。Xcode 安装完成后，就可以开始编写 Swift 代码了。接下来我们在应用文件夹打开 Xcode，打开后在屏幕顶部选择 File => New => Playground。接着 为 playground 设置一个名字并选择 iOS 平台。

3、如果你想创建 OS x 程序，需要导入 Cocoa 包 import Cocoa以上程序载入后，会在Playground 窗口右侧显示程序执行结果。

4、选择一个Single View Application，并点击next，创建一个简单示例app应用。

5、接着我们输入项目名称（ProctName),公司名称（Organization Name),公司标识前缀名（Organization identifier) 还要选择开发语言(Language),选择设备（Devices)。其中Language有两个选项：Objective-c和swift，因为我们是学习swift当然选择swift项了。 点击Next下一步。

6、选择存放的目录，如果要使用Git源代码管理，将勾上Source Control的create git repository on My Mac. 点击create创建项目。

7、项目创建后，默认生成了一个示例文件，可以看到swift将oc中的h和m文件合并成了一个文件（即swift后缀名文件). Main.storyboard相当于xib文件，有比xib更多的功能。

8、打开main.storyboard,默认看到一个简单的空白的应用界面，大小为平板界面大小。 如果开发都只需要开发兼容iphone手机的app,那么可以把Use Auto Layout的勾去掉（默认为勾上）。弹出了一个对话框，让我们选择界面尺寸，iPhone 或 iPad。我们选择iPhone的尺寸。

9、界面添加点内容，在右下方找到Text控件，将它拖入storyboard上，并双击写入文本Hello World!

10、运行一下模拟器（command+R 快捷键或在菜单栏中选择 Proct => Run)。

至此，第一个Swift项目就完成了。

10、swift介绍

《Swift》是一种支持多编程范式和编译式的开源编程语言,苹果于2014年WWDC（苹果开发者大会）发布，用于开发 iOS，OS X 和 watchOS 应用程序。 Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。 Swift 在 Mac OS 和 iOS 平台可以和 Object-C 使用相同的运行环境。 2015年6月8日，苹果于WWDC 2015上宣布，Swift将开放源代码，包括编译器和标准库。

Swift 是一种全新的编程语言，结合了 C 和 Objective-C 的优点，并且不受C兼容性的限制。Swift 采用的安全编程模式添加了很多新特性，这使得编程更简单，更灵活，也更有趣。Swift 在 Foundation 和 Cocoa的基础上构建框架，并且采用了很多 Objective-C 的命名参数以及动态对象模型，并且支持过程式编程和面向对象编程。Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来，既能够开发简单的小程序，也能够构建出一套完整的操作系统。

2. Swift Package Manager iOS 使用教程

SPM (Swift Package Manager)，Apple 官方推出的包管理机制，在
Swift 3.0 版本中被引入，支持 macOS 和 Linux。在 Xcode 11 发布的时候，通过于 libSwiftPM 集成来支持 iOS、watchOS 和 tvOS 平台。

由于官方网站和网上针对 iOS 支持的文章不多，通过整合各方资料和探索研究，整理了这份文档。

通过 Xcode 的向导创建一个简单的 iOS 工程，如下图所示：

通过菜单 File -> Swift Packages -> Add Package Dependency... 添加第三方 package。

配置中多了 Swift Packages 选项卡：

Targets 中已经自动添加链接：

通过菜单 File -> New -> Swift Package... 来创建本地 package：

经过测试，这一步非必须

包括应用、本地文件、链接等。
添加远端(按照第 2 步): https://github.com/arthurlee/DemoDownloader.git

本文主要记录了主要的试验步骤，写的很是简略，如有不足，请大家不吝赐教，不胜感激！

3. 如何使在Swift中使用UIScrollView进行滚动和缩放

UIScrollView是IOS中非常有用的一个组件。它是通用组件UITableView的基类也是放置尺寸大于一个屏幕的内容时很好的组织方式。本教程会介绍UIScrollView的下列用法:
如何使用UIScrollView浏览大尺寸图片。
如何在缩放时保持UIScrollView中的内容居中.
如何在UIScrollView中嵌入复杂的显示层次关系。
如何使用UIScrollView的分页（paging）特性, 联合使用UIPageControl在不同页面之间移动。
通过“偷窥”UIScrollView得到前一页，后一页还有当前页的缩略图。
其他内容!
本文假设你熟悉Swift语言和IOS开发。如果你完全是一名初学者, 你可能需要先学习一下本站的其他课程。
本文还假设你知道如何使用Interface Builder在view中添加对象和在你的代码和Storyboard连接outlets。 如果你刚刚接触Storyboards和Interface Builder, 你可以在开始本教程之前线学习一下本站的Storyboards教程。
开始
打开Xcode创建工程。选择File\New\Project…, 接下来选择iOS\Application\Single View Application模版。 在proct name输入框中输入ScrollViews, language选择Swift, devices选择 iPhone.

单击Next选择工程文件的保存位置。
之后下载工程的资源压缩包, 然后将解加压后的文件拖拽到工程的根目录。并确保选中了“Copy items if needed”复选框。

本文会介绍Scroll view 的四种不同使用方式, 工程采用一个tableview来提供这四个选项。每个选项打开一个新的视图控制器（view controller）来展示scroll views的一种用法。
下图展示了完成时storyboard的状态：

通过下列步骤创建一个tableview:
打开Main.storyboard删除当前场景。 选择view controller (单击 storyboard) 然后删除它。
关闭Auto Layout功能。在Utilities面板中选择File Inspector, 取消Use Auto Layout复选框的选中状态。这会弹出一个警告窗口。在弹出窗口中确保“Keep size class data for:”选中了iPhone。然后选择Disable Size Classes。

接下来, 添加一个Table View Controller，从Object Library中拖拽一个Table View Controller到storyboard。
选中刚添加的table, 然后在菜单中选择Editor\Embed In\Navigation Controller。
同时选中table view和table view controller, 将Attributes Inspector中的content type修改为Static Cells。

在文档概要视图中Table View单击下面的按钮显示storyboard层次关系视图，然后选中Table View Section. 将行数设置为4。

依次编辑table view的每一行, 将style设置为Basic，编辑显示的标签:
Image Scroll
Custom View Scroll
Paged
Paged with Peeking
注释: 由于你将每一行的style设置成了“Basic”, 表单的每一行会出现额外的标签子组件。你要再次展开每行的子项目来进行编辑。
保存storyboard, 之后构建并运行

4. 《函数式Swift》pdf下载在线阅读全文，求百度网盘云资源

《函数式Swift》网络网盘pdf最新全集下载:
链接: https://pan..com/s/1HNZWZEaD7RbdOBH6f0bhEQ

?pwd=bp7n 提取码: bp7n
简介：是一本引领你进入 Swift 函数式编程世界的读物，它让更多的中国开发者有机会接触并了解 Swift 语言函数式的一面，是广大程序开发者不可多得的工具书。

5. SWIFT的学习入门

第一个程序应该在屏幕上打印“Hello, world”。在 Swift 中，可以用一行代码实现：
println("Hello, world")
如果你写过 C 或者 Objective-C 代码，那你应该很熟悉这种形式——在 Swift 中，这行代码就是一个
完整的程序。你不需要为了输入输出或者字符串处理导入一个单独的库。全局作用域中的代码会被自动当
做程序的入口点，所以你也不需要main函数。你同样不需要在每个语句结尾写上分号。
这个教程会通过一系列编程例子来让你对 Swift 有初步了解，如果你有什么不理解的地方也不用担心—
—任何本章介绍的内容都会在后面的章节中详细讲解。
注意：
为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运
行结果。 使用let来声明常量，使用var来声明变量。一个常量的值在编译时并不需要获取，但是你只能为它赋值一
次。也就是说你可以用常量来表示这样一个值：你只需要决定一次，但是需要使用很多次。
var myVariable = 42
myVariable = 50
let myConstant = 42
常量或者变量的类型必须和你赋给它们的值一样。然而，声明时类型是可选的，声明的同时赋值的话，编
译器会自动推断类型。在上面的例子中，编译器推断出myVariable是一个整数（integer）因为它的初始
值是整数。
如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割。
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70
创建一个常量，显式指定类型为Float并指定初始值为4。
值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。
let label = "The width is"
let width = 94
let widthLabel = label + String(width)
删除最后一行中的String，错误提示是什么？
有一种更简单的把值转换成字符串的方法：把值写到括号中，并且在括号之前写一个反斜杠。例如：
let apples = 3
let oranges = 5
let appleSummary = "I have (apples) apples."
let fruitSummary = "I have (apples + oranges) pieces of fruit."
使用()来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。
使用方括号[]来创建数组和字典，并使用下标或者键（key）来访问元素。
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
要创建一个空数组或者字典，使用初始化语法。
let emptyArray = [String]()
let emptyDictionary = Dictionary<String, Float>()
如果类型信息可以被推断出来，你可以用[]和[:]来创建空数组和空字典——就像你声明变量或者给函数
传参数的时候一样。
shoppingList = [] // 去逛街并买点东西 使用if和switch来进行条件操作，使用for-in、for、while和do-while来进行循环。包裹条件和循环变
量括号可以省略，但是语句体的大括号是必须的。
let indivialScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in indivialScores {
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
teamScore
在if语句中，条件必须是一个布尔表达式——这意味着像if score { ... }这样的代码将报错，而不会隐
形地与 0 做对比。
你可以一起使用if和let来处理值缺失的情况。有些变量的值是可选的。一个可选的值可能是一个具体的
值或者是nil，表示值缺失。在类型后面加一个问号来标记这个变量的值是可选的。
var optionalString: String? = "Hello"
optionalString == nil
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, (name)"
}
把optionalName改成nil，greeting会是什么？添加一个else语句，当optionalName是nil时给greeting
赋一个不同的值。
如果变量的可选值是nil，条件会判断为false，大括号中的代码会被跳过。如果不是nil，会将值赋给let
后面的常量，这样代码块中就可以使用这个值了。
switch支持任意类型的数据以及各种比较操作——不仅仅是整数以及测试相等。
let vegetable = "red pepper"
switch vegetable {
case "celery":
let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
let vegetableComment = "Is it a spicy (x)?"
default:
let vegetableComment = "Everything tastes good in soup."
}
删除default语句，看看会有什么错误？
运行switch中匹配到的子句之后，程序会退出switch语句，并不会继续向下运行，所以不需要在每个子句
结尾写break。
你可以使用for-in来遍历字典，需要两个变量来表示每个键值对。
let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
largest
添加另一个变量来记录哪种类型的数字是最大的。
使用while来重复运行一段代码直到不满足条件。循环条件可以在开头也可以在结尾。
var n = 2
while n < 100 {
n = n * 2
}
n
var m = 2
do {
m = m * 2
} while m < 100
m
你可以在循环中使用..<来表示范围，也可以使用传统的写法，两者是等价的：
var firstForLoop = 0
for i in 0..<3 {
firstForLoop += i
}
firstForLoop
var secondForLoop = 0
for var i = 0; i < 3; ++i {
secondForLoop += 1
}
secondForLoop
使用..<创建的范围不包含上界，如果想包含的话需要使用...。 使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值。
func greet(name: String, day: String) -> String {
return "Hello (name), today is (day)."
}
greet("Bob", "Tuesday")
删除day参数，添加一个参数来表示今天吃了什么午饭。
使用一个元组来返回多个值。
func getGasPrices() -> (Double, Double, Double) {
return (3.59, 3.69, 3.79)
}
getGasPrices()
函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式：
func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(42, 597, 12)
函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂
的函数。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
函数是第一等类型，这意味着函数可以作为另一个函数的返回值。
func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
函数也可以当做参数传入另一个函数。
func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, lessThanTen)
函数实际上是一种特殊的闭包，你可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭
包函数体进行分离。
numbers.map({
(number: Int) -> Int in
let result = 3 * number
return result
})
有很多种创建闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和
返回值。单个语句闭包会把它语句的值当做结果返回。
numbers.map({ number in 3 * number })
你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作
为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。
sort([1, 5, 3, 12, 2]) { $0 > $1 } 使用class和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文
是类。同样，方法和函数声明也一样。
class Shape {
var numberOfSides = 0
func simpleDescription() -> String {
return "A shape with (numberOfSides) sides."
}
}
要创建一个类的实例，在类名后面加上括号。使用点语法来访问实例的属性和方法。
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
这个版本的Shape类缺少了一些重要的东西：一个构造函数来初始化类实例。使用init来创建一个构造器
。
class NamedShape {
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
func simpleDescription() -> String {
return "A shape with (numberOfSides) sides."
}
}
注意self被用来区别实例变量。当你创建实例的时候，像传入函数参数一样给类传入构造器的参数。每个属性都需要赋值——无论是通过声明（就像numberOfSides）还是通过构造器（就像name）。如果你需要在删除对象之前进行一些清理工作，使用deinit创建一个析构函数。子类的定义方法是在它们的类名后面加上父类的名字，用冒号分割。创建类的时候并不需要一个标准的根类，所以你可以忽略父类。
子类如果要重写父类的方法的话，需要用override标记——如果没有添加override就重写父类方法的话编译器会报错。编译器同样会检测override标记的方法是否确实在父类中。
class Square: NamedShape {
var sideLength: Double
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 4
}
func area() -> Double {
return sideLength * sideLength
}
override func simpleDescription() -> String {
return "A square with sides of length (sideLength)."
}
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()
创建NamedShape的另一个子类Circle，构造器接收两个参数，一个是半径一个是名称，实现area和
describe方法。
属性可以有 getter 和 setter 。
class EquilateralTriangle: NamedShape {
var sideLength: Double = 0.0
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 3
}
var perimeter: Double {
get {
return 3.0 * sideLength
}
set {
sideLength = newValue / 3.0
}
}
override func simpleDescription() -> String {
return "An equilateral triagle with sides of length (sideLength)."
}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
triangle.perimeter
triangle.perimeter = 9.9
triangle.sideLength
在perimeter的 setter 中，新值的名字是newValue。你可以在set之后显式的设置一个名字。
注意EquilateralTriangle类的构造器执行了三步：
设置子类声明的属性值
调用父类的构造器
改变父类定义的属性值。其他的工作比如调用方法、getters和setters也可以在这个阶段完成。
如果你不需要计算属性但是需要在设置一个新值之前运行一些代码，使用willSet和didSet。
比如，下面的类确保三角形的边长总是和正方形的边长相同。
class TriangleAndSquare {
var triangle: EquilateralTriangle {
willSet {
square.sideLength = newValue.sideLength
}
}
var square: Square {
willSet {
triangle.sideLength = newValue.sideLength
}
}
init(size: Double, name: String) {
square = Square(sideLength: size, name: name)
triangle = EquilateralTriangle(sideLength: size, name: name)
}
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
triangleAndSquare.square.sideLength
triangleAndSquare.triangle.sideLength
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
triangleAndSquare.triangle.sideLength
类中的方法和一般的函数有一个重要的区别，函数的参数名只在函数内部使用，但是方法的参数名需要在
调用的时候显式说明（除了第一个参数）。默认情况下，方法的参数名和它在方法内部的名字一样，不过
你也可以定义第二个名字，这个名字被用在方法内部。
class Counter {
var count: Int = 0
func incrementBy(amount: Int, numberOfTimes times: Int) {
count += amount * times
}
}
var counter = Counter()
counter.incrementBy(2, numberOfTimes: 7)
处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加?。如果?之前的值是nil，?后面
的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表
达式的值也是一个可选值。
let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength 使用enum来创建一个枚举。就像类和其他所有命名类型一样，枚举可以包含方法。
enum Rank: Int {
case Ace = 1
case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
case Jack, Queen, King
func simpleDescription() -> String {
switch self {
case .Ace:
return "ace"
case .Jack:
return "jack"
case .Queen:
return "queen"
case .King:
return "king"
default:
return String(self.toRaw())
}
}
}
let ace = Rank.Ace
let aceRawValue = ace.toRaw()
写一个函数，通过比较它们的原始值来比较两个Rank值。
在上面的例子中，枚举原始值的类型是Int，所以你只需要设置第一个原始值。剩下的原始值会按照顺序
赋值。你也可以使用字符串或者浮点数作为枚举的原始值。
使用toRaw和fromRaw函数来在原始值和枚举值之间进行转换。
if let convertedRank = Rank.fromRaw(3) {
let threeDescription = convertedRank.simpleDescription()
}
枚举的成员值是实际值，并不是原始值的另一种表达方法。实际上，如果原始值没有意义，你不需要设置
。
enum Suit {
case Spades, Hearts, Diamonds, Clubs
func simpleDescription() -> String {
switch self {
case .Spades:
return "spades"
case .Hearts:
return "hearts"
case .Diamonds:
return "diamonds"
case .Clubs:
return "clubs"
}
}
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simpleDescription()
给Suit添加一个color方法，对spades和clubs返回“black”，对hearts和diamonds返回“red”。
注意，有两种方式可以引用Hearts成员：给hearts常量赋值时，枚举成员Suit.Hearts需要用全名来引用
，因为常量没有显式指定类型。在switch里，枚举成员使用缩写.Hearts来引用，因为self的值已经知道
是一个suit。已知变量类型的情况下你可以使用缩写。
使用struct来创建一个结构体。结构体和类有很多相同的地方，比如方法和构造器。它们之间最大的一个
区别就是 结构体是传值，类是传引用。
struct Card {
var rank: Rank
var suit: Suit
func simpleDescription() -> String {
return "The (rank.simpleDescription()) of
(suit.simpleDescription())"
}
}
let threeOfSpades = Card(rank: .Three, suit: .Spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()
给Card添加一个方法，创建一副完整的扑克牌并把每张牌的 rank 和 suit 对应起来。
一个枚举成员的实例可以有实例值。相同枚举成员的实例可以有不同的值。创建实例的时候传入值即可。
实例值和原始值是不同的：枚举成员的原始值对于所有实例都是相同的，而且你是在定义枚举的时候设置
原始值。
例如，考虑从服务器获取日出和日落的时间。服务器会返回正常结果或者错误信息。
enum ServerResponse {
case Result(String, String)
case Error(String)
}
let success = ServerResponse.Result("6:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")
switch success {
case let .Result(sunrise, sunset):
let serverResponse = "Sunrise is at (sunrise) and sunset is at (sunset)."
case let .Error(error):
let serverResponse = "Failure... (error)"
}
给ServerResponse和switch添加第三种情况。
注意如何从ServerResponse中提取日升和日落时间。 使用protocol来声明一个接口。
protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
类、枚举和结构体都可以实现接口。
class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int = 69105
func adjust() {
simpleDescription += " Now 100% adjusted."
}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
struct SimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() {
simpleDescription += " (adjusted)"
}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
写一个实现这个接口的枚举。
注意声明SimpleStructure时候mutating关键字用来标记一个会修改结构体的方法。SimpleClass的声明
不需要标记任何方法因为类中的方法经常会修改类。
使用extension来为现有的类型添加功能，比如添加一个计算属性的方法。你可以使用扩展来给任意类型
添加协议，甚至是你从外部库或者框架中导入的类型。
extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number (self)"
}
mutating func adjust() {
self += 42
}
}
7.simpleDescription
给Double类型写一个扩展，添加absoluteValue功能。
你可以像使用其他命名类型一样使用接口名——例如，创建一个有不同类型但是都实现一个接口的对象集
合。当你处理类型是接口的值时，接口外定义的方法不可用。
let protocolValue: ExampleProtocol = a
protocolValue.simpleDescription
// protocolValue.anotherProperty // Uncomment to see the error
即使protocolValue变量运行时的类型是simpleClass，编译器会把它的类型当做ExampleProtocol。这表
示你不能调用类在它实现的接口之外实现的方法或者属性。 在尖括号里写一个名字来创建一个泛型函数或者类型。
func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
var result = ItemType[]()
for i in 0..<times {
result += item
}
return result
}
repeat("knock", 4)
你也可以创建泛型类、枚举和结构体。
// Reimplement the Swift standard library's optional type
enum OptionalValue<T> {
case None
case Some(T)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some(100)
在类型名后面使用where来指定一个需求列表——例如，要限定实现一个协议的类型，需要限定两个类型
要相同，或者限定一个类必须有一个特定的父类。
func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element:
Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
for lhsItem in lhs {
for rhsItem in rhs {
if lhsItem == rhsItem {
return true
}
}
}
return false
}
anyCommonElements([1, 2, 3], [3])
修改anyCommonElements函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。
简单起见，你可以忽略where，只在冒号后面写接口或者类名。<T: Equatable>和<T where T:Equatable>是等价的。

6. swift标准库有哪些内置函数

swift的新内置函数太多了，就基本的数据类型中，Int Double Float String Array等都有很多的方法，一时半会也讲不完。http://www.cocoachina.com/special/swift/ cocoachina是个不错网站，去论坛可以找到很多讲swift的地方，也有刚刚翻译完的swift的中文版pdf。
但是我看了原版的书之后，觉得虽然苹果的原版图书讲的是很清晰、易懂，但是对于一些新的概念，难懂的方面都没有讲到。即使在读中文版的时候也会一知半解。所以
推荐www.imooc.com这个网站，有一门新开的swift教程，不是很长，看完了估计比看几遍书都管用。

7. IOS（一）swift知识点速记

var a = "ddd"
print(a)

let a = 1
print(a)

var b : Int = 1

声明：

取值 使用！，每次取值需要先判断是否为nil

可选绑定

整型字面量可以是一个十进制，二进制，八进制或十六进制常量。 二进制前缀为 0b，八进制前缀为 0o，十六进制前缀为 0x，十进制没有前缀：

布尔型字面量的默认类型是 Bool。布尔值字面量有三个值，它们是 Swift 的保留关键字：

声明

属性

方法

数组赋给变量则，可以增删修数组元素；如果赋给常量，则数组大小内容都不可更改。

创建数组

访问数组元素

数组操作

遍历数组

合并数组

数组属性

用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。
创建字典，赋给变量，则可增删修，赋给常量，则什么都不能变。

创建字典

访问字典

修改字典

字典内删除元素

字典遍历

字典转换为数组 ，将key单独抽取出来形成数组，将value单独抽取出来形成数组

字典属性

元组与数组类似，不同的是，元组中的元素可以是任意类型，使用的是圆括号。

函数中使用元祖

如果没有显示指定函数返回值，隐式返回值将会是Void。
函数定义和调用

函数参数名

可变参数，可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数，其数量是不确定的。可变参数通过 在变量类型名后面加入（...） 的方式来定义。

参数类型：

函数类型，使用函数类型就像使用其他类型一样，可以自己定义函数类型

定义一个叫做 addition 的变量，参数与返回值类型均是 Int ，并让这个新变量指向 sum 函数。注意，sum 和 addition 要有同样的类型。

函数嵌套，指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。

本文参考 菜鸟教程 swift教程 做的笔记
https://www.runoob.com/swift/swift-tutorial.html

8. 《Swift基础教程第2版》txt下载在线阅读全文,求百度网盘云资源

《Swift基础教程 第2版》（【美】皮特）电子书网盘下载免费在线阅读

链接:https://pan..com/s/1JF2DOj3J6DdjoCILvzntSA

提取码:y1wc

书名：Swift基础教程 第2版

作者：【美】皮特

译者：袁国忠

出版社：人民邮电出版社

出版年份：2016-6-1

页数：242

内容简介：

本书针对初学者，从变量、类型、函数、闭包等基本概念入手，结合Swift 示例，一步步指导读者使用Swift 开发App。书的最后给出了一个App 开发全流程。

本书适合任何想学习Swift 的人员参考。

作者简介：

Boisy G. Pitre

资深苹果开发专家，曾任Siri语音识别技术提供方Nuance公司Mac产品小组的资深软件工程师，参与开发了语音识别软件Dragon Dictate。MacTech杂志“Developer to Developer”月度专栏作家，曾多次在MacTech和CocoaConf等会议上发表技术演讲。现任情绪识别公司Affectiva的移动远景规划师，领导团队致力于将公司的表情分析技术迁移到移动平台。

9. Swift中结构体的方法调度&内存分区

如下结构体

在 汇编模式 下，可知 结构体 的 函数 调用方式是 静态调用 (直接调用)：

通过在 MachOView 中打开 可执行文件 ：

通过上图可知：在 调用函数 时，不用再去其他地方查找teach的函数地址， 编译链接 完成之后，地址就已经 确定 放在 text 字段里；所以说 结构体 的函数调度方式是 静态 调度，意味着 结构体 是 不 会 存储 其中的 函数 ，执行 效率 非常 高 。

存储的是 符号 位于( String Table )字符串表中的 位置 ， 不 直接存储 符号 。

符号 经过 swift 命令重整（ nm ）变成了符号表中存放的内容。
所以也可以通过以下命令在 终端 拿到 符号表 ：

其中：
path --> 可执行文件 的地址
addr -->指定 函数地址
如下图：

在 Release 模式下，会多生成一个 .dsYM 文件用于 捕获崩溃 、 查找debug 信息，在 线上使用 该文件。 符号表 中 不 再 保留 那些静态链接的函数符号（在字符串表中的位置信息），因为一旦编译完成就能确定地址，这时符号表 精简很多 ，不占用macho文件大小，保留的是那些 不能确定地址的符号 （在字符串表中的位置）。

总结：静态调度的函数一旦 编译完成 就能确定 地址 ，再通过 地址 调用函数，只是在 debug 模式下为了 方便调试 才将该地址的 符号信息 以字符串形式 存储 在 字符串表 中，在字符串表中的 位置信息 又 存储 在 符号表 中，并 不 是通过 符号表 中去查找到函数 地址 再进行调度，要注意 先后顺序 。

首先需了解：
程序的 静态基地址 ：在 Load Commands 中 __TEXT 字段里， VM Address 就是静态基地址。

程序运行 首地址 ：在 lldb 中通过 image list 命令来 查看 首地址。

随机偏移地址 ：在可执行程序随机装载到内存中时的随机地址，就是我们当前这application偏移的地址。可通过 程序运行首地址 - 程序的静态基地址 得到。

最终： 静态函数的地址 = 符号表中函数地址 + 随机偏移地址

通过上图可知：
偏移地址 = 程序运行首地址 - 程序的静态基地址即 0x5a47000

计算一下：静态函数的地址 = 符号表中函数地址 + 随机偏移地址 即
0x105a48db0 = 0x100001DB0 + 0x5a47000

这张表的本质其实就类似我们理解的 数组 ，声明在 class 内部的方法在 不 加任何 关键字 修饰的过程中， 连续 存放在我们当前的 地址空间 中。

首先了解 ARM64 下的几个 汇编指令 ：

通过以下例子在汇编模式下：

可以看出上面的函数都是按 顺序 放在 函数表 中。

接下来通过 SIL 中查源码断点来看一下：

可看出 V-Table 就是一个 数组 结构。

如果更改方法声明的 位置 ，将方法放在 extension 中声明：

汇编模式下可看出：如果方法声明放在 extension 中，则是直接 地址调用 。为什么呢？举个例子：在Swift中，一个类有 子类 ，有 extension ，extension可以写在任意Swift文件中，如果 子类 所在文件优 先 于 extension 所在文件 加载 ，子类的函数表会首先 继承 父类的函数表，其次是自己的函数列表，当加载到extension时发现有函数，这时子类中没有指针记录哪些是父类方法哪些是自己的方法，就没法将extension中的方法按 顺序 的插入自己的 函数表 中。

扩展：OC中分类方法的调用

汇编模式下直接 地址调用 ：

SIL 的 V-Table 中也没有加入 final 修饰的 teach 函数：

OC-Swift 桥接演示：
在 OC 项目中新建 Swift 文件并选择 Create Bridging Header ，Swift中：

要在 OC 中使用 Swift 文件，就需要导入 头文件 ，头文件查看方式如下：

如果 YYTeacher 不继承 NSObject ，该头文件中则没有与 YYTeacher 相关的类信息，就不能访问到 YYTeacher 这个类。
继承 NSObject 后头文件中才有下列信息：

接下来在 OC 文件中：

在 OC 中，只能访问到有 @objc 修饰的 teach 函数，而没有 @objc 修饰的 teach1 则不能被访问到。

这时调用 t.teach() 打印的则是 teach1 ， @_dynamicReplacement(for:teach) 在 extension 中将 teach() 动态替换成 teach1() 。

内存分区 模型如下图：

上面例子中的 age 就存放在 栈 内存中。

上面例子中的 t里面存放的地址 就是在 堆区 地址。

在上面例子中，

注意： SEGMENT 和 SECTION 是 Macho 文件对 格式 的划分，而内存分区是人为对 内存布局 的分区，所以对于上面例子中 a 存放在 全局区 和在 Macho 文件中存放 __DATA.__data 里面互不冲突。

从上面图片中可以看出， 全局已初始化变量 a和age2的地址比较 接近 ，而且比 全局未初始化变量 的地址 低 ，可以更详细的对全局区进行分区：

如果例子中加入 全局已初始化静态常量

因为 age3 是 静态不可修改 的，macho文件直接 不 会记录 age3 的 符号 信息， 赋值 过程中对于编译器来说 age3 这个 符号 根本 不存在 ，就是一个值 30 ，这里的 int b = age3 就相当于 int b = 30 。

对于Swift来说， let age = 10
这种情况下，因为age是不可变的，所以不允许通过 po withUnsafePointer(to: &age){print($0)} 这种方式来获取age的地址。

可以通过以下方式在 汇编模式 下来获取 age 的地址为 0x100008028 ：

可知 age 的符号信息在 macho 文件中存放在 __DATA.__common 里面.
综上可知：和 C/OC 相比， Swift 对于 全局 变量在 Macho 文件中的 划分规则 是 不一样 的.