var myVariable = 42// 变量 myVariable = 50 let myConstant = 42// 常量 let explicitDouble: Double = 70// 带类型的常量
类型转换
1 2 3
let label = "The width is " let width = 94 let widthLabel = label + String(width) // 必须强制转换
在字符串中包含变量
1 2 3 4
let apples = 3 let oranges = 5 let appleSummary = "I have \(apples) apples." let fruitSummary = "I have \(apples + oranges) pieces of fruit."
数组与字典
1 2 3 4 5 6 7 8
var shoppingList = ["catfish", "water", "tulips", "blue paint"] shoppingList[1] = "bottle of water" var occupations = [ "Malcolm": "Captain", "Kaylee": "Mechanic", ] occupations["Jayne"] = "Public Relations"
1 2
let emptyArray = [String]() // 空数组 let emptyDictionary = [String: Float]() // 空字典
可选类型
1 2 3 4 5 6 7 8
var optionalString: String? = "Hello" print(optionalString == nil) var optionalName: String? = "John Appleseed" var greeting = "Hello!" iflet name = optionalName { // 获取可选类型的值 greeting = "Hello, \(name)" }
1 2 3
let nickName: String? = nil let fullName: String = "John Appleseed" let informalGreeting = "Hi \(nickName ?? fullName)"// 给可选类型一个默认值.当nickName为nil, 返回默认值,否则返回nickName的值.
switch语句
1 2 3 4 5 6 7 8 9 10 11
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.") caselet x where x.hasSuffix("pepper"): // 条件选项 print("Is it a spicy \(x)?") default: print("Everything tastes good in soup.") }
for-in语句
1 2 3 4 5 6 7 8 9 10 11 12 13 14
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 } } } print(largest)
while语句
1 2 3 4 5 6 7 8 9 10 11
var n = 2 while n < 100 { n = n * 2 } print(n) var m = 2 repeat { m = m * 2 } while m < 100 print(m)
range范围
..<包前不包后
...包前包后
1 2 3 4 5
var total = 0 for i in0..<4 { total += i } print(total)
enumRank: Int{ case ace = 1 case two, three, four, five, six, seven, eight, nine, ten case jack, queen, king funcsimpleDescription() -> String { switchself { case .ace: return"ace" case .jack: return"jack" case .queen: return"queen" case .king: return"king" default: returnString(self.rawValue) } } } let ace = Rank.ace let aceRawValue = ace.rawValue // 获取原始值
structCard{ var rank: Rank var suit: Suit // 结构体也可以有方法 funcsimpleDescription() -> String { return"The \(rank.simpleDescription()) of \(suit.simpleDescription())" } } let threeOfSpades = Card(rank: .three, suit: .spades) let threeOfSpadesDescription = threeOfSpades.simpleDescription()
带值的枚举
1 2 3 4 5 6 7 8 9 10 11 12 13 14
enumServerResponse{ case result(String, String) case failure(String) } let success = ServerResponse.result("6:00 am", "8:09 pm") let failure = ServerResponse.failure("Out of cheese.") switch success { caselet .result(sunrise, sunset): print("Sunrise is at \(sunrise) and sunset is at \(sunset).") caselet .failure(message): print("Failure... \(message)") }
协议和扩展
协议protocol
1 2 3 4
protocolExampleProtocol{ var simpleDescription: String { get } mutatingfuncadjust()// mutating 表示可以改变对象,class不需要,结构体需要 }
// 类,结构体和枚举都可以实现协议 classSimpleClass: ExampleProtocol{ var simpleDescription: String = "A very simple class." var anotherProperty: Int = 69105 funcadjust() { simpleDescription += " Now 100% adjusted." } } var a = SimpleClass() a.adjust() let aDescription = a.simpleDescription structSimpleStructure: ExampleProtocol{ var simpleDescription: String = "A simple structure" mutatingfuncadjust() { simpleDescription += " (adjusted)" } } var b = SimpleStructure() b.adjust() let bDescription = b.simpleDescription
扩展extension,可以添加对象的机能
1 2 3 4 5 6 7 8 9 10
// 扩展int,添加一个计算属性和一个方法 extensionInt: ExampleProtocol{ var simpleDescription: String { return"The number \(self)" } mutatingfuncadjust() { self += 42 } } print(7.simpleDescription)
错误处理
错误协议Error
1 2 3 4 5 6
// 实现错误协议表明这是错误 enumPrinterError: Error{ case outOfPaper case noToner case onFire }
错误声明throws和错误抛出throw
1 2 3 4 5 6
funcsend(job: Int, toPrinter printerName: String)throws -> String { if printerName == "Never Has Toner" { throwPrinterError.noToner } return"Job sent" }
错误捕捉try,catch
1 2 3 4 5 6
do { let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng") print(printerResponse) } catch { print(error) // error是默认的错误名,也可以自己命名 }
错误捕捉分支
1 2 3 4 5 6 7 8 9 10
do { let printerResponse = try send(job: 1440, toPrinter: "Gutenberg") print(printerResponse) } catchPrinterError.onFire { print("I willl just put this over here, with the rest of the fire.") } catchlet printerError asPrinterError { print("Printer error: \(printerError).") } catch { print(error) }
错误转可选类型
如果抛出错误,可选类型的值为nil,而且错误被无视
如果正常,可选类型的值为返回值
1 2
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler") let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")
延迟执行defer
defer块中的代码会在函数的其他代码执行完后运行。
(有点像析构函数)
1 2 3 4 5 6 7 8 9 10 11 12 13 14
var fridgeIsOpen = false let fridgeContent = ["milk", "eggs", "leftovers"] funcfridgeContains(_ food: String) -> Bool { fridgeIsOpen = true defer { fridgeIsOpen = false } let result = fridgeContent.contains(food) return result } fridgeContains("banana") print(fridgeIsOpen)
泛型
泛型方法
1 2 3 4 5 6 7 8
funcmakeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] { var result = [Item]() for_in0..<numberOfTimes { result.append(item) } return result } makeArray(repeating: "knock", numberOfTimes:4)
泛型类,枚举和构造体
1 2 3 4 5 6 7
// Reimplement the Swift standard library's optional type enumOptionalValue<Wrapped> { casenone case some(Wrapped) } var possibleInteger: OptionalValue<Int> = .none possibleInteger = .some(100)
条件化泛型,where条件
1 2 3 4 5 6 7 8 9 10 11
funcanyCommonElements<T: Sequence, U: Sequence where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element>(_ lhs: T, _ rhs: U) -> Bool { for lhsItem in lhs { for rhsItem in rhs { if lhsItem == rhsItem { returntrue } } } returnfalse } anyCommonElements([1, 2, 3], [3])