《swift2.0 官方教程中文版》 第3章-03表达式

import Foundation

//Swift 中存在四种表达式: 前缀(prefix)表达式,二元(binary)表达式,主要(primary)表达式和后缀(po stfix)表达式。表达式可以返回一个值,以及运行某些逻辑(causes a side effect)

/*前缀表达式***********************************************/

//前缀表达式由可选的前缀符号和表达式组成。(这个前缀符号只能接收一个参数)

/*try 操作符***********************************************/

//try表达式由紧跟在可能会出错的表达式后面的 try 操作符组成,形式如下: try expression 强制的try表示由紧 跟在可能会出错的表达式后面的 try! 操作符组成,出错时会产生一个运行时错误,形式如下: try! expression

/*二元表达式***********************************************/

//二元表达式由 "左边参数" + "二元运算符" + "右边参数" 组成, 它有如下的形式:

//left-hand argument operator right-hand argument

/*赋值表达式***********************************************/

//就是把右边的 value 赋值给左边的 expression. 如果左边的expression 需要接收多个参数(是一个tuple ),那么右边必须也是一个具有同样数量参数的tuple. 

//(a, _, (b, c)) = ("test", 9.45, (12, 3))

// a is "test", b is 12, c is 3, and 9.45 is ignored

/*三元条件运算符***********************************************/

//三元条件运算符 是根据条件来获取值。 形式如下:

//condition ? expression used if true : expression used if false

/*类型转换运算符***********************************************/

//有4种类型转换运算符: is , as, ? 和! 它们有如下的形式:

//expression is type

//expression as type

//expression is? type expression as! type

func f(any: Any) {print("Function for Any")}

func f(int: Int) { print("Function for Int") }

let x = 10

f(x)

// prints "Function for Int"

let y: Any = x

f(y)

// prints "Function for Any"

f(x as Any)

// prints "Function for Any"

//桥接运算可以让你把一个Swift标准库中的类型的表达式作为一个与之相关的基础类(比如NSString)来使 用,而不需要新建一个实例

/*主表达式***********************************************/

//主表达式是最基本的表达式。 它们可以跟 前缀表达式,二元表达式,后缀表达式以及其他主要表达式组合使用。

//self表达式是对 当前type 或者当前instance的引用。它的形式如下

class SomeClass {

    var greeting: String

    init(greeting: String) {

        self.greeting = greeting

    }

}

struct Point {

    var x = 0.0, y = 0.0

    mutating func moveByX(deltaX: Double, y deltaY: Double) {

        self = Point(x: x+deltaX, y: y+deltaY)

    }

}

//超类表达式可以使我们在某个class中访问它的超类.

//闭包(closure) 表达式可以建立一个闭包(在其他语言中也叫 lambda, 或者 匿名函数(anonymous function)). 跟函数(function)的声明一样, 闭包(closure)包含了可执行的代码(跟方法主体(statement)类 似) 以及接收(capture)的参数。 它的形式如下:

//{(parameters) -> return type in

//    statements

//}

//闭包还有几种特殊的形式, 让使用更加简洁:

//? 闭包可以省略 它的参数的type 和返回值的type. 如果省略了参数和参数类型,就也要省略 'in'关键字。 如果 被省略的type 无法被编译器获知(inferred) ,那么就会抛出编译错误。

//? 闭包可以省略参数,转而在方法体(statement)中使用 $0, $1, $2 来引用出现的第一个,第二个,第三个 参数。

//? 如果闭包中只包含了一个表达式,那么该表达式就会自动成为该闭包的返回值。 在执行 'type inference '时,该表达式也会返回。

//下面几个闭包表达式是 等价的:

//myFunction {

//    (x:Int, y:Int) -> Int in

//    return x+y

//}

//myFunction {

//    (x, y) in

//    return x+y

//}

//myFunction {return $0 + $1}

//myFunction {$0 +$1}

//myFunction { print(self.title) } // strong capture 

//myFunction { [weak self] in print(self!.title) } // weak capture 

//myFunction { [unowned self] in print(self.title) } // unowned capture

/*后缀表达式***********************************************/

//后缀表达式就是在某个表达式的后面加上操作符。 严格的讲,每个主要表达式(primary expression)都是一个后缀表达式

//class SomeSubClass: SomeSuperClass {

//    init() {

//        // subclass initialization goes here

//        super.init()

//    }

//}

let initializer: Int -> String = String.init

let oneTwoThree = [1, 2, 3].map(initializer).reduce("", combine: +)

print(oneTwoThree)

// prints "123"

class SomeBaseClass {

    class func printClassName() {

        print("SomeBaseClass")

    }

}

class SomeSubClass: SomeBaseClass {

    override class func printClassName() {

        print("SomeSubClass")

        super.printClassName()

    }

}

let someInstance: SomeBaseClass = SomeSubClass()

// someInstance is of type SomeBaseClass at compile time, but 

// someInstance is of type SomeSubClass at runtime 

someInstance.dynamicType.printClassName()

// prints "SomeSubClass"

func someFunctionWithSideEffects() -> Int {

    return 42 // No actual side effects.

}

var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]

someDictionary["not here"]?[0] = someFunctionWithSideEffects()

print(someDictionary)

// someFunctionWithSideEffects is not evaluated

// someDictionary is still [b: [10, 20], a: [1, 2, 3]]

someDictionary["a"]?[0] = someFunctionWithSideEffects()

print(someDictionary)

// someFunctionWithSideEffects is evaluated and returns 42 

// someDictionary is now [b: [10, 20], a: [42, 2, 3]]