Swift 语言基础

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基础部分

第一个Swift程序

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

Swift没有main函数，第一个非声明语句开始执行，表达式或者控制结构，类、结构体、枚举和方法等属于声明语句。
Swift通过import引入其他类库，和Python语言的导入很像。
Swift语句不需要双引号结尾（尽管加上也不报错），除非一行包含多条语句，也和Python有点类似。

数据类型

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

分类	数据类型
基础类型	Int整形和UInt无符号整形
_	Float和Double浮点型
_	Bool布尔型
_	Character字符型
_	String字符串类型
枚举类型	enum
结构体类型	struct
集合类型	Array数组
_	Set集合
_	Dictionary字典
高阶数据类型	Tuple元组
_	Optinal可选类型

基础类型使用

var intValue:Int = 1            // 通过var定义一个Int变量
var floatValue:Float = 1.0      // 通过var定义一个Float变量
var doubleValue:Double = 2.000  // 通过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 numberMax = Int.max         // 枚举值,Int整形最大值9223372036854775807
let score = 96                  // 自动推导为Int类型
let width = 10.32               // 自动推导为Double类型
let name = "Bobby"              // 自动推导为String类型
let anotherPi = 3 + 0.14159     // 表达式中同时出现了整数和浮点数,会被推测为Double类型

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

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

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

集合类型使用

// Array数组
// 定义数组的几种方式

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

// Dictionary字典
var dictIntToStr1:Dictionary = [200:"success",404:"error"]
var dictIntToStr2:[Int:String] = [200:"success", 404:"error"]
var dictIntToStr3 = [200:"success", 404:"error"]

// return: [200: "success", 404: "error"]
//[200: "success", 404: "error"]
//[200: "success", 404: "error"]

dictIntToStr1[200] = "hahaha"       //修改元素,通过key找到value,进行修改
dictIntToStr1[500] = "server"       //添加元素 500:"server"

元组使用

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

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

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

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

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

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

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

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

可选类型使用

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

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

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

var age = "29"

// Swift2.0中String.toInt()已重名为Int(String)的可失败构造器,因为构造器语法更适合类型转换。
var ageInt = Int(age)

// 可选类型判断
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 newAge2:Int = age2  // 不用强制解包直接赋值给Int类型（程序会自动解包）
if var tempAge = age2 {
    print("tempAge=\(tempAge)")
} else {
    print("age=nil")
}

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