Swift开始写的时候是1.0-2.0期间，之后一直写OC，再次使用Swift工作的时候会生疏或者不熟悉变化，这篇文章目的是复习Swift且记录一些3.0-4.0的变化，没有基础，只有一些生疏的点
if 判断只能bool
if 0 {}这种不行了
??句式
类似条件判断句式，只不过判断的是可选值是否为nil
|
1 2 3 4 5 |
let nickName: String? = nil let fullName: String = "John Appleseed" let informalGreeting = "Hi \(nickName ?? fullName)" //输出John Appleseed |
Switch
可以用let x where这种方法判断
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
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.") } |
每个case如果执行了不会继续执行下面的case，所以不用每个都写一个 break
repeate while
do while类似，无论如何都会执行一次的循环
|
1 2 3 4 5 |
var m = 2 repeat { m *= 2 } while m < 100 print(m) |
..<和…
..<不包含后面最大值 …两个值都包含
|
1 2 3 4 5 6 7 8 9 |
var total = 0 for i in 0...4 { total += i } print(total) |
数组里的例子
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
let names = ["Anna", "Alex", "Brian", "Jack"] for name in names[2...] { print(name) } // Brian // Jack for name in names[...2] { print(name) } // Anna // Alex // Brian for name in names[..<2] { print(name) } // Anna // Alex” |
func的参数和返回
参数可以起别名，比如name是person参数别名，返回可以用元祖返回多个结果
|
1 2 3 4 5 |
func greet(name person: String, on day: String) -> (person: String, day: String) { return (person, day) } |
func嵌套
func实现嵌套在另一个func内部
|
1 2 3 4 5 6 7 8 9 |
func returnFifteen() -> Int { var y = 10 func add() { y += 5 } add() return y } returnFifteen() |
func作为另一个func的返回值
|
1 2 3 4 5 6 7 8 |
func makeIncrementer() -> ((Int) -> Int) { func addOne(number: Int) -> Int { return 1 + number } return addOne } var increment = makeIncrementer() increment(7) |
func作为另一个func的参数
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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(list: numbers, condition: lessThanTen) |
closure的一个例子，map
|
1 2 3 4 |
numbers.map({ (number: Int) -> Int in let result = 3 * number return result }) |
简写，省略参数和closure返回值
|
1 |
let mappedNumbers = numbers.map({ number in 3 * number }) |
简写，省略参数和in句式和closure返回值
|
1 |
let sortedNumbers = numbers.sorted { $0 > $1 } |
closure作为方法最后一个参数时，可以提到方法圆括号外面，就一个参数时，可以省略圆括号
|
1 2 3 4 5 |
reversedNames = names.sorted({ $0 > $1 }) reversedNames = names.sorted() { $0 > $1 } reversedNames = names.sorted { $0 > $1 } |
Class和继承例子
“Every property needs a value assigned—either in its declaration (as with numberOfSides) or in the initializer (as with name).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
class NamedShape { var numberOfSides: Int = 0 var name: String init(name: String) { self.name = name } func simpleDescription() -> String { return "A shape with \(numberOfSides) sides." } } class Square: NamedShape { var sideLength: Double init(sideLength: Double, name: String) { //关于赋值看上面的红字 //这里注意sideLength属性声明的时候没有赋初始值，调用super.init前需要保证所有property已经initialize //换句话说就像红字说的，所有属性都需要在声明阶段或者所在类初始化阶段赋值 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() |
子类一般initializer需要几步
1 Setting the value of properties that the subclass declares.
2 Calling the superclass’s initializer.
3 Changing the value of properties defined by the superclass. Any additional setup work that uses methods, getters, or setters can also be done at this point.
计算属性
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
class EquilateralTriangle: NamedShape { var sideLength: Double = 0.0 init(sideLength: Double, name: String) { self.sideLength = sideLength super.init(name: name) numberOfSides = 3 } //计算属性实现get set方法 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) triangle.perimeter = 9.9 print(triangle.sideLength) |
ENUM
独特的写法是可以一行定义多个，且可以在枚举里面得到rawValue，实现func
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
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.rawValue) } } } let ace = Rank.ace let aceRawValue = ace.rawValue ace.simpleDescription() |
也可以用rawValue找到指定值
|
1 2 3 4 5 6 7 8 9 10 11 |
if let convertedRank = Rank(rawValue: 3) { let threeDescription = convertedRank.simpleDescription() print(threeDescription) }else { print("convertedrank = nil") } |
associate值
关联值比较实用，比如一个买卖stock的方法，一个包含买和卖的传统枚举，分别为0和1，那么购买方法本来是这样的
|
1 2 3 4 5 6 7 |
enum Trade { case Buy case Sell } func trade(tradeType: Trade, stock: String, amount: Int) { } |
利用关联值可以解放方法，调用起来的时候更简单，初始化枚举的时候就传入值好了
|
1 2 3 4 5 6 7 |
enum Trade { case Buy(stock: String, amount: Int) case Sell(stock: String, amount: Int) } func trade(type: Trade) { } |
判断associate值的例子
|
1 2 3 4 |
let trade = Trade.Buy(stock: "APPL", amount: 500) if case let Trade.Buy(stock, amount) = trade { print("buy \(amount) of \(stock)") } |
enum里面也可以定义方法，举个例子，用switch case来指定case对应的行为
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
enum Device { case iPad, iPhone, AppleTV, AppleWatch func introduced() -> String { switch self { case .AppleTV: return "\(self) was introduced 2006" case .iPhone: return "\(self) was introduced 2007" case .iPad: return "\(self) was introduced 2010" case .AppleWatch: return "\(self) was introduced 2014" } } } print (Device.iPhone.introduced()) // prints: "iPhone was introduced 2007" |
给enum里面添加计算属性
|
1 2 3 4 5 6 7 8 9 |
enum Device { case iPad, iPhone var year: Int { switch self { case .iPhone: return 2007 case .iPad: return 2010 } } } |
protocol
//和OC类似，实现协议，定义了协议的属性和方法，那么尊写这个协议的类就要实现协议中的属性和方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
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 |
protocol用于保护
|
1 2 3 4 |
let protocolValue: ExampleProtocol = a print(protocolValue.simpleDescription) //print(protocolValue.anotherProperty) // Uncomment to see the error //虽然a这个对象有anotherProperty属性，但是protocolValue声明是ExampleProtocol的，编译器就会认为不存在anotherProperty属性 |
extension
|
1 2 3 4 5 6 7 8 9 |
extension Int: ExampleProtocol { var simpleDescription: String { return "The number \(self)" } mutating func adjust() { self += 42 } } print(7.simpleDescription) |
Error Handling
|
1 2 3 4 5 6 7 8 |
//->前面加了throws意思是这个function有可能throw error //throw error 意味着这个方法立刻return且调用方会处理这个error func send(job: Int, toPrinter printerName: String) throws -> String { if printerName == "Never Has Toner" { throw PrinterError.noToner } return "Job sent" } |
一种方式是do catch处理
|
1 2 3 4 5 6 7 8 9 10 11 |
do { //在有可能throw error的方法前面添加try let printerResponse = try send(job: 1040, toPrinter: "Never Has Toner") print(printerResponse) } catch { print(error) } |
或者简单点儿
|
1 2 3 |
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler") let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner") |
Generics(泛型)
这个OC以前没有，简单的例子，Item可以任何类型，不用因为参数类型不一样写多个函数重复造轮子了
|
1 2 3 4 5 6 7 8 9 10 11 |
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) |
typealiases
|
1 |
typealias AudioSample = UInt16 |
Optionals
非Optionals值不可以设置nil
|
1 2 3 4 |
var serverResponseCode: Int? = 404 // serverResponseCode contains an actual Int value of 404 serverResponseCode = nil // serverResponseCode now contains no value |
没设置初始值的optionals默认为nil
Optional binding(if let)
代替强制unwrap的句式，用于option value 是否为空
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
var optionalName: String? = "lixiaoyao" var greeting = "Hello!" if let name = optionalName { greeting = "Hello, \(name)" } else { greeting = "oops" } |
Implicitly Unwrapped Optionals(隐式可选值)
简单地说一个类声明一个属性为可选值且一定会有初始值，那么用的时候每次都得!很麻烦，所以对于初始化一定有值，且使用过程中一定不会为nil的属性可以用隐式可选，生命的时候在类型后面加上叹号，取值的时候就不用加叹号了
|
1 2 3 4 5 |
let possibleString: String? = "An optional string." let forcedString: String = possibleString! // requires an exclamation mark let assumedString: String! = "An implicitly unwrapped optional string." let implicitString: String = assumedString // no need for an exclamation mark |
Closure设置属性默认值
|
1 2 3 4 5 6 7 |
class SomeClass { let someProperty: SomeType = { // 在这个闭包中给 someProperty 创建一个默认值 // someValue 必须和 SomeType 类型相同 return someValue }() } |
闭包结尾的大括号后面接了一对空的小括号。这是用来告诉 Swift 需要立刻执行此闭包。如果你忽略了这对括号，相当于是将闭包本身作为值赋值给了属性，而不是将闭包的返回值赋值给属性。
注意：
如果你使用闭包来初始化属性的值，请记住在闭包执行时，实例的其它部分都还没有初始化。这意味着你不能够在闭包里访问其它的属性，就算这个属性有默认值也不允许。同样，你也不能使用隐式的self属性，或者调用其它的实例方法。
String
|
1 2 3 4 5 |
str = "test" //range是string.index类型的，传给string才返回字符串，比如str[string.index] let range = str.index(str.startIndex, offsetBy: 3)..<str.index(str.startIndex, offsetBy: 10) str[range] visualize(str, range: range) |
取范围值，返回一个可选值，自动判断越界
|
1 |
let i = contents.index(contents.startIndex, offsetBy: 10, limitedBy: contents.endIndex) |