//: Playground - noun: a place where people can play

 import UIKit

 /*

     Swift学习第五节

 可选类型 optional(可能是任何值)

 */

 let possibleNumber = ""

 var result = Int(possibleNumber)

 print(result)

 result.dynamicType

 //上面就是一个可选类型的举例,possibleNumber开始是一个string,然后强转为Int,这里可能失败(可能转为Int,也可能是nil).

 var x:Int?   //定义一个可选类型x,可能Int也可能其他.默认为nil

 var address:String?

 var successRate:Double?

 result = nil //可以为一个可选类型赋值为nil,但是普通类型不可以

 //访问可选类型

 if result != nil{

    print(result!)

 }

 //print(x!) error;可选类型不能直接输出,必须先行判断

 if let num = result{

   print(result)

 }else{

   print("num为nil")
 

 //: Playground - noun: a place where people can play

 import UIKit

 /*

 swift学习第六节

 函数  函数参数

 func 方法名(参数名:参数类型){

    方法体

 }

 */

 //写一个方法

 func printName(){

   print("my name is 少停")

 }

 printName()//调用

 func ten(num:Int){

   print("\(num * 10)")

 }

 ten()

 func mult(num1:Int,num2:Int){

   print("\(num1*num2)")

 }

 mult(, num2: )  //num2  为外部参数名

 func create(num3:Int,_ num4:Int){

   print("\(num3*num4)")   // _ 使用_代替外部参数名简化

 }

 create(, )

 func make(NUM1 num1:Int,NUM2 num2:Int){

   print("\(num1*num2)")

 }                    //NUM1 NUM2 外部参数名,外部参数名只是方便理解

 make(NUM1: , NUM2: )

 func make1(NUM1 num1:Int = ,NUM2 num2:Int = ){   //为参数赋初始化

    print("\(num1*num2)")

 }

 make1()

 func arySum(number:Double ...){//参数为Double类型的number,可以有很多个

     var sum: Double =

     for i in number{

        sum += i

     }

     print("\(sum)")

 }

 arySum(,,,,)

 arySum(,)

 //func sum(value : Int){

 //  value++

 //}  error:swift中函数参数分为常量参数和变量参数,函数参数默认是常量参数,不能修改.

 func sum(var value:Int){

     value++;

 }

 var m = ;

 sum(m);

 m

 //在函数内对一个参数进行修改后,在函数外部仍然不会改变

 func summ(inout value:Int){//想在函数内修改参数后,在外部仍然有效需要使用inout

   value++

 }

 var n =

 summ(&n)

 n

 //: Playground - noun: a place where people can play

 import UIKit

 /*

 swift学习第七节

 函数 函数返回值和类型

 */

 func sum(num1:Int,num2:Int) -> Int{   //返回一个返回值

     return num1*num2;

 }

 var m = sum(, num2: )

 func num(num1:Int,num2:Int) -> (Int,Int){   //返回两个返回值

   return (num1,num2)

 }

 var table = num(, num2: )

 table.

 table.

 func  num2(num1:Int,num2:Int) -> (n1:Int,n2:Int){   //返回两个返回值,且为返回值赋名

    return (num1,num2)

 }

 var nn = num2(, num2: )

 nn.n1

 nn.n2

 func string2Int(str:String) -> Int?{

    return Int(str)

 }

 var n = string2Int("")

 n.dynamicType

 var f1:(Int,Int) -> Int = sum

 var f2:(Int,Int) -> (Int,Int) = num

 var f3:String -> Int? = string2Int

 //----------------------------------------------------------------

 //把函数作为参数使用:execute为一个函数,这个函数有两个参数,一个参数是一个函数(参数为string,返回值是int),另外一个参数是string

 func execute(fn:(String) -> Int?,fnParam:String){

   fn(fnParam)

 }

 execute(f3, fnParam: "")

 //----------------------------------------------------------------

 //func increment(n:Int) -> Int{

 //  return n+1

 //}

 //func decrement(n:Int) -> Int{

 //  return n-1

 //}

 ////whichOne函数:有一个参数n,返回值是一个函数(参数是int,返回值也是int)

 ////func whichOne(n:Bool) -> ((Int) -> Int){

 ////    return n ? increment : decrement

 ////}

 //typealias op = (Int) -> Int

 //func whichOne(n:Bool) -> op{

 //   return n ? increment : decrement

 //}

 //var one = 1

 //var one2Ten  = whichOne(one < 10)

 //while one < 10 {

 //   one = one2Ten(one)

 //}

 //上面的代码可以使用内嵌函数增强可读性

 typealias op = (Int) -> Int

 func whichOne(n:Bool) -> op{

     func increment(n:Int) -> Int{

         return n+

     }

     func decrement(n:Int) -> Int{

         return n-

     }

     return n ? increment : decrement

 }

 var one =

 var one2Ten  = whichOne(one < )

 while one <  {

     one = one2Ten(one)

 }

 //: Playground - noun: a place where people can play

 import UIKit

 /*

 swift学习第八节

 Closures

 */

 let ten =

 var addClosure: (Int,Int) -> Int = {(a:Int,b:Int) -> Int in

    return a + b

 }

 addClosure(,)

 addClosure = { a, b in return a + b}

 addClosure = {a, b in a + b}    //Single expression closure

 addClosure = {$ + $}