Swift 学习笔记

Swift更新较快，现在语法也比较稳定了，iOS开发 Swift语言肯定是趋势，所以最近开始学习Swift，直接swift3.0 入手。

在看完swift语言之后，自己开始写一些简单的小demo，在这个过程中发现一些Swift和Objecobt-C的使用差异持续更新：

Swift中没有 #pragma mark 函数注释说明，网上一查，Swift不支持这个了，因为#pragma mark 是属于C的语法，swift中有了新的一些语法，如：//MARK: //FIXME: //TODO

// MARK: - 生成分隔线
// MARK: 说明

如果你想自己定义//warning: 或者其他的，可以通过脚本实现，在Target -> Build Phases -> + ->New Run Script Phases

TAGS="TODO:|warning:"
echo "searching ${SRCROOT} for ${TAGS}"
find "${SRCROOT}" \( -name "*.swift" \) -print0 | xargs -0 egrep --with-filename --line-number --only-matching "($TAGS).*\$" | perl -p -e "s/($TAGS)/ warning: \$1/"

如下图：

图1.png

运行之后能在左侧看到警告，这个在我们实际开发项目中还是比较实用的，所以这个必须得加上去。

图2.png

这样项目开发是不是很清楚了？

2.Optional

**Optional 是Swift中的一种特殊的类型，它本身有一个枚举的定义，简单来说就是这个形式：

Enum Optional {
    case None
    case Some(Wrapped)
}

Swift在变量定义的时候 var 需要有个初始值，这是我在没看到 Optional之前，以为是Swift的特点，看到Optional之后，之后可以像Object-C一样可以不用赋值，但需要加上?

如声明一个 Optional的Int类型的变量

var num : Int?

在引用这个Optional变量的时候，需要做特殊的处理，强制解包(使用！) 如下：

num = 2
let total = num! + 2

let possibleString: String? = "An optional string."
let forcedString: String = possibleString!  //需要❗️来强制拆包 符合变量定义的时候有初始值

使用if let 来安全的操作Optional值，只有num存在时，变量numValue才会被初始化赋值

if let numValue = num { 
   print(numValue)
}
else{ 
   print("error")
}

3.defer
这个swift 新增的一个关键字defer 推迟执行看下下面例子

func testForDefer() {
    print("123")
    defer {
        print("456")
    }
    print("789")
}
testForDefer()

输出：123 789 456
这个有点像Java中的 try finally控制语句，在finally中的代码块执行我们最后想要做的事，Swift中用defer 可以达到同样的效果，不得不说Swift进步很多。

4.闭包
嵌套函数

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

incrementor函数引用（捕获）了

当前runningTotal变量，这边的变量生命周期不会随着函数结束而停止makeIncrementor 的返回类型为 () -> Int,这意味着返回的是一个函数

**let incrementByTen = makeIncrementor(forIncrement: 10) **
incrementByTen 不是一个Int值： (()) -> Int

可以理解为一个无参函数，为了返回Int 可以调用incrementByTen()

尾随闭包：闭包必须是参数列表的最后一个参数

func followingClosure(index:Int,closure: () -> Int ){
       print("1")
      print(closure())
}
followingClosure(index: 100, closure:    {
        print("2")
        return 3
})

//括号之后是个函数 () -> Int 这是尾随闭包的意义所在
followingClosure(index: 100) { () -> Int in
    print("2")
    return 3
}

自动闭包
自动闭包不接受任何参数，被调用时会返回被包装在其中的表达式的值。

var listABC = ["A","B","C"]
let listProvider = { 
   print("autoClosure")
    listABC.remove(at: 0)
}
listProvider() //执行这句之后 闭包内的函数才执行 通过这个控制执行的时 自动执行代码 是它的关键所在

逃逸闭包
当一个传入函数的闭包在函数执行结束之后才会被调用，这样的闭包就叫做逃逸闭包。如果一个函数的参数有一个逃逸闭包，可以在参数前加@escaping关键字来修饰。一个闭包是逃逸必要的条件是这个闭包需要存储在函数外部

逃逸闭包一般用于异步函数的回调
官方例子

var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    completionHandlers.append(completionHandler)
}

func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)
// 输出 "200"

completionHandlers.first?()
print(instance.x)
// 输出 "100"

例子中可以看出：
逃逸闭包类中的变量或常量必须显示指明self，而普通的闭包可以直接使用x。
从使用的方式地和作用，是不是和Object-C中的block 很像。

Swift 学习笔记

你可能感兴趣的:(Swift 学习笔记)