博客

基本语法

print("Hello,world")

Note

声明的结尾不需要写分号

简单值

Type Infer: 类型推断

含义：编译器compiler会根据给定的值（constant、variable）自动推断value的类型。

let implicitInteger = 70 // 自动推断值是一个整型
let implicitDouble = 70.0 // 自动推断值是一个double类型

如何初始值没有提供足够的信息（或没有一个初始值），那么通过在变量后面写具体的类型类指定数据类型，中间用冒号分割。

let explicitDouble:Double = 79

值不会隐式转换为另一个类型，需要显式的创建一个类型的实例

let label = "The width is "
let width = 94
let widthLable = label + String(width)

移除String（），将会报错：

Binary operator ‘+’ cannot be applied to operands of type ‘String’ and ‘Int’

数字转字符串的写法总结

数组和字典

创建

：使用方括号[]

var shoppingList = ["fish", "water", "vegitables"]
var occupations = [
	"Mal": "Caption",
  "Sel":"Machine",
]

创建空数组或字典

let emptyArray:[String] = []
let emptyDictionay: [String: Float] = [:]

访问：

1. 使用index
2. 使用key值

shoppingList[1] = "air"
occupations[Sel] = "Plbulic"

数组添加元素

数组会自动增长

shoppingList.append("blue paint")

流程控制

条件：

if

、

switch

循环：

for-in

、while、

repeat-while

条件和循环变量周围的圆括号可以省略，但body体周围的花括号是必须的

let individualScores = [56,59,60,34,12]
var teamScore = 0
for score in individualScores {
	if score > 50 {
		teamScore += 4
	} else {
		teamScore += 1
	}
}

if声明的注意事项

条件判断必须为一个布尔表达式，if score {…} 是错误的写法

if的其他用法：可选值?与??操作符

if

和

let

一起表示值可能丢失

什么是可选值optional

value 可能有值也可以是nil

可选值写法：在一个类型后面加问号表示该值为可选值

var optionalString: String? = "Hello"

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
	greeting = "Hello, \(name)"
}

代码执行逻辑

1. 
   optionalName
   
   为
   
   nil
   
   ,条件为
   
   false
   
   , 花括号中的代码将被跳过。
2. 否则，可选值将会被解包，分配给let后面的常量，此时解包的name值在代码块内可用。

处理可选值的方法？？操作符

??操作符

?? 用于提供默认值，如果可选值丢失，使用默认值代替

let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"

Switch的用法

支持任何类型的数据和各种各样的比较操作符，不限于整数和相等性测试

let vegetable = "red pepper"
switch vegetable {
  case "celery":
  	print("Add some raisins and make ants on a log.")
  case "cucumber", "wattercress":
  	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.")
}

switch

用法注意点：

1. default 关键字是必须有的，因为switch循环需要穷尽所有情况；
2. 
   let
   
   能够被用在模式中匹配模式给一个常量
3. 一旦case被匹配，执行将退出，不再执行下一个case，所以不需要break声明。

for-in

可用于通过key-value对遍历数组

特点

1. 无序集合，所以键值遍历是任意的顺序

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)

“_”代码占位符

**… < **表示索引循环

var total = 0
for i in 0..< 4 {
  total += i
}
print(tatal)

while

作用

：while用于重复一段代码块直到条件改变。

条件在结尾

：如果循环的条件放在结尾，那么会保证循环至少执行一次。

var n = 2
while n < 100 {
	n *= 2
}
print(n)

var m = 2
repeat {
	m *= 2
} while m < 100
print(m)

函数和闭包

函数

func greet(person:String, day: String) -> String {
	retrun "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

标签名命名规则

Note

默认情况下使用参数名作为参数的标签名，但可以在参数名前面自定义标签名，或者写“_”表示没有标签名

func greet(_ person: String, on day: String) -> String {
	return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

元组

func calculateStatistics (scores: [Int]) -> (min: Int,max: Int, sum: Int) {
	var min = scores[0]
  var max = scores[0]
  var sum = 0
  
  for 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)
print(statistics.2)

嵌套函数

1. 函数可以被嵌套
2. 被嵌套的函数可以访问外部函数的变量
3. 嵌套函数可以用来组织长函数或复杂函数

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 ture
    }
  }
  return false
}
func lessThanTen(number: Int) -> Bool {
  return number < 10
}
var numbers = [20,19,17,2]
hasAnyMatches(list: numbers, condition:lessThanTen)

如何创建闭包

函数是一种特殊的闭包，如何创建没有名称的闭包

1. 使用**{}**将没有名称的闭包括起来
2. 使用
   
   in
   
   将函数和返回值与主体分开

number.map({(number: Int) -> Int in
	let result = 3 * number
  return result
})

闭包的简化写法1

当一个闭包的类型是已知的，那么可以省略闭包的参数类型或返回类型或者两者。只声明闭包并隐式的返回它的值。

let mappedNumbers = numbers.map({number in 3 * number})
print(mappedNumbers)

闭包的简化写法2

• 可以通通过数字而不是名称引用参数
• 当闭包是函数的唯一参数是，可以完全省略圆括号

let sortedNumbers = numbers.sorted { $0  > $1 }
print(sortedNumbers)

对象和类

如何声明一个类

1. 
   class
   
   关键字后面跟着一个类名
2. 类中属性的声明与常量和变量的生命相同，只是作用域是在类中
3. 类中方法、函数的声明也一样

class Shape {
  var numberOfSides = 0
  func simpleDescription() -> String {
    	return "A shape with \(numberOfSides) sides."
  }
}

如何创建一个实例

var shape = Shape()
shape.numbersOfSides = 7
var shapeDescription = shape.simpleDescription()

创建一个带初始化器的实例

当实例创建的时候，初始化器被创建，使用

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."
  }
}

Note:

每一个属性都需要赋值，要么在声明中，如numberOfSides, 要么在初始化器中，如name

self

用于区分属性名和传给初始化器的参数名

当创建类的实例的时候初始化器会想函数的参数一样被传递

deinit析构器

创建析构器，如果你需要在对象销毁的时候执行一些清理操作

如何包含父类

• 在子类名称的后面包含父类名，以冒号区隔
• 包含父类不是必须的，所以可以根据需要决定是否添加

关于子类方法的复写

• 子类要复写父类方法，需要添加关键字
  
  override
  
• 如果没有添加
  
  override
  
  ，会出现编译错误
• 如果添加了
  
  override
  
  ，也会出现编译错误

class Square: NameShapre {
  var sideLength: Double
  
  init(sideLength: Double, name: String) {
    	self.sideLength = sideLength
      super.init(name:name)
    	numberOfSides = 4
  }
  
  func area() -> Double {
    	return sideLength * sideLenth
  }
  
  override func simpleDescription() -> String {
    return "A square with sides of length \(sideLeght)."
  }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

属性的getter和setter

除了简单的属性存储，属性能有getter和setter

class EquilateralTriangle: NamedShape {
  init(sideLength: Double, name Stirng) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 3
  }
  var perimeter: Double {
      get {
        return 3.0 * sideLength
      }
      set {
        sideLength = newValue / 3.0
      }
   }
  override func simpleDescirption() -> String {
      return "An equilateral triangle with sides of length \(sideLength)."
  }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
triangle.perimeter = 9.9
print(triangle.sideLength)

Note

1. 对于perimeter的setter,有一个隐式的名称
   
   newValue
   
   ,你可以在set后面加圆括号提供一个名字
2. 注意
   
   EquilateralTriangle
   
   有3个不同的步骤：
   1. 设置子类声明的属性值
   2. 调用父类的初始化器
   3. 改变在父类定义的属性值。任何使用方法、getter或setter的附加设置工作也在这里完成。

属性的willSet和didSet

如果你不需要计算属性，但仍然需要在设置一个新值之前或之后提供代码，可以使用

willSet

和

didSet

。

当值在初始化器之外变化是，就会运行你提高的代码。

class TriangleAndSquare {
  var triangle: EquilaterTriangle {
    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: 100, name: "another test shape")
print(riangleAndSquare.square.sideLength)
print(riangleAndSquare.triangle.sideLength)
triangleAndSquare.square(sideLength: 50, name: "larger square")
print(triangleAndSquare.trianlge.sideLength)

可选值的使用与计算逻辑

当使用可选值时，你可以在方法、属性和下标操作前写

？

，如果 **？**前面的值为nil，那么 **？**后面的会被忽略，整个表达式的值为nil.否则，可选值被解包，获取解包值，在这种情况下，整个表达式的值是一个可选值。

let optionalSquare: Square? = Square(sideLength: 2.5, name：'optional square')
let sideLegnth = optionalSquare?.sideLength

枚举和结构体

如何创建一个枚举

使用

enum

创建一个枚举，像类与其他命名类型一样，枚举有与他们相关联的方法。

enum Rank: Int {
  case ace = 1
  case two, three, four, five, six, serven, eight, nine, ten
  case jack, queen, king
  
  func simepleDescirption() -> 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

Note

1.默认行的值从0开始，然后依次增长，但你能够通过复制改变。上面的例子ace被赋值为1，剩下的按递增顺序分配。

2.rawValue还可以是字符串或Float类型，此时每个case都需要声明，无法像数字一样按顺序增长

3.case的方法依然使用

rawValue

属性

4.注意一下，以上case, three的

rawValue

为3，jack的

rawValue

为11

枚举初始化器

使用

init?(rawValue:)

去从一个

rawValue

初始化实例。

• 当
  
  rawValue
  
  匹配时返回一个枚举
  
  case
  
• 当
  
  rawValue
  
  不匹配时，返回
  
  nil
  

if let convertedRank = Rank(rawValue: 11) {
  canvertedRank.simpleDescription()
}

枚举的rawValue不是必须的

枚举的case值是实际的值，并不是raw values的另一种写法，因此，在没有一个有意义的raw value的情况下，你可以不用提供。

enum Suit {
  case spades, hearts, diamond, clubs
  
  func simpleDescription() -> String {
    switch self {
      case .spades: 
      	return "spades"
      case .hearts:
      	return "hearts"
      case .diamonds: 
      	return "diamond"
      case .clubs: 
      	return "clubs"
    }
  }
}
let hearts = Suit.hearts
let heartsDescripton = hearts.simpleDescription()

什么时候用省略形式

hearts

常量的赋值使用的是全名

Suit.hearts

但在

switch

内部，

case

使用的是简略形式**.hearts**,因为

self

与之相配

在其他任何时候，只要是指的类型是已知的，都可以使用缩略形式

实例决定的枚举值

如果枚举值有

rawValues

,这些值被决定作为声明的一部分，意味着每一个实例的某个case总有相同的枚举值。

另一种选择是让case和case的值相关联，这样值由实例决定，不同的实例它的case值是不同的。可以认为这些值是枚举实例的存储属性。

enum ServerResponse {
  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 {
  case let .result(sunrise, sunset):
  	print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
  case let .failure(message):
  	print("Failure... \(message)")
}

结构体

struct

关键字用于创建结构体，struct支持很多和类相同的行为，包含方法和初始化器。

structures 和 classes有什么不同

structures总是被copied

当类在代码中传递时，它传递的是引用

协议和扩展

使用

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 aDescirption = a.simpleDescription

struct SimpleStucture: ExampleProtocol {
  var simpleDescription: String = "A simple structure"
  mutating func adjust() {
    simpleDescription += " (adjusted)"
  }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

Note

mutating

关键字声明在struct 表示修改，在class中不用声明这个关键字，因为class中本来就可以修改。

extension关键字：拓展类型的功能

使用

extension

给已经存在的类型添加功能，例如一个新方法或者计算属性，可以使用

extension

添加协议一致性给在其他地方声明的类型，或一个库或框架中导入的类型。

extension Int: ExampleProtocol {
  var simpleDescription: String {
    retrun "The number \(self)"
  }
  mutating func adjust() {
    self +=42
  }
}
print(7.simpleDescription)

用协议声明的属性不能使用协议外定义的方法

你可以使用

protocol

想使用其他任何被命名的类型一样，例如，去创建一个有不同类型的集合对象，但是他们都遵守同一个协议。当处理类型为协议类型的值是，协议之外的方法不可用。

class SimpleClass: ExampleProtocol {
  var simpleDescription:String = "A very simple class."
  var anotherProperty: Int = 3455
  func adjust() {
    simpleDescription += " Now 100% ajusted."
  }
}
var a = SimpleClass()
let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty) // Uncomment to see error

Note

虽然

protocolValue

变量有一个运行时类型

SimpleClass

，但编译器处理它作为被给的类型**ExmapleProtocol **,这意味着你不能方法协议之外，遵守该协议的类实现的属性或方法。

错误处理

错误的表示

使用遵守

Error

协议的任何类型表示错误

enum PrinterError: Error {
  case outOfPaper
  case noToner
  case onFire
}

定义一个可以抛出错误的函数

如果你在函数内抛出一个错误，函数会立即返回并调用处理函数错误的代码。

func send(job: Int, toPrinter printerName: String) throws -> String {
  if printerName == "Never Has Toner" {
    throw PrinterError.noToner
  }
  return "Job sent"
}

处理错误的方法：do-catch

do：

代码块内在一个能抛出错误的代码前面标记

try

**catch **：代码块内自动给一个error名字，你可以用一个不同的名字

do {
  let printerResponse = try send(job: 1040, toPrinter: "Never Has Toner")
  print(printerResponse)
} catch {
  print(error)
}

catch可以写多个用于处理具体的错误

catch

之后写case和

switch

之后是一样的。

do {
  let printerResponse = try send(job: 111, toPrinter: "Tne")
} catch PrinterError.onFire {
  print("I'll just put this over here.")
} catch let printerError as PrinterError {
  print("Printer error: \(printerError).")
} catch {
  print(error)
}

错误处理方法try？

使用

try？

具体的错误将被放弃，并将返回

nil

如果有值，则该值被返回

let printerSuccess = try? send(job:111, toPrinter: "Merge") // Job sent
let printerFalure = try? send(job:1993, toPrinter: "Never Has Toner")  // nil

defer的用法

defer的含义

见字如意，延迟代码执行，会在函数内的所有其他代码执行完成之后执行,因此可以将构建代码和清理代码写在一起，虽然他们会执行在不同的时间。

var fridgeOpen = false
let fridgeContent = ["milk","eggs","leftovers"]

func fridgeContains(_ food: String) -> Bool {
  defer {
    fridgeIsOpen = false
  }
  fridgeIsOpen = true
  let result = fridgeContent.contains(food)
  return result
}
fridgeContains("banana")
print(fridgeIsOpen)

泛型

如何定义一个泛型

: 在尖括号内一个名字，组成泛型函数或类型,

name

名字自定义

func makeArray<Item>(repeating item: Ele, numberOfTimes: Int) -> [Item] {
  var result: [Item] = []
  for _ in 0..<numberOfTimes {
    result.append(item)
  }
  return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

函数function、方法method、类class、枚举enum、结构体struct都可以使用泛型

enum OptionalValue<Wrapped> {
  case none
  case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possbileInteger = .some("100")

where的用法

where

可用于在body前面指定一些条件，比如实现一个protocal,要求两个类型相同，或者要求一个类有特殊的父类。

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool 
where T.Element: Equatable, T.Element == U.Element{
  for lhsItem in lhs {
    for rhsItem in rhs {
      if lhsItem == rhsItem {
        return true
      }
    }
  }
  return false
}

Note

<T: Equatable>

与

… where T: Equatable

是相同的。

大纲概览

reference




a swift tour