《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(xas 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

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

    classfunc printClassName() {

        print("SomeBaseClass")

    }

}

class SomeSubClass: SomeBaseClass {

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

    return42 // 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]]