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,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,a: [42,3]]
