《The Swift Progremming Language 3.0中文版》读书笔记

笔记

Swift语言代码书写规范说明

• 所有的冒号:之后留一个空格的位置。
• 双目操作符的两端各流出一个空格的位置。
• 不将{另起一行进行书写，并且在其之前留出一个空格的位置。
• 在if语句的}之后留一个空格，然后写else语句。
• 逗号,紧贴在前一个单词之后，其后跟一个空格。
• 类名以首字母大写的单词开头，变量名和函数名以首字母小写的单词开头，而共同的是，除了首个单词以外的之后所有单词的首字母均大写，其余字母小写。
• ?操作符紧贴其前的量，例如做可选值时的使用。

欢迎使用Swift

1. 声明常量：let，默认自动推断类型，可以使用“:typename”在变量后面声明类型：

let explicitDouble: Double 

2. 值永远不会被隐式转换为其他类型。

如果要转换成字符串也可以像下面这样，便于将字符串变量的值嵌入字符串中输出：

let label = "the width is "
let width = 94
let widthlabel = label + "\(width)"

3. 创建一个空数组或者字典：

let emptyArray = [String]()
let emptyDictionary = [String:Float]()

如果类型信息可以被推断出来。。。

4. 控制流

• 条件操作：if和switch
• 循环操作：for-in、for、while、repeat-while
  包裹条件和循环变量的括号可以省略，但是与具体的大括号是必须的。
  if语句中，条件必须是一个布尔表达式。

5. nil、NSNull、Nil、NULL的区别

• nil空对象，已经在内存中释放；
• NSNull值为空的对象，“需要一个容器，但是里面什么都没有”；
• Nil空类；
• NULL空指针，与C语言中一致。

6. 使用if let 来处理值确实的情况：

var optionalString: String? = "Hello"
print(optionalString == nil)//false
var optionalName: String? = nil
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
} else {
    greeting = "Hello, Tom"
}

如果变量的可选值是，条件会判断为，大括号中的代码会被跳过。如果不是，会将值解包并赋给后面的常量，这样代码块中就可以使用这个值了。

另外一种处理可选值的方法是通过??操作符来提供一个默认值：

let nickName:String? = nil
let fullName:String = "John Appleseed"
let informalGreeding = "Hi \(nickName ?? fullName)"

7. switch支持任意类型的数据以及各种比较操作-不仅仅是整数以及测试相等：

let vegetable = "red pepper"
switch vegetable {
case let x where x.hasSuffix("pepper")://高端操作
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}

无需break语句。

8. 使用..<创建范围，创建的范围不包含上界，如果想包含的话需要使用...。

9. 函数

1. 使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值的类型：

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

• 默认情况下，函数使用它们的参数名称个作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用_表示不适用参数标签。
• 使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。

2. 函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式：

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(numbers: 42, 57, 1)

3. 函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，可以使用嵌套函数重构一个太长或者太复杂的函数。

4. 函数是第一等类型，这意味着函数可以作为另一个函数的返回值：

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var incrementer = makeIncrementer()
incrementer(7)

5. 函数也可以当做参数传入另一个函数：

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
}
hasAnyMatches(List: [20, 19, 70, 12], condition: lessThanTen)//只写函数名

10. 闭包

函数实际上是一种特殊的闭包：它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即使闭包是在一个不同的作用域被执行的---你已经在嵌套函数例子中所看到。你可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离。

let numbers = [76, 24]
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)

11. 类和对象

使用init来创建一个构造器。

class NamedShape {
    var numberOfSides = 0
    var name: String
    init(name: String) {
        self.name = name
    }
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides"
    }
}

注意self被用来区别实例变量。
使用deinit创建一个析构函数。

1. 父类

• 在初始化函数init中，super被用来指向父类，可以使用super来调用父类的init函数。

子类如果要重写父类的方法的话，需要用 override 标记——如果没有添加 override 就重写父类方法的话编译器 会报错。编译器同样会检测 override 标记的方法是否确实在父类中。

2. 属性

除了储存简单的属性之外，属性可以有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 {
            sideLength = newValue / 3.0//
        }
    }
    override func simpleDescription() -> String {
        return "An equilateral triagle with sides of length \(sideLength)."
    }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)

• 在 perimeter 的 setter 中，新值的名字是 newValue 。你可以在 set 之后显式的设置一个名字。

• 注意 EquilateralTriangle 类的构造器执行了三步:

  • 设置子类声明的属性值
  • 调用父类的构造器
  • 改变父类定义的属性值。其他的工作比如调用方法、getters 和 setters 也可以在这个阶段完成。
• 如果你不需要计算属性，但是仍然需要在设置一个新值之前或者之后运行代码，使用 willSet 和 didSet 。

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)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)

3. 处理变量的可选值时，你可以在操作(比如方法、属性和子脚本)之前加?。如果?之前的值是nil，?后面的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")//如果这里赋值为nil，并且下一语句中没有`?`，则会出错
let sideLength = optionalSquare?.sideLength

枚举和结构体

• 使用rawValue属性来访问一个枚举成员的原始值。
• 也可以使用字符串或者浮点数作为枚举的原始值。
• 使用 init?(rawValue:) 初始化构造器在原始值和枚举值之间进行转换。

if let convertedRank = Rank(rawValue: 3) {
    let threeDescription = convertedRank.simpleDescription()
}