Swift 学习笔记(二)

最近学习Swift语言，此为此课程的第二节，希望自己能在这条道路上坚持住，不断自我迭代发展。

Functions and Closures

使用func来定义函数，并在括号内声明参数名和参数类型，使用->来表示函数返回值的类型。

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

swift中函数默认使用参数名作为标签，可以使用_，或在参数名前自定义一个标签（如下的on）来代替默认标签的使用。

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

使用tuple来使得函数返回一个复合的值。

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)

函数的嵌套，可以在一个函数中定义另一个函数，并在这个函数中使用。

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即为addOne函数
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]
hasAnyMatches(list: numbers, condition: lessThanTen)

闭包的使用，用{}围成的一个代码块。使用in来分离参数和代码及返回值。

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

闭包更简洁的写法，当闭包的类型已知时，省略参数类型，和返回值类型

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

可以使用数字代替参数名来调用，这在短的闭包中非常有用，当闭包是函数的唯一参数，可以省略（）

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

Objects and Classes

使用class来定义一个类，并用相同的方法来在类中定义变量，常量，函数。

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

使用init函数，在创造一个实例的时候来初始化这个实例。

class NamedShape {
    var numberOfSides: Int = 0
    var name: String

    init(name: String) {
       self.name = name  //self 代表自身的参数name 相当于构造函数
    }

    func simpleDescription() -> String {
       return "A shape with \(numberOfSides) sides."
    }
}

使用override关键字来声明子类覆盖超类，super关键字来使用超类的方法。

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

类中的变量也有get和set函数，分别不同作用：

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 {
            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)

使用willset来使得两个变量的值保持一致。

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength  //修改triangle的值时，square的值也会相应的更改。
        }
    }
    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)
    }
}

Enumerations and Structures

use enum to create an enumeration.like class and other name type.enumeration has its function and method.

num 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.king
let aceRawValue = ace.rawValue //rawValue is a method inside,which point out the number of rank.

use structto create structure.one of the most inportant differencies between classes and structure is that structure are always bo copied when they are psaaing around your code,but structure pass by the reference.

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

Protocols and Extensions

赏

谢谢你请我吃糖果

支付宝