獲取版本號
swift -version
Hello world
print("Hello, world!")
末尾不需要分號
值
常量(let),變量(var)
var myVariable = 42
myVariable = 50
let myConstant = 42
可以顯式聲明變量類型,若沒有則隱式推斷,類似下面的Double
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70
賦值同一類型
let label = "The width is "
let width = 94
// 去掉String報錯
// Binary operator '+' cannot be applied to operands of type 'String' and 'Int'
let widthLabel = label + String(width)
字符串中通過\(變量名)的方法得到變量的字符串表示
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
多行文本的寫法
// """ """ 包含的內容
let quotation = """Even though there's whitespace to the left,the actual lines aren't indented.Except for this line.Double quotes (") can appear without being escaped.I still have \(apples + oranges) pieces of fruit."""
數組/字典通過 [] 遍歷
var fruits = ["strawberries", "limes", "tangerines"]
fruits[1] = "grapes"var occupations = ["Malcolm": "Captain","Kaylee": "Mechanic",]
occupations["Jayne"] = "Public Relations"
自動擴容
fruits.append("blueberries")
print(fruits)
空數組/字典
fruits = []
occupations = [:]// 指定類型
let emptyArray: [String] = []
let emptyDictionary: [String: Float] = [:]
控制流
循環: for-in,while,repeat-while
條件: if
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {if score > 50 {teamScore += 3} else {teamScore += 1}
}
print(teamScore)
// Prints "11"if + 賦值
let scoreDecoration = if teamScore > 10 {"🎉"
} else {""
}
print("Score:", teamScore, scoreDecoration)
屬于語法糖,少寫一個賦值
var n = 2
while n < 100 {n *= 2
}
print(n)
// Prints "128"var m = 2
// 這個其它語言中一般是用do, 用repeat可能是為了強調循環?
repeat {m *= 2
} while m < 100
print(m)
// Prints "128"
var total = 0
for i in 0..<4 {total += i
}
print(total)
// Prints "6"
for i in 0..<4, i的遍歷區間是0,1,2,3
可選型(optional)
- 類型后面跟問號
if let name = optionalName會解包,能確定name是nil還是有具體的值
var optionalString: String? = "Hello"
print(optionalString == nil)
// Prints "false"var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {greeting = "Hello, \(name)"print(greeting)
}
還有種處理可選型的方法是通過??
let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"
nickname 有值則用nickname的值,沒有值則用??后的值。這是種默認值的寫法,更健壯的處理當數據可能為nil的情況。
switch 的寫法
let vegetable = "red pepper"
switch vegetable {
case "celery":print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):print("Is it a spicy \(x)?")
default:print("Everything tastes good in soup.")
}
// Prints "Is it a spicy red pepper?"
case類型可以是String，這點比Objective-C方便很多，編程語言是給人讀的。
去掉default語句會報Switch must be exhaustive編譯錯誤,這是編程的實踐，避免開發者遺漏
未使用的變量_
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 (_, numbers) in interestingNumbers {for number in numbers {if number > largest {largest = number}}
}
print(largest)
訪問for循環時沒有使用到字典的key,用_可以告訴編譯器這件事方便優化
// 如果非要定義了不用,會給一個警告
Immutable value 'key' was never used; consider replacing with '_' or removing it
函數和閉包
- 函數關鍵字
func ->后跟返回值- 函數定義對參數的聲明和
objective-c類似
func greet(person: String, day: String) -> String {return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")
通過元組(tuple)可以處理多個值
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {var min = scores[0]var max = scores[0]var sum = 0for score in scores {if score > max {max = score} else if score < min {min = score}sum += score}return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
// Prints "120"
print(statistics.2)
// Prints "120"
嵌套函數
func returnFifteen() -> Int {var y = 10func add() {y += 5}add()return y
}
returnFifteen()
這個見的少,只見過類似概念的Java里的內部類
函數作返回值，參數
Functions are a first-class type. This means that a function can return another function as its value.
類型：規定了變量可以取的值得范圍，以及該類型的值可以進行的操作。根據類型的值的可賦值狀況，可以把類型分為三類：
1、一級的（first class）。該等級類型的值可以傳給子程序作為參數，可以從子程序里返回，可以賦給變量。大多數程序設計語言里，整型、字符類型等簡單類型都是一級的。
2、二級的（second class）。該等級類型的值可以傳給子程序作為參數，但是不能從子程序里返回，也不能賦給變量。
3、三級的（third class）。該等級類型的值連作為參數傳遞也不行。
函數當返回值
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]
// lessThanTen 函數作為參數
hasAnyMatches(list: numbers, condition: lessThanTen)
閉包
函數是一種特殊的閉包，有名字的閉包(closures)
// {} 內的是閉包
numbers.map({ (number: Int) -> Int inlet result = 3 * numberreturn result
})
簡化閉包寫法
省略return
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
當閉包是函數的唯一參數時，可以完全省略括號
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
對象和類
class Shape {var numberOfSides = 0func simpleDescription() -> String {return "A shape with \(numberOfSides) sides."}
}
創建對象
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
初始化函數
class NamedShape {var numberOfSides: Int = 0var name: Stringinit(name: String) {self.name = name}func simpleDescription() -> String {return "A shape with \(numberOfSides) sides."}
}
子類重寫父類方法
class Square: NamedShape {var sideLength: Doubleinit(sideLength: Double, name: String) {self.sideLength = sideLengthsuper.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()
屬性訪問器getter && setter
class EquilateralTriangle: NamedShape {var sideLength: Double = 0.0init(sideLength: Double, name: String) {self.sideLength = sideLengthsuper.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 triangle with sides of length \(sideLength)."}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
// Prints "9.3"
triangle.perimeter = 9.9
print(triangle.sideLength)
// Prints "3.3000000000000003"
計算屬性
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")
print(triangleAndSquare.square.sideLength)
// Prints "10.0"
print(triangleAndSquare.triangle.sideLength)
// Prints "10.0"
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
// Prints "50.0"
枚舉和結構體
enum Rank: Int {case ace = 1case two, three, four, five, six, seven, eight, nine, tencase jack, queen, kingfunc simpleDescription() -> String {switch self {case .ace:return "ace"case .jack:return "jack"case .queen:return "queen"case .king:return "king"default:return String(self.rawValue)}}
}
let ace = Rank.ace
let aceRawValue = ace.rawValue
rawValue 默認0開始，然后遞增
枚舉的 case 值是實際值，而不僅僅是編寫其原始值的另一種方式。事實上，在沒有有意義的原始值的情況下，可以不必提供原始值。
enum Suit {case spades, hearts, diamonds, clubsfunc 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()并發
異步方法的關鍵字 async，調用異步方法前面加await
func fetchUserID(from server: String) async -> Int {print("fetchUserID")if server == "primary" {return 97}return 501
}func fetchUsername(from server: String) async -> String {print("fetchUsername")let userID = await fetchUserID(from: server)if userID == 501 {return "John Appleseed"}return "Guest"
}func connectUser(to server: String) async {// 異步調用async let userID = fetchUserID(from: server)async let username = fetchUsername(from: server)// 等待返回后執行下一句let greeting = await "Hello \(username), user ID \(userID)"print(greeting)
}Task {await connectUser(to: "primary2")
}
等待任務組
let userIDs = await withTaskGroup(of: Int.self) { group infor server in ["primary", "secondary", "development"] {group.addTask {return await fetchUserID(from: server)}}var results: [Int] = []for await result in group {results.append(result)}return results
}
協議與擴展
使用關鍵字Protocol定義協議
protocol ExampleProtocol {var simpleDescription: String { get }mutating func adjust()
}
類,枚舉和結構體都可以實現協議
class SimpleClass: ExampleProtocol {var simpleDescription: String = "A very simple class."var anotherProperty: Int = 69105func adjust() {simpleDescription += " Now 100% adjusted."}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescriptionstruct SimpleStructure: ExampleProtocol {var simpleDescription: String = "A simple structure"mutating func adjust() {simpleDescription += " (adjusted)"}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
結構體的adjust方法前有mutating修飾用于修改結構體的成員
可以使用擴展來為已有的類型添加方法
extension Int: ExampleProtocol {var simpleDescription: String {return "The number \(self)"}mutating func adjust() {self += 42}}
print(7.simpleDescription)
// Prints "The number 7"
異常捕獲
通過實現Error協議來表示錯誤類型
enum PrinterError: Error {case outOfPapercase noTonercase onFire
}
throws 關鍵字來拋出異常
func send(job: Int, toPrinter printerName: String) throws -> String {if printerName == "Never Has Toner" {throw PrinterError.noToner}return "Job sent"
}
可以使用 do-catch 來捕獲異常，try 修飾可能會拋出異常的代碼
do {let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")print(printerResponse)
} catch {print(error)
}
// Prints "Job sent"
多種異常的處理
do {let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")print(printerResponse)
} catch PrinterError.onFire {print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {print("Printer error: \(printerError).")
} catch {print(error)
}
// Prints "Job sent"
defer關鍵詞修飾的代碼會在函數所有代碼執行完成后，函數return返回前執行。
無論代碼是否拋出異常都會執行。它一般用于建立或清理代碼。
有點類似finally 部分,可以避免異常的時候沒釋放內存。這在某個函數有多個返回出口的時候特別有用。
var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]func fridgeContains(_ food: String) -> Bool {fridgeIsOpen = truedefer {fridgeIsOpen = false}let result = fridgeContent.contains(food)return result
}
if fridgeContains("banana") {print("Found a banana")
}
print(fridgeIsOpen)
泛型
泛型: <類型>
func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {var result: [Item] = []for _ in 0..<numberOfTimes {result.append(item)}return result
}
makeArray(repeating: "knock", numberOfTimes: 4)
可以對方法，函數，類，枚舉，結構體應用泛型
// where T.Element: Equatable , T.Element == U.Element表示：只有元素遵循 Equatable 協議且內部的類型一致時才可以使用anyCommonElements方法
func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Boolwhere T.Element: Equatable, T.Element == U.Element
{for lhsItem in lhs {for rhsItem in rhs {if lhsItem == rhsItem {return true}}}return false
}
anyCommonElements([1, 2, 3], [3])
參考
- Swift-Doc
- 什么是 First-class function？
- Swift系列之關于Swift defer的正確使用
- Swift限定泛型、協議擴展或約束的where
