IOS开发学习-篇外Swift2常用语法-3

要不是swift的出现我永远都不会学习IOS开发，不过swift的一些基本用法还是需要动手写一写的。

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

import UIKit

var str = "Hello, playground"

var ary:Array<Int> = [10,2,3];

ary.sort(>)

for i in ary {
    print(i);
}

if !ary.isEmpty {
    print("array is empty.");
}

// 这里着重讲一下swift的 ? 和 !，这里你要了解一个swift类型 Optional ，好了那么直接说明
// vara 是String类型，而 varb 是Optional类型，在使用varb?的时候表示如果这个变量为空那
// 么接下来的方法就不执行,什么时候解包呢(就是!)，如果你在使用这个值但是这个不能为Optional
// 的时候,下面有个例子就是，或者是你能确保有值，你也可以解包使用
var vara:String = "VARA"
var varb:String? = "1"
varb?.compare("a")
let intVarB:Int = Int(varb!)!
varb!.compare("1")
varb = nil

struct sts {
    init (n1:Int, n2:Int) {
        num1 = n1;
        num2 = n2;
    }

    var num1:Int
    var num2:Int
}

var stsObj = sts(n1:10, n2:20);
print(stsObj.num1)

//这里是为了演示 swift 中的循环引用问题 和 闭包循环引用问题，通常内存泄漏常见的问题，
//swift中使用弱引用来解决
class Girl {

    var by:Boy?

    init() {
        print("Girl init!")
    }

    deinit {
        print("Girl deinit...")
    }
}

class Boy {

    weak var gl:Girl?

    init() {
        print("Boy init!")
    }

    deinit {
        print("Boy deinit...")
    }
}


var gl:Girl? = Girl();
var by:Boy? = Boy();

gl!.by = by
by!.gl = gl

by = nil
gl = nil




class People {

    var name:String?

    lazy var age: ()->Int = {
        [unowned self] in
        self.name = "name"
        return 10;
    }

    init() {
        print("People init!")
    }

    deinit {
        print("People deinit...")
    }

    private static let str:String = "String..."

    class func getString()->String {
        return str
    }
}

var pp:People? = People()
print(pp!.age())
print(People.str)
print(People.getString())
pp = nil

//这是是定义一个函数类型的参数，最简单的回调方式
func callback(age:Int) -> Void {
    print("Callback age:\(age)")
}

func source(cb:(age:Int)->Void) -> Void {
    cb(age: 10)
}

source(callback)


//枚举的使用方式
enum Enum1 {
    case A
    case C,D,E
}

switch Enum1.C {
case Enum1.A:
    print("switch A")
case Enum1.C:
    print("switch C")
default:
    print("Default")
}

//扩展现有类的方法，还可以扩展协议，属性等
extension String {
    func toPrint() -> Void {
        print(self)
    }
}

let sss1 = "3"
sss1.toPrint();

//基本类型互转
let sss1Int = Int(sss1)

//最新的 swift 允许使用类和结构体来定义ErrorType，这里用的是枚举还是挺方便的
enum MyError : ErrorType {
    case NullPointerError
}

//  swift 异常抛出方式
func getException() throws -> Void {
    throw MyError.NullPointerError
}

//  swift 的异常处理，这里简单的做法
do {
    try getException()
} catch MyError.NullPointerError {
    print("MyError NullPointerError...")
}


//  swift 协议定义方式，协议定义中属性必须指定一个get或者set
protocol SomeProtocol {
    var p1:Int {get}
    var p2:Int {get set}

    func getNumber1() -> Int
}

protocol AnotherProtocol {
    var int1:Int {get set}

    func getIntNum() -> Int

}

//  swift 的类是不能多继承的，但是协议可以
//  协议定义的属性和方法必须全部实现这一点和Java很像
class ClassProtocol: SomeProtocol,AnotherProtocol {

    var p1: Int = 100
    var p2: Int = 200
    var int1: Int = 300


    func getIntNum() -> Int {
        return int1
    }

    func getNumber1() -> Int {
        return p2
    }
}

// swift 中的字典使用和()类型的使用
var map:Dictionary? = ["a":"a","b":"b"]
print((map?["a"])!)
for (k,v) in map! {
    print("key is \(k) value is \(v)")
}
let kv = (1,2,3)
kv.dynamicType
kv.0
kv.1
kv.2

//swift中的日期使用
var date:NSDate? = NSDate();
print(Int(date!.timeIntervalSince1970*1000))




//这里是cocoa的队列API，比NSThread更高级的API，简单使用
var queue:NSOperationQueue? = NSOperationQueue()
class SomeOperation: NSOperation {

    lazy var queue:()->NSOperationQueue = {
        var q:NSOperationQueue = NSOperationQueue()
        return q
    }

    override func main() {
        print("this is run in SomeOperation!\(NSThread.currentThread())")

    }

    override init() {
        super.init()
        print("SomeOperation init!")
    }

    deinit {
        print("SomeOperation deinit...")
    }
}

class AnotherOperation: NSOperation {

    lazy var queue:NSOperationQueue = {
        [weak self] ()->NSOperationQueue in  //这一行可以省略
        var q:NSOperationQueue = NSOperationQueue()
        return q
    }()

    override func main() {
        print("this is run in AnotherOperation!\(NSThread.currentThread())")

    }

    override init() {
        super.init()
        print("AnotherOperation init!")
    }

    deinit {
        print("AnotherOperation deinit...")
    }
}

var operation:SomeOperation? = SomeOperation()
//这个不会销毁，因为当前类有对象的引用
queue?.addOperation(operation!)
//下面两个会销毁,这两个对象生成queue的方式不一样，多次调用时SomeOperation只有一个对象，而AnotherOperation有多个对象
queue?.addOperation(SomeOperation())
queue?.addOperation(AnotherOperation())

//sleep(1)  //Playground中队列还没运行程序就执行完了这里让它睡1秒


//这里是swift自带的JSON的处理，验证字典是否是JSON对象
NSJSONSerialization.isValidJSONObject(map!)
//将字典对象转换成为一个JSON对象
var data:AnyObject = try! NSJSONSerialization.dataWithJSONObject(map!, options: [])
//这里是将字符串转换成为JSON对象
var jsonString = "{\"a\":\"b\"}"
var jsonData:NSData? = jsonString.dataUsingEncoding(NSUTF8StringEncoding)
do {
    var jsonMap = try NSJSONSerialization.JSONObjectWithData(jsonData!, options: [])
    var aValue = jsonMap.objectForKey("a")
    print("json value : \(aValue)")
} catch {
    let ex:ErrorType = error
}

//线程锁
var lock = NSLock()
lock.lock()
print("Lock")
lock.unlock()

//同步代码函数
objc_sync_enter(data)
print("objc sync enter")
objc_sync_exit(data)



//延迟执行代码块，相当于java中的finally但是如果报错之后的不会执行，defer修饰的代码块只会在函数执行完后执行
func testDefer() throws -> Void {

    defer {
        print("1")
    }

    //throw MyError.NullPointerError

    defer {
        print("2")
    }

    defer {
        print("3")
    }

    print("run code...")
}
try! testDefer()

//guard修饰的流程控制语句，else后的代码块是当条件为假的时候执行，这里执行之后直接返回
func testGuard() -> Void {

    guard let a:String=map!["a"] else {
        print("guard else code...")
        return
    }

    print("testGuard func code... \(a)")
}
testGuard()