iOS学习笔记41-Swift(一)基础部分

一、Swift语言介绍

• Swift是苹果2014年推出的全新的编程语言，它继承了C语言、ObjC的特性，且克服了C语言的兼容性问题。
• Swift发展过程中不仅保留了ObjC很多语法特性，它也借鉴了多种现代化语言的特点，在其中你可以看到C#、Java、Javascript、Python等多种语言的影子。
• 在2015年的WWDC上，苹果还宣布Swift的新版本Swift2.0，并在之后宣布Swift开源，除了支持iOS、OS X之外还将支持Linux。
• Swift语言是苹果强推的一种编程语言，未来可能会取代ObjC的地位。

这里不会从零基础一点点剖析这门语言的语法，旨在帮助大家快速从ObjC快速过渡到Swift开发中，入门初学可以参考The Swift Programming Language中文手册
和Swift系列学习推荐

Xcode从6.0开始加入了Playground代码测试，可以实时查看代码执行结果，如果还没有Xcode6以上的，可以使用在线Swift编译网站调试：Swift在线编译网站

二、Swift基础部分

1. 第一个Swift程序

import Foundation
/* Swift没有main函数，默认从第一个非声明语句开始执行，自上而下执行 */
println("Hello World!")

1. Swift没有main函数，第一个非声明语句开始执行，表达式或者控制结构，类、结构体、枚举和方法等属于声明语句。

2. Swift通过import引入其他类库，和Python语言的导入很像。
3. Swift语句不需要双引号结尾（尽管加上也不报错），除非一行包含多条语句，也和Python有点类似。

2. 数据类型

Swift包含了C和ObjC语言中的所有基础类型，还增加了一些高阶类型

1. 基础类型：

• Int整形和UInt无符号整形
• Float和Double浮点型
• Bool布尔型
• Character字符型
• String字符串类型

2. 枚举类型enum和结构体类型struct
3. 集合类型

• Array数组
• Set集合
• Dictionary字典

4. 高阶数据类型

• Tuple元组
• Optinal可选类型

3. 基础类型使用

import Foundation
var intValue:Int = 1            //通过var定义一个Int变量
var floatValue:Float = 1.0      //通过var定义一个Float变量
var doubleValue:Double = 2.0000     //通过var定义一个Double变量
var boolValue:Bool = true           //通过var定义一个Bool变量,if语句中的条件只能是布尔类型
var charValue:Character = "c"       //通过var定义一个Character变量
var strValue:String = "hello"       //通过var定义一个String变量
let number:Int = 1      //let表示常量，值不能被修改
let numMax = Int.max    //枚举值，Int整形最大值9223372036854775807
let score = 96      //自动推导为Int类型
let width = 10.32       //自动推导为Double类型
let name = "Join"       //自动推导为String类型
let anotherPi = 3 + 0.14159 //表达式中同时出现了整数和浮点数，会被推测为Double类型 

/* println中通过的\(var或者let变量)进行格式化输出 */
println("log some value: score = \(score)")
//等价于println("log some value: score = " + String(score))

//Swift是强类型语言，不同类型变量不能运算，会报错，但字面量除外
Error: -> let sum = intValue + floatValue
Success: -> let sumNum = 1 + 1.2

1. Swift通过var进行变量定义，通过let进行常量定义（这和JavaScript类似）

2. Swift添加了类型推断，对于赋值的常量或者变量会自动推断其具体类型
3. Swift是强类型语言，不同的数据类型之间不能隐式转化，如果需要转化只能强制转化
4. 在Swift中类型转换直接通过其类型构造函数即可，降低了API的学习成本

4. 集合类型使用

//Array数组
//定义数组的几种方式
var arrStr1:Array<String> = ["hello","world"]
var arrStr2:[String] = ["hello","world"]
var arrDouble1:[Double] = []
var arrDouble2 = [Double]()
//追加元素
arrStr1 += ["Swift","Obj-C"]    //arrStr1 = ["hello","world","Swift","Obj-C"]
arrStr1.append("Swift")         //arrStr1 = ["hello","world","Swift","Obj-C","Swift"]
//修改元素，x...y表示[x,y]区间，是Swift语法特性
arrStr1[3...4] = ["Array","Change"]    //arrStr1 = ["hello","world","Swift","Array","Change"]
arrStr1[1] = "Nice"                 //arrStr1 = ["hello","Nice","Swift","Array","Change"]
//删除元素
arrStr1.removeAtIndex(1)               //arrStr1 = ["hello","Swift","Array","Change"]
//插入元素
arrStr1.insert("insert", atIndex: 2)   //arrStr1 = ["hello","Swift","insert","Array","Change"]

//Set集合
var setStr1:Set<String> = ["hello","world"] //定义集合，注意集合没有数组的简化格式
var setStr2:Set = [1,2]             //自动推导类型为Set<Int>
setStr1.insert("!")     //插入元素，不保证顺序
setStr1.remove("!")     //删除元素
setStr1.contains("!")     //判断是否包含

//Dictionary字典
var dictIntToStr1:Dictionary<Int,String> = [200:"success", 404:"error"]
var dictIntToStr2:[Int:String] = [200:"success", 404:"error"]
var dictIntToStr3 = [200:"success", 404:"error"]        //自动推导为[Int,String]类型
dictIntToStr2[200] = "hahaha"        //修改元素，通过key找到value，进行修改
dictIntToStr1[500] = "server"        //添加元素 500:"server"
print(dictIntToStr1) //结果：[500: "server", 200: "success", 404: "error"]
print(dictIntToStr2) //结果：[200: "hahaha", 404: "error"]
print(dictIntToStr3) //结果：[200: "success", 404: "error"]

5. 元组使用

元组就像是不能修改的数组一样，元组中的值是不能修改的，不过元组内的值可以使任意类型，并不要求是相同类型，这一点和数组不同

/**
 * 元组的基本用法
 */
var point = (x:50, y:100) //自动推断其类型：(Int,Int)
print(point.x) //可以用类似于结构体的方式直接访问元素,结果：50
print(point.y) //结果：100
print(point.0) //也可以采用类似数组的方式使用下标访问，结果：50
print(point.1) //结果：100

//元组也可以不指定元素名称，访问的时候只能使用下标
let frame:(Int,Int,Int,Float) = (0,0,100,100.0)
print(frame) //结果：(0, 0, 100, 100.0)

//注意下面的语句是错误的，如果指定了元组的类型则无法指定元素名称
Error: -> let frame:(Int,Int,Int,Int) = (x:0, y:0, width:100, height:100)

var size = (width:100, 25) //仅仅给其中一个元素命名
print(size.width) //结果：100
print(size.1)  //结果：25

var httpStatus:(Int,String) = (200, "success") //元组的元素类型并不一定相同

var (status, description) = httpStatus //一次性赋值给多个变量，此时status=200，description="success"

//接收元组的其中一个值忽略另一个值使用"_"(注意在Swift中很多情况下使用_忽略某个值或变量)
var ( sta , _ ) = httpStatus
print("sta = \(sta)") //结果：sta = 200

6. 可选类型使用

上面的类型定义的常量或变量初始化都必须有值，而可选类型暗示了常量或者变量可以没有值

/**
 * 可选类型基础
 */
var x:Float? //使用？声明成一个可选类型，如果不赋值，默认为nil
x = 172.0
var y:Float = 60.0

//注意此句报错，因为Int和Int？根本就是两种不同的类型，在Swift中两种不同的类型不能运算
Error: -> var z = x + y 
Success: -> var z = x! + y     //使用！进行强制解包，得到基本类型

//注意ageInt是Int可选类型而不是Int类型，因为String的toInt()方法并不能保证其一定能转化为Int类型
var age:String = "29"
var ageInt = Int(age) //ageInt是Int?可选类型

/**
* 可选类型判断
*/
if ageInt == nil {
    print("ageInt = nil")
} else {
    print("ageInt = \(ageInt!)") //注意这里使用感叹号!强制解析
}

/**
 * 可选类型绑定
 * 如果可选类型有值，则将值赋值给一个临时变量或者常量（此时此变量或者常量接受的值已经不是可选类型）
 * 如果没有值，则不执行此条件
 */
if let newAge = ageInt{ //此时newAge可以定义成常量也可以定义成变量
    print("newAge = \(newAge)") //注意这里并不需要对newAge强制解包
} else {
    print("ageInt = nil")
}

/**
* 隐式解析可选类型
*/
var age2:Int! = 0 //通过感叹号声明隐式解析可选类型，此后使用时虽然是可选类型但是不用强制解包
age2 = 29
var newAge:Int = age2 //不用强制解包直接赋值给Int类型（程序会自动解包）

if let tempAge = age2 {
    print("tempAge = \(tempAge)")
}else{
    print("age=nil")
}

1. Swift中类似于Int和Int?并不是同一种类型，不能进行相关运算，如果要运算只能用感叹号解包；

2. 可选类型其本质，就是此类型内部存储分为Some和None两个部分，如果有值则存储到Some中，没有值则为None，使用感叹号强制解包的过程就是取出Some部分；
3. 如果一个可选类型从第一次赋值之后就能保证有值，那么使用时就不必进行强制解包了，这种情况下可以使用隐式可选解析类型

7. 运算符

Swift除了支持基本运算符以外，还多了2个特殊的运算符，分别是区间运算符和溢出运算符

/**
 * 区间运算符,通常用于整形或者字符范围(例如"a"..."z"）
 */
for i in 1...5 { //闭区间运算符...（从1到5，包含5）
    println("i=\(i)")
}
for i in 1..<5{ //半开区间运算符..<(从1到4)
    println("i=\(i)")
}
var str = "hello world."
var range = "a"..."z"
for t in str {
    if range.contains(String(t)) {
        print(t) //结果：helloworld
    }
}
//溢出运算符
var a = UInt8.max //a = 255
Error: -> var b:UInt8 = a + 1 //注意b会出现溢出,此句报错
//下面使用溢出运算符，结果为：0
Success: -> var b:UInt8 = a &+ 1
//类似的还有&-、&*、&/,使用溢出运算符可以在最大值和最小值之前循环而不会报错，下面c的值为255
Success: -> var c:UInt8 = b &- 1

8. 控制流

Swift的多数控制流和其他语言相差不大，有for-in、while、do-while、if-else、switch等，下面只讲一些特殊的语法：

var a = ["a","b","c","d","e","f","g"]
let b = a[1]
/**
* switch支持一个case多个模式匹配，
* 同时case后不用写break也会在匹配到种情况后自动跳出匹配，不存在隐式贯穿，
* 如果想要贯穿在case之后添加"fallthrough"关键字
*/
switch b{
case "a","b":
    println("b = a or b = b")
case "c","d","e","f":
    println("b in (c,d,e,f)")
default:
    println("b = g")
}
/**
 * switch匹配区间,同时注意switch必须匹配所有情况，否则必须加上default
 */
let c:Int = 88
switch c{
case 1...60:
    println("1 - 60")
case 61...90:
    println("61 - 90")
case 91...100:
    println("91 - 100")
default:
    println("1 > c > 100")
}
/**
*  switch元组匹配、值绑定、where条件匹配
*  注意下面的匹配没有default，因为它包含了所有情况
*/
var d = (x:900, y:0)
switch d{
case (0, 0):
    println("d in (0,0)")
case (_, 0):        //忽略x值匹配
    println("d in y")
case (0, let y):        //值绑定
    println("d in x,y = \(y)")
case (-100...100, -100...100): 
    //注意这里有可能和第一、二、三个条件重合，但是Swift允许多个case匹配同一个条件，但是只会执行第一个匹配
    println("x in（0-100），y in （0-100）")
case let (x, y) where x == y: //where条件匹配,注意这里的写法等同于：(let x,let y) where x==y
    println("x = y = \(x)")
case let (x, y):
    println("x = \(x),y = \(y)")    
}
/* 利用标签你可以随意指定转移的位置 */
var a = 5
whileLoop: while --a > 0 {
    for var i = 0;i < a;++i{
        println("a=\(a),i=\(i)")
       /* 
          如果此处直接使用break将跳出for循环，而由于这里使用标签直接跳出了while，
          结果只会打印一次，其结果为：a=4,i=0
       */
        break whileLoop
    }
}

有什么问题在下方评论区中提出！O(∩_∩)O哈！