Swift学习笔记（一）

注：本文为自己学习The Swift Programming Language的笔记

1.HelloSwift

OS X 10.9.3安装Xcode6 beta，新建一个OSX Command Line Tool工程。

修改helloworld程序，给Swift打声招呼，Swift编程之旅开始啦。

println("Hello, Swift")  

注意Swift类似Python，不需要在行末尾加分号。

2.变量和常量

let定义常量（允许被赋值一次），var定义变量。

let和var在定义时不需要显示地注明类型，但是在非定义阶段Swift不支持隐式转换。

let myConstant = 70.0  
var myVariable = myConstant - 10  
println(myVariable)  

输出结果为60.0，myVariable的类型被隐式转化为Double类型。

let myConstant1 = 70.0  
var myVariable1 = 80  
myVariable1 = myVariable1 - myConstant1  
println(myVariable1)  

XCode报错：不能找到－号关于提供变量类型的重载，即不能隐式转换类型。

添加显示转换，修改这一行。

myVariable1 = myVariable1 - Int(myConstant1)  

当然也可以显式的声明变量，用冒号实现。

let myConstant2: Double = 70

数值转换为字符串String有两种方法，一是类似于上面的显式转换，二是用 \() 符号，输出均是My Age is 20.

var myAge = 20  
var str = "My Age is " + String(myAge) + "."  
println(str)  
str = "My Age is \(myAge)."  
println(str)  

3.数组和字典

[ ]符号用于定义数组和字典（键值对数据结构），可以吧数组看作键隐式为自然数的字典。

var nameList = ["ZhangSan","LiSi","WangMaZi"]  
println(nameList[1])  

输出是LiSi，Swift的数组下标也是从0开始。

数组的长度是初始化时候固定的，字典可以直接增加键值对，输出为20。

var ageDict = ["ZhangSan":18,"LiSi":13,"WangMaZi":35]  
ageDict["JCGuo"] = myAge  
println(ageDict["JCGuo"])  

可以定义空的数组和字典

let emptyArray = String[]()  
let emptyDictionary = Dictionary<String, Float>()  

字典可以嵌套数组，值的数据类型可以任意。

let interestingNumbers = [  
    "Prime": [2,3,5,7,11,13],  
    "Fibonacci": [1,1,2,3,5,8],  
    "Square": [1,4,9,16,25]  
]  

4.控制流

4.1普通用法

Swift支持传统C语言的条件语句if和switch、循环语句for-in、for、while、do-while，基本用法和C语言一致。

for people in nameList {  
    if ageDict[people] >= 18 {  
        println("\(people) is an adult.")  
    }  
    else {  
        println("\(people) is just a child.")  
    }  
}  

注意，判断条件的括号可以省略，判断条件一定是boolean型不能是整型或其他。

4.2可空字符串作判断条件

String？显示的定义可空字符串，字符串可以有值也可以赋值为空nil。

可空字符串可以作为判断条件，非空时相当于true，nil时相当于false，而普通String类型不行。

var optionalName: String? = "JCGuo"  
var greeting = "Hello!"  
if optionalName {  
    greeting = "Hello,\(optionalName)"  
}  

原书中介绍if-let用法，实际上就是在判断条件中定义一个常量，隐式的将其转换为可空字符串类型：

if let name = optionalName {  
    greeting = "Hello,\(name)"  
}  

4.3switch增强

Swift的switch用大括号将case括起来，支持各种类型的值，而满足关系也不仅局限于相等关系。

let vegetable = "red pepper"  
switch vegetable {  
case "cucumber","watercress":  
    println("Add some raisins and make ants on a log.")  
case let x where x.hasSuffix("pepper"):  
    println("Is it a spicy \(vegetable)?")  
default:  
    println("Everything tastes good")  
}  

switch必须有default语句，两个相同反馈的case用逗号隔开。

let可以灵活运用于case中，let x where x.hasSuffix("pepper")代表一个有后缀为pepper的常量。

4.4for增强

对字典可以用for-in语法枚举字典的键值对：

for(kind,numbers) in interestingNumbers{  
    for number in numbers{  
        println("\(number) is a " + kind)  
    }  
}  

..符号可以代替传统的for语句语法：

for i in 1..4 {  
    println(i)  
}  
for var i = 1; i < 4; i++ {  
    println(i)  
}  

两句是等价的，注意1..4的不是代表1到4，而是大于等于一。

Swift还支持...符号，..生成的是前闭后开区间，而...生成的是闭区间。

5.函数和闭包

5.1函数定义

先看例子：

func greet(name: String, day: String) -> String{  
    return "Hello \(name), how is your \(day)?"  
}  
println(greet("JCGuo","Friday"))  

func是定义函数关键词，在函数名后面把参数括起来（参数格式为 参数名：类型），->后面接返回值类型。

参数可以为空返回值也可以为空，返回值为空的省略-> :

func func1(){  
}  

5.2返回值可以是元组

func staffInformation(number : Int) -> (String, Int?){  
    return(nameList[number],ageDict[nameList[number]])  
}  
println((staffInformation(1)))  

输出为元组(LiSi,13)，这里发现字典ageDict隐式的把值类型确定为Int？而不是Int［待解决］。

5.3支持可变长参数

func sumOf(numbers: Int...) -> Int{  
    var sum = 0;  
    for number in numbers {  
        sum += number  
    }  
    return sum  
}  
println(sumOf(1,2,3))  
println(sumOf())  

5.4函数嵌套定义

函数定义可以嵌套，在一个函数体中定义另一个函数：

func cubeSumOf(numbers: Int...) -> Int{  
    var cubeSum = 0;  
    func pow(a: Int, b: Int) -> Int{  
        var rtn = 1  
        for i in 0..b {  
            rtn *= a  
        }  
        return rtn  
    }  
    for number in numbers {  
        cubeSum += pow(number,3)  
    }  
    return cubeSum  
}  
println(cubeSumOf(1,2,3))  

内部函数作用域在函数体内。

5.4函数返回值是函数

返回一个参数为Int，返回值为Int的函数：

func makeIncrementer() -> (Int -> Int) {  
    func addOne(number: Int) -> Int {  
        return 1 + number  
    }  
    return addOne  
}  
var increment = makeIncrementer()  
increment(7)  

5.5函数参数是函数

参数为函数的函数：

func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {  
    for item in list {  
        if condition(item) {  
            return true  
        }  
    }  
    return false  
}  
func lessThanTen(number: Int) -> Bool {  
    return number < 10  
}  
var numbers = [20, 19, 7, 12]  
println("It is \(hasAnyMatches(numbers, lessThanTen)).") 

5.6闭包

闭包是一个拥有与多变量并且绑定了变量的环境的表达式，闭包可以看作是没有名字的匿名函数，原书讲的是函数一种特殊形式的闭包。

闭包用于函数间传值调用，用途类似于函数指针做参数，下面是5.4中例子用闭包的实现：

func hasAnyMatches(list: Int[], condition: (number:Int) -> Bool) -> Bool {  
    for item in list {  
        if condition(number:item) {  
            return true  
        }  
    }  
    return false  
}  
var numbers = [20, 19, 7, 12]  
var v = hasAnyMatches(numbers, {  
    (number: Int) -> Bool in  
        return number < 10  
})  
println("It is \(v).")  

闭包的定义在一对大括号{ }中，它的参数和返回类型定义都和函数相似，用关键词in指出闭包体的开始。

调用闭包时，语法和函数指针稍有不同。condition是参数名称，而它的类型是闭包 (number: Int) -> Bool。

引用闭包时也要指出闭包参数名称condition(number:item)而不是condition(item)。

关于闭包的性质和用法有待后续学习！［待解决］