###函数和闭包
- 使用
func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值的类型。
func greet(name: String, food: String) -> String {
return "Hello \(name), let's eat some \(food)"
}
greet("Lin", food: "fruit")
- 使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。
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([10, 21, 25, 50, 3])
print(statistics.max)
print(statistics.2) //表示返回值的位置
print(statistics.sum)
- 函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式
func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(1,2,3,4,5,6,7,8,9)
//计算平均值
func averageCalculate(numbers: [Int]) -> Float {
var average: Float = 0.0
var sum = 0
for number in numbers {
sum += number
}
let doubleSum = Float(sum)
let count = Float (numbers.count)
average = doubleSum / count
return average
}
- 函数可以嵌套,被嵌套的函数可以访问外侧函数的变量。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
- 函数是第一等类型，这意味着函数可以作为另一个函数的返回值。
func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return number + 1
}
return addOne
}
var incrementer = makeIncrementer()
incrementer(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,13, 12, 0]
hasAnyMatches(numbers, condition: lessThanTen)
- 函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用
{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离。
numbers.map({
(number: Int) -> Int in
var result = 0
if number % 2 == 0 && number != 0{
return number
}else{
return 0
}
})
numbers.map({
(number: Int) -> Int in
let result = number * 3
return result
})
- 有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
- 你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。
let sortedNumbers = numbers.sort {$0 < $1}
print(sortedNumbers)
对象和类
- 使用
class和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文是类。同样，方法和函数声明也一样。
class Shape {
let word = "Hi"
var numberOfSides = 0
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides"
}
func phrase(name: String) -> String {
return "\(word), \(name)"
}
}
- 要创建一个类的实例，在类名后面加上括号。使用点语法来访问实例的属性和方法。
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
var shapePhrase = shape.phrase("Lin")
- 这个版本的
Shape类缺少了一些重要的东西：一个构造函数来初始化类实例。使用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"
}
}
-
注意
self被用来区别实例变量,当你创建实例的时候，像传入函数参数一样给类传入构造器的参数。 -
子类的定义方法是在它们的类名后面加上父类的名字，用冒号分割。创建类的时候并不需要一个标准的根类，所以你可以忽略父类。
-
子类如果要重写父类的方法的话，需要用
override标记——如果没有添加override就重写父类方法的话编译器会报错。编译器同样会检测override标记的方法是否确实在父类中。
class Square: NamedShape {
var sideLength: Double
init(sideLength: Double, name: String) {
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: 1.2, name: "Lin")
test.area()
test.simpleDescription()
class Circle: NamedShape {
var radius: Double
init(radius: Double, name: String) {
self.radius = radius
super.init(name: name)
numberOfSides = 5
}
func area() -> Double {
return radius * radius * 3.1415
}
override func simpleDescription() -> String {
return "this is a circle named \(name), area is \(area())"
}
}
let testCircle = Circle(radius: 7.24, name: "Lin")
testCircle.simpleDescription()
- 除了储存简单的属性之外，属性可以有 getter 和 setter 。
class EquilateralTriangle: NamedShape {
var sideLength: Double = 0.0
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 3
}
var perimeter: Double {
get {
return 3.0 * sideLength
}
set {
return sideLength = newValue / 3.0
}
}
override func simpleDescription() -> String {
return "An equilateral triangle with sides of length \(sideLength)"
}
}
var triangle = EquilateralTriangle(sideLength: 9.0, name: "Triangle")
triangle.perimeter
triangle.perimeter = 99.0
triangle.sideLength
-
在
perimeter的setter中，新值的名字是newValue。你可以在set之后显式的设置一个名字。 -
注意EquilateralTriangle类的构造器执行了三步：
设置子类声明的属性值
调用父类的构造器
改变父类定义的属性值。其他的工作比如调用方法、getters和setters也可以在这个阶段完成。
- 如果你不需要计算属性，但是仍然需要在设置一个新值之前或者之后运行代码，使用
willSet和didSet。
class SquareAndTriangle {
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 = SquareAndTriangle(size: 3.0, name: "T&S")
triangleAndSquare.square.sideLength
triangleAndSquare.triangle.sideLength
triangleAndSquare.square = Square(sideLength: 8.0, name: "Lix")
triangleAndSquare.triangle.sideLength
- 处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加
?。如果?之前的值是nil，?后面的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。
let optionalSquare: Square? = Square(sideLength: 8.0, name: "Lin")
let sideLength = optionalSquare?.sideLength
sideLength