Swift基础学习

今天回头要改，不着重点，有点太基础

iOS 老菜鸟开始Swift学习
关于集合类弄数据的初妈化

NSArray	NSDictionary	Set
var a:Array = ["fuck","okay"]	var b:Dictionary = [200:"success",400:"women"]	var c:Set = [1,2]
var a:[String] = ["fuck","okay"]	var b:[Int:String] = [200:"success"]
var a:Array<String> = ["fuck","okay"]	var b:Dictionary<Int,String> = [200:"success",400:"women"]	var c:Set<String> = ["hellos","world"]
var a:[Double] = []	var b:[Int:String] = [:]
var a = [Double] ()	var b = [Int:String]（）
var a = Array<Double>()	var b = Dictionary<String>()

数组，集合，字典内的所有元素需要相同类型
如果想明确表示数组中存放的是不同类型的数据,
可以使用Any关键字, 表示数组中可以存放不同类型的数据

var arr = [1,"hjp",17] as [Any]
var arr:Array<Any> = [1,"hjq",1.75]


var  dict = ["name":"hjq","age":25.5] as Any
var  dict2:Dictionary<String,AnyObject> = ["name":"j" as AnyObject,"age":25.5 as AnyObject]
var dict4:[String:AnyObject] = ["name":"hjq" as AnyObject ,"age":30 as AnyObject ]
let dic:[String:Any] = ["name":"zhang","age":12]

Tuple

//自动推断元素类型
var point = (x:50,y:100) 

var size = (width:100,25) 
size.width  //用属性访问
size.1  //用下标访问

var httpStatus:(Int,String)=(200,"success") 
var (status,description)=httpStatus //一次性赋值给多个变量，此时status=200，description="success"
var (sta,_)=httpStatus     //忽略另一个值使用"_"

println("sta=\(sta)") //结果：sta=200

可选类型

可能有值也可能没有值则设置为可选类型

var x:Float? //使用？定义的可选类型，如果不赋值默认为nil
x = 172.0
var y:Float = 69

//var z = x+y
//报错 Float 和 Float? 是两种不同类型

var z=x!+y //使用！进行强制解包

 //ageInt 也是Int? 类型，因为 toInt无法保证有值
 //ageInt强制解包
var age="29"
var ageInt = Int(age)!

//通过感叹号声明隐式解析可选类型
//此后使用时虽然是可选类型但是不用强制解包
var age:Int!=29
var ageInt = Int(age)

区间运算符

for i in 1...5 {
    print("i=\(i)")
}
var  we = "hello   World"
var range = "a"..."z"
for t in we {
    if  range.contains(String(t)){
        print(t)
    }
}

控制流

//switch支持多模式匹配，case后不用break不会穿透，
//如果要穿透，后面加fallthrough
var ao = ["a","b","c","d","e","f","g"]
let bo = ao[1]
switch bo {
case "a","b":
    print("bo= a or bo = b")
case "c","d","e","f":
    print("bo = c,d,e,f")
default:
    print("bo = g")
}

let co:Int = 88
switch co {
case 1...60:
    print("1-60")
case 61...90:
    print("61-90")
fallthrough
case 91...100:
    print("91-100")
default:     //前面都不匹配才执行default,
    print("1>c>100")
}



//注意这里有可能和第一、二、三个条件重合，
//但是Swift允许多个case匹配同一个条件，
//但是只会执行第一个匹配
var d=(x:900,y:0)
switch d{
case (0,0):
    print("d in (0,0)")
case (_,0): //忽略x值匹配
    print("d in y")
case (-100...1000,-100...100):
    print("x in（0-100），y in （0-100）")
case let (x,y) where x==y:
    //where条件匹配,注意这里的写法等同于：(let x,let y) where x==y
    print("x=y=\(x)")
case let (x, y)://值绑定
    print("x=\(x),y=\(y)") 
}

函数

//注意参数和返回值，如果没有返回值可以不写返回值或者写成Void、空元组()
//注意Void的本质就是空元组
func sum(num1:Int ,num2:Int)->Int{
    return num1+num2;
}
print(sum(num1: 1, num2: 2))

////自动推断sum3类型,不同函数类型不能直接赋值
var a = 2
var b = 1


//函数作为返回值
func fn() ->(Int,Int)->Int{
    
    func minus(a:Int,b:Int)->Int{
        return a-b
    }
    return minus(a:b:);
}
//函数作为参数
func caculate(num1:Int,num2:Int,fn:(Int,Int)->Int) ->Int{
    return fn(num1,num2)
}

闭包

闭包的特点就是可以捕获和存储上下文中的常量或者变量的引用，即使这些常量或者变量在原作用域已经被销毁了在代码块中仍然可以使用。

func sum(num1:Int,num2:Int)->Int{
    return num1+num2
}

func minus(num1:Int,num2:Int)->Int{
    return num1-num2
}
func caculate(num1:Int,num2:Int,fn:(Int,Int)->Int)->Int{
    return fn(num1,num2)
}

var (a,b)=(1,2)
//利用函数表达
caculate(num1: a, num2: b, fn: sum(num1:num2:))
caculate(num1: a, num2: b, fn: minus(num1:num2:))
//利用闭包表达表达式简化
caculate(num1: a, num2: b) { (num1, num2) -> Int in
    return num1-num2
}
//Swift中如果一个函数的最后一个参数是一个函数类型的参数（或者说是闭包表达式）
//则可以将此参数写在函数括号之后，这种闭包称之为“尾随闭包”。

func add()->()->Int{
    var  total = 0
    var  step = 1
    func fn()->Int{
        total += step
        return total
    }
    return  fn
}
var a1 = add()
a1 = add()
print("\(a1())")

类

Swift中一个类可以不继承于任何其他基类，那么此类本身就是一个基类

 var p = Person.init(name: "kevien")
        p.height = 72.5
        p.showMessage()
        
        //引用类型
        var p2 = p
        p2.name = "kaoru"
        print(p.name)
        
        if p === p2 {
            print("p====p2")
        }

类的属性分为：储存属性和计算属性，不再强调成员变量的概念