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 文件中的 劃分規則 是 不一樣 的.