swift系统学习第二章

 1 //: Playground - noun: a place where people can play
 2 
 3 import UIKit
 4 
 5 /*
 6     Swift学习第五节
 7 可选类型 optional(可能是任何值)
 8 
 9 
10 */
11 let possibleNumber = "520"
12 var result = Int(possibleNumber)
13 print(result)
14 result.dynamicType
15 //上面就是一个可选类型的举例,possibleNumber开始是一个string,然后强转为Int,这里可能失败(可能转为Int,也可能是nil).
16 
17 var x:Int?   //定义一个可选类型x,可能Int也可能其他.默认为nil
18 var address:String?
19 var successRate:Double?
20 
21 result = nil //可以为一个可选类型赋值为nil,但是普通类型不可以
22 
23 //访问可选类型
24 if result != nil{
25    print(result!)
26 }
27 //print(x!) error;可选类型不能直接输出,必须先行判断
28 
29 if let num = result{
30   print(result)
31 }else{
32   print("num为nil")
33 

 1 //: Playground - noun: a place where people can play
 2 
 3 import UIKit
 4 /*
 5 swift学习第六节
 6 函数  函数参数
 7 func 方法名(参数名:参数类型){
 8    方法体
 9 }
10 */
11 //写一个方法
12 func printName(){
13   print("my name is 少停")
14 }
15 printName()//调用
16 
17 
18 func ten(num:Int){
19   print("\(num * 10)")
20 }
21 ten(20)
22 
23 func mult(num1:Int,num2:Int){
24   print("\(num1*num2)")
25 }
26 mult(20, num2: 10)  //num2  为外部参数名
27 
28 func create(num3:Int,_ num4:Int){
29   print("\(num3*num4)")   // _ 使用_代替外部参数名简化
30 }
31 create(1, 2)
32 
33 func make(NUM1 num1:Int,NUM2 num2:Int){
34   print("\(num1*num2)")
35 }                    //NUM1 NUM2 外部参数名,外部参数名只是方便理解
36 make(NUM1: 3, NUM2: 4)
37 
38 func make1(NUM1 num1:Int = 11,NUM2 num2:Int = 11){   //为参数赋初始化
39    print("\(num1*num2)")
40 }
41 make1()
42 
43 func arySum(number:Double ...){//参数为Double类型的number,可以有很多个
44     var sum: Double = 0
45     for i in number{
46        sum += i
47     }
48     print("\(sum)")
49 }
50 arySum(1,2,3,4,5)
51 arySum(1,2)
52 
53 //func sum(value : Int){
54 //  value++
55 //}  error:swift中函数参数分为常量参数和变量参数,函数参数默认是常量参数,不能修改.
56 
57 func sum(var value:Int){
58     value++;
59 }
60 var m = 10;
61 sum(m);
62 m
63 //在函数内对一个参数进行修改后,在函数外部仍然不会改变
64 
65 func summ(inout value:Int){//想在函数内修改参数后,在外部仍然有效需要使用inout
66   value++
67 }
68 var n = 10
69 summ(&n)
70 n

 1 //: Playground - noun: a place where people can play
 2 
 3 import UIKit
 4 
 5 /*
 6 swift学习第七节
 7 函数 函数返回值和类型
 8 
 9 */
10 func sum(num1:Int,num2:Int) -> Int{   //返回一个返回值
11     return num1*num2;
12 }
13 var m = sum(2, num2: 3)
14 
15 func num(num1:Int,num2:Int) -> (Int,Int){   //返回两个返回值
16   return (num1,num2)
17 }
18 var table = num(25, num2: 52)
19 table.0
20 table.1
21 
22 func  num2(num1:Int,num2:Int) -> (n1:Int,n2:Int){   //返回两个返回值,且为返回值赋名
23    return (num1,num2)
24 }
25 var nn = num2(9, num2: 1)
26 nn.n1
27 nn.n2
28 
29 func string2Int(str:String) -> Int?{
30    return Int(str)
31 }
32 var n = string2Int("132")
33 n.dynamicType
34 
35 
36 var f1:(Int,Int) -> Int = sum
37 var f2:(Int,Int) -> (Int,Int) = num
38 var f3:String -> Int? = string2Int
39 //----------------------------------------------------------------
40 //把函数作为参数使用:execute为一个函数,这个函数有两个参数,一个参数是一个函数(参数为string,返回值是int),另外一个参数是string
41 func execute(fn:(String) -> Int?,fnParam:String){
42   fn(fnParam)
43 }
44 execute(f3, fnParam: "1000")
45 
46 //----------------------------------------------------------------
47 
48 //func increment(n:Int) -> Int{
49 //  return n+1
50 //}
51 //func decrement(n:Int) -> Int{
52 //  return n-1
53 //}
54 ////whichOne函数:有一个参数n,返回值是一个函数(参数是int,返回值也是int)
55 ////func whichOne(n:Bool) -> ((Int) -> Int){
56 ////    return n ? increment : decrement
57 ////}
58 //typealias op = (Int) -> Int
59 //func whichOne(n:Bool) -> op{
60 //   return n ? increment : decrement
61 //}
62 //var one = 1
63 //var one2Ten  = whichOne(one < 10)
64 //while one < 10 {
65 //   one = one2Ten(one)
66 //}
67 //上面的代码可以使用内嵌函数增强可读性
68 typealias op = (Int) -> Int
69 func whichOne(n:Bool) -> op{
70     func increment(n:Int) -> Int{
71         return n+1
72     }
73     func decrement(n:Int) -> Int{
74         return n-1
75     }
76     
77     return n ? increment : decrement
78 }
79 var one = 1
80 var one2Ten  = whichOne(one < 10)
81 while one < 10 {
82     one = one2Ten(one)
83 }

 1 //: Playground - noun: a place where people can play
 2 
 3 import UIKit
 4 /*
 5 swift学习第八节
 6 Closures
 7 
 8 
 9 */
10 let ten = 10
11 var addClosure: (Int,Int) -> Int = {(a:Int,b:Int) -> Int in
12    return a + b
13 }
14 addClosure(1,2)
15 addClosure = { a, b in return a + b}
16 addClosure = {a, b in a + b}    //Single expression closure
17 addClosure = {$0 + $1}