变量和简单类型

对于变量来说就好比它是一个鞋盒子,它包含了一个严格定义的单个值. 每一个变量都需要显式正式的定义. 要想将一个对象塞进鞋盒子, 就需要让这个变量指向这个对象. 这里我们说说如何定义和初始化一个变量.还有会说道一些内置的简单类型.(之所以说简单是相对于集合这样的复杂类型,之后会说到_)

Variable Scope and Lifetime
Variable Declaration
Computed Initializer
Computed Variables
Setter Observers
Lazy Initialization
Built-In Simple Types

变量的作用域和生命周期

全局变量

定义在一个swift 文件顶层的变量就是全局的变量.

属性

属性是对于那些定义在顶层的对象类型(类,枚举或者结构)来说的,有2中属性,一是实例的属性,二是静态/类属性.

实例属性

默认的来说, 一个属性它就是实例的属性,
静态/类属性

就是在定义他们的时候通过 static 或者 class 关键字来修饰的属性.

看下面的代码

// File1:
class Dog {
    static let staticProperty = "staticProperty"
    let instanceProperty = "instanceProperty"
    func printInstanceProperty() {
        print(self.instanceProperty) // *
    }
}
// File2:
class Cat {
    func printDogStaticProperty() {
        print(Dog.staticProperty) // *
    }
    func printDogInstanceProperty() {
        let d = Dog()
        print(d.instanceProperty) // *
    }
}

本地变量

在函数体内的变量我们就称之为本地的变量,一个本地的变量它的生存范围就是在{}之间.

class Dog {
    func printLocalVariable() {
        let localVariable = "local"
        print(localVariable) // *
    }
}

定义变量

可以通过 let 或者 var 来定义变量区别在于:

通过 let, 变量将会变成常理, 意味着它的值不会再变.
通过var, 它就是真正意义的变量.

而一旦定义变量他们的类型是不能够改变的. 尽管他们的值是可以修改但是这些值都应该是一类的.

定义变量三种方法:

var x:Int
var x = 1
var s:Int = 1

推荐第三种显式给类型并初始化.

计算生成的初始化方法

有些时候你需要执行那么几行代码来给一个变量初始值, 一个简单的方法就是通过匿名函数立即执行的方式来实现:

let times: Bool  = {
  if val == 1 {
    return true
  } else {
    return false
  }
}

计算生成的变量

setter 方法

var now : String { 
    get { 
        return Date().description 
    }
    set { 
        print(newValue) 
    }
}

setter监视

swift 同样有另外一个特性就是能够 hook 进去一些方法来监视 set 方法.

var s = "whatever" { 
    willSet { 
        print(newValue) 
    }
    didSet { 
        print(oldValue) 
        // self.s = "something else"
    }
}

惰性初始化

全局变量, 默认惰性初始化. 对于全局变量来说当 app 启动的时候完全没有必要初始化, 因为程序还是没有跑起来呢,所以延迟到之后的某个步骤才合适.
静态属性, 默认也是延迟.
实例属性, 默认并不是延迟的, 但是可以通过 lazy 关键字来让它延迟.而且必须要 var 来声明.

内置简单类型

Bool var selected : Bool = false
Numbers
- Int
- Double
- 数字转换
- 运算符
- 比较
String
Character
Range
Tuple
Optional
- umwrapped optional
- implicitly unwrapped optional

let stringMaybe : String? = "howdy"
let upper = stringMaybe.uppercased() // compile error

上面的代码里的 stringMayBe 其他它是 Optional 封装过的. 你要让它当 string 你需要解出来

let stringMaybe : String? = "howdy"
let upper = stringMaybe!.uppercased()

func realStringExpecter(_ s:String) {}
var stringMaybe : String! = "howdy"
realStringExpecter(stringMaybe) // no problem

好神奇的 Nil

var stringMaybe : String? = "Howdy"
print(stringMaybe) // Optional("Howdy")
if stringMaybe == nil {
    print("it is empty") // does not print
}
stringMaybe = nil
print(stringMaybe) // nil
if stringMaybe == nil {
    print("it is empty") // prints
}

Optional Chains

let stringMaybe : String? = "howdy"
let upper = stringMaybe!.uppercased()

optional 的对象比较

let s : String? = "Howdy"
if s == "Howdy" { // ... they _are_ equal!

为什么需要 Optional