面向过程 数据结构

3.1 常量和变量

定义常量和变量

let a = 1
var b = 2

显式定义和隐式定义

无需指定强类型，编译器会自动根据初始值推断出其类型。与c#相似。如果在定义时不初始化，则必须显式定义
var username:String

可选变量

类似C#的可空类型。

var str1:String?//默认为nil

处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加?。如果?之前的值是nil，?后面的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

你可以使用if语句来判断一个可选是否包含值。如果可选有值，结果是true；如果没有值，结果是false。
当你确定可选确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析（forced unwrapping）：

if convertedNumber {
println("(possibleNumber) has an integer value of (convertedNumber!)")
} else {
println("(possibleNumber) could not be converted to an integer")
}
// 输出 "123 has an integer value of 123"

使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前，一定要确定可选包含一个非nil的值。

Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中，nil是一个指向不存在对象的指针。在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选都可以被设置为nil，不只是对象类型。

下面的例子展示了可选String和隐式解析可选String之间的区别：

let possibleString: String? = "An optional string."
println(possibleString!) // 需要惊叹号来获取值
// 输出 "An optional string."

let assumedString: String! = "An implicitly unwrapped optional string."
println(assumedString) // 不需要感叹号
// 输出 "An implicitly unwrapped optional string."
你可以把隐式解析可选当做一个可以自动解析的可选。你要做的只是声明的时候把感叹号放到类型的结尾，而不是每次取值的可选名字的结尾。

支持utf8 unicode字符集

变量名或常量名支持utf8字符集
var 姓名=''你好''
println(姓名)

3.2注释和分号

多行注释支持嵌套
/*// /**/ */

3.3基本数据类型

字符串和字符

var ch = "u"//默认类型推断出是字符串
var ch1:Character = "u"
在swift语言中，字符串是值类型的(实际上是结构体struct)，和c#等大多数语言不一样。

元组类型 tuplets

由于函数返回值需要返回多个值，但是又不期望单独去创建一个结构体或类型，这个时候则可以使用元组类型，从而减少对象的创建。
func getUser() -> (String , Int) {
return ("benoly",99)
}

可以通过下标访问元组的项。
var user = getUser()
println(user.0)//benoly
println(user.1)//99

通过声明元组类型变量获取
var (name,age) = getUser()

3.4基本运算符

需要注意的是，有些运算符需要空格隔开，不然ide会抛出错误提示。

赋值运算符

算数运算符

+-*/%
取模运算和其他语言有些不一样，可支持浮点数取模。
println(5%0.2)//0.2

比较运算符

== 和 === 区别

不要和Javascript 混淆。前者是内容值相等比较，后者是引用地址值相等比较。

三目运算符

逻辑运算符

3.5集合类型

数组array

字典dictianary

用for-in来遍历字典

let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}

3.6控制流

for in

你可以在循环中使用..来表示范围，也可以使用传统的写法，两者是等价的：

var firstForLoop = 0
for i in 0..3 {
firstForLoop += i
}
firstForLoop

var secondForLoop = 0
for var i = 0; i < 3; ++i {
secondForLoop += 1
}
secondForLoop
使用..创建的范围不包含上界，如果想包含的话需要使用...。

if else

var str1:String?=nil

还可以借助if let 条件判断的同时进行赋值
if let str2 = str1{//如果str1有值，则赋值给str2，同时if 条件为true;否则，如果str1没有值，则if条件为false,执行else语句。
//true
str3 = str2
}
else{
//false
}

while

do while

switch

和其他语言不一样的是,break不需要的，swift里默认就是 break，case执行完成之后跳出整个switch。
Case还支持范围比较。
case 1...10:

3.7函数

一般参数

func setUser1 (username:String , age:Int) -> void {
//...
}
setUser1("benoly",99)

外部参数

func setUser2 (user username:String , age:Int) -> void {
//...
}
setUser2(user:"benoly",99)

func setUser3 (#username:String , age:Int) -> void {
//...
}
setUser3(username :"benoly",99)

参数默认值

参数可设置默认值，这和C#4.0有着相同之处。
func setUser4 (#username:String , age:Int=99) -> void {
//...
}
setUser4(username :"benoly")

//当调用函数时传入有默认值的参数，该参数自动变为外部参数
setUser4(username :"benoly",age:100)

可变参数

func join(strs:String...) -> String{
//...
}

Join("str1","str2","str3")

输入输出参数

类似C#中的 ref 关键字，也就是引用参数传递。
func setUser(inout user:String){
user += " hello"
}

var user = "user1"
setUser(&user)

函数类型

类似C#中的委托,函数指针，传递函数。
func sort( compare:(Int,Int)->Boolean ){
//...
}

函数嵌套

类似javascript的函数包含函数,javascript的闭包。

3.8 闭包

类似C#里的匿名函数表达式。
不理解为啥叫闭包?

3.9 枚举类型

使用enum来创建一个枚举。就像类和其他所有命名类型一样，枚举可以包含方法。

enum Rank: Int {
case Ace = 1
case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
case Jack, Queen, King
func simpleDescription() -> String {
switch self {
case .Ace:
return "ace"
case .Jack:
return "jack"
case .Queen:
return "queen"
case .King:
return "king"
default:
return String(self.toRaw())
}
}
}
let ace = Rank.Ace
let aceRawValue = ace.toRaw()

实例值定义

//todo

在上面的例子中，枚举原始值的类型是Int，所以你只需要设置第一个原始值。剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。

使用toRaw和fromRaw函数来在原始值和枚举值之间进行转换。

if let convertedRank = Rank.fromRaw(3) {
let threeDescription = convertedRank.simpleDescription()
}
枚举的成员值是实际值，并不是原始值的另一种表达方法。实际上，如果原始值没有意义，你不需要设置。

原始值定义

enum Status:Int{
case NotSet=0
case Open=1
}

面向对象的数据结构

3.10 类

类的实例的创建

实例化不需要new，这和其他语言不大一样。

class User {
var name:String = "n/a"

//默认构造函数，无需显式定义。
//init (){}

}

var user1 = User()

类的构造函数和析构函数

class User {
var name:String = "n/a"

//自定义构造函数
init (name:String){
   self.name = name
}

//自定义析构函数
deinit {
    self.name = nil
}

}

var user1 = User(name:"user1")//构造函数的参数默认就是外部参数

类的继承

支持多继承

//todo

类中的方法

类中的方法和一般的函数有一个重要的区别，函数的参数名只在函数内部使用，但是方法的参数名需要在调用的时候显式说明（除了第一个参数）。默认情况下，方法的参数名和它在方法内部的名字一样，不过你也可以定义第二个名字，这个名字被用在方法内部。

class Counter {
var count: Int = 0
func incrementBy(amount: Int, numberOfTimes times: Int) {
count += amount * times
}
}
var counter = Counter()
counter.incrementBy(2, numberOfTimes: 7)

3.11结构体

struct User {
var name = "n/a"
var age = 99

func getName() -> String {
   return name
}

}

调用方式有2种
var user1 = User()
var user2 = User(name:"benoly",Age:100)

结构体与类的区别：

• 结构体的成员访问无需借助self
• 结构体有默认的初始化器，通过初始化器的外部参数，对成员赋值
• 结构体是值类型
• 结构体无析构函数,也就是说无法手动干预结构体实例的销毁。

3.12协议

类、枚举和结构体都可以实现接口。

mutating关键字用来标记一个会修改结构体的方法

协议的继承

协议类似其他语言里的接口，同时，和C#的接口可以继承接口一样，swift的协议也是可以继承协议的。定义的方式也和C#相似太多。

protocol IEntityBase {
var keyName:String{ get }
var id:Int{ get set }
func save()->Bool
}

协议的合成

// todo

扩展方法

和C#扩展方法类似。

使用extension来为现有的类型添加功能，比如添加一个计算属性的方法。你可以使用扩展来给任意类型添加协议，甚至是你从外部库或者框架中导入的类型。

extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number (self)"
}
mutating func adjust() {
self += 42
}
}

3.13范型