获取版本号
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
